Bring in snapshot of the MdePkg from Tianocore's EDK2 project at gitvendor/edk2/7babb4372e6a34cbbc54249b25056272a5a9924c

hash 7babb4372e6a34cbbc54249b25056272a5a9924c From 2017-Mar-03.

EDK2 is Intel's BSD Licensed UEFI implementation. We'll be bringing in
various routines from there rather than reimplementing them from
scratch for libefivar and the EFI boot loader.

The upstream repo has ^M ending on everything (sometimes multiple
times!), so the following script was run prior to import so changes we
have to do don't first include changing every line:

% find . -type f | xargs -n 1 sed -I.BAK -e `printf "s/\r//g"`
% find . -name \*.BAK | xargs rm

Also, only the MdePkg was brought in (it's 17MB, while the entire repo
is 250MB). It's almost completely certain nothing else will be used,
but if it is, it can be brough in along side MdePkg in the future.

Obtained from: https://github.com/tianocore/edk2.git

1977 files changed, 355088 insertions, 0 deletions

diff --git a/MdePkg/Contributions.txt b/MdePkg/Contributions.txt
new file mode 100644
index 000000000000..34f09578f993
--- /dev/null
+++ b/MdePkg/Contributions.txt
@@ -0,0 +1,218 @@
+
+======================
+= Code Contributions =
+======================
+
+To make a contribution to a TianoCore project, follow these steps.
+1. Create a change description in the format specified below to
+   use in the source control commit log.
+2. Your commit message must include your "Signed-off-by" signature,
+   and "Contributed-under" message.
+3. Your "Contributed-under" message explicitly states that the
+   contribution is made under the terms of the specified
+   contribution agreement.  Your "Contributed-under" message
+   must include the name of contribution agreement and version.
+   For example: Contributed-under: TianoCore Contribution Agreement 1.0
+   The "TianoCore Contribution Agreement" is included below in
+   this document.
+4. Submit your code to the TianoCore project using the process
+   that the project documents on its web page.  If the process is
+   not documented, then submit the code on development email list
+   for the project.
+5. It is preferred that contributions are submitted using the same
+   copyright license as the base project. When that is not possible,
+   then contributions using the following licenses can be accepted:
+   * BSD (2-clause): http://opensource.org/licenses/BSD-2-Clause
+   * BSD (3-clause): http://opensource.org/licenses/BSD-3-Clause
+   * MIT: http://opensource.org/licenses/MIT
+   * Python-2.0: http://opensource.org/licenses/Python-2.0
+   * Zlib: http://opensource.org/licenses/Zlib
+
+   Contributions of code put into the public domain can also be
+   accepted.
+
+   Contributions using other licenses might be accepted, but further
+   review will be required.
+
+=====================================================
+= Change Description / Commit Message / Patch Email =
+=====================================================
+
+Your change description should use the standard format for a
+commit message, and must include your "Signed-off-by" signature
+and the "Contributed-under" message.
+
+== Sample Change Description / Commit Message =
+
+=== Start of sample patch email message ===
+
+From: Contributor Name <contributor@example.com>
+Subject: [PATCH] CodeModule: Brief-single-line-summary
+
+Full-commit-message
+
+Contributed-under: TianoCore Contribution Agreement 1.0
+Signed-off-by: Contributor Name <contributor@example.com>
+---
+
+An extra message for the patch email which will not be considered part
+of the commit message can be added here.
+
+Patch content inline or attached
+
+=== End of sample patch email message ===
+
+=== Notes for sample patch email ===
+
+* The first line of commit message is taken from the email's subject
+  line following [PATCH]. The remaining portion of the commit message
+  is the email's content until the '---' line.
+* git format-patch is one way to create this format
+
+=== Definitions for sample patch email ===
+
+* "CodeModule" is a short idenfier for the affected code.  For
+  example MdePkg, or MdeModulePkg UsbBusDxe.
+* "Brief-single-line-summary" is a short summary of the change.
+* The entire first line should be less than ~70 characters.
+* "Full-commit-message" a verbose multiple line comment describing
+  the change.  Each line should be less than ~70 characters.
+* "Contributed-under" explicitely states that the contribution is
+  made under the terms of the contribtion agreement.  This
+  agreement is included below in this document.
+* "Signed-off-by" is the contributor's signature identifying them
+  by their real/legal name and their email address.
+
+========================================
+= TianoCore Contribution Agreement 1.0 =
+========================================
+
+INTEL CORPORATION ("INTEL") MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+INFORMATION AND/OR OTHER MATERIALS FOR USE IN THE TIANOCORE OPEN SOURCE
+PROJECT (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE
+TERMS AND CONDITIONS OF THIS AGREEMENT BETWEEN YOU AND INTEL AND/OR THE
+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR
+REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE
+CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS
+OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+USE THE CONTENT.
+
+Unless otherwise indicated, all Content made available on the TianoCore
+site is provided to you under the terms and conditions of the BSD
+License ("BSD"). A copy of the BSD License is available at
+http://opensource.org/licenses/bsd-license.php
+or when applicable, in the associated License.txt file.
+
+Certain other content may be made available under other licenses as
+indicated in or with such Content. (For example, in a License.txt file.)
+
+You accept and agree to the following terms and conditions for Your
+present and future Contributions submitted to TianoCore site. Except
+for the license granted to Intel hereunder, You reserve all right,
+title, and interest in and to Your Contributions.
+
+== SECTION 1: Definitions ==
+* "You" or "Contributor" shall mean the copyright owner or legal
+  entity authorized by the copyright owner that is making a
+  Contribution hereunder. All other entities that control, are
+  controlled by, or are under common control with that entity are
+  considered to be a single Contributor. For the purposes of this
+  definition, "control" means (i) the power, direct or indirect, to
+  cause the direction or management of such entity, whether by
+  contract or otherwise, or (ii) ownership of fifty percent (50%)
+  or more of the outstanding shares, or (iii) beneficial ownership
+  of such entity.
+* "Contribution" shall mean any original work of authorship,
+  including any modifications or additions to an existing work,
+  that is intentionally submitted by You to the TinaoCore site for
+  inclusion in, or documentation of, any of the Content. For the
+  purposes of this definition, "submitted" means any form of
+  electronic, verbal, or written communication sent to the
+  TianoCore site or its representatives, including but not limited
+  to communication on electronic mailing lists, source code
+  control systems, and issue tracking systems that are managed by,
+  or on behalf of, the TianoCore site for the purpose of
+  discussing and improving the Content, but excluding
+  communication that is conspicuously marked or otherwise
+  designated in writing by You as "Not a Contribution."
+
+== SECTION 2: License for Contributions ==
+* Contributor hereby agrees that redistribution and use of the
+  Contribution in source and binary forms, with or without
+  modification, are permitted provided that the following
+  conditions are met:
+** Redistributions of source code must retain the Contributor's
+   copyright notice, this list of conditions and the following
+   disclaimer.
+** Redistributions in binary form must reproduce the Contributor's
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+* Disclaimer. None of the names of Contributor, Intel, or the names
+  of their respective contributors may be used to endorse or
+  promote products derived from this software without specific
+  prior written permission.
+* Contributor grants a license (with the right to sublicense) under
+  claims of Contributor's patents that Contributor can license that
+  are infringed by the Contribution (as delivered by Contributor) to
+  make, use, distribute, sell, offer for sale, and import the
+  Contribution and derivative works thereof solely to the minimum
+  extent necessary for licensee to exercise the granted copyright
+  license; this patent license applies solely to those portions of
+  the Contribution that are unmodified. No hardware per se is
+  licensed.
+* EXCEPT AS EXPRESSLY SET FORTH IN SECTION 3 BELOW, THE
+  CONTRIBUTION IS PROVIDED BY THE CONTRIBUTOR "AS IS" AND ANY
+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+  PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  CONTRIBUTOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+  CONTRIBUTION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+  DAMAGE.
+
+== SECTION 3: Representations ==
+* You represent that You are legally entitled to grant the above
+  license. If your employer(s) has rights to intellectual property
+  that You create that includes Your Contributions, You represent
+  that You have received permission to make Contributions on behalf
+  of that employer, that Your employer has waived such rights for
+  Your Contributions.
+* You represent that each of Your Contributions is Your original
+  creation (see Section 4 for submissions on behalf of others).
+  You represent that Your Contribution submissions include complete
+  details of any third-party license or other restriction
+  (including, but not limited to, related patents and trademarks)
+  of which You are personally aware and which are associated with
+  any part of Your Contributions.
+
+== SECTION 4: Third Party Contributions ==
+* Should You wish to submit work that is not Your original creation,
+  You may submit it to TianoCore site separately from any
+  Contribution, identifying the complete details of its source
+  and of any license or other restriction (including, but not
+  limited to, related patents, trademarks, and license agreements)
+  of which You are personally aware, and conspicuously marking the
+  work as "Submitted on behalf of a third-party: [named here]".
+
+== SECTION 5: Miscellaneous ==
+* Applicable Laws. Any claims arising under or relating to this
+  Agreement shall be governed by the internal substantive laws of
+  the State of Delaware or federal courts located in Delaware,
+  without regard to principles of conflict of laws.
+* Language. This Agreement is in the English language only, which
+  language shall be controlling in all respects, and all versions
+  of this Agreement in any other language shall be for accommodation
+  only and shall not be binding. All communications and notices made
+  or given pursuant to this Agreement, and all documentation and
+  support to be provided, unless otherwise noted, shall be in the
+  English language.
+
diff --git a/MdePkg/Include/AArch64/ProcessorBind.h b/MdePkg/Include/AArch64/ProcessorBind.h
new file mode 100644
index 000000000000..3fc678c756b3
--- /dev/null
+++ b/MdePkg/Include/AArch64/ProcessorBind.h
@@ -0,0 +1,154 @@
+/** @file
+  Processor or Compiler specific defines and types for AArch64.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+  Portions copyright (c) 2011 - 2013, ARM Ltd. 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices
+///
+#define MDE_CPU_AARCH64
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#ifndef __GNUC__
+#pragma pack()
+#endif
+
+#if _MSC_EXTENSIONS
+  //
+  // use Microsoft* C compiler dependent integer width types
+  //
+  typedef unsigned __int64    UINT64;
+  typedef __int64             INT64;
+  typedef unsigned __int32    UINT32;
+  typedef __int32             INT32;
+  typedef unsigned short      UINT16;
+  typedef unsigned short      CHAR16;
+  typedef short               INT16;
+  typedef unsigned char       BOOLEAN;
+  typedef unsigned char       UINT8;
+  typedef char                CHAR8;
+  typedef signed char         INT8;
+#else
+  //
+  // Assume standard AARCH64 alignment.
+  //
+  typedef unsigned long long  UINT64;
+  typedef long long           INT64;
+  typedef unsigned int        UINT32;
+  typedef int                 INT32;
+  typedef unsigned short      UINT16;
+  typedef unsigned short      CHAR16;
+  typedef short               INT16;
+  typedef unsigned char       BOOLEAN;
+  typedef unsigned char       UINT8;
+  typedef char                CHAR8;
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef UINT64  UINTN;
+
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef INT64   INTN;
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x8000000000000000ULL
+
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC000000000000000ULL
+
+///
+/// Maximum legal AARCH64  address
+///
+#define MAX_ADDRESS   0xFFFFFFFFFFFFFFFFULL
+
+///
+/// Maximum legal AArch64 INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFFFFFFFFFFULL)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFFFFFFFFFFULL)
+
+///
+/// The stack alignment required for AARCH64
+///
+#define CPU_STACK_ALIGNMENT  16
+
+///
+/// Page allocation granularity for AARCH64
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x10000)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#define EFIAPI
+
+// When compiling with Clang, we still use GNU as for the assembler, so we still
+// need to define the GCC_ASM* macros.
+#if defined(__GNUC__) || defined(__clang__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+
+  #define GCC_ASM_EXPORT(func__)  \
+         .global  _CONCATENATE (__USER_LABEL_PREFIX__, func__)    ;\
+         .type ASM_PFX(func__), %function
+
+  #define GCC_ASM_IMPORT(func__)  \
+         .extern  _CONCATENATE (__USER_LABEL_PREFIX__, func__)
+
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On ARM CPU architectures, these two pointer values are the same,
+  so the implementation of this macro is very simple.
+
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#endif
diff --git a/MdePkg/Include/Arm/ProcessorBind.h b/MdePkg/Include/Arm/ProcessorBind.h
new file mode 100644
index 000000000000..ba024c072d71
--- /dev/null
+++ b/MdePkg/Include/Arm/ProcessorBind.h
@@ -0,0 +1,182 @@
+/** @file
+  Processor or Compiler specific defines and types for ARM.
+
+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices
+///
+#define MDE_CPU_ARM
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#ifndef __GNUC__
+#pragma pack()
+#endif
+
+//
+// RVCT does not support the __builtin_unreachable() macro
+//
+#ifdef __ARMCC_VERSION
+#define UNREACHABLE()
+#endif
+
+#if _MSC_EXTENSIONS 
+  //
+  // use Microsoft* C compiler dependent integer width types
+  //
+  typedef unsigned __int64    UINT64;
+  typedef __int64             INT64;
+  typedef unsigned __int32    UINT32;
+  typedef __int32             INT32;
+  typedef unsigned short      UINT16;
+  typedef unsigned short      CHAR16;
+  typedef short               INT16;
+  typedef unsigned char       BOOLEAN;
+  typedef unsigned char       UINT8;
+  typedef char                CHAR8;
+  typedef signed char         INT8;
+#else
+  //
+  // Assume standard ARM alignment. 
+  // Need to check portability of long long
+  //
+  typedef unsigned long long  UINT64;
+  typedef long long           INT64;
+  typedef unsigned int        UINT32;
+  typedef int                 INT32;
+  typedef unsigned short      UINT16;
+  typedef unsigned short      CHAR16;
+  typedef short               INT16;
+  typedef unsigned char       BOOLEAN;
+  typedef unsigned char       UINT8;
+  typedef char                CHAR8;
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef UINT32  UINTN;
+
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef INT32   INTN;
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT      0x80000000
+
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS   0xC0000000
+
+///
+/// Maximum legal ARM address
+///
+#define MAX_ADDRESS  0xFFFFFFFF
+
+///
+/// Maximum legal ARM INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFF)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFF)
+
+///
+/// The stack alignment required for ARM
+///
+#define CPU_STACK_ALIGNMENT  sizeof(UINT64)
+
+///
+/// Page allocation granularity for ARM
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#define EFIAPI    
+
+// When compiling with Clang, we still use GNU as for the assembler, so we still
+// need to define the GCC_ASM* macros.
+#if defined(__GNUC__) || defined(__clang__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+
+  #if !defined(__APPLE__)
+    ///
+    /// ARM EABI defines that the linker should not manipulate call relocations
+    /// (do bl/blx conversion) unless the target symbol has function type.
+    /// CodeSourcery 2010.09 started requiring the .type to function properly
+    ///
+    #define INTERWORK_FUNC(func__)   .type ASM_PFX(func__), %function
+
+    #define GCC_ASM_EXPORT(func__)  \
+             .global  _CONCATENATE (__USER_LABEL_PREFIX__, func__)    ;\
+             .type ASM_PFX(func__), %function  
+
+    #define GCC_ASM_IMPORT(func__)  \
+             .extern  _CONCATENATE (__USER_LABEL_PREFIX__, func__)
+             
+  #else
+    //
+    // .type not supported by Apple Xcode tools 
+    //
+    #define INTERWORK_FUNC(func__)  
+
+    #define GCC_ASM_EXPORT(func__)  \
+             .globl  _CONCATENATE (__USER_LABEL_PREFIX__, func__)    \
+  
+    #define GCC_ASM_IMPORT(name)  
+
+  #endif
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On ARM CPU architectures, these two pointer values are the same, 
+  so the implementation of this macro is very simple.
+  
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+  
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#endif
+
+
diff --git a/MdePkg/Include/Base.h b/MdePkg/Include/Base.h
new file mode 100644
index 000000000000..70cb9992a6fd
--- /dev/null
+++ b/MdePkg/Include/Base.h
@@ -0,0 +1,1270 @@
+/** @file
+  Root include file for Mde Package Base type modules
+
+  This is the include file for any module of type base. Base modules only use
+  types defined via this include file and can be ported easily to any
+  environment. There are a set of base libraries in the Mde Package that can
+  be used to implement base modules.
+
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2009, Apple Inc. 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 __BASE_H__
+#define __BASE_H__
+
+//
+// Include processor specific binding
+//
+#include <ProcessorBind.h>
+
+#if defined(_MSC_EXTENSIONS)
+//
+// Disable warning when last field of data structure is a zero sized array.
+//
+#pragma warning ( disable : 4200 )
+#endif
+
+/**
+  Verifies the storage size of a given data type.
+
+  This macro generates a divide by zero error or a zero size array declaration in
+  the preprocessor if the size is incorrect.  These are declared as "extern" so
+  the space for these arrays will not be in the modules.
+
+  @param  TYPE  The date type to determine the size of.
+  @param  Size  The expected size for the TYPE.
+
+**/
+#define VERIFY_SIZE_OF(TYPE, Size) extern UINT8 _VerifySizeof##TYPE[(sizeof(TYPE) == (Size)) / (sizeof(TYPE) == (Size))]
+
+//
+// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
+// Section 2.3.1 of the UEFI 2.3 Specification.
+//
+VERIFY_SIZE_OF (BOOLEAN, 1);
+VERIFY_SIZE_OF (INT8, 1);
+VERIFY_SIZE_OF (UINT8, 1);
+VERIFY_SIZE_OF (INT16, 2);
+VERIFY_SIZE_OF (UINT16, 2);
+VERIFY_SIZE_OF (INT32, 4);
+VERIFY_SIZE_OF (UINT32, 4);
+VERIFY_SIZE_OF (INT64, 8);
+VERIFY_SIZE_OF (UINT64, 8);
+VERIFY_SIZE_OF (CHAR8, 1);
+VERIFY_SIZE_OF (CHAR16, 2);
+
+//
+// The following three enum types are used to verify that the compiler
+// configuration for enum types is compliant with Section 2.3.1 of the 
+// UEFI 2.3 Specification. These enum types and enum values are not 
+// intended to be used. A prefix of '__' is used avoid conflicts with
+// other types.
+//
+typedef enum {
+  __VerifyUint8EnumValue = 0xff
+} __VERIFY_UINT8_ENUM_SIZE;
+
+typedef enum {
+  __VerifyUint16EnumValue = 0xffff
+} __VERIFY_UINT16_ENUM_SIZE;
+
+typedef enum {
+  __VerifyUint32EnumValue = 0xffffffff
+} __VERIFY_UINT32_ENUM_SIZE;
+
+VERIFY_SIZE_OF (__VERIFY_UINT8_ENUM_SIZE, 4);
+VERIFY_SIZE_OF (__VERIFY_UINT16_ENUM_SIZE, 4);
+VERIFY_SIZE_OF (__VERIFY_UINT32_ENUM_SIZE, 4);
+
+//
+// The Microsoft* C compiler can removed references to unreferenced data items
+//  if the /OPT:REF linker option is used. We defined a macro as this is a
+//  a non standard extension
+//
+#if defined(_MSC_EXTENSIONS) && !defined (MDE_CPU_EBC)
+  ///
+  /// Remove global variable from the linked image if there are no references to
+  /// it after all compiler and linker optimizations have been performed.
+  ///
+  ///
+  #define GLOBAL_REMOVE_IF_UNREFERENCED __declspec(selectany)
+#else
+  ///
+  /// Remove the global variable from the linked image if there are no references
+  ///  to it after all compiler and linker optimizations have been performed.
+  ///
+  ///
+  #define GLOBAL_REMOVE_IF_UNREFERENCED
+#endif
+
+//
+// Should be used in combination with NORETURN to avoid 'noreturn' returns
+// warnings.
+//
+#ifndef UNREACHABLE
+  #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)
+    ///
+    /// Signal compilers and analyzers that this call is not reachable.  It is
+    /// up to the compiler to remove any code past that point.
+    /// Not implemented by GCC 4.4 or earlier.
+    ///
+    #define UNREACHABLE()  __builtin_unreachable ()
+  #elif defined (__has_feature)
+    #if __has_builtin (__builtin_unreachable)
+      ///
+      /// Signal compilers and analyzers that this call is not reachable.  It is
+      /// up to the compiler to remove any code past that point.
+      ///
+      #define UNREACHABLE()  __builtin_unreachable ()
+    #endif
+  #endif
+
+  #ifndef UNREACHABLE
+    ///
+    /// Signal compilers and analyzers that this call is not reachable.  It is
+    /// up to the compiler to remove any code past that point.
+    ///
+    #define UNREACHABLE()
+  #endif
+#endif
+
+//
+// Signaling compilers and analyzers that a certain function cannot return may
+// remove all following code and thus lead to better optimization and less
+// false positives.
+//
+#ifndef NORETURN
+  #if defined (__GNUC__) || defined (__clang__)
+    ///
+    /// Signal compilers and analyzers that the function cannot return.
+    /// It is up to the compiler to remove any code past a call to functions
+    /// flagged with this attribute.
+    ///
+    #define NORETURN  __attribute__((noreturn))
+  #elif defined(_MSC_EXTENSIONS) && !defined(MDE_CPU_EBC)
+    ///
+    /// Signal compilers and analyzers that the function cannot return.
+    /// It is up to the compiler to remove any code past a call to functions
+    /// flagged with this attribute.
+    ///
+    #define NORETURN  __declspec(noreturn)
+  #else
+    ///
+    /// Signal compilers and analyzers that the function cannot return.
+    /// It is up to the compiler to remove any code past a call to functions
+    /// flagged with this attribute.
+    ///
+    #define NORETURN
+  #endif
+#endif
+
+//
+// Should be used in combination with ANALYZER_NORETURN to avoid 'noreturn'
+// returns warnings.
+//
+#ifndef ANALYZER_UNREACHABLE
+  #ifdef __clang_analyzer__
+    #if __has_builtin (__builtin_unreachable)
+      ///
+      /// Signal the analyzer that this call is not reachable.
+      /// This excludes compilers.
+      ///
+      #define ANALYZER_UNREACHABLE()  __builtin_unreachable ()
+    #endif
+  #endif
+
+  #ifndef ANALYZER_UNREACHABLE
+    ///
+    /// Signal the analyzer that this call is not reachable.
+    /// This excludes compilers.
+    ///
+    #define ANALYZER_UNREACHABLE()
+  #endif
+#endif
+
+//
+// Static Analyzers may issue errors about potential NULL-dereferences when
+// dereferencing a pointer, that has been checked before, outside of a
+// NULL-check.  This may lead to false positives, such as when using ASSERT()
+// for verification.
+//
+#ifndef ANALYZER_NORETURN
+  #ifdef __has_feature
+    #if __has_feature (attribute_analyzer_noreturn)
+      ///
+      /// Signal analyzers that the function cannot return.
+      /// This excludes compilers.
+      ///
+      #define ANALYZER_NORETURN  __attribute__((analyzer_noreturn))
+    #endif
+  #endif
+
+  #ifndef ANALYZER_NORETURN
+    ///
+    /// Signal the analyzer that the function cannot return.
+    /// This excludes compilers.
+    ///
+    #define ANALYZER_NORETURN
+  #endif
+#endif
+
+//
+// For symbol name in assembly code, an extra "_" is sometimes necessary
+//
+
+///
+/// Private worker functions for ASM_PFX()
+///
+#define _CONCATENATE(a, b)  __CONCATENATE(a, b)
+#define __CONCATENATE(a, b) a ## b
+
+///
+/// The __USER_LABEL_PREFIX__ macro predefined by GNUC represents the prefix
+/// on symbols in assembly language.
+///
+#define ASM_PFX(name) _CONCATENATE (__USER_LABEL_PREFIX__, name)
+
+#if __APPLE__
+  //
+  // Apple extension that is used by the linker to optimize code size
+  // with assembly functions. Put at the end of your .S files
+  //
+  #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED  .subsections_via_symbols
+#else
+  #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED
+#endif
+
+#ifdef __CC_ARM
+  //
+  // Older RVCT ARM compilers don't fully support #pragma pack and require __packed
+  // as a prefix for the structure.
+  //
+  #define PACKED  __packed
+#else
+  #define PACKED
+#endif
+
+///
+/// 128 bit buffer containing a unique identifier value.
+/// Unless otherwise specified, aligned on a 64 bit boundary.
+///
+typedef struct {
+  UINT32  Data1;
+  UINT16  Data2;
+  UINT16  Data3;
+  UINT8   Data4[8];
+} GUID;
+
+///
+/// 4-byte buffer. An IPv4 internet protocol address.
+///
+typedef struct {
+  UINT8 Addr[4];
+} IPv4_ADDRESS;
+
+///
+/// 16-byte buffer. An IPv6 internet protocol address.
+///
+typedef struct {
+  UINT8 Addr[16];
+} IPv6_ADDRESS;
+
+//
+// 8-bytes unsigned value that represents a physical system address.
+//
+typedef UINT64 PHYSICAL_ADDRESS;
+
+///
+/// LIST_ENTRY structure definition.
+///
+typedef struct _LIST_ENTRY LIST_ENTRY;
+
+///
+/// _LIST_ENTRY structure definition.
+///
+struct _LIST_ENTRY {
+  LIST_ENTRY  *ForwardLink;
+  LIST_ENTRY  *BackLink;
+};
+
+//
+// Modifiers to abstract standard types to aid in debug of problems
+//
+
+///
+/// Datum is read-only.
+///
+#define CONST     const
+
+///
+/// Datum is scoped to the current file or function.
+///
+#define STATIC    static
+
+///
+/// Undeclared type.
+///
+#define VOID      void
+
+//
+// Modifiers for Data Types used to self document code.
+// This concept is borrowed for UEFI specification.
+//
+
+///
+/// Datum is passed to the function.
+///
+#define IN
+
+///
+/// Datum is returned from the function.
+///
+#define OUT
+
+///
+/// Passing the datum to the function is optional, and a NULL
+/// is passed if the value is not supplied.
+///
+#define OPTIONAL
+
+//
+//  UEFI specification claims 1 and 0. We are concerned about the
+//  compiler portability so we did it this way.
+//
+
+///
+/// Boolean true value.  UEFI Specification defines this value to be 1,
+/// but this form is more portable.
+///
+#define TRUE  ((BOOLEAN)(1==1))
+
+///
+/// Boolean false value.  UEFI Specification defines this value to be 0,
+/// but this form is more portable.
+///
+#define FALSE ((BOOLEAN)(0==1))
+
+///
+/// NULL pointer (VOID *)
+///
+#define NULL  ((VOID *) 0)
+
+//
+// Null character
+//
+#define CHAR_NULL             0x0000
+
+///
+/// Maximum values for common UEFI Data Types
+///
+#define MAX_INT8    ((INT8)0x7F)
+#define MAX_UINT8   ((UINT8)0xFF)
+#define MAX_INT16   ((INT16)0x7FFF)
+#define MAX_UINT16  ((UINT16)0xFFFF)
+#define MAX_INT32   ((INT32)0x7FFFFFFF)
+#define MAX_UINT32  ((UINT32)0xFFFFFFFF)
+#define MAX_INT64   ((INT64)0x7FFFFFFFFFFFFFFFULL)
+#define MAX_UINT64  ((UINT64)0xFFFFFFFFFFFFFFFFULL)
+
+#define  BIT0     0x00000001
+#define  BIT1     0x00000002
+#define  BIT2     0x00000004
+#define  BIT3     0x00000008
+#define  BIT4     0x00000010
+#define  BIT5     0x00000020
+#define  BIT6     0x00000040
+#define  BIT7     0x00000080
+#define  BIT8     0x00000100
+#define  BIT9     0x00000200
+#define  BIT10    0x00000400
+#define  BIT11    0x00000800
+#define  BIT12    0x00001000
+#define  BIT13    0x00002000
+#define  BIT14    0x00004000
+#define  BIT15    0x00008000
+#define  BIT16    0x00010000
+#define  BIT17    0x00020000
+#define  BIT18    0x00040000
+#define  BIT19    0x00080000
+#define  BIT20    0x00100000
+#define  BIT21    0x00200000
+#define  BIT22    0x00400000
+#define  BIT23    0x00800000
+#define  BIT24    0x01000000
+#define  BIT25    0x02000000
+#define  BIT26    0x04000000
+#define  BIT27    0x08000000
+#define  BIT28    0x10000000
+#define  BIT29    0x20000000
+#define  BIT30    0x40000000
+#define  BIT31    0x80000000
+#define  BIT32    0x0000000100000000ULL
+#define  BIT33    0x0000000200000000ULL
+#define  BIT34    0x0000000400000000ULL
+#define  BIT35    0x0000000800000000ULL
+#define  BIT36    0x0000001000000000ULL
+#define  BIT37    0x0000002000000000ULL
+#define  BIT38    0x0000004000000000ULL
+#define  BIT39    0x0000008000000000ULL
+#define  BIT40    0x0000010000000000ULL
+#define  BIT41    0x0000020000000000ULL
+#define  BIT42    0x0000040000000000ULL
+#define  BIT43    0x0000080000000000ULL
+#define  BIT44    0x0000100000000000ULL
+#define  BIT45    0x0000200000000000ULL
+#define  BIT46    0x0000400000000000ULL
+#define  BIT47    0x0000800000000000ULL
+#define  BIT48    0x0001000000000000ULL
+#define  BIT49    0x0002000000000000ULL
+#define  BIT50    0x0004000000000000ULL
+#define  BIT51    0x0008000000000000ULL
+#define  BIT52    0x0010000000000000ULL
+#define  BIT53    0x0020000000000000ULL
+#define  BIT54    0x0040000000000000ULL
+#define  BIT55    0x0080000000000000ULL
+#define  BIT56    0x0100000000000000ULL
+#define  BIT57    0x0200000000000000ULL
+#define  BIT58    0x0400000000000000ULL
+#define  BIT59    0x0800000000000000ULL
+#define  BIT60    0x1000000000000000ULL
+#define  BIT61    0x2000000000000000ULL
+#define  BIT62    0x4000000000000000ULL
+#define  BIT63    0x8000000000000000ULL
+
+#define  SIZE_1KB    0x00000400
+#define  SIZE_2KB    0x00000800
+#define  SIZE_4KB    0x00001000
+#define  SIZE_8KB    0x00002000
+#define  SIZE_16KB   0x00004000
+#define  SIZE_32KB   0x00008000
+#define  SIZE_64KB   0x00010000
+#define  SIZE_128KB  0x00020000
+#define  SIZE_256KB  0x00040000
+#define  SIZE_512KB  0x00080000
+#define  SIZE_1MB    0x00100000
+#define  SIZE_2MB    0x00200000
+#define  SIZE_4MB    0x00400000
+#define  SIZE_8MB    0x00800000
+#define  SIZE_16MB   0x01000000
+#define  SIZE_32MB   0x02000000
+#define  SIZE_64MB   0x04000000
+#define  SIZE_128MB  0x08000000
+#define  SIZE_256MB  0x10000000
+#define  SIZE_512MB  0x20000000
+#define  SIZE_1GB    0x40000000
+#define  SIZE_2GB    0x80000000
+#define  SIZE_4GB    0x0000000100000000ULL
+#define  SIZE_8GB    0x0000000200000000ULL
+#define  SIZE_16GB   0x0000000400000000ULL
+#define  SIZE_32GB   0x0000000800000000ULL
+#define  SIZE_64GB   0x0000001000000000ULL
+#define  SIZE_128GB  0x0000002000000000ULL
+#define  SIZE_256GB  0x0000004000000000ULL
+#define  SIZE_512GB  0x0000008000000000ULL
+#define  SIZE_1TB    0x0000010000000000ULL
+#define  SIZE_2TB    0x0000020000000000ULL
+#define  SIZE_4TB    0x0000040000000000ULL
+#define  SIZE_8TB    0x0000080000000000ULL
+#define  SIZE_16TB   0x0000100000000000ULL
+#define  SIZE_32TB   0x0000200000000000ULL
+#define  SIZE_64TB   0x0000400000000000ULL
+#define  SIZE_128TB  0x0000800000000000ULL
+#define  SIZE_256TB  0x0001000000000000ULL
+#define  SIZE_512TB  0x0002000000000000ULL
+#define  SIZE_1PB    0x0004000000000000ULL
+#define  SIZE_2PB    0x0008000000000000ULL
+#define  SIZE_4PB    0x0010000000000000ULL
+#define  SIZE_8PB    0x0020000000000000ULL
+#define  SIZE_16PB   0x0040000000000000ULL
+#define  SIZE_32PB   0x0080000000000000ULL
+#define  SIZE_64PB   0x0100000000000000ULL
+#define  SIZE_128PB  0x0200000000000000ULL
+#define  SIZE_256PB  0x0400000000000000ULL
+#define  SIZE_512PB  0x0800000000000000ULL
+#define  SIZE_1EB    0x1000000000000000ULL
+#define  SIZE_2EB    0x2000000000000000ULL
+#define  SIZE_4EB    0x4000000000000000ULL
+#define  SIZE_8EB    0x8000000000000000ULL
+
+#define  BASE_1KB    0x00000400
+#define  BASE_2KB    0x00000800
+#define  BASE_4KB    0x00001000
+#define  BASE_8KB    0x00002000
+#define  BASE_16KB   0x00004000
+#define  BASE_32KB   0x00008000
+#define  BASE_64KB   0x00010000
+#define  BASE_128KB  0x00020000
+#define  BASE_256KB  0x00040000
+#define  BASE_512KB  0x00080000
+#define  BASE_1MB    0x00100000
+#define  BASE_2MB    0x00200000
+#define  BASE_4MB    0x00400000
+#define  BASE_8MB    0x00800000
+#define  BASE_16MB   0x01000000
+#define  BASE_32MB   0x02000000
+#define  BASE_64MB   0x04000000
+#define  BASE_128MB  0x08000000
+#define  BASE_256MB  0x10000000
+#define  BASE_512MB  0x20000000
+#define  BASE_1GB    0x40000000
+#define  BASE_2GB    0x80000000
+#define  BASE_4GB    0x0000000100000000ULL
+#define  BASE_8GB    0x0000000200000000ULL
+#define  BASE_16GB   0x0000000400000000ULL
+#define  BASE_32GB   0x0000000800000000ULL
+#define  BASE_64GB   0x0000001000000000ULL
+#define  BASE_128GB  0x0000002000000000ULL
+#define  BASE_256GB  0x0000004000000000ULL
+#define  BASE_512GB  0x0000008000000000ULL
+#define  BASE_1TB    0x0000010000000000ULL
+#define  BASE_2TB    0x0000020000000000ULL
+#define  BASE_4TB    0x0000040000000000ULL
+#define  BASE_8TB    0x0000080000000000ULL
+#define  BASE_16TB   0x0000100000000000ULL
+#define  BASE_32TB   0x0000200000000000ULL
+#define  BASE_64TB   0x0000400000000000ULL
+#define  BASE_128TB  0x0000800000000000ULL
+#define  BASE_256TB  0x0001000000000000ULL
+#define  BASE_512TB  0x0002000000000000ULL
+#define  BASE_1PB    0x0004000000000000ULL
+#define  BASE_2PB    0x0008000000000000ULL
+#define  BASE_4PB    0x0010000000000000ULL
+#define  BASE_8PB    0x0020000000000000ULL
+#define  BASE_16PB   0x0040000000000000ULL
+#define  BASE_32PB   0x0080000000000000ULL
+#define  BASE_64PB   0x0100000000000000ULL
+#define  BASE_128PB  0x0200000000000000ULL
+#define  BASE_256PB  0x0400000000000000ULL
+#define  BASE_512PB  0x0800000000000000ULL
+#define  BASE_1EB    0x1000000000000000ULL
+#define  BASE_2EB    0x2000000000000000ULL
+#define  BASE_4EB    0x4000000000000000ULL
+#define  BASE_8EB    0x8000000000000000ULL
+
+//
+//  Support for variable length argument lists using the ANSI standard.
+//
+//  Since we are using the ANSI standard we used the standard naming and
+//  did not follow the coding convention
+//
+//  VA_LIST  - typedef for argument list.
+//  VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.
+//  VA_END (VA_LIST Marker) - Clear Marker
+//  VA_ARG (VA_LIST Marker, var arg size) - Use Marker to get an argument from
+//    the ... list. You must know the size and pass it in this macro.
+//  VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
+//
+//  example:
+//
+//  UINTN
+//  ExampleVarArg (
+//    IN UINTN  NumberOfArgs,
+//    ...
+//    )
+//  {
+//    VA_LIST Marker;
+//    UINTN   Index;
+//    UINTN   Result;
+//
+//    //
+//    // Initialize the Marker
+//    //
+//    VA_START (Marker, NumberOfArgs);
+//    for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {
+//      //
+//      // The ... list is a series of UINTN values, so average them up.
+//      //
+//      Result += VA_ARG (Marker, UINTN);
+//    }
+//
+//    VA_END (Marker);
+//    return Result
+//  }
+//
+
+/**
+  Return the size of argument that has been aligned to sizeof (UINTN).
+
+  @param  n    The parameter size to be aligned.
+
+  @return The aligned size.
+**/
+#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
+
+#if defined(__CC_ARM)
+//
+// RVCT ARM variable argument list support.
+//
+
+///
+/// Variable used to traverse the list of arguments. This type can vary by
+/// implementation and could be an array or structure.
+///
+#ifdef __APCS_ADSABI
+  typedef int         *va_list[1];
+  #define VA_LIST     va_list
+#else
+  typedef struct __va_list { void *__ap; } va_list;
+  #define VA_LIST                          va_list
+#endif
+
+#define VA_START(Marker, Parameter)   __va_start(Marker, Parameter)
+
+#define VA_ARG(Marker, TYPE)          __va_arg(Marker, TYPE)
+
+#define VA_END(Marker)                ((void)0)
+
+// For some ARM RVCT compilers, __va_copy is not defined
+#ifndef __va_copy
+  #define __va_copy(dest, src) ((void)((dest) = (src)))
+#endif
+
+#define VA_COPY(Dest, Start)          __va_copy (Dest, Start)
+
+#elif defined(__GNUC__)
+
+#if defined(MDE_CPU_X64) && !defined(NO_MSABI_VA_FUNCS)
+//
+// X64 only. Use MS ABI version of GCC built-in macros for variable argument lists.
+//
+///
+/// Both GCC and LLVM 3.8 for X64 support new variable argument intrinsics for Microsoft ABI
+///
+
+///
+/// Variable used to traverse the list of arguments. This type can vary by
+/// implementation and could be an array or structure.
+///
+typedef __builtin_ms_va_list VA_LIST;
+
+#define VA_START(Marker, Parameter)  __builtin_ms_va_start (Marker, Parameter)
+
+#define VA_ARG(Marker, TYPE)         ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
+
+#define VA_END(Marker)               __builtin_ms_va_end (Marker)
+
+#define VA_COPY(Dest, Start)         __builtin_ms_va_copy (Dest, Start)
+
+#else
+//
+// Use GCC built-in macros for variable argument lists.
+//
+
+///
+/// Variable used to traverse the list of arguments. This type can vary by
+/// implementation and could be an array or structure.
+///
+typedef __builtin_va_list VA_LIST;
+
+#define VA_START(Marker, Parameter)  __builtin_va_start (Marker, Parameter)
+
+#define VA_ARG(Marker, TYPE)         ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
+
+#define VA_END(Marker)               __builtin_va_end (Marker)
+
+#define VA_COPY(Dest, Start)         __builtin_va_copy (Dest, Start)
+
+#endif
+
+#else
+///
+/// Variable used to traverse the list of arguments. This type can vary by
+/// implementation and could be an array or structure.
+///
+typedef CHAR8 *VA_LIST;
+
+/**
+  Retrieves a pointer to the beginning of a variable argument list, based on
+  the name of the parameter that immediately precedes the variable argument list.
+
+  This function initializes Marker to point to the beginning of the variable
+  argument list that immediately follows Parameter.  The method for computing the
+  pointer to the next argument in the argument list is CPU-specific following the
+  EFIAPI ABI.
+
+  @param   Marker       The VA_LIST used to traverse the list of arguments.
+  @param   Parameter    The name of the parameter that immediately precedes
+                        the variable argument list.
+
+  @return  A pointer to the beginning of a variable argument list.
+
+**/
+#define VA_START(Marker, Parameter) (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))
+
+/**
+  Returns an argument of a specified type from a variable argument list and updates
+  the pointer to the variable argument list to point to the next argument.
+
+  This function returns an argument of the type specified by TYPE from the beginning
+  of the variable argument list specified by Marker.  Marker is then updated to point
+  to the next argument in the variable argument list.  The method for computing the
+  pointer to the next argument in the argument list is CPU-specific following the EFIAPI ABI.
+
+  @param   Marker   VA_LIST used to traverse the list of arguments.
+  @param   TYPE     The type of argument to retrieve from the beginning
+                    of the variable argument list.
+
+  @return  An argument of the type specified by TYPE.
+
+**/
+#define VA_ARG(Marker, TYPE)   (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))
+
+/**
+  Terminates the use of a variable argument list.
+
+  This function initializes Marker so it can no longer be used with VA_ARG().
+  After this macro is used, the only way to access the variable argument list is
+  by using VA_START() again.
+
+  @param   Marker   VA_LIST used to traverse the list of arguments.
+
+**/
+#define VA_END(Marker)      (Marker = (VA_LIST) 0)
+
+/**
+  Initializes a VA_LIST as a copy of an existing VA_LIST.
+
+  This macro initializes Dest as a copy of Start, as if the VA_START macro had been applied to Dest
+  followed by the same sequence of uses of the VA_ARG macro as had previously been used to reach
+  the present state of Start. 
+
+  @param   Dest   VA_LIST used to traverse the list of arguments.
+  @param   Start  VA_LIST used to traverse the list of arguments.
+
+**/
+#define VA_COPY(Dest, Start)  ((void)((Dest) = (Start)))
+
+#endif
+
+///
+/// Pointer to the start of a variable argument list stored in a memory buffer. Same as UINT8 *.
+///
+typedef UINTN  *BASE_LIST;
+
+/**
+  Returns the size of a data type in sizeof(UINTN) units rounded up to the nearest UINTN boundary.
+
+  @param  TYPE  The date type to determine the size of.
+
+  @return The size of TYPE in sizeof (UINTN) units rounded up to the nearest UINTN boundary.
+**/
+#define _BASE_INT_SIZE_OF(TYPE) ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))
+
+/**
+  Returns an argument of a specified type from a variable argument list and updates
+  the pointer to the variable argument list to point to the next argument.
+
+  This function returns an argument of the type specified by TYPE from the beginning
+  of the variable argument list specified by Marker.  Marker is then updated to point
+  to the next argument in the variable argument list.  The method for computing the
+  pointer to the next argument in the argument list is CPU specific following the EFIAPI ABI.
+
+  @param   Marker   The pointer to the beginning of a variable argument list.
+  @param   TYPE     The type of argument to retrieve from the beginning
+                    of the variable argument list.
+
+  @return  An argument of the type specified by TYPE.
+
+**/
+#define BASE_ARG(Marker, TYPE)   (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))
+
+/**
+  The macro that returns the byte offset of a field in a data structure.
+
+  This function returns the offset, in bytes, of field specified by Field from the
+  beginning of the  data structure specified by TYPE. If TYPE does not contain Field,
+  the module will not compile.
+
+  @param   TYPE     The name of the data structure that contains the field specified by Field.
+  @param   Field    The name of the field in the data structure.
+
+  @return  Offset, in bytes, of field.
+
+**/
+#ifdef __GNUC__
+#if __GNUC__ >= 4
+#define OFFSET_OF(TYPE, Field) ((UINTN) __builtin_offsetof(TYPE, Field))
+#endif
+#endif
+
+#ifndef OFFSET_OF
+#define OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field))
+#endif
+
+/**
+  Macro that returns a pointer to the data structure that contains a specified field of
+  that data structure.  This is a lightweight method to hide information by placing a
+  public data structure inside a larger private data structure and using a pointer to
+  the public data structure to retrieve a pointer to the private data structure.
+
+  This function computes the offset, in bytes, of field specified by Field from the beginning
+  of the  data structure specified by TYPE.  This offset is subtracted from Record, and is
+  used to return a pointer to a data structure of the type specified by TYPE. If the data type
+  specified by TYPE does not contain the field specified by Field, then the module will not compile.
+
+  @param   Record   Pointer to the field specified by Field within a data structure of type TYPE.
+  @param   TYPE     The name of the data structure type to return.  This data structure must
+                    contain the field specified by Field.
+  @param   Field    The name of the field in the data structure specified by TYPE to which Record points.
+
+  @return  A pointer to the structure from one of it's elements.
+
+**/
+#define BASE_CR(Record, TYPE, Field)  ((TYPE *) ((CHAR8 *) (Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))
+
+/**
+  Rounds a value up to the next boundary using a specified alignment.
+
+  This function rounds Value up to the next boundary using the specified Alignment.
+  This aligned value is returned.
+
+  @param   Value      The value to round up.
+  @param   Alignment  The alignment boundary used to return the aligned value.
+
+  @return  A value up to the next boundary.
+
+**/
+#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
+
+/**
+  Adjust a pointer by adding the minimum offset required for it to be aligned on
+  a specified alignment boundary.
+
+  This function rounds the pointer specified by Pointer to the next alignment boundary
+  specified by Alignment. The pointer to the aligned address is returned.
+
+  @param   Pointer    The pointer to round up.
+  @param   Alignment  The alignment boundary to use to return an aligned pointer.
+
+  @return  Pointer to the aligned address.
+
+**/
+#define ALIGN_POINTER(Pointer, Alignment) ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))
+
+/**
+  Rounds a value up to the next natural boundary for the current CPU.
+  This is 4-bytes for 32-bit CPUs and 8-bytes for 64-bit CPUs.
+
+  This function rounds the value specified by Value up to the next natural boundary for the
+  current CPU. This rounded value is returned.
+
+  @param   Value      The value to round up.
+
+  @return  Rounded value specified by Value.
+
+**/
+#define ALIGN_VARIABLE(Value)  ALIGN_VALUE ((Value), sizeof (UINTN))
+
+
+/**
+  Return the maximum of two operands.
+
+  This macro returns the maximum of two operand specified by a and b.
+  Both a and b must be the same numerical types, signed or unsigned.
+
+  @param   a        The first operand with any numerical type.
+  @param   b        The second operand. Can be any numerical type as long as is
+                    the same type as a.
+
+  @return  Maximum of two operands.
+
+**/
+#define MAX(a, b)                       \
+  (((a) > (b)) ? (a) : (b))
+
+/**
+  Return the minimum of two operands.
+
+  This macro returns the minimal of two operand specified by a and b.
+  Both a and b must be the same numerical types, signed or unsigned.
+
+  @param   a        The first operand with any numerical type.
+  @param   b        The second operand. It should be the same any numerical type with a.
+
+  @return  Minimum of two operands.
+
+**/
+#define MIN(a, b)                       \
+  (((a) < (b)) ? (a) : (b))
+
+/**
+  Return the absolute value of a signed operand.
+
+  This macro returns the absolute value of the signed operand specified by a.
+
+  @param   a        The signed operand.
+
+  @return  The absolute value of the signed operand.
+
+**/
+#define ABS(a)                          \
+  (((a) < 0) ? (-(a)) : (a))
+
+//
+// Status codes common to all execution phases
+//
+typedef UINTN RETURN_STATUS;
+
+/**
+  Produces a RETURN_STATUS code with the highest bit set.
+
+  @param  StatusCode    The status code value to convert into a warning code.
+                        StatusCode must be in the range 0x00000000..0x7FFFFFFF.
+
+  @return The value specified by StatusCode with the highest bit set.
+
+**/
+#define ENCODE_ERROR(StatusCode)     ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
+
+/**
+  Produces a RETURN_STATUS code with the highest bit clear.
+
+  @param  StatusCode    The status code value to convert into a warning code.
+                        StatusCode must be in the range 0x00000000..0x7FFFFFFF.
+
+  @return The value specified by StatusCode with the highest bit clear.
+
+**/
+#define ENCODE_WARNING(StatusCode)   ((RETURN_STATUS)(StatusCode))
+
+/**
+  Returns TRUE if a specified RETURN_STATUS code is an error code.
+
+  This function returns TRUE if StatusCode has the high bit set.  Otherwise, FALSE is returned.
+
+  @param  StatusCode    The status code value to evaluate.
+
+  @retval TRUE          The high bit of StatusCode is set.
+  @retval FALSE         The high bit of StatusCode is clear.
+
+**/
+#define RETURN_ERROR(StatusCode)     (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
+
+///
+/// The operation completed successfully.
+///
+#define RETURN_SUCCESS               0
+
+///
+/// The image failed to load.
+///
+#define RETURN_LOAD_ERROR            ENCODE_ERROR (1)
+
+///
+/// The parameter was incorrect.
+///
+#define RETURN_INVALID_PARAMETER     ENCODE_ERROR (2)
+
+///
+/// The operation is not supported.
+///
+#define RETURN_UNSUPPORTED           ENCODE_ERROR (3)
+
+///
+/// The buffer was not the proper size for the request.
+///
+#define RETURN_BAD_BUFFER_SIZE       ENCODE_ERROR (4)
+
+///
+/// The buffer was not large enough to hold the requested data.
+/// The required buffer size is returned in the appropriate
+/// parameter when this error occurs.
+///
+#define RETURN_BUFFER_TOO_SMALL      ENCODE_ERROR (5)
+
+///
+/// There is no data pending upon return.
+///
+#define RETURN_NOT_READY             ENCODE_ERROR (6)
+
+///
+/// The physical device reported an error while attempting the
+/// operation.
+///
+#define RETURN_DEVICE_ERROR          ENCODE_ERROR (7)
+
+///
+/// The device can not be written to.
+///
+#define RETURN_WRITE_PROTECTED       ENCODE_ERROR (8)
+
+///
+/// The resource has run out.
+///
+#define RETURN_OUT_OF_RESOURCES      ENCODE_ERROR (9)
+
+///
+/// An inconsistency was detected on the file system causing the
+/// operation to fail.
+///
+#define RETURN_VOLUME_CORRUPTED      ENCODE_ERROR (10)
+
+///
+/// There is no more space on the file system.
+///
+#define RETURN_VOLUME_FULL           ENCODE_ERROR (11)
+
+///
+/// The device does not contain any medium to perform the
+/// operation.
+///
+#define RETURN_NO_MEDIA              ENCODE_ERROR (12)
+
+///
+/// The medium in the device has changed since the last
+/// access.
+///
+#define RETURN_MEDIA_CHANGED         ENCODE_ERROR (13)
+
+///
+/// The item was not found.
+///
+#define RETURN_NOT_FOUND             ENCODE_ERROR (14)
+
+///
+/// Access was denied.
+///
+#define RETURN_ACCESS_DENIED         ENCODE_ERROR (15)
+
+///
+/// The server was not found or did not respond to the request.
+///
+#define RETURN_NO_RESPONSE           ENCODE_ERROR (16)
+
+///
+/// A mapping to the device does not exist.
+///
+#define RETURN_NO_MAPPING            ENCODE_ERROR (17)
+
+///
+/// A timeout time expired.
+///
+#define RETURN_TIMEOUT               ENCODE_ERROR (18)
+
+///
+/// The protocol has not been started.
+///
+#define RETURN_NOT_STARTED           ENCODE_ERROR (19)
+
+///
+/// The protocol has already been started.
+///
+#define RETURN_ALREADY_STARTED       ENCODE_ERROR (20)
+
+///
+/// The operation was aborted.
+///
+#define RETURN_ABORTED               ENCODE_ERROR (21)
+
+///
+/// An ICMP error occurred during the network operation.
+///
+#define RETURN_ICMP_ERROR            ENCODE_ERROR (22)
+
+///
+/// A TFTP error occurred during the network operation.
+///
+#define RETURN_TFTP_ERROR            ENCODE_ERROR (23)
+
+///
+/// A protocol error occurred during the network operation.
+///
+#define RETURN_PROTOCOL_ERROR        ENCODE_ERROR (24)
+
+///
+/// A function encountered an internal version that was
+/// incompatible with a version requested by the caller.
+///
+#define RETURN_INCOMPATIBLE_VERSION  ENCODE_ERROR (25)
+
+///
+/// The function was not performed due to a security violation.
+///
+#define RETURN_SECURITY_VIOLATION    ENCODE_ERROR (26)
+
+///
+/// A CRC error was detected.
+///
+#define RETURN_CRC_ERROR             ENCODE_ERROR (27)
+
+///
+/// The beginning or end of media was reached.
+///
+#define RETURN_END_OF_MEDIA          ENCODE_ERROR (28)
+
+///
+/// The end of the file was reached.
+///
+#define RETURN_END_OF_FILE           ENCODE_ERROR (31)
+
+///
+/// The language specified was invalid.
+///
+#define RETURN_INVALID_LANGUAGE      ENCODE_ERROR (32)
+
+///
+/// The security status of the data is unknown or compromised
+/// and the data must be updated or replaced to restore a valid
+/// security status.
+///
+#define RETURN_COMPROMISED_DATA      ENCODE_ERROR (33)
+
+///
+/// A HTTP error occurred during the network operation.
+///
+#define RETURN_HTTP_ERROR            ENCODE_ERROR (35)
+
+///
+/// The string contained one or more characters that
+/// the device could not render and were skipped.
+///
+#define RETURN_WARN_UNKNOWN_GLYPH    ENCODE_WARNING (1)
+
+///
+/// The handle was closed, but the file was not deleted.
+///
+#define RETURN_WARN_DELETE_FAILURE   ENCODE_WARNING (2)
+
+///
+/// The handle was closed, but the data to the file was not
+/// flushed properly.
+///
+#define RETURN_WARN_WRITE_FAILURE    ENCODE_WARNING (3)
+
+///
+/// The resulting buffer was too small, and the data was
+/// truncated to the buffer size.
+///
+#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4)
+
+///
+/// The data has not been updated within the timeframe set by
+/// local policy for this type of data.
+///
+#define RETURN_WARN_STALE_DATA       ENCODE_WARNING (5)
+
+///
+/// The resulting buffer contains UEFI-compliant file system.
+///
+#define RETURN_WARN_FILE_SYSTEM      ENCODE_WARNING (6)
+
+
+/**
+  Returns a 16-bit signature built from 2 ASCII characters.
+
+  This macro returns a 16-bit value built from the two ASCII characters specified
+  by A and B.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+
+  @return A 16-bit value built from the two ASCII characters specified by A and B.
+
+**/
+#define SIGNATURE_16(A, B)        ((A) | (B << 8))
+
+/**
+  Returns a 32-bit signature built from 4 ASCII characters.
+
+  This macro returns a 32-bit value built from the four ASCII characters specified
+  by A, B, C, and D.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+  @param  C    The third ASCII character.
+  @param  D    The fourth ASCII character.
+
+  @return A 32-bit value built from the two ASCII characters specified by A, B,
+          C and D.
+
+**/
+#define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
+
+/**
+  Returns a 64-bit signature built from 8 ASCII characters.
+
+  This macro returns a 64-bit value built from the eight ASCII characters specified
+  by A, B, C, D, E, F, G,and H.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+  @param  C    The third ASCII character.
+  @param  D    The fourth ASCII character.
+  @param  E    The fifth ASCII character.
+  @param  F    The sixth ASCII character.
+  @param  G    The seventh ASCII character.
+  @param  H    The eighth ASCII character.
+
+  @return A 64-bit value built from the two ASCII characters specified by A, B,
+          C, D, E, F, G and H.
+
+**/
+#define SIGNATURE_64(A, B, C, D, E, F, G, H) \
+    (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
+
+#if defined(_MSC_EXTENSIONS) && !defined (__INTEL_COMPILER) && !defined (MDE_CPU_EBC)
+  #pragma intrinsic(_ReturnAddress)
+  /**
+    Get the return address of the calling function.
+
+    Based on intrinsic function _ReturnAddress that provides the address of
+    the instruction in the calling function that will be executed after
+    control returns to the caller.
+
+    @param L    Return Level.
+
+    @return The return address of the calling function or 0 if L != 0.
+
+  **/
+  #define RETURN_ADDRESS(L)     ((L == 0) ? _ReturnAddress() : (VOID *) 0)
+#elif defined(__GNUC__)
+  void * __builtin_return_address (unsigned int level);
+  /**
+    Get the return address of the calling function.
+
+    Based on built-in Function __builtin_return_address that returns
+    the return address of the current function, or of one of its callers.
+
+    @param L    Return Level.
+
+    @return The return address of the calling function.
+
+  **/
+  #define RETURN_ADDRESS(L)     __builtin_return_address (L)
+#else
+  /**
+    Get the return address of the calling function.
+
+    @param L    Return Level.
+
+    @return 0 as compilers don't support this feature.
+
+  **/
+  #define RETURN_ADDRESS(L)     ((VOID *) 0)
+#endif
+
+/**
+  Return the number of elements in an array.
+
+  @param  Array  An object of array type. Array is only used as an argument to
+                 the sizeof operator, therefore Array is never evaluated. The
+                 caller is responsible for ensuring that Array's type is not
+                 incomplete; that is, Array must have known constant size.
+
+  @return The number of elements in Array. The result has type UINTN.
+
+**/
+#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0]))
+
+#endif
+
diff --git a/MdePkg/Include/Ebc/ProcessorBind.h b/MdePkg/Include/Ebc/ProcessorBind.h
new file mode 100644
index 000000000000..ca46b80561ab
--- /dev/null
+++ b/MdePkg/Include/Ebc/ProcessorBind.h
@@ -0,0 +1,152 @@
+/** @file
+  Processor or compiler specific defines and types for EBC.
+
+  We currently only have one EBC compiler so there may be some Intel compiler
+  specific functions in this file.
+
+Copyright (c) 2006 - 2013, 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices
+///
+#define MDE_CPU_EBC
+
+//
+// Native integer types
+//
+
+///
+/// 1-byte signed value
+///
+typedef signed char           INT8;
+///
+/// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+/// values are undefined.
+///
+typedef unsigned char         BOOLEAN;
+///
+/// 1-byte unsigned value.
+///
+typedef unsigned char         UINT8;
+///
+/// 1-byte Character.
+///
+typedef char                  CHAR8;
+///
+/// 2-byte signed value.
+///
+typedef short                 INT16;
+///
+/// 2-byte unsigned value.
+///
+typedef unsigned short        UINT16;
+///
+/// 2-byte Character.  Unless otherwise specified all strings are stored in the
+/// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+///
+typedef unsigned short        CHAR16;
+///
+/// 4-byte signed value.
+///
+typedef int                   INT32;
+///
+/// 4-byte unsigned value.
+///
+typedef unsigned int          UINT32;
+///
+/// 8-byte signed value.
+///
+typedef __int64               INT64;
+///
+/// 8-byte unsigned value.
+///
+typedef unsigned __int64      UINT64;
+
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+/// "long" type scales to the processor native size with EBC compiler
+///
+typedef long                  INTN;
+///
+/// The unsigned value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions)
+/// "long" type scales to the processor native size with the EBC compiler.
+///
+typedef unsigned long         UINTN;
+
+///
+/// A value of native width with the highest bit set.
+/// Scalable macro to set the most significant bit in a natural number.
+///
+#define MAX_BIT     (1ULL << (sizeof (INTN) * 8 - 1)) 
+///
+/// A value of native width with the two highest bits set.
+/// Scalable macro to set the most 2 significant bits in a natural number.
+///
+#define MAX_2_BITS  (3ULL << (sizeof (INTN) * 8 - 2))
+
+///
+/// Maximum legal EBC address
+///
+#define MAX_ADDRESS   ((UINTN) ~0)
+
+///
+/// Maximum legal EBC INTN and UINTN values.
+///
+#define MAX_UINTN  ((UINTN) ~0)
+#define MAX_INTN   ((INTN)~MAX_BIT)
+
+///
+/// The stack alignment required for EBC
+///
+#define CPU_STACK_ALIGNMENT   sizeof(UINTN)
+
+///
+/// Page allocation granularity for EBC
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+
+///
+/// Modifier to ensure that all protocol member functions and EFI intrinsics
+/// use the correct C calling convention. All protocol member functions and
+/// EFI intrinsics are required to modify their member functions with EFIAPI.
+///
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#else
+#define EFIAPI    
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On EBC architectures, these two pointer values are the same, 
+  so the implementation of this macro is very simple.
+  
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#endif 
+
diff --git a/MdePkg/Include/Guid/Acpi.h b/MdePkg/Include/Guid/Acpi.h
new file mode 100644
index 000000000000..3897ae62ff30
--- /dev/null
+++ b/MdePkg/Include/Guid/Acpi.h
@@ -0,0 +1,46 @@
+/** @file
+  GUIDs used for ACPI entries in the EFI system table
+
+  These GUIDs point the ACPI tables as defined in the ACPI specifications.
+  ACPI 2.0 specification defines the ACPI 2.0 GUID. UEFI 2.0 defines the 
+  ACPI 2.0 Table GUID and ACPI Table GUID.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __ACPI_GUID_H__
+#define __ACPI_GUID_H__
+
+#define ACPI_TABLE_GUID \
+  { \
+    0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_ACPI_TABLE_GUID \
+  { \
+    0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+
+#define ACPI_10_TABLE_GUID     ACPI_TABLE_GUID
+
+//
+// ACPI 2.0 or newer tables should use EFI_ACPI_TABLE_GUID.
+//
+#define EFI_ACPI_20_TABLE_GUID EFI_ACPI_TABLE_GUID
+
+extern EFI_GUID gEfiAcpiTableGuid;
+extern EFI_GUID gEfiAcpi10TableGuid;
+extern EFI_GUID gEfiAcpi20TableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/Apriori.h b/MdePkg/Include/Guid/Apriori.h
new file mode 100644
index 000000000000..6d4fc74d406b
--- /dev/null
+++ b/MdePkg/Include/Guid/Apriori.h
@@ -0,0 +1,30 @@
+/** @file
+  GUID used as an FV filename for A Priori file. The A Priori file contains a
+  list of FV filenames that the DXE dispatcher will schedule reguardless of
+  the dependency grammar.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.0.
+
+**/
+
+#ifndef __APRIORI_GUID_H__
+#define __APRIORI_GUID_H__
+
+#define EFI_APRIORI_GUID \
+  { \
+    0xfc510ee7, 0xffdc, 0x11d4, {0xbd, 0x41, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+
+extern EFI_GUID gAprioriGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/AprioriFileName.h b/MdePkg/Include/Guid/AprioriFileName.h
new file mode 100644
index 000000000000..d99893887d1b
--- /dev/null
+++ b/MdePkg/Include/Guid/AprioriFileName.h
@@ -0,0 +1,44 @@
+/** @file
+  The GUID PEI_APRIORI_FILE_NAME_GUID definition is the file
+  name of the PEI a priori file that is stored in a firmware
+  volume.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.0.
+
+**/
+
+#ifndef __PEI_APRIORI_FILE_NAME_H__
+#define __PEI_APRIORI_FILE_NAME_H__
+
+#define PEI_APRIORI_FILE_NAME_GUID \
+  { 0x1b45cc0a, 0x156a, 0x428a, { 0x62, 0XAF, 0x49, 0x86, 0x4d, 0xa0, 0xe6, 0xe6 } }
+
+
+///   
+///  This file must be of type EFI_FV_FILETYPE_FREEFORM and must
+///  contain a single section of type EFI_SECTION_RAW. For details on
+///  firmware volumes, firmware file types, and firmware file section
+///  types.
+///
+typedef struct {
+  ///
+  /// An array of zero or more EFI_GUID type entries that match the file names of PEIM
+  /// modules in the same Firmware Volume. The maximum number of entries. 
+  ///
+  EFI_GUID  FileNamesWithinVolume[1];
+} PEI_APRIORI_FILE_CONTENTS;
+
+extern EFI_GUID gPeiAprioriFileNameGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Guid/CapsuleReport.h b/MdePkg/Include/Guid/CapsuleReport.h
new file mode 100644
index 000000000000..051a41bde9f3
--- /dev/null
+++ b/MdePkg/Include/Guid/CapsuleReport.h
@@ -0,0 +1,105 @@
+/** @file
+  Guid & data structure used for Capsule process result variables
+  
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.4 spec.
+
+**/
+
+
+#ifndef _CAPSULE_REPORT_GUID_H__
+#define _CAPSULE_REPORT_GUID_H__
+
+//
+// This is the GUID for capsule result variable.
+//
+#define EFI_CAPSULE_REPORT_GUID \
+  { \
+    0x39b68c46, 0xf7fb, 0x441b, {0xb6, 0xec, 0x16, 0xb0, 0xf6, 0x98, 0x21, 0xf3 } \
+  }
+
+
+typedef struct {
+
+  ///
+  /// Size in bytes of the variable including any data beyond header as specified by CapsuleGuid
+  ///
+  UINT32     VariableTotalSize;
+
+  ///
+  /// For alignment
+  ///
+  UINT32     Reserved;
+
+  ///
+  /// Guid from EFI_CAPSULE_HEADER
+  ///
+  EFI_GUID   CapsuleGuid;
+
+  ///
+  /// Timestamp using system time when processing completed
+  ///
+  EFI_TIME   CapsuleProcessed;
+
+  ///
+  /// Result of the capsule processing. Exact interpretation of any error code may depend
+  /// upon type of capsule processed
+  ///
+  EFI_STATUS CapsuleStatus;
+} EFI_CAPSULE_RESULT_VARIABLE_HEADER;
+
+
+typedef struct {
+
+  ///
+  /// Version of this structure, currently 0x00000001
+  ///
+  UINT16   Version;
+
+  ///
+  /// The index of the payload within the FMP capsule which was processed to generate this report
+  /// Starting from zero
+  ///
+  UINT8    PayloadIndex;
+
+  ///
+  /// The UpdateImageIndex from EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER
+  /// (after unsigned conversion from UINT8 to UINT16).
+  ///
+  UINT8    UpdateImageIndex;
+
+  ///
+  /// The UpdateImageTypeId Guid from EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.
+  ///
+  EFI_GUID UpdateImageTypeId;
+
+  ///
+  /// In case of capsule loaded from disk, the zero-terminated array containing file name of capsule that was processed.
+  /// In case of capsule submitted directly to UpdateCapsule() there is no file name, and this field is required to contain a single 16-bit zero character 
+  ///  which is included in VariableTotalSize.
+  ///
+  /// CHAR16 CapsuleFileName[];
+  ///
+
+  ///
+  /// This field will contain a zero-terminated CHAR16 string containing the text representation of the device path of device publishing Firmware Management Protocol  
+  /// (if present). In case where device path is not present and the target is not otherwise known to firmware, or when payload was blocked by policy, or skipped,
+  /// this field is required to contain a single 16-bit zero character which is included in VariableTotalSize.
+  ///
+  /// CHAR16 CapsuleTarget[];
+  ///
+} EFI_CAPSULE_RESULT_VARIABLE_FMP;
+
+
+extern EFI_GUID gEfiCapsuleReportGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/Cper.h b/MdePkg/Include/Guid/Cper.h
new file mode 100644
index 000000000000..f6f5bc2df8fb
--- /dev/null
+++ b/MdePkg/Include/Guid/Cper.h
@@ -0,0 +1,1235 @@
+/** @file
+  GUIDs and definitions used for Common Platform Error Record.
+
+  Copyright (c) 2011 - 2016, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.6 Specification.
+
+**/
+
+#ifndef __CPER_GUID_H__
+#define __CPER_GUID_H__
+
+#pragma pack(1)
+
+#define EFI_ERROR_RECORD_SIGNATURE_START   SIGNATURE_32('C', 'P', 'E', 'R')
+#define EFI_ERROR_RECORD_SIGNATURE_END     0xFFFFFFFF
+
+#define EFI_ERROR_RECORD_REVISION          0x0101
+
+///
+/// Error Severity in Error Record Header and Error Section Descriptor
+///@{
+#define EFI_GENERIC_ERROR_RECOVERABLE                0x00000000
+#define EFI_GENERIC_ERROR_FATAL                      0x00000001
+#define EFI_GENERIC_ERROR_CORRECTED                  0x00000002
+#define EFI_GENERIC_ERROR_INFO                       0x00000003
+///@}
+
+///
+/// The validation bit mask indicates the validity of the following fields
+/// in Error Record Header.
+///@{
+#define EFI_ERROR_RECORD_HEADER_PLATFORM_ID_VALID    BIT0
+#define EFI_ERROR_RECORD_HEADER_TIME_STAMP_VALID     BIT1
+#define EFI_ERROR_RECORD_HEADER_PARTITION_ID_VALID   BIT2
+///@}
+
+///
+/// Timestamp is precise if this bit is set and correlates to the time of the
+/// error event.
+///
+#define EFI_ERROR_TIME_STAMP_PRECISE                 BIT0
+
+///
+/// The timestamp correlates to the time when the error information was collected
+/// by the system software and may not necessarily represent the time of the error
+/// event. The timestamp contains the local time in BCD format.
+///
+typedef struct {
+  UINT8              Seconds;
+  UINT8              Minutes;
+  UINT8              Hours;
+  UINT8              Flag;
+  UINT8              Day;
+  UINT8              Month;
+  UINT8              Year;
+  UINT8              Century;
+} EFI_ERROR_TIME_STAMP;
+
+///
+/// GUID value indicating the record association with an error event notification type.
+///@{
+#define EFI_EVENT_NOTIFICATION_TYEP_CMC_GUID \
+  { \
+    0x2DCE8BB1, 0xBDD7, 0x450e, { 0xB9, 0xAD, 0x9C, 0xF4, 0xEB, 0xD4, 0xF8, 0x90 } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_CPE_GUID \
+  { \
+    0x4E292F96, 0xD843, 0x4a55, { 0xA8, 0xC2, 0xD4, 0x81, 0xF2, 0x7E, 0xBE, 0xEE } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_MCE_GUID \
+  { \
+    0xE8F56FFE, 0x919C, 0x4cc5, { 0xBA, 0x88, 0x65, 0xAB, 0xE1, 0x49, 0x13, 0xBB } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_PCIE_GUID \
+  { \
+    0xCF93C01F, 0x1A16, 0x4dfc, { 0xB8, 0xBC, 0x9C, 0x4D, 0xAF, 0x67, 0xC1, 0x04 } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_INIT_GUID \
+  { \
+    0xCC5263E8, 0x9308, 0x454a, { 0x89, 0xD0, 0x34, 0x0B, 0xD3, 0x9B, 0xC9, 0x8E } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_NMI_GUID \
+  { \
+    0x5BAD89FF, 0xB7E6, 0x42c9, { 0x81, 0x4A, 0xCF, 0x24, 0x85, 0xD6, 0xE9, 0x8A } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_BOOT_GUID \
+  { \
+    0x3D61A466, 0xAB40, 0x409a, { 0xA6, 0x98, 0xF3, 0x62, 0xD4, 0x64, 0xB3, 0x8F } \
+  }
+#define EFI_EVENT_NOTIFICATION_TYEP_DMAR_GUID \
+  { \
+    0x667DD791, 0xC6B3, 0x4c27, { 0x8A, 0x6B, 0x0F, 0x8E, 0x72, 0x2D, 0xEB, 0x41 } \
+  }
+///@}
+
+///
+/// Error Record Header Flags
+///@{
+#define EFI_HW_ERROR_FLAGS_RECOVERED                 0x00000001
+#define EFI_HW_ERROR_FLAGS_PREVERR                   0x00000002
+#define EFI_HW_ERROR_FLAGS_SIMULATED                 0x00000004
+///@}
+
+///
+/// Common error record header
+///
+typedef struct {
+  UINT32               SignatureStart;
+  UINT16               Revision;
+  UINT32               SignatureEnd;
+  UINT16               SectionCount;
+  UINT32               ErrorSeverity;
+  UINT32               ValidationBits;
+  UINT32               RecordLength;
+  EFI_ERROR_TIME_STAMP TimeStamp;
+  EFI_GUID             PlatformID;
+  EFI_GUID             PartitionID;
+  EFI_GUID             CreatorID;
+  EFI_GUID             NotificationType;
+  UINT64               RecordID;
+  UINT32               Flags;
+  UINT64               PersistenceInfo;
+  UINT8                Resv1[12];
+  ///
+  /// An array of SectionCount descriptors for the associated
+  /// sections. The number of valid sections is equivalent to the
+  /// SectionCount. The buffer size of the record may include
+  /// more space to dynamically add additional Section
+  /// Descriptors to the error record.
+  ///
+} EFI_COMMON_ERROR_RECORD_HEADER;
+
+#define EFI_ERROR_SECTION_REVISION  0x0100
+
+///
+/// Validity Fields in Error Section Descriptor.
+///
+#define EFI_ERROR_SECTION_FRU_ID_VALID               BIT0
+#define EFI_ERROR_SECTION_FRU_STRING_VALID           BIT1
+
+///
+/// Flag field contains information that describes the error section
+/// in Error Section Descriptor.
+///
+#define EFI_ERROR_SECTION_FLAGS_PRIMARY                        BIT0
+#define EFI_ERROR_SECTION_FLAGS_CONTAINMENT_WARNING            BIT1
+#define EFI_ERROR_SECTION_FLAGS_RESET                          BIT2
+#define EFI_ERROR_SECTION_FLAGS_ERROR_THRESHOLD_EXCEEDED       BIT3
+#define EFI_ERROR_SECTION_FLAGS_RESOURCE_NOT_ACCESSIBLE        BIT4
+#define EFI_ERROR_SECTION_FLAGS_LATENT_ERROR                   BIT5
+
+///
+/// Error Sectition Type GUIDs in Error Section Descriptor
+///@{
+#define EFI_ERROR_SECTION_PROCESSOR_GENERIC_GUID \
+  { \
+    0x9876ccad, 0x47b4, 0x4bdb, { 0xb6, 0x5e, 0x16, 0xf1, 0x93, 0xc4, 0xf3, 0xdb } \
+  }
+#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_GUID \
+  { \
+    0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d } \
+  }
+#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_IA32X64_GUID \
+  { \
+    0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d } \
+  }
+#define EFI_ERROR_SECTION_PROCESSOR_SPECIFIC_ARM_GUID \
+  { \
+    0xe19e3d16, 0xbc11, 0x11e4, { 0x9c, 0xaa, 0xc2, 0x05, 0x1d, 0x5d, 0x46, 0xb0 } \
+  }
+#define EFI_ERROR_SECTION_PLATFORM_MEMORY_GUID \
+  { \
+    0xa5bc1114, 0x6f64, 0x4ede, { 0xb8, 0x63, 0x3e, 0x83, 0xed, 0x7c, 0x83, 0xb1 } \
+  }
+#define EFI_ERROR_SECTION_PLATFORM_MEMORY2_GUID \
+  { \
+    0x61EC04FC, 0x48E6, 0xD813, { 0x25, 0xC9, 0x8D, 0xAA, 0x44, 0x75, 0x0B, 0x12 } \
+  }
+#define EFI_ERROR_SECTION_PCIE_GUID \
+  { \
+    0xd995e954, 0xbbc1, 0x430f, { 0xad, 0x91, 0xb4, 0x4d, 0xcb, 0x3c, 0x6f, 0x35 } \
+  }
+#define EFI_ERROR_SECTION_FW_ERROR_RECORD_GUID \
+  { \
+    0x81212a96, 0x09ed, 0x4996, { 0x94, 0x71, 0x8d, 0x72, 0x9c, 0x8e, 0x69, 0xed } \
+  }
+#define EFI_ERROR_SECTION_PCI_PCIX_BUS_GUID \
+  { \
+    0xc5753963, 0x3b84, 0x4095, { 0xbf, 0x78, 0xed, 0xda, 0xd3, 0xf9, 0xc9, 0xdd } \
+  }
+#define EFI_ERROR_SECTION_PCI_DEVICE_GUID \
+  { \
+    0xeb5e4685, 0xca66, 0x4769, { 0xb6, 0xa2, 0x26, 0x06, 0x8b, 0x00, 0x13, 0x26 } \
+  }
+#define EFI_ERROR_SECTION_DMAR_GENERIC_GUID \
+  { \
+    0x5b51fef7, 0xc79d, 0x4434, { 0x8f, 0x1b, 0xaa, 0x62, 0xde, 0x3e, 0x2c, 0x64 } \
+  }
+#define EFI_ERROR_SECTION_DIRECTED_IO_DMAR_GUID \
+  { \
+    0x71761d37, 0x32b2, 0x45cd, { 0xa7, 0xd0, 0xb0, 0xfe, 0xdd, 0x93, 0xe8, 0xcf } \
+  }
+#define EFI_ERROR_SECTION_IOMMU_DMAR_GUID \
+  { \
+    0x036f84e1, 0x7f37, 0x428c, { 0xa7, 0x9e, 0x57, 0x5f, 0xdf, 0xaa, 0x84, 0xec } \
+  }
+///@}
+
+///
+/// Error Section Descriptor
+///
+typedef struct {
+  UINT32                 SectionOffset;
+  UINT32                 SectionLength;
+  UINT16                 Revision;
+  UINT8                  SecValidMask;
+  UINT8                  Resv1;
+  UINT32                 SectionFlags;
+  EFI_GUID               SectionType;
+  EFI_GUID               FruId;
+  UINT32                 Severity;
+  CHAR8                  FruString[20];
+} EFI_ERROR_SECTION_DESCRIPTOR;
+
+///
+/// The validation bit mask indicates whether or not each of the following fields are
+/// valid in Proessor Generic Error section.
+///@{
+#define EFI_GENERIC_ERROR_PROC_TYPE_VALID            BIT0
+#define EFI_GENERIC_ERROR_PROC_ISA_VALID             BIT1
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_VALID      BIT2
+#define EFI_GENERIC_ERROR_PROC_OPERATION_VALID       BIT3
+#define EFI_GENERIC_ERROR_PROC_FLAGS_VALID           BIT4
+#define EFI_GENERIC_ERROR_PROC_LEVEL_VALID           BIT5
+#define EFI_GENERIC_ERROR_PROC_VERSION_VALID         BIT6
+#define EFI_GENERIC_ERROR_PROC_BRAND_VALID           BIT7
+#define EFI_GENERIC_ERROR_PROC_ID_VALID              BIT8
+#define EFI_GENERIC_ERROR_PROC_TARGET_ADDR_VALID     BIT9
+#define EFI_GENERIC_ERROR_PROC_REQUESTER_ID_VALID    BIT10
+#define EFI_GENERIC_ERROR_PROC_RESPONDER_ID_VALID    BIT11
+#define EFI_GENERIC_ERROR_PROC_INST_IP_VALID         BIT12
+///@}
+
+///
+/// The type of the processor architecture in Proessor Generic Error section.
+///@{
+#define EFI_GENERIC_ERROR_PROC_TYPE_IA32_X64         0x00
+#define EFI_GENERIC_ERROR_PROC_TYPE_IA64             0x01
+///@}
+
+///
+/// The type of the instruction set executing when the error occurred in Proessor
+/// Generic Error section.
+///@{
+#define EFI_GENERIC_ERROR_PROC_ISA_IA32              0x00
+#define EFI_GENERIC_ERROR_PROC_ISA_IA64              0x01
+#define EFI_GENERIC_ERROR_PROC_ISA_X64               0x02
+///@}
+
+///
+/// The type of error that occurred in Proessor Generic Error section.
+///@{
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_UNKNOWN    0x00
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_CACHE      0x01
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_TLB        0x02
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_BUS        0x04
+#define EFI_GENERIC_ERROR_PROC_ERROR_TYPE_MICRO_ARCH 0x08
+///@}
+
+///
+/// The type of operation in Proessor Generic Error section.
+///@{
+#define EFI_GENERIC_ERROR_PROC_OPERATION_GENERIC               0x00
+#define EFI_GENERIC_ERROR_PROC_OPERATION_DATA_READ             0x01
+#define EFI_GENERIC_ERROR_PROC_OPERATION_DATA_WRITE            0x02
+#define EFI_GENERIC_ERROR_PROC_OPERATION_INSTRUCTION_EXEC      0x03
+///@}
+
+///
+/// Flags bit mask indicates additional information about the error in Proessor Generic
+/// Error section
+///@{
+#define EFI_GENERIC_ERROR_PROC_FLAGS_RESTARTABLE     BIT0
+#define EFI_GENERIC_ERROR_PROC_FLAGS_PRECISE_IP      BIT1
+#define EFI_GENERIC_ERROR_PROC_FLAGS_OVERFLOW        BIT2
+#define EFI_GENERIC_ERROR_PROC_FLAGS_CORRECTED       BIT3
+///@}
+
+///
+/// Processor Generic Error Section
+/// describes processor reported hardware errors for logical processors in the system.
+///
+typedef struct {
+  UINT64             ValidFields;
+  UINT8              Type;
+  UINT8              Isa;
+  UINT8              ErrorType;
+  UINT8              Operation;
+  UINT8              Flags;
+  UINT8              Level;
+  UINT16             Resv1;
+  UINT64             VersionInfo;
+  CHAR8              BrandString[128];
+  UINT64             ApicId;
+  UINT64             TargetAddr;
+  UINT64             RequestorId;
+  UINT64             ResponderId;
+  UINT64             InstructionIP;
+} EFI_PROCESSOR_GENERIC_ERROR_DATA;
+
+
+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
+///
+/// IA32 and x64 Specific definitions.
+///
+
+///
+/// GUID value indicating the type of Processor Error Information structure
+/// in IA32/X64 Processor Error Information Structure.
+///@{
+#define EFI_IA32_X64_ERROR_TYPE_CACHE_CHECK_GUID \
+  { \
+    0xA55701F5, 0xE3EF, 0x43de, {0xAC, 0x72, 0x24, 0x9B, 0x57, 0x3F, 0xAD, 0x2C } \
+  }
+#define EFI_IA32_X64_ERROR_TYPE_TLB_CHECK_GUID \
+  { \
+    0xFC06B535, 0x5E1F, 0x4562, {0x9F, 0x25, 0x0A, 0x3B, 0x9A, 0xDB, 0x63, 0xC3 } \
+  }
+#define EFI_IA32_X64_ERROR_TYPE_BUS_CHECK_GUID \
+  { \
+    0x1CF3F8B3, 0xC5B1, 0x49a2, {0xAA, 0x59, 0x5E, 0xEF, 0x92, 0xFF, 0xA6, 0x3C } \
+  }
+#define EFI_IA32_X64_ERROR_TYPE_MS_CHECK_GUID \
+  { \
+    0x48AB7F57, 0xDC34, 0x4f6c, {0xA7, 0xD3, 0xB0, 0xB5, 0xB0, 0xA7, 0x43, 0x14 } \
+  }
+///@}
+
+///
+/// The validation bit mask indicates which fields in the IA32/X64 Processor
+/// Error Record structure are valid.
+///@{
+#define EFI_IA32_X64_PROCESSOR_ERROR_APIC_ID_VALID         BIT0
+#define EFI_IA32_X64_PROCESSOR_ERROR_CPU_ID_INFO_VALID     BIT1
+///@}
+
+///
+/// IA32/X64 Processor Error Record
+///
+typedef struct {
+  UINT64             ValidFields;
+  UINT64             ApicId;
+  UINT8              CpuIdInfo[48];
+} EFI_IA32_X64_PROCESSOR_ERROR_RECORD;
+
+///
+/// The validation bit mask indicates which fields in the Cache Check structure
+/// are valid.
+///@{
+#define EFI_CACHE_CHECK_TRANSACTION_TYPE_VALID       BIT0
+#define EFI_CACHE_CHECK_OPERATION_VALID              BIT1
+#define EFI_CACHE_CHECK_LEVEL_VALID                  BIT2
+#define EFI_CACHE_CHECK_CONTEXT_CORRUPT_VALID        BIT3
+#define EFI_CACHE_CHECK_UNCORRECTED_VALID            BIT4
+#define EFI_CACHE_CHECK_PRECISE_IP_VALID             BIT5
+#define EFI_CACHE_CHECK_RESTARTABLE_VALID            BIT6
+#define EFI_CACHE_CHECK_OVERFLOW_VALID               BIT7
+///@}
+
+///
+/// Type of cache error in the Cache Check structure
+///@{
+#define EFI_CACHE_CHECK_ERROR_TYPE_INSTRUCTION       0
+#define EFI_CACHE_CHECK_ERROR_TYPE_DATA_ACCESS       1
+#define EFI_CACHE_CHECK_ERROR_TYPE_GENERIC           2
+///@}
+
+///
+/// Type of cache operation that caused the error in the Cache
+/// Check structure
+///@{
+#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC                 0
+#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC_READ            1
+#define EFI_CACHE_CHECK_OPERATION_TYPE_GENERIC_WRITE           2
+#define EFI_CACHE_CHECK_OPERATION_TYPE_DATA_READ               3
+#define EFI_CACHE_CHECK_OPERATION_TYPE_DATA_WRITE              4
+#define EFI_CACHE_CHECK_OPERATION_TYPE_INSTRUCTION_FETCH       5
+#define EFI_CACHE_CHECK_OPERATION_TYPE_PREFETCH                6
+#define EFI_CACHE_CHECK_OPERATION_TYPE_EVICTION                7
+#define EFI_CACHE_CHECK_OPERATION_TYPE_SNOOP                   8
+///@}
+
+///
+/// IA32/X64 Cache Check Structure
+///
+typedef struct {
+  UINT64             ValidFields:16;
+  UINT64             TransactionType:2;
+  UINT64             Operation:4;
+  UINT64             Level:3;
+  UINT64             ContextCorrupt:1;
+  UINT64             ErrorUncorrected:1;
+  UINT64             PreciseIp:1;
+  UINT64             RestartableIp:1;
+  UINT64             Overflow:1;
+  UINT64             Resv1:34;
+} EFI_IA32_X64_CACHE_CHECK_INFO;
+
+///
+/// The validation bit mask indicates which fields in the TLB Check structure
+/// are valid.
+///@{
+#define EFI_TLB_CHECK_TRANSACTION_TYPE_VALID         BIT0
+#define EFI_TLB_CHECK_OPERATION_VALID                BIT1
+#define EFI_TLB_CHECK_LEVEL_VALID                    BIT2
+#define EFI_TLB_CHECK_CONTEXT_CORRUPT_VALID          BIT3
+#define EFI_TLB_CHECK_UNCORRECTED_VALID              BIT4
+#define EFI_TLB_CHECK_PRECISE_IP_VALID               BIT5
+#define EFI_TLB_CHECK_RESTARTABLE_VALID              BIT6
+#define EFI_TLB_CHECK_OVERFLOW_VALID                 BIT7
+///@}
+
+///
+/// Type of cache error in the TLB Check structure
+///@{
+#define EFI_TLB_CHECK_ERROR_TYPE_INSTRUCTION         0
+#define EFI_TLB_CHECK_ERROR_TYPE_DATA_ACCESS         1
+#define EFI_TLB_CHECK_ERROR_TYPE_GENERIC             2
+///@}
+
+///
+/// Type of cache operation that caused the error in the TLB
+/// Check structure
+///@{
+#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC         0
+#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC_READ    1
+#define EFI_TLB_CHECK_OPERATION_TYPE_GENERIC_WRITE   2
+#define EFI_TLB_CHECK_OPERATION_TYPE_DATA_READ       3
+#define EFI_TLB_CHECK_OPERATION_TYPE_DATA_WRITE      4
+#define EFI_TLB_CHECK_OPERATION_TYPE_INST_FETCH      5
+#define EFI_TLB_CHECK_OPERATION_TYPE_PREFETCH        6
+///@}
+
+///
+/// IA32/X64 TLB Check Structure
+///
+typedef struct {
+  UINT64             ValidFields:16;
+  UINT64             TransactionType:2;
+  UINT64             Operation:4;
+  UINT64             Level:3;
+  UINT64             ContextCorrupt:1;
+  UINT64             ErrorUncorrected:1;
+  UINT64             PreciseIp:1;
+  UINT64             RestartableIp:1;
+  UINT64             Overflow:1;
+  UINT64             Resv1:34;
+} EFI_IA32_X64_TLB_CHECK_INFO;
+
+///
+/// The validation bit mask indicates which fields in the MS Check structure
+/// are valid.
+///@{
+#define EFI_BUS_CHECK_TRANSACTION_TYPE_VALID         BIT0
+#define EFI_BUS_CHECK_OPERATION_VALID                BIT1
+#define EFI_BUS_CHECK_LEVEL_VALID                    BIT2
+#define EFI_BUS_CHECK_CONTEXT_CORRUPT_VALID          BIT3
+#define EFI_BUS_CHECK_UNCORRECTED_VALID              BIT4
+#define EFI_BUS_CHECK_PRECISE_IP_VALID               BIT5
+#define EFI_BUS_CHECK_RESTARTABLE_VALID              BIT6
+#define EFI_BUS_CHECK_OVERFLOW_VALID                 BIT7
+#define EFI_BUS_CHECK_PARTICIPATION_TYPE_VALID       BIT8
+#define EFI_BUS_CHECK_TIME_OUT_VALID                 BIT9
+#define EFI_BUS_CHECK_ADDRESS_SPACE_VALID            BIT10
+///@}
+
+///
+/// Type of cache error in the Bus Check structure
+///@{
+#define EFI_BUS_CHECK_ERROR_TYPE_INSTRUCTION         0
+#define EFI_BUS_CHECK_ERROR_TYPE_DATA_ACCESS         1
+#define EFI_BUS_CHECK_ERROR_TYPE_GENERIC             2
+///@}
+
+///
+/// Type of cache operation that caused the error in the Bus
+/// Check structure
+///@{
+#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC         0
+#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC_READ    1
+#define EFI_BUS_CHECK_OPERATION_TYPE_GENERIC_WRITE   2
+#define EFI_BUS_CHECK_OPERATION_TYPE_DATA_READ       3
+#define EFI_BUS_CHECK_OPERATION_TYPE_DATA_WRITE      4
+#define EFI_BUS_CHECK_OPERATION_TYPE_INST_FETCH      5
+#define EFI_BUS_CHECK_OPERATION_TYPE_PREFETCH        6
+///@}
+
+///
+/// Type of Participation
+///@{
+#define EFI_BUS_CHECK_PARTICIPATION_TYPE_REQUEST     0
+#define EFI_BUS_CHECK_PARTICIPATION_TYPE_RESPONDED   1
+#define EFI_BUS_CHECK_PARTICIPATION_TYPE_OBSERVED    2
+#define EFI_BUS_CHECK_PARTICIPATION_TYPE_GENERIC     3
+///@}
+
+///
+/// Type of Address Space
+///@{
+#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_MEMORY      0
+#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_RESERVED    1
+#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_IO          2
+#define EFI_BUS_CHECK_ADDRESS_SPACE_TYPE_OTHER       3
+///@}
+
+///
+/// IA32/X64 Bus Check Structure
+///
+typedef struct {
+  UINT64             ValidFields:16;
+  UINT64             TransactionType:2;
+  UINT64             Operation:4;
+  UINT64             Level:3;
+  UINT64             ContextCorrupt:1;
+  UINT64             ErrorUncorrected:1;
+  UINT64             PreciseIp:1;
+  UINT64             RestartableIp:1;
+  UINT64             Overflow:1;
+  UINT64             ParticipationType:2;
+  UINT64             TimeOut:1;
+  UINT64             AddressSpace:2;
+  UINT64             Resv1:29;
+} EFI_IA32_X64_BUS_CHECK_INFO;
+
+///
+/// The validation bit mask indicates which fields in the MS Check structure
+/// are valid.
+///@{
+#define EFI_MS_CHECK_ERROR_TYPE_VALID                BIT0
+#define EFI_MS_CHECK_CONTEXT_CORRUPT_VALID           BIT1
+#define EFI_MS_CHECK_UNCORRECTED_VALID               BIT2
+#define EFI_MS_CHECK_PRECISE_IP_VALID                BIT3
+#define EFI_MS_CHECK_RESTARTABLE_VALID               BIT4
+#define EFI_MS_CHECK_OVERFLOW_VALID                  BIT5
+///@}
+
+///
+/// Error type identifies the operation that caused the error.
+///@{
+#define EFI_MS_CHECK_ERROR_TYPE_NO                             0
+#define EFI_MS_CHECK_ERROR_TYPE_UNCLASSIFIED                   1
+#define EFI_MS_CHECK_ERROR_TYPE_MICROCODE_PARITY               2
+#define EFI_MS_CHECK_ERROR_TYPE_EXTERNAL                       3
+#define EFI_MS_CHECK_ERROR_TYPE_FRC                            4
+#define EFI_MS_CHECK_ERROR_TYPE_INTERNAL_UNCLASSIFIED          5
+///@}
+
+///
+/// IA32/X64 MS Check Field Description
+///
+typedef struct {
+  UINT64             ValidFields:16;
+  UINT64             ErrorType:3;
+  UINT64             ContextCorrupt:1;
+  UINT64             ErrorUncorrected:1;
+  UINT64             PreciseIp:1;
+  UINT64             RestartableIp:1;
+  UINT64             Overflow:1;
+  UINT64             Resv1:40;
+} EFI_IA32_X64_MS_CHECK_INFO;
+
+///
+/// IA32/X64 Check Information Item
+///
+typedef union {
+  EFI_IA32_X64_CACHE_CHECK_INFO  CacheCheck;
+  EFI_IA32_X64_TLB_CHECK_INFO    TlbCheck;
+  EFI_IA32_X64_BUS_CHECK_INFO    BusCheck;
+  EFI_IA32_X64_MS_CHECK_INFO     MsCheck;
+  UINT64                         Data64;
+} EFI_IA32_X64_CHECK_INFO_ITEM;
+
+///
+/// The validation bit mask indicates which fields in the IA32/X64 Processor Error
+/// Information Structure are valid.
+///@{
+#define EFI_IA32_X64_ERROR_PROC_CHECK_INFO_VALID       BIT0
+#define EFI_IA32_X64_ERROR_PROC_TARGET_ADDR_VALID      BIT1
+#define EFI_IA32_X64_ERROR_PROC_REQUESTER_ID_VALID     BIT2
+#define EFI_IA32_X64_ERROR_PROC_RESPONDER_ID_VALID     BIT3
+#define EFI_IA32_X64_ERROR_PROC_INST_IP_VALID          BIT4
+///@}
+
+///
+/// IA32/X64 Processor Error Information Structure
+///
+typedef struct {
+  EFI_GUID                     ErrorType;
+  UINT64                       ValidFields;
+  EFI_IA32_X64_CHECK_INFO_ITEM CheckInfo;
+  UINT64                       TargetId;
+  UINT64                       RequestorId;
+  UINT64                       ResponderId;
+  UINT64                       InstructionIP;
+} EFI_IA32_X64_PROCESS_ERROR_INFO;
+
+///
+/// IA32/X64 Processor Context Information Structure
+///
+typedef struct {
+  UINT16             RegisterType;
+  UINT16             ArraySize;
+  UINT32             MsrAddress;
+  UINT64             MmRegisterAddress;
+  //
+  // This field will provide the contents of the actual registers or raw data.
+  // The number of Registers or size of the raw data reported is determined
+  // by (Array Size / 8) or otherwise specified by the context structure type
+  // definition.
+  //
+} EFI_IA32_X64_PROCESSOR_CONTEXT_INFO;
+
+///
+/// Register Context Type
+///@{
+#define EFI_REG_CONTEXT_TYPE_UNCLASSIFIED            0x0000
+#define EFI_REG_CONTEXT_TYPE_MSR                     0x0001
+#define EFI_REG_CONTEXT_TYPE_IA32                    0x0002
+#define EFI_REG_CONTEXT_TYPE_X64                     0x0003
+#define EFI_REG_CONTEXT_TYPE_FXSAVE                  0x0004
+#define EFI_REG_CONTEXT_TYPE_DR_IA32                 0x0005
+#define EFI_REG_CONTEXT_TYPE_DR_X64                  0x0006
+#define EFI_REG_CONTEXT_TYPE_MEM_MAP                 0x0007
+///@}
+
+///
+/// IA32 Register State
+///
+typedef struct {
+  UINT32             Eax;
+  UINT32             Ebx;
+  UINT32             Ecx;
+  UINT32             Edx;
+  UINT32             Esi;
+  UINT32             Edi;
+  UINT32             Ebp;
+  UINT32             Esp;
+  UINT16             Cs;
+  UINT16             Ds;
+  UINT16             Ss;
+  UINT16             Es;
+  UINT16             Fs;
+  UINT16             Gs;
+  UINT32             Eflags;
+  UINT32             Eip;
+  UINT32             Cr0;
+  UINT32             Cr1;
+  UINT32             Cr2;
+  UINT32             Cr3;
+  UINT32             Cr4;
+  UINT32             Gdtr[2];
+  UINT32             Idtr[2];
+  UINT16             Ldtr;
+  UINT16             Tr;
+} EFI_CONTEXT_IA32_REGISTER_STATE;
+
+///
+/// X64 Register State
+///
+typedef struct {
+  UINT64             Rax;
+  UINT64             Rbx;
+  UINT64             Rcx;
+  UINT64             Rdx;
+  UINT64             Rsi;
+  UINT64             Rdi;
+  UINT64             Rbp;
+  UINT64             Rsp;
+  UINT64             R8;
+  UINT64             R9;
+  UINT64             R10;
+  UINT64             R11;
+  UINT64             R12;
+  UINT64             R13;
+  UINT64             R14;
+  UINT64             R15;
+  UINT16             Cs;
+  UINT16             Ds;
+  UINT16             Ss;
+  UINT16             Es;
+  UINT16             Fs;
+  UINT16             Gs;
+  UINT32             Resv1;
+  UINT64             Rflags;
+  UINT64             Rip;
+  UINT64             Cr0;
+  UINT64             Cr1;
+  UINT64             Cr2;
+  UINT64             Cr3;
+  UINT64             Cr4;
+  UINT64             Gdtr[2];
+  UINT64             Idtr[2];
+  UINT16             Ldtr;
+  UINT16             Tr;
+} EFI_CONTEXT_X64_REGISTER_STATE;
+
+///
+/// The validation bit mask indicates each of the following field is in IA32/X64
+/// Processor Error Section.
+///
+typedef struct {
+  UINT64             ApicIdValid:1;
+  UINT64             CpuIdInforValid:1;
+  UINT64             ErrorInfoNum:6;
+  UINT64             ContextNum:6;
+  UINT64             Resv1:50;
+} EFI_IA32_X64_VALID_BITS;
+
+#endif
+
+///
+/// Error Status Fields
+///
+typedef struct {
+  UINT64          Resv1:8;
+  UINT64          Type:8;
+  UINT64          AddressSignal:1;        ///< Error in Address signals or in Address portion of transaction
+  UINT64          ControlSignal:1;        ///< Error in Control signals or in Control portion of transaction
+  UINT64          DataSignal:1;           ///< Error in Data signals or in Data portion of transaction
+  UINT64          DetectedByResponder:1;  ///< Error detected by responder
+  UINT64          DetectedByRequester:1;  ///< Error detected by requestor
+  UINT64          FirstError:1;           ///< First Error in the sequence - option field
+  UINT64          OverflowNotLogged:1;    ///< Additional errors were not logged due to lack of resources
+  UINT64          Resv2:41;
+} EFI_GENERIC_ERROR_STATUS;
+
+///
+/// Error Type
+///
+typedef enum {
+  ///
+  /// General Internal errors
+  ///
+  ErrorInternal       = 1,
+  ErrorBus            = 16,
+  ///
+  /// Component Internal errors
+  ///
+  ErrorMemStorage     = 4,        // Error in memory device
+  ErrorTlbStorage     = 5,        // TLB error in cache
+  ErrorCacheStorage   = 6,
+  ErrorFunctionalUnit = 7,
+  ErrorSelftest       = 8,
+  ErrorOverflow       = 9,
+  ///
+  /// Bus internal errors
+  ///
+  ErrorVirtualMap     = 17,
+  ErrorAccessInvalid  = 18,       // Improper access
+  ErrorUnimplAccess   = 19,       // Unimplemented memory access
+  ErrorLossOfLockstep = 20,
+  ErrorResponseInvalid= 21,       // Response not associated with request
+  ErrorParity         = 22,
+  ErrorProtocol       = 23,
+  ErrorPath           = 24,       // Detected path error
+  ErrorTimeout        = 25,       // Bus timeout
+  ErrorPoisoned       = 26        // Read data poisoned
+} EFI_GENERIC_ERROR_STATUS_ERROR_TYPE;
+
+///
+/// Validation bit mask indicates which fields in the memory error record are valid
+/// in Memory Error section
+///@{
+#define EFI_PLATFORM_MEMORY_ERROR_STATUS_VALID                 BIT0
+#define EFI_PLATFORM_MEMORY_PHY_ADDRESS_VALID                  BIT1
+#define EFI_PLATFORM_MEMORY_PHY_ADDRESS_MASK_VALID             BIT2
+#define EFI_PLATFORM_MEMORY_NODE_VALID                         BIT3
+#define EFI_PLATFORM_MEMORY_CARD_VALID                         BIT4
+#define EFI_PLATFORM_MEMORY_MODULE_VALID                       BIT5
+#define EFI_PLATFORM_MEMORY_BANK_VALID                         BIT6
+#define EFI_PLATFORM_MEMORY_DEVICE_VALID                       BIT7
+#define EFI_PLATFORM_MEMORY_ROW_VALID                          BIT8
+#define EFI_PLATFORM_MEMORY_COLUMN_VALID                       BIT9
+#define EFI_PLATFORM_MEMORY_BIT_POS_VALID                      BIT10
+#define EFI_PLATFORM_MEMORY_REQUESTOR_ID_VALID                 BIT11
+#define EFI_PLATFORM_MEMORY_RESPONDER_ID_VALID                 BIT12
+#define EFI_PLATFORM_MEMORY_TARGET_ID_VALID                    BIT13
+#define EFI_PLATFORM_MEMORY_ERROR_TYPE_VALID                   BIT14
+#define EFI_PLATFORM_MEMORY_ERROR_RANK_NUM_VALID               BIT15
+#define EFI_PLATFORM_MEMORY_ERROR_CARD_HANDLE_VALID            BIT16
+#define EFI_PLATFORM_MEMORY_ERROR_MODULE_HANDLE_VALID          BIT17
+#define EFI_PLATFORM_MEMORY_ERROR_EXTENDED_ROW_BIT_16_17_VALID BIT18
+#define EFI_PLATFORM_MEMORY_ERROR_BANK_GROUP_VALID             BIT19
+#define EFI_PLATFORM_MEMORY_ERROR_BANK_ADDRESS_VALID           BIT20
+#define EFI_PLATFORM_MEMORY_ERROR_CHIP_IDENTIFICATION_VALID    BIT21
+///@}
+
+///
+/// Memory Error Type identifies the type of error that occurred in Memory
+/// Error section
+///@{
+#define EFI_PLATFORM_MEMORY_ERROR_UNKNOWN                      0x00
+#define EFI_PLATFORM_MEMORY_ERROR_NONE                         0x01
+#define EFI_PLATFORM_MEMORY_ERROR_SINGLEBIT_ECC                0x02
+#define EFI_PLATFORM_MEMORY_ERROR_MLTIBIT_ECC                  0x03
+#define EFI_PLATFORM_MEMORY_ERROR_SINGLESYMBOLS_CHIPKILL       0x04
+#define EFI_PLATFORM_MEMORY_ERROR_MULTISYMBOL_CHIPKILL         0x05
+#define EFI_PLATFORM_MEMORY_ERROR_MATER_ABORT                  0x06
+#define EFI_PLATFORM_MEMORY_ERROR_TARGET_ABORT                 0x07
+#define EFI_PLATFORM_MEMORY_ERROR_PARITY                       0x08
+#define EFI_PLATFORM_MEMORY_ERROR_WDT                          0x09
+#define EFI_PLATFORM_MEMORY_ERROR_INVALID_ADDRESS              0x0A
+#define EFI_PLATFORM_MEMORY_ERROR_MIRROR_FAILED                0x0B
+#define EFI_PLATFORM_MEMORY_ERROR_SPARING                      0x0C
+#define EFI_PLATFORM_MEMORY_ERROR_SCRUB_CORRECTED              0x0D
+#define EFI_PLATFORM_MEMORY_ERROR_SCRUB_UNCORRECTED            0x0E
+#define EFI_PLATFORM_MEMORY_ERROR_MEMORY_MAP_EVENT             0x0F
+///@}
+
+///
+/// Memory Error Section
+///
+typedef struct {
+  UINT64                   ValidFields;
+  EFI_GENERIC_ERROR_STATUS ErrorStatus;
+  UINT64                   PhysicalAddress;      // Error physical address
+  UINT64                   PhysicalAddressMask;  // Grnaularity
+  UINT16                   Node;                 // Node #
+  UINT16                   Card;
+  UINT16                   ModuleRank;           // Module or Rank#
+  UINT16                   Bank;
+  UINT16                   Device;
+  UINT16                   Row;
+  UINT16                   Column;
+  UINT16                   BitPosition;
+  UINT64                   RequestorId;
+  UINT64                   ResponderId;
+  UINT64                   TargetId;
+  UINT8                    ErrorType;
+  UINT8                    Extended;
+  UINT16                   RankNum;
+  UINT16                   CardHandle;
+  UINT16                   ModuleHandle;
+} EFI_PLATFORM_MEMORY_ERROR_DATA;
+
+///
+/// Validation bit mask indicates which fields in the memory error record 2 are valid
+/// in Memory Error section 2
+///@{
+#define EFI_PLATFORM_MEMORY2_ERROR_STATUS_VALID                 BIT0
+#define EFI_PLATFORM_MEMORY2_PHY_ADDRESS_VALID                  BIT1
+#define EFI_PLATFORM_MEMORY2_PHY_ADDRESS_MASK_VALID             BIT2
+#define EFI_PLATFORM_MEMORY2_NODE_VALID                         BIT3
+#define EFI_PLATFORM_MEMORY2_CARD_VALID                         BIT4
+#define EFI_PLATFORM_MEMORY2_MODULE_VALID                       BIT5
+#define EFI_PLATFORM_MEMORY2_BANK_VALID                         BIT6
+#define EFI_PLATFORM_MEMORY2_DEVICE_VALID                       BIT7
+#define EFI_PLATFORM_MEMORY2_ROW_VALID                          BIT8
+#define EFI_PLATFORM_MEMORY2_COLUMN_VALID                       BIT9
+#define EFI_PLATFORM_MEMORY2_RANK_VALID                         BIT10
+#define EFI_PLATFORM_MEMORY2_BIT_POS_VALID                      BIT11
+#define EFI_PLATFORM_MEMORY2_CHIP_ID_VALID                      BIT12
+#define EFI_PLATFORM_MEMORY2_MEMORY_ERROR_TYPE_VALID            BIT13
+#define EFI_PLATFORM_MEMORY2_STATUS_VALID                       BIT14
+#define EFI_PLATFORM_MEMORY2_REQUESTOR_ID_VALID                 BIT15
+#define EFI_PLATFORM_MEMORY2_RESPONDER_ID_VALID                 BIT16
+#define EFI_PLATFORM_MEMORY2_TARGET_ID_VALID                    BIT17
+#define EFI_PLATFORM_MEMORY2_CARD_HANDLE_VALID                  BIT18
+#define EFI_PLATFORM_MEMORY2_MODULE_HANDLE_VALID                BIT19
+#define EFI_PLATFORM_MEMORY2_BANK_GROUP_VALID                   BIT20
+#define EFI_PLATFORM_MEMORY2_BANK_ADDRESS_VALID                 BIT21
+///@}
+
+///
+/// Memory Error Type identifies the type of error that occurred in Memory
+/// Error section 2
+///@{
+#define EFI_PLATFORM_MEMORY2_ERROR_UNKNOWN                      0x00
+#define EFI_PLATFORM_MEMORY2_ERROR_NONE                         0x01
+#define EFI_PLATFORM_MEMORY2_ERROR_SINGLEBIT_ECC                0x02
+#define EFI_PLATFORM_MEMORY2_ERROR_MLTIBIT_ECC                  0x03
+#define EFI_PLATFORM_MEMORY2_ERROR_SINGLESYMBOL_CHIPKILL        0x04
+#define EFI_PLATFORM_MEMORY2_ERROR_MULTISYMBOL_CHIPKILL         0x05
+#define EFI_PLATFORM_MEMORY2_ERROR_MASTER_ABORT                 0x06
+#define EFI_PLATFORM_MEMORY2_ERROR_TARGET_ABORT                 0x07
+#define EFI_PLATFORM_MEMORY2_ERROR_PARITY                       0x08
+#define EFI_PLATFORM_MEMORY2_ERROR_WDT                          0x09
+#define EFI_PLATFORM_MEMORY2_ERROR_INVALID_ADDRESS              0x0A
+#define EFI_PLATFORM_MEMORY2_ERROR_MIRROR_BROKEN                0x0B
+#define EFI_PLATFORM_MEMORY2_ERROR_MEMORY_SPARING               0x0C
+#define EFI_PLATFORM_MEMORY2_ERROR_SCRUB_CORRECTED              0x0D
+#define EFI_PLATFORM_MEMORY2_ERROR_SCRUB_UNCORRECTED            0x0E
+#define EFI_PLATFORM_MEMORY2_ERROR_MEMORY_MAP_EVENT             0x0F
+///@}
+
+///
+/// Memory Error Section 2
+///
+typedef struct {
+  UINT64                    ValidFields;
+  EFI_GENERIC_ERROR_STATUS  ErrorStatus;
+  UINT64                    PhysicalAddress;      // Error physical address
+  UINT64                    PhysicalAddressMask;  // Grnaularity
+  UINT16                    Node;                 // Node #
+  UINT16                    Card;
+  UINT16                    Module;               // Module or Rank#
+  UINT16                    Bank;
+  UINT32                    Device;
+  UINT32                    Row;
+  UINT32                    Column;
+  UINT32                    Rank;
+  UINT32                    BitPosition;
+  UINT8                     ChipId;
+  UINT8                     MemErrorType;
+  UINT8                     Status;
+  UINT8                     Reserved;
+  UINT64                    RequestorId;
+  UINT64                    ResponderId;
+  UINT64                    TargetId;
+  UINT32                    CardHandle;
+  UINT32                    ModuleHandle;
+} EFI_PLATFORM_MEMORY2_ERROR_DATA;
+
+///
+/// Validation bits mask indicates which of the following fields is valid
+/// in PCI Express Error Record.
+///@{
+#define EFI_PCIE_ERROR_PORT_TYPE_VALID               BIT0
+#define EFI_PCIE_ERROR_VERSION_VALID                 BIT1
+#define EFI_PCIE_ERROR_COMMAND_STATUS_VALID          BIT2
+#define EFI_PCIE_ERROR_DEVICE_ID_VALID               BIT3
+#define EFI_PCIE_ERROR_SERIAL_NO_VALID               BIT4
+#define EFI_PCIE_ERROR_BRIDGE_CRL_STS_VALID          BIT5
+#define EFI_PCIE_ERROR_CAPABILITY_INFO_VALID         BIT6
+#define EFI_PCIE_ERROR_AER_INFO_VALID                BIT7
+///@}
+
+///
+/// PCIe Device/Port Type as defined in the PCI Express capabilities register
+///@{
+#define EFI_PCIE_ERROR_PORT_PCIE_ENDPOINT            0x00000000
+#define EFI_PCIE_ERROR_PORT_PCI_ENDPOINT             0x00000001
+#define EFI_PCIE_ERROR_PORT_ROOT_PORT                0x00000004
+#define EFI_PCIE_ERROR_PORT_UPSWITCH_PORT            0x00000005
+#define EFI_PCIE_ERROR_PORT_DOWNSWITCH_PORT          0x00000006
+#define EFI_PCIE_ERROR_PORT_PCIE_TO_PCI_BRIDGE       0x00000007
+#define EFI_PCIE_ERROR_PORT_PCI_TO_PCIE_BRIDGE       0x00000008
+#define EFI_PCIE_ERROR_PORT_ROOT_INT_ENDPOINT        0x00000009
+#define EFI_PCIE_ERROR_PORT_ROOT_EVENT_COLLECTOR     0x0000000A
+///@}
+
+///
+/// PCI Slot number
+///
+typedef struct {
+  UINT16          Resv1:3;
+  UINT16          Number:13;
+} EFI_GENERIC_ERROR_PCI_SLOT;
+
+///
+/// PCIe Root Port PCI/bridge PCI compatible device number and
+/// bus number information to uniquely identify the root port or
+/// bridge. Default values for both the bus numbers is zero.
+///
+typedef struct {
+  UINT16                     VendorId;
+  UINT16                     DeviceId;
+  UINT8                      ClassCode[3];
+  UINT8                      Function;
+  UINT8                      Device;
+  UINT16                     Segment;
+  UINT8                      PrimaryOrDeviceBus;
+  UINT8                      SecondaryBus;
+  EFI_GENERIC_ERROR_PCI_SLOT Slot;
+  UINT8                      Resv1;
+} EFI_GENERIC_ERROR_PCIE_DEV_BRIDGE_ID;
+
+///
+/// PCIe Capability Structure
+///
+typedef struct {
+  UINT8           PcieCap[60];
+} EFI_PCIE_ERROR_DATA_CAPABILITY;
+
+///
+/// PCIe Advanced Error Reporting Extended Capability Structure.
+///
+typedef struct {
+  UINT8           PcieAer[96];
+} EFI_PCIE_ERROR_DATA_AER;
+
+///
+/// PCI Express Error Record
+///
+typedef struct {
+  UINT64                               ValidFields;
+  UINT32                               PortType;
+  UINT32                               Version;
+  UINT32                               CommandStatus;
+  UINT32                               Resv2;
+  EFI_GENERIC_ERROR_PCIE_DEV_BRIDGE_ID DevBridge;
+  UINT64                               SerialNo;
+  UINT32                               BridgeControlStatus;
+  EFI_PCIE_ERROR_DATA_CAPABILITY       Capability;
+  EFI_PCIE_ERROR_DATA_AER              AerInfo;
+} EFI_PCIE_ERROR_DATA;
+
+///
+/// Validation bits Indicates which of the following fields is valid
+/// in PCI/PCI-X Bus Error Section.
+///@{
+#define EFI_PCI_PCIX_BUS_ERROR_STATUS_VALID          BIT0
+#define EFI_PCI_PCIX_BUS_ERROR_TYPE_VALID            BIT1
+#define EFI_PCI_PCIX_BUS_ERROR_BUS_ID_VALID          BIT2
+#define EFI_PCI_PCIX_BUS_ERROR_BUS_ADDRESS_VALID     BIT3
+#define EFI_PCI_PCIX_BUS_ERROR_BUS_DATA_VALID        BIT4
+#define EFI_PCI_PCIX_BUS_ERROR_COMMAND_VALID         BIT5
+#define EFI_PCI_PCIX_BUS_ERROR_REQUESTOR_ID_VALID    BIT6
+#define EFI_PCI_PCIX_BUS_ERROR_COMPLETER_ID_VALID    BIT7
+#define EFI_PCI_PCIX_BUS_ERROR_TARGET_ID_VALID       BIT8
+///@}
+
+///
+/// PCI Bus Error Type in PCI/PCI-X Bus Error Section
+///@{
+#define EFI_PCI_PCIX_BUS_ERROR_UNKNOWN               0x0000
+#define EFI_PCI_PCIX_BUS_ERROR_DATA_PARITY           0x0001
+#define EFI_PCI_PCIX_BUS_ERROR_SYSTEM                0x0002
+#define EFI_PCI_PCIX_BUS_ERROR_MASTER_ABORT          0x0003
+#define EFI_PCI_PCIX_BUS_ERROR_BUS_TIMEOUT           0x0004
+#define EFI_PCI_PCIX_BUS_ERROR_MASTER_DATA_PARITY    0x0005
+#define EFI_PCI_PCIX_BUS_ERROR_ADDRESS_PARITY        0x0006
+#define EFI_PCI_PCIX_BUS_ERROR_COMMAND_PARITY        0x0007
+///@}
+
+///
+/// PCI/PCI-X Bus Error Section
+///
+typedef struct {
+  UINT64                   ValidFields;
+  EFI_GENERIC_ERROR_STATUS ErrorStatus;
+  UINT16                   Type;
+  UINT16                   BusId;
+  UINT32                   Resv2;
+  UINT64                   BusAddress;
+  UINT64                   BusData;
+  UINT64                   BusCommand;
+  UINT64                   RequestorId;
+  UINT64                   ResponderId;
+  UINT64                   TargetId;
+} EFI_PCI_PCIX_BUS_ERROR_DATA;
+
+///
+/// Validation bits Indicates which of the following fields is valid
+/// in PCI/PCI-X Component Error Section.
+///@{
+#define EFI_PCI_PCIX_DEVICE_ERROR_STATUS_VALID                 BIT0
+#define EFI_PCI_PCIX_DEVICE_ERROR_ID_INFO_VALID                BIT1
+#define EFI_PCI_PCIX_DEVICE_ERROR_MEM_NUM_VALID                BIT2
+#define EFI_PCI_PCIX_DEVICE_ERROR_IO_NUM_VALID                 BIT3
+#define EFI_PCI_PCIX_DEVICE_ERROR_REG_DATA_PAIR_VALID          BIT4
+///@}
+
+///
+/// PCI/PCI-X Device Identification Information
+///
+typedef struct {
+  UINT16          VendorId;
+  UINT16          DeviceId;
+  UINT8           ClassCode[3];
+  UINT8           Function;
+  UINT8           Device;
+  UINT8           Bus;
+  UINT8           Segment;
+  UINT8           Resv1;
+  UINT32          Resv2;
+} EFI_GENERIC_ERROR_PCI_DEVICE_ID;
+
+///
+/// Identifies the type of firmware error record
+///
+#define EFI_FIRMWARE_ERROR_TYPE_IPF_SAL              0x00
+
+///
+/// Firmware Error Record Section
+///
+typedef struct {
+  UINT8       ErrorType;
+  UINT8       Resv1[7];
+  UINT64      RecordId;
+} EFI_FIRMWARE_ERROR_DATA;
+
+///
+/// Fault Reason in DMAr Generic Error Section
+///@{
+#define EFI_DMA_FAULT_REASON_TABLE_ENTRY_NOT_PRESENT           0x01
+#define EFI_DMA_FAULT_REASON_TABLE_ENTRY_INVALID               0x02
+#define EFI_DMA_FAULT_REASON_ACCESS_MAPPING_TABLE_ERROR        0x03
+#define EFI_DMA_FAULT_REASON_RESV_BIT_ERROR_IN_MAPPING_TABLE   0x04
+#define EFI_DMA_FAULT_REASON_ACCESS_ADDR_OUT_OF_SPACE          0x05
+#define EFI_DMA_FAULT_REASON_INVALID_ACCESS                    0x06
+#define EFI_DMA_FAULT_REASON_INVALID_REQUEST                   0x07
+#define EFI_DMA_FAULT_REASON_ACCESS_TRANSLATE_TABLE_ERROR      0x08
+#define EFI_DMA_FAULT_REASON_RESV_BIT_ERROR_IN_TRANSLATE_TABLE 0x09
+#define EFI_DMA_FAULT_REASON_INVALID_COMMAOND                  0x0A
+#define EFI_DMA_FAULT_REASON_ACCESS_COMMAND_BUFFER_ERROR       0x0B
+///@}
+
+///
+/// DMA access type in DMAr Generic Error Section
+///@{
+#define EFI_DMA_ACCESS_TYPE_READ                     0x00
+#define EFI_DMA_ACCESS_TYPE_WRITE                    0x01
+///@}
+
+///
+/// DMA address type in DMAr Generic Error Section
+///@{
+#define EFI_DMA_ADDRESS_UNTRANSLATED                 0x00
+#define EFI_DMA_ADDRESS_TRANSLATION                  0x01
+///@}
+
+///
+/// Architecture type in DMAr Generic Error Section
+///@{
+#define EFI_DMA_ARCH_TYPE_VT                         0x01
+#define EFI_DMA_ARCH_TYPE_IOMMU                      0x02
+///@}
+
+///
+/// DMAr Generic Error Section
+///
+typedef struct {
+  UINT16      RequesterId;
+  UINT16      SegmentNumber;
+  UINT8       FaultReason;
+  UINT8       AccessType;
+  UINT8       AddressType;
+  UINT8       ArchType;
+  UINT64      DeviceAddr;
+  UINT8       Resv1[16];
+} EFI_DMAR_GENERIC_ERROR_DATA;
+
+///
+/// Intel VT for Directed I/O specific DMAr Errors
+///
+typedef struct {
+  UINT8           Version;
+  UINT8           Revision;
+  UINT8           OemId[6];
+  UINT64          Capability;
+  UINT64          CapabilityEx;
+  UINT32          GlobalCommand;
+  UINT32          GlobalStatus;
+  UINT32          FaultStatus;
+  UINT8           Resv1[12];
+  UINT64          FaultRecord[2];
+  UINT64          RootEntry[2];
+  UINT64          ContextEntry[2];
+  UINT64          PteL6;
+  UINT64          PteL5;
+  UINT64          PteL4;
+  UINT64          PteL3;
+  UINT64          PteL2;
+  UINT64          PteL1;
+} EFI_DIRECTED_IO_DMAR_ERROR_DATA;
+
+///
+/// IOMMU specific DMAr Errors
+///
+typedef struct {
+  UINT8           Revision;
+  UINT8           Resv1[7];
+  UINT64          Control;
+  UINT64          Status;
+  UINT8           Resv2[8];
+  UINT64          EventLogEntry[2];
+  UINT8           Resv3[16];
+  UINT64          DeviceTableEntry[4];
+  UINT64          PteL6;
+  UINT64          PteL5;
+  UINT64          PteL4;
+  UINT64          PteL3;
+  UINT64          PteL2;
+  UINT64          PteL1;
+} EFI_IOMMU_DMAR_ERROR_DATA;
+
+#pragma pack()
+
+extern EFI_GUID gEfiEventNotificationTypeCmcGuid;
+extern EFI_GUID gEfiEventNotificationTypeCpeGuid;
+extern EFI_GUID gEfiEventNotificationTypeMceGuid;
+extern EFI_GUID gEfiEventNotificationTypePcieGuid;
+extern EFI_GUID gEfiEventNotificationTypeInitGuid;
+extern EFI_GUID gEfiEventNotificationTypeNmiGuid;
+extern EFI_GUID gEfiEventNotificationTypeBootGuid;
+extern EFI_GUID gEfiEventNotificationTypeDmarGuid;
+
+extern EFI_GUID gEfiProcessorGenericErrorSectionGuid;
+extern EFI_GUID gEfiProcessorSpecificErrorSectionGuid;
+extern EFI_GUID gEfiIa32X64ProcessorErrorSectionGuid;
+extern EFI_GUID gEfiArmProcessorErrorSectionGuid ;
+extern EFI_GUID gEfiPlatformMemoryErrorSectionGuid;
+extern EFI_GUID gEfiPlatformMemory2ErrorSectionGuid;
+extern EFI_GUID gEfiPcieErrorSectionGuid;
+extern EFI_GUID gEfiFirmwareErrorSectionGuid;
+extern EFI_GUID gEfiPciBusErrorSectionGuid;
+extern EFI_GUID gEfiPciDevErrorSectionGuid;
+extern EFI_GUID gEfiDMArGenericErrorSectionGuid;
+extern EFI_GUID gEfiDirectedIoDMArErrorSectionGuid;
+extern EFI_GUID gEfiIommuDMArErrorSectionGuid;
+
+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
+///
+/// IA32 and x64 Specific definitions.
+///
+
+extern EFI_GUID gEfiIa32X64ErrorTypeCacheCheckGuid;
+extern EFI_GUID gEfiIa32X64ErrorTypeTlbCheckGuid;
+extern EFI_GUID gEfiIa32X64ErrorTypeBusCheckGuid;
+extern EFI_GUID gEfiIa32X64ErrorTypeMsCheckGuid;
+
+#endif
+
+#endif
diff --git a/MdePkg/Include/Guid/DebugImageInfoTable.h b/MdePkg/Include/Guid/DebugImageInfoTable.h
new file mode 100644
index 000000000000..553ebd258854
--- /dev/null
+++ b/MdePkg/Include/Guid/DebugImageInfoTable.h
@@ -0,0 +1,80 @@
+/** @file
+  GUID and related data structures used with the Debug Image Info Table.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __DEBUG_IMAGE_INFO_GUID_H__
+#define __DEBUG_IMAGE_INFO_GUID_H__
+
+#include <Protocol/LoadedImage.h>
+
+///
+/// EFI_DEBUG_IMAGE_INFO_TABLE configuration table GUID declaration.
+///
+#define EFI_DEBUG_IMAGE_INFO_TABLE_GUID \
+  { \
+    0x49152e77, 0x1ada, 0x4764, {0xb7, 0xa2, 0x7a, 0xfe, 0xfe, 0xd9, 0x5e, 0x8b } \
+  }
+
+#define EFI_DEBUG_IMAGE_INFO_UPDATE_IN_PROGRESS 0x01
+#define EFI_DEBUG_IMAGE_INFO_TABLE_MODIFIED     0x02
+
+#define EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL        0x01
+
+typedef struct {
+  UINT64                Signature;          ///< A constant UINT64 that has the value EFI_SYSTEM_TABLE_SIGNATURE
+  EFI_PHYSICAL_ADDRESS  EfiSystemTableBase; ///< The physical address of the EFI system table. 
+  UINT32                Crc32;              ///< A 32-bit CRC value that is used to verify the EFI_SYSTEM_TABLE_POINTER structure is valid.
+} EFI_SYSTEM_TABLE_POINTER;
+
+typedef struct {
+  ///
+  /// Indicates the type of image info structure. For PE32 EFI images,
+  /// this is set to EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL.
+  ///
+  UINT32                     ImageInfoType;
+  ///
+  /// A pointer to an instance of the loaded image protocol for the associated image.
+  ///
+  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImageProtocolInstance;
+  ///
+  /// Indicates the image handle of the associated image.
+  ///
+  EFI_HANDLE                 ImageHandle;
+} EFI_DEBUG_IMAGE_INFO_NORMAL;
+
+typedef union {
+  UINT32                      *ImageInfoType;
+  EFI_DEBUG_IMAGE_INFO_NORMAL *NormalImage;
+} EFI_DEBUG_IMAGE_INFO;
+
+typedef struct {
+  ///
+  /// UpdateStatus is used by the system to indicate the state of the debug image info table.
+  ///
+  volatile UINT32       UpdateStatus;
+  ///
+  /// The number of EFI_DEBUG_IMAGE_INFO elements in the array pointed to by EfiDebugImageInfoTable.
+  ///
+  UINT32                TableSize;
+  ///
+  /// A pointer to the first element of an array of EFI_DEBUG_IMAGE_INFO structures.
+  ///
+  EFI_DEBUG_IMAGE_INFO  *EfiDebugImageInfoTable;
+} EFI_DEBUG_IMAGE_INFO_TABLE_HEADER;
+
+extern EFI_GUID gEfiDebugImageInfoTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/DxeServices.h b/MdePkg/Include/Guid/DxeServices.h
new file mode 100644
index 000000000000..be2b5b3e96d0
--- /dev/null
+++ b/MdePkg/Include/Guid/DxeServices.h
@@ -0,0 +1,28 @@
+/** @file
+  GUID used to identify the DXE Services Table
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.0.
+
+**/
+
+#ifndef __DXE_SERVICES_GUID_H__
+#define __DXE_SERVICES_GUID_H__
+
+#define DXE_SERVICES_TABLE_GUID \
+  { \
+    0x5ad34ba, 0x6f02, 0x4214, {0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9 } \
+  }
+
+extern EFI_GUID gEfiDxeServicesTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/EventGroup.h b/MdePkg/Include/Guid/EventGroup.h
new file mode 100644
index 000000000000..04ee0e0fdaad
--- /dev/null
+++ b/MdePkg/Include/Guid/EventGroup.h
@@ -0,0 +1,52 @@
+/** @file
+  GUIDs for gBS->CreateEventEx Event Groups. Defined in UEFI spec 2.0 and PI 1.2.1.
+
+Copyright (c) 2006 - 2012, 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 __EVENT_GROUP_GUID__
+#define __EVENT_GROUP_GUID__
+
+                                             
+#define EFI_EVENT_GROUP_EXIT_BOOT_SERVICES \
+  { 0x27abf055, 0xb1b8, 0x4c26, { 0x80, 0x48, 0x74, 0x8f, 0x37, 0xba, 0xa2, 0xdf } }
+
+extern EFI_GUID gEfiEventExitBootServicesGuid;
+
+
+#define EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE \
+  { 0x13fa7698, 0xc831, 0x49c7, { 0x87, 0xea, 0x8f, 0x43, 0xfc, 0xc2, 0x51, 0x96 } }
+
+extern EFI_GUID gEfiEventVirtualAddressChangeGuid;
+
+
+#define EFI_EVENT_GROUP_MEMORY_MAP_CHANGE \
+  { 0x78bee926, 0x692f, 0x48fd, { 0x9e, 0xdb, 0x1, 0x42, 0x2e, 0xf0, 0xd7, 0xab } }
+
+extern EFI_GUID gEfiEventMemoryMapChangeGuid;
+
+
+#define EFI_EVENT_GROUP_READY_TO_BOOT \
+  { 0x7ce88fb3, 0x4bd7, 0x4679, { 0x87, 0xa8, 0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b } }
+
+extern EFI_GUID gEfiEventReadyToBootGuid;
+
+#define EFI_EVENT_GROUP_DXE_DISPATCH_GUID \
+  { 0x7081e22f, 0xcac6, 0x4053, { 0x94, 0x68, 0x67, 0x57, 0x82, 0xcf, 0x88, 0xe5 }}
+
+extern EFI_GUID gEfiEventDxeDispatchGuid;
+
+#define EFI_END_OF_DXE_EVENT_GROUP_GUID \
+  { 0x2ce967a, 0xdd7e, 0x4ffc, { 0x9e, 0xe7, 0x81, 0xc, 0xf0, 0x47, 0x8, 0x80 } }
+
+extern EFI_GUID gEfiEndOfDxeEventGroupGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/EventLegacyBios.h b/MdePkg/Include/Guid/EventLegacyBios.h
new file mode 100644
index 000000000000..f69aa18f9a21
--- /dev/null
+++ b/MdePkg/Include/Guid/EventLegacyBios.h
@@ -0,0 +1,28 @@
+/** @file
+  GUID is the name of events used with CreateEventEx in order to be notified 
+  when the EFI boot manager is about to boot a legacy boot option.
+  Events of this type are notificated just before Int19h is invoked. 
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.0.
+
+**/
+
+#ifndef __EVENT_LEGACY_BIOS_GUID_H__
+#define __EVENT_LEGACY_BIOS_GUID_H__
+
+#define EFI_EVENT_LEGACY_BOOT_GUID \
+   { 0x2a571201, 0x4966, 0x47f6, {0x8b, 0x86, 0xf3, 0x1e, 0x41, 0xf3, 0x2f, 0x10 } }
+
+extern EFI_GUID gEfiEventLegacyBootGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FileInfo.h b/MdePkg/Include/Guid/FileInfo.h
new file mode 100644
index 000000000000..5a2e081b4672
--- /dev/null
+++ b/MdePkg/Include/Guid/FileInfo.h
@@ -0,0 +1,71 @@
+/** @file
+  Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.SetInfo()
+  and EFI_FILE_PROTOCOL.GetInfo() to set or get generic file information.
+  This GUID is defined in UEFI specification.
+
+Copyright (c) 2006 - 2010, 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 __FILE_INFO_H__
+#define __FILE_INFO_H__
+
+#define EFI_FILE_INFO_ID \
+  { \
+    0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct {
+  ///
+  /// The size of the EFI_FILE_INFO structure, including the Null-terminated FileName string.
+  ///
+  UINT64    Size;
+  ///
+  /// The size of the file in bytes.
+  ///
+  UINT64    FileSize;
+  ///
+  /// PhysicalSize The amount of physical space the file consumes on the file system volume.
+  ///
+  UINT64    PhysicalSize;
+  ///
+  /// The time the file was created.
+  ///
+  EFI_TIME  CreateTime;
+  ///
+  /// The time when the file was last accessed.
+  ///
+  EFI_TIME  LastAccessTime;
+  ///
+  /// The time when the file's contents were last modified.
+  ///
+  EFI_TIME  ModificationTime;
+  ///
+  /// The attribute bits for the file.
+  ///
+  UINT64    Attribute;
+  ///
+  /// The Null-terminated name of the file.
+  ///
+  CHAR16    FileName[1];
+} EFI_FILE_INFO;
+
+///
+/// The FileName field of the EFI_FILE_INFO data structure is variable length.
+/// Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to
+/// be the size of the data structure without the FileName field.  The following macro
+/// computes this size correctly no matter how big the FileName array is declared.
+/// This is required to make the EFI_FILE_INFO data structure ANSI compilant.
+///
+#define SIZE_OF_EFI_FILE_INFO OFFSET_OF (EFI_FILE_INFO, FileName)
+
+extern EFI_GUID gEfiFileInfoGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FileSystemInfo.h b/MdePkg/Include/Guid/FileSystemInfo.h
new file mode 100644
index 000000000000..f666ae5571ab
--- /dev/null
+++ b/MdePkg/Include/Guid/FileSystemInfo.h
@@ -0,0 +1,63 @@
+/** @file
+  Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.GetInfo()
+  or EFI_FILE_PROTOCOL.SetInfo() to get or set information about the system's volume.
+  This GUID is defined in UEFI specification.
+
+Copyright (c) 2006 - 2010, 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 __FILE_SYSTEM_INFO_H__
+#define __FILE_SYSTEM_INFO_H__
+
+#define EFI_FILE_SYSTEM_INFO_ID \
+  { \
+    0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct {
+  ///
+  /// The size of the EFI_FILE_SYSTEM_INFO structure, including the Null-terminated VolumeLabel string.
+  ///
+  UINT64  Size;
+  ///
+  /// TRUE if the volume only supports read access.
+  ///
+  BOOLEAN ReadOnly;
+  ///
+  /// The number of bytes managed by the file system.
+  ///
+  UINT64  VolumeSize;
+  ///
+  /// The number of available bytes for use by the file system.
+  ///
+  UINT64  FreeSpace;
+  ///
+  /// The nominal block size by which files are typically grown.
+  ///
+  UINT32  BlockSize;
+  ///
+  /// The Null-terminated string that is the volume's label.
+  ///
+  CHAR16  VolumeLabel[1];
+} EFI_FILE_SYSTEM_INFO;
+
+///
+/// The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length.
+/// Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs
+/// to be the size of the data structure without the VolumeLable field.  The following macro
+/// computes this size correctly no matter how big the VolumeLable array is declared.
+/// This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant.
+///
+#define SIZE_OF_EFI_FILE_SYSTEM_INFO  OFFSET_OF (EFI_FILE_SYSTEM_INFO, VolumeLabel)
+
+extern EFI_GUID gEfiFileSystemInfoGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h b/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h
new file mode 100644
index 000000000000..0f41f9a34e03
--- /dev/null
+++ b/MdePkg/Include/Guid/FileSystemVolumeLabelInfo.h
@@ -0,0 +1,37 @@
+/** @file
+  Provides a GUID and a data structure that can be used with EFI_FILE_PROTOCOL.GetInfo()
+  or EFI_FILE_PROTOCOL.SetInfo() to get or set the system's volume label.
+  This GUID is defined in UEFI specification.
+
+  Copyright (c) 2006 - 2008, 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 __FILE_SYSTEM_VOLUME_LABEL_INFO_H__
+#define __FILE_SYSTEM_VOLUME_LABEL_INFO_H__
+
+#define EFI_FILE_SYSTEM_VOLUME_LABEL_ID \
+  { \
+    0xDB47D7D3, 0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } \
+  }
+
+typedef struct {
+  ///
+  /// The Null-terminated string that is the volume's label.
+  ///
+  CHAR16  VolumeLabel[1];
+} EFI_FILE_SYSTEM_VOLUME_LABEL;
+
+#define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL \
+        OFFSET_OF (EFI_FILE_SYSTEM_VOLUME_LABEL, VolumeLabel)
+
+extern EFI_GUID gEfiFileSystemVolumeLabelInfoIdGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FirmwareContentsSigned.h b/MdePkg/Include/Guid/FirmwareContentsSigned.h
new file mode 100644
index 000000000000..c13a21eb1356
--- /dev/null
+++ b/MdePkg/Include/Guid/FirmwareContentsSigned.h
@@ -0,0 +1,26 @@
+/** @file
+  GUID is used to define the signed section.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.2.1.
+
+**/
+
+#ifndef __FIRMWARE_CONTENTS_SIGNED_GUID_H__
+#define __FIRMWARE_CONTENTS_SIGNED_GUID_H__
+
+#define EFI_FIRMWARE_CONTENTS_SIGNED_GUID \
+   { 0xf9d89e8, 0x9259, 0x4f76, {0xa5, 0xaf, 0xc, 0x89, 0xe3, 0x40, 0x23, 0xdf } }
+
+extern EFI_GUID gEfiFirmwareContentsSignedGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FirmwareFileSystem2.h b/MdePkg/Include/Guid/FirmwareFileSystem2.h
new file mode 100644
index 000000000000..9e12fd608444
--- /dev/null
+++ b/MdePkg/Include/Guid/FirmwareFileSystem2.h
@@ -0,0 +1,40 @@
+/** @file
+  Guid used to define the Firmware File System 2.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUIDs introduced in PI Version 1.0.
+
+**/
+
+#ifndef __FIRMWARE_FILE_SYSTEM2_GUID_H__
+#define __FIRMWARE_FILE_SYSTEM2_GUID_H__
+
+/// 
+/// The firmware volume header contains a data field for 
+/// the file system GUID
+/// 
+#define EFI_FIRMWARE_FILE_SYSTEM2_GUID \
+  { 0x8c8ce578, 0x8a3d, 0x4f1c, { 0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 } }
+
+///
+/// A Volume Top File (VTF) is a file that must be 
+/// located such that the last byte of the file is 
+/// also the last byte of the firmware volume
+/// 
+#define EFI_FFS_VOLUME_TOP_FILE_GUID \
+  { 0x1BA0062E, 0xC779, 0x4582, { 0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x9 } }
+
+
+extern EFI_GUID gEfiFirmwareFileSystem2Guid;
+extern EFI_GUID gEfiFirmwareVolumeTopFileGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/FirmwareFileSystem3.h b/MdePkg/Include/Guid/FirmwareFileSystem3.h
new file mode 100644
index 000000000000..37ee56a97afd
--- /dev/null
+++ b/MdePkg/Include/Guid/FirmwareFileSystem3.h
@@ -0,0 +1,30 @@
+/** @file
+  Guid used to define the Firmware File System 3.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUIDs introduced in PI Version 1.0.
+
+**/
+
+#ifndef __FIRMWARE_FILE_SYSTEM3_GUID_H__
+#define __FIRMWARE_FILE_SYSTEM3_GUID_H__
+
+/// 
+/// The firmware volume header contains a data field for the file system GUID
+/// {5473C07A-3DCB-4dca-BD6F-1E9689E7349A}
+///
+#define EFI_FIRMWARE_FILE_SYSTEM3_GUID \
+  { 0x5473c07a, 0x3dcb, 0x4dca, { 0xbd, 0x6f, 0x1e, 0x96, 0x89, 0xe7, 0x34, 0x9a }}
+
+extern EFI_GUID gEfiFirmwareFileSystem3Guid;
+
+#endif // __FIRMWARE_FILE_SYSTEM3_GUID_H__
diff --git a/MdePkg/Include/Guid/FmpCapsule.h b/MdePkg/Include/Guid/FmpCapsule.h
new file mode 100644
index 000000000000..2d97b109d093
--- /dev/null
+++ b/MdePkg/Include/Guid/FmpCapsule.h
@@ -0,0 +1,98 @@
+/** @file
+  Guid & data structure used for Delivering Capsules Containing Updates to Firmware
+  Management Protocol
+
+  Copyright (c) 2013 - 2015, 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.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.4 spec.
+
+**/
+
+
+#ifndef _FMP_CAPSULE_GUID_H__
+#define _FMP_CAPSULE_GUID_H__
+
+//
+// This is the GUID of the capsule for Firmware Management Protocol.
+//
+#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_ID_GUID \
+  { \
+    0x6dcbd5ed, 0xe82d, 0x4c44, {0xbd, 0xa1, 0x71, 0x94, 0x19, 0x9a, 0xd9, 0x2a } \
+  }
+
+#pragma pack(1)
+
+typedef struct {
+  UINT32 Version;
+
+  ///
+  /// The number of drivers included in the capsule and the number of corresponding
+  /// offsets stored in ItemOffsetList array.
+  ///
+  UINT16 EmbeddedDriverCount;
+
+  ///
+  /// The number of payload items included in the capsule and the number of
+  /// corresponding offsets stored in the ItemOffsetList array.
+  ///
+  UINT16 PayloadItemCount;
+
+  ///
+  /// Variable length array of dimension [EmbeddedDriverCount + PayloadItemCount]
+  /// containing offsets of each of the drivers and payload items contained within the capsule
+  ///
+  // UINT64 ItemOffsetList[];
+} EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER;
+
+typedef struct {
+  UINT32   Version;
+
+  ///
+  /// Used to identify device firmware targeted by this update. This guid is matched by
+  /// system firmware against ImageTypeId field within a EFI_FIRMWARE_IMAGE_DESCRIPTOR
+  ///
+  EFI_GUID UpdateImageTypeId;
+
+  ///
+  /// Passed as ImageIndex in call to EFI_FIRMWARE_MANAGEMENT_PROTOCOL.SetImage()
+  ///
+  UINT8    UpdateImageIndex;
+  UINT8    reserved_bytes[3];
+
+  ///
+  /// Size of the binary update image which immediately follows this structure
+  ///
+  UINT32   UpdateImageSize;
+
+  ///
+  /// Size of the VendorCode bytes which optionally immediately follow binary update image in the capsule
+  ///
+  UINT32   UpdateVendorCodeSize;
+
+  ///
+  /// The HardwareInstance to target with this update. If value is zero it means match all
+  /// HardwareInstances. This field allows update software to target only a single device in
+  /// cases where there are more than one device with the same ImageTypeId GUID.
+  /// This header is outside the signed data of the Authentication Info structure and
+  /// therefore can be modified without changing the Auth data.
+  ///
+  UINT64   UpdateHardwareInstance;
+} EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER;
+
+#pragma pack()
+
+
+#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION       0x00000001
+#define EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION 0x00000002
+
+extern EFI_GUID gEfiFmpCapsuleGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/GlobalVariable.h b/MdePkg/Include/Guid/GlobalVariable.h
new file mode 100644
index 000000000000..a0be1a94c604
--- /dev/null
+++ b/MdePkg/Include/Guid/GlobalVariable.h
@@ -0,0 +1,192 @@
+/** @file
+  GUID for EFI (NVRAM) Variables.
+
+  Copyright (c) 2006 - 2016, 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.             
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.1
+**/
+
+#ifndef __GLOBAL_VARIABLE_GUID_H__
+#define __GLOBAL_VARIABLE_GUID_H__
+
+#define EFI_GLOBAL_VARIABLE \
+  { \
+    0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C } \
+  }
+
+extern EFI_GUID gEfiGlobalVariableGuid;
+
+//
+// Follow UEFI 2.4 spec:
+// To prevent name collisions with possible future globally defined variables,
+// other internal firmware data variables that are not defined here must be
+// saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
+// any other GUID defined by the UEFI Specification. Implementations must
+// only permit the creation of variables with a UEFI Specification-defined
+// VendorGuid when these variables are documented in the UEFI Specification.
+//
+// Note: except the globally defined variables defined below, the spec also defines
+// L"Boot####"      - A boot load option.
+// L"Driver####"    - A driver load option.
+// L"SysPrep####"   - A System Prep application load option.
+// L"Key####"       - Describes hot key relationship with a Boot#### load option.
+// The attribute for them is NV+BS+RT, #### is a printed hex value, and no 0x or h
+// is included in the hex value. They can not be expressed as a #define like other globally
+// defined variables, it is because we can not list the Boot0000, Boot0001, etc one by one.
+//
+
+///
+/// The language codes that the firmware supports. This value is deprecated.
+/// Its attribute is BS+RT.
+///
+#define EFI_LANG_CODES_VARIABLE_NAME                L"LangCodes"
+///
+/// The language code that the system is configured for. This value is deprecated.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_LANG_VARIABLE_NAME                      L"Lang"
+///
+/// The firmware's boot managers timeout, in seconds, before initiating the default boot selection.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_TIME_OUT_VARIABLE_NAME                  L"Timeout"
+///
+/// The language codes that the firmware supports.
+/// Its attribute is BS+RT.
+///
+#define EFI_PLATFORM_LANG_CODES_VARIABLE_NAME       L"PlatformLangCodes"
+///
+/// The language code that the system is configured for.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_PLATFORM_LANG_VARIABLE_NAME             L"PlatformLang"
+///
+/// The device path of the default input/output/error output console.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_CON_IN_VARIABLE_NAME                    L"ConIn"
+#define EFI_CON_OUT_VARIABLE_NAME                   L"ConOut"
+#define EFI_ERR_OUT_VARIABLE_NAME                   L"ErrOut"
+///
+/// The device path of all possible input/output/error output devices.
+/// Its attribute is BS+RT.
+///
+#define EFI_CON_IN_DEV_VARIABLE_NAME                L"ConInDev"
+#define EFI_CON_OUT_DEV_VARIABLE_NAME               L"ConOutDev"
+#define EFI_ERR_OUT_DEV_VARIABLE_NAME               L"ErrOutDev"
+///
+/// The ordered boot option load list.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_BOOT_ORDER_VARIABLE_NAME                L"BootOrder"
+///
+/// The boot option for the next boot only.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_BOOT_NEXT_VARIABLE_NAME                 L"BootNext"
+///
+/// The boot option that was selected for the current boot.
+/// Its attribute is BS+RT.
+///
+#define EFI_BOOT_CURRENT_VARIABLE_NAME              L"BootCurrent"
+///
+/// The types of boot options supported by the boot manager. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME       L"BootOptionSupport"
+///
+/// The ordered driver load option list.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_DRIVER_ORDER_VARIABLE_NAME              L"DriverOrder"
+///
+/// The ordered System Prep Application load option list.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_SYS_PREP_ORDER_VARIABLE_NAME            L"SysPrepOrder"
+///
+/// Identifies the level of hardware error record persistence
+/// support implemented by the platform. This variable is
+/// only modified by firmware and is read-only to the OS.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME        L"HwErrRecSupport"
+///
+/// Whether the system is operating in setup mode (1) or not (0).
+/// All other values are reserved. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_SETUP_MODE_NAME                         L"SetupMode"
+///
+/// The Key Exchange Key Signature Database.
+/// Its attribute is NV+BS+RT+AT.
+///
+#define EFI_KEY_EXCHANGE_KEY_NAME                   L"KEK"
+///
+/// The public Platform Key.
+/// Its attribute is NV+BS+RT+AT.
+///
+#define EFI_PLATFORM_KEY_NAME                       L"PK"
+///
+/// Array of GUIDs representing the type of signatures supported
+/// by the platform firmware. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_SIGNATURE_SUPPORT_NAME                  L"SignatureSupport"
+///
+/// Whether the platform firmware is operating in Secure boot mode (1) or not (0).
+/// All other values are reserved. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_SECURE_BOOT_MODE_NAME                   L"SecureBoot"
+///
+/// The OEM's default Key Exchange Key Signature Database. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_KEK_DEFAULT_VARIABLE_NAME               L"KEKDefault"
+///
+/// The OEM's default public Platform Key. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_PK_DEFAULT_VARIABLE_NAME                L"PKDefault"
+///
+/// The OEM's default secure boot signature store. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_DB_DEFAULT_VARIABLE_NAME                L"dbDefault"
+///
+/// The OEM's default secure boot blacklist signature store. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_DBX_DEFAULT_VARIABLE_NAME               L"dbxDefault"
+///
+/// The OEM's default secure boot timestamp signature store. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_DBT_DEFAULT_VARIABLE_NAME               L"dbtDefault"
+///
+/// Allows the firmware to indicate supported features and actions to the OS.
+/// Its attribute is BS+RT.
+///
+#define EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME    L"OsIndicationsSupported"
+///
+/// Allows the OS to request the firmware to enable certain features and to take certain actions.
+/// Its attribute is NV+BS+RT.
+///
+#define EFI_OS_INDICATIONS_VARIABLE_NAME            L"OsIndications"
+///
+/// Whether the system is configured to use only vendor provided
+/// keys or not. Should be treated as read-only.
+/// Its attribute is BS+RT.
+///
+#define EFI_VENDOR_KEYS_VARIABLE_NAME               L"VendorKeys"
+
+#endif
diff --git a/MdePkg/Include/Guid/Gpt.h b/MdePkg/Include/Guid/Gpt.h
new file mode 100644
index 000000000000..af2b1a12f82c
--- /dev/null
+++ b/MdePkg/Include/Guid/Gpt.h
@@ -0,0 +1,43 @@
+/** @file
+  Guids used for the GPT (GUID Partition Table)
+
+  GPT defines a new disk partitioning scheme and also describes 
+  usage of the legacy Master Boot Record (MBR) partitioning scheme. 
+
+  Copyright (c) 2006 - 2007, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.1 spec.
+
+**/
+
+#ifndef __GPT_GUID_H__
+#define __GPT_GUID_H__
+
+#define EFI_PART_TYPE_UNUSED_GUID \
+  { \
+    0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } \
+  }
+
+#define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID \
+  { \
+    0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b } \
+  }
+
+#define EFI_PART_TYPE_LEGACY_MBR_GUID \
+  { \
+    0x024dee41, 0x33e7, 0x11d3, {0x9d, 0x69, 0x00, 0x08, 0xc7, 0x81, 0xf3, 0x9f } \
+  }
+
+extern EFI_GUID gEfiPartTypeUnusedGuid;
+extern EFI_GUID gEfiPartTypeSystemPartGuid;
+extern EFI_GUID gEfiPartTypeLegacyMbrGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/GraphicsInfoHob.h b/MdePkg/Include/Guid/GraphicsInfoHob.h
new file mode 100644
index 000000000000..46dd29ddb2d2
--- /dev/null
+++ b/MdePkg/Include/Guid/GraphicsInfoHob.h
@@ -0,0 +1,51 @@
+/** @file
+  Hob guid for Information about the graphics mode.
+
+  Copyright (c) 2015 - 2016, 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.
+
+  @par Revision Reference:
+  This HOB is introduced in in PI Version 1.4.
+
+**/
+
+#ifndef _GRAPHICS_INFO_HOB_GUID_H_
+#define _GRAPHICS_INFO_HOB_GUID_H_
+
+#include <Protocol/GraphicsOutput.h>
+
+#define EFI_PEI_GRAPHICS_INFO_HOB_GUID \
+  { \
+    0x39f62cce, 0x6825, 0x4669, { 0xbb, 0x56, 0x54, 0x1a, 0xba, 0x75, 0x3a, 0x07 } \
+  }
+
+#define EFI_PEI_GRAPHICS_DEVICE_INFO_HOB_GUID \
+  { \
+    0xe5cb2ac9, 0xd35d, 0x4430, { 0x93, 0x6e, 0x1d, 0xe3, 0x32, 0x47, 0x8d, 0xe7 } \
+  }
+
+typedef struct {
+  EFI_PHYSICAL_ADDRESS                  FrameBufferBase;
+  UINT32                                FrameBufferSize;
+  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  GraphicsMode;
+} EFI_PEI_GRAPHICS_INFO_HOB;
+
+typedef struct {
+  UINT16                                VendorId;           ///< Ignore if the value is 0xFFFF.
+  UINT16                                DeviceId;           ///< Ignore if the value is 0xFFFF.
+  UINT16                                SubsystemVendorId;  ///< Ignore if the value is 0xFFFF.
+  UINT16                                SubsystemId;        ///< Ignore if the value is 0xFFFF.
+  UINT8                                 RevisionId;         ///< Ignore if the value is 0xFF.
+  UINT8                                 BarIndex;           ///< Ignore if the value is 0xFF.
+} EFI_PEI_GRAPHICS_DEVICE_INFO_HOB;
+
+extern EFI_GUID gEfiGraphicsInfoHobGuid;
+extern EFI_GUID gEfiGraphicsDeviceInfoHobGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/HardwareErrorVariable.h b/MdePkg/Include/Guid/HardwareErrorVariable.h
new file mode 100644
index 000000000000..4f644155a1da
--- /dev/null
+++ b/MdePkg/Include/Guid/HardwareErrorVariable.h
@@ -0,0 +1,28 @@
+/** @file
+  GUID for hardware error record variables.
+
+  Copyright (c) 2007 - 2009, 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.
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.1.
+
+**/
+
+#ifndef _HARDWARE_ERROR_VARIABLE_GUID_H_
+#define _HARDWARE_ERROR_VARIABLE_GUID_H_
+
+#define EFI_HARDWARE_ERROR_VARIABLE \
+  { \
+    0x414E6BDD, 0xE47B, 0x47cc, {0xB2, 0x44, 0xBB, 0x61, 0x02, 0x0C, 0xF5, 0x16} \
+  }
+
+extern EFI_GUID gEfiHardwareErrorVariableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/HiiFormMapMethodGuid.h b/MdePkg/Include/Guid/HiiFormMapMethodGuid.h
new file mode 100644
index 000000000000..8b37807f3d24
--- /dev/null
+++ b/MdePkg/Include/Guid/HiiFormMapMethodGuid.h
@@ -0,0 +1,25 @@
+/** @file
+  Guid used to identify HII FormMap configuration method.
+
+  Copyright (c) 2009, 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.             
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.2 spec.
+**/
+
+#ifndef __EFI_HII_FORMMAP_GUID_H__
+#define __EFI_HII_FORMMAP_GUID_H__
+
+#define EFI_HII_STANDARD_FORM_GUID \
+  { 0x3bd2f4ec, 0xe524, 0x46e4, { 0xa9, 0xd8, 0x51, 0x1, 0x17, 0x42, 0x55, 0x62 } }
+
+extern EFI_GUID gEfiHiiStandardFormGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/HiiKeyBoardLayout.h b/MdePkg/Include/Guid/HiiKeyBoardLayout.h
new file mode 100644
index 000000000000..c2619713ed27
--- /dev/null
+++ b/MdePkg/Include/Guid/HiiKeyBoardLayout.h
@@ -0,0 +1,27 @@
+/** @file
+
+  HII keyboard layout GUID as defined in UEFI2.1 specification
+  
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.1 spec.
+
+**/
+
+#ifndef __HII_KEYBOARD_LAYOUT_GUID_H__
+#define __HII_KEYBOARD_LAYOUT_GUID_H__
+
+#define EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID \
+  { 0x14982a4f, 0xb0ed, 0x45b8, { 0xa8, 0x11, 0x5a, 0x7a, 0x9b, 0xc2, 0x32, 0xdf }}
+
+extern EFI_GUID gEfiHiiKeyBoardLayoutGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/HiiPlatformSetupFormset.h b/MdePkg/Include/Guid/HiiPlatformSetupFormset.h
new file mode 100644
index 000000000000..2503879a4c7a
--- /dev/null
+++ b/MdePkg/Include/Guid/HiiPlatformSetupFormset.h
@@ -0,0 +1,35 @@
+/** @file
+  GUID indicates that the form set contains forms designed to be used 
+  for platform configuration and this form set will be displayed.
+
+Copyright (c) 2006 - 2010, 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.             
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.1.
+
+**/
+
+#ifndef __HII_PLATFORM_SETUP_FORMSET_GUID_H__
+#define __HII_PLATFORM_SETUP_FORMSET_GUID_H__
+
+#define EFI_HII_PLATFORM_SETUP_FORMSET_GUID \
+  { 0x93039971, 0x8545, 0x4b04, { 0xb4, 0x5e, 0x32, 0xeb, 0x83, 0x26, 0x4, 0xe } }
+
+#define EFI_HII_DRIVER_HEALTH_FORMSET_GUID \
+  { 0xf22fc20c, 0x8cf4, 0x45eb, { 0x8e, 0x6, 0xad, 0x4e, 0x50, 0xb9, 0x5d, 0xd3 } }
+
+#define EFI_HII_USER_CREDENTIAL_FORMSET_GUID \
+  { 0x337f4407, 0x5aee, 0x4b83, { 0xb2, 0xa7, 0x4e, 0xad, 0xca, 0x30, 0x88, 0xcd } }
+
+extern EFI_GUID gEfiHiiPlatformSetupFormsetGuid;
+extern EFI_GUID gEfiHiiDriverHealthFormsetGuid;
+extern EFI_GUID gEfiHiiUserCredentialFormsetGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/HobList.h b/MdePkg/Include/Guid/HobList.h
new file mode 100644
index 000000000000..94c1a58e0f03
--- /dev/null
+++ b/MdePkg/Include/Guid/HobList.h
@@ -0,0 +1,30 @@
+/** @file
+  GUIDs used for HOB List entries
+
+  These GUIDs point the HOB List passed from PEI to DXE.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUID introduced in PI Version 1.0.
+
+**/
+
+#ifndef __HOB_LIST_GUID_H__
+#define __HOB_LIST_GUID_H__
+
+#define HOB_LIST_GUID \
+  { \
+    0x7739f24c, 0x93d7, 0x11d4, {0x9a, 0x3a, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+extern EFI_GUID gEfiHobListGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/ImageAuthentication.h b/MdePkg/Include/Guid/ImageAuthentication.h
new file mode 100644
index 000000000000..a81b79b83850
--- /dev/null
+++ b/MdePkg/Include/Guid/ImageAuthentication.h
@@ -0,0 +1,352 @@
+/** @file
+  Image signature database are defined for the signed image validation.
+
+  Copyright (c) 2009 - 2016, 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.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.5 spec.
+**/
+
+#ifndef __IMAGE_AUTHTICATION_H__
+#define __IMAGE_AUTHTICATION_H__
+
+#include <Guid/GlobalVariable.h>
+#include <Protocol/Hash.h>
+
+#define EFI_IMAGE_SECURITY_DATABASE_GUID \
+  { \
+    0xd719b2cb, 0x3d3a, 0x4596, { 0xa3, 0xbc, 0xda, 0xd0, 0xe, 0x67, 0x65, 0x6f } \
+  }
+
+///
+/// Varialbe name with guid EFI_IMAGE_SECURITY_DATABASE_GUID
+/// for the authorized signature database.
+///
+#define EFI_IMAGE_SECURITY_DATABASE       L"db"
+///
+/// Varialbe name with guid EFI_IMAGE_SECURITY_DATABASE_GUID
+/// for the forbidden signature database.
+///
+#define EFI_IMAGE_SECURITY_DATABASE1      L"dbx"
+///
+/// Variable name with guid EFI_IMAGE_SECURITY_DATABASE_GUID
+/// for the timestamp signature database.
+///
+#define EFI_IMAGE_SECURITY_DATABASE2      L"dbt"
+
+#define SECURE_BOOT_MODE_ENABLE           1
+#define SECURE_BOOT_MODE_DISABLE          0
+
+#define SETUP_MODE                        1
+#define USER_MODE                         0
+
+//***********************************************************************
+// Signature Database
+//***********************************************************************
+///
+/// The format of a signature database.
+///
+#pragma pack(1)
+
+typedef struct {
+  ///
+  /// An identifier which identifies the agent which added the signature to the list.
+  ///
+  EFI_GUID          SignatureOwner;
+  ///
+  /// The format of the signature is defined by the SignatureType.
+  ///
+  UINT8             SignatureData[1];
+} EFI_SIGNATURE_DATA;
+
+typedef struct {
+  ///
+  /// Type of the signature. GUID signature types are defined in below.
+  ///
+  EFI_GUID            SignatureType;
+  ///
+  /// Total size of the signature list, including this header.
+  ///
+  UINT32              SignatureListSize;
+  ///
+  /// Size of the signature header which precedes the array of signatures.
+  ///
+  UINT32              SignatureHeaderSize;
+  ///
+  /// Size of each signature.
+  ///
+  UINT32              SignatureSize;
+  ///
+  /// Header before the array of signatures. The format of this header is specified
+  /// by the SignatureType.
+  /// UINT8           SignatureHeader[SignatureHeaderSize];
+  ///
+  /// An array of signatures. Each signature is SignatureSize bytes in length.
+  /// EFI_SIGNATURE_DATA Signatures[][SignatureSize];
+  ///
+} EFI_SIGNATURE_LIST;
+
+typedef struct {
+  ///
+  /// The SHA256 hash of an X.509 certificate's To-Be-Signed contents.
+  ///
+  EFI_SHA256_HASH     ToBeSignedHash;
+  ///
+  /// The time that the certificate shall be considered to be revoked.
+  ///
+  EFI_TIME            TimeOfRevocation;
+} EFI_CERT_X509_SHA256;
+
+typedef struct {
+  ///
+  /// The SHA384 hash of an X.509 certificate's To-Be-Signed contents.
+  ///
+  EFI_SHA384_HASH     ToBeSignedHash;
+  ///
+  /// The time that the certificate shall be considered to be revoked.
+  ///
+  EFI_TIME            TimeOfRevocation;
+} EFI_CERT_X509_SHA384;
+
+typedef struct {
+  ///
+  /// The SHA512 hash of an X.509 certificate's To-Be-Signed contents.
+  ///
+  EFI_SHA512_HASH     ToBeSignedHash;
+  ///
+  /// The time that the certificate shall be considered to be revoked.
+  ///
+  EFI_TIME            TimeOfRevocation;
+} EFI_CERT_X509_SHA512;
+
+#pragma pack()
+
+///
+/// This identifies a signature containing a SHA-256 hash. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) +
+/// 32 bytes.
+///
+#define EFI_CERT_SHA256_GUID \
+  { \
+    0xc1c41626, 0x504c, 0x4092, {0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28} \
+  }
+
+///
+/// This identifies a signature containing an RSA-2048 key. The key (only the modulus
+/// since the public key exponent is known to be 0x10001) shall be stored in big-endian
+/// order.
+/// The SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size
+/// of SignatureOwner component) + 256 bytes.
+///
+#define EFI_CERT_RSA2048_GUID \
+  { \
+    0x3c5766e8, 0x269c, 0x4e34, {0xaa, 0x14, 0xed, 0x77, 0x6e, 0x85, 0xb3, 0xb6} \
+  }
+
+///
+/// This identifies a signature containing a RSA-2048 signature of a SHA-256 hash.  The
+/// SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size of
+/// SignatureOwner component) + 256 bytes.
+///
+#define EFI_CERT_RSA2048_SHA256_GUID \
+  { \
+    0xe2b36190, 0x879b, 0x4a3d, {0xad, 0x8d, 0xf2, 0xe7, 0xbb, 0xa3, 0x27, 0x84} \
+  }
+
+///
+/// This identifies a signature containing a SHA-1 hash.  The SignatureSize shall always
+/// be 16 (size of SignatureOwner component) + 20 bytes.
+///
+#define EFI_CERT_SHA1_GUID \
+  { \
+    0x826ca512, 0xcf10, 0x4ac9, {0xb1, 0x87, 0xbe, 0x1, 0x49, 0x66, 0x31, 0xbd} \
+  }
+
+///
+/// TThis identifies a signature containing a RSA-2048 signature of a SHA-1 hash.  The
+/// SignatureHeader size shall always be 0. The SignatureSize shall always be 16 (size of
+/// SignatureOwner component) + 256 bytes.
+///
+#define EFI_CERT_RSA2048_SHA1_GUID \
+  { \
+    0x67f8444f, 0x8743, 0x48f1, {0xa3, 0x28, 0x1e, 0xaa, 0xb8, 0x73, 0x60, 0x80} \
+  }
+
+///
+/// This identifies a signature based on an X.509 certificate. If the signature is an X.509
+/// certificate then verification of the signature of an image should validate the public
+/// key certificate in the image using certificate path verification, up to this X.509
+/// certificate as a trusted root.  The SignatureHeader size shall always be 0. The
+/// SignatureSize may vary but shall always be 16 (size of the SignatureOwner component) +
+/// the size of the certificate itself.
+/// Note: This means that each certificate will normally be in a separate EFI_SIGNATURE_LIST.
+///
+#define EFI_CERT_X509_GUID \
+  { \
+    0xa5c059a1, 0x94e4, 0x4aa7, {0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72} \
+  }
+
+///
+/// This identifies a signature containing a SHA-224 hash. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) +
+/// 28 bytes.
+///
+#define EFI_CERT_SHA224_GUID \
+  { \
+    0xb6e5233, 0xa65c, 0x44c9, {0x94, 0x7, 0xd9, 0xab, 0x83, 0xbf, 0xc8, 0xbd} \
+  }
+
+///
+/// This identifies a signature containing a SHA-384 hash. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) +
+/// 48 bytes.
+///
+#define EFI_CERT_SHA384_GUID \
+  { \
+    0xff3e5307, 0x9fd0, 0x48c9, {0x85, 0xf1, 0x8a, 0xd5, 0x6c, 0x70, 0x1e, 0x1} \
+  }
+
+///
+/// This identifies a signature containing a SHA-512 hash. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of SignatureOwner component) +
+/// 64 bytes.
+///
+#define EFI_CERT_SHA512_GUID \
+  { \
+    0x93e0fae, 0xa6c4, 0x4f50, {0x9f, 0x1b, 0xd4, 0x1e, 0x2b, 0x89, 0xc1, 0x9a} \
+  }
+
+///
+/// This identifies a signature containing the SHA256 hash of an X.509 certificate's
+/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component)
+/// + 48 bytes for an EFI_CERT_X509_SHA256 structure. If the TimeOfRevocation is non-zero,
+/// the certificate should be considered to be revoked from that time and onwards, and
+/// otherwise the certificate shall be considered to always be revoked.
+///
+#define EFI_CERT_X509_SHA256_GUID \
+  { \
+    0x3bd2a492, 0x96c0, 0x4079, {0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed } \
+  }
+
+///
+/// This identifies a signature containing the SHA384 hash of an X.509 certificate's
+/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component)
+/// + 64 bytes for an EFI_CERT_X509_SHA384 structure. If the TimeOfRevocation is non-zero,
+/// the certificate should be considered to be revoked from that time and onwards, and
+/// otherwise the certificate shall be considered to always be revoked.
+///
+#define EFI_CERT_X509_SHA384_GUID \
+  { \
+    0x7076876e, 0x80c2, 0x4ee6, {0xaa, 0xd2, 0x28, 0xb3, 0x49, 0xa6, 0x86, 0x5b } \
+  }
+
+///
+/// This identifies a signature containing the SHA512 hash of an X.509 certificate's
+/// To-Be-Signed contents, and a time of revocation. The SignatureHeader size shall
+/// always be 0. The SignatureSize shall always be 16 (size of the SignatureOwner component)
+/// + 80 bytes for an EFI_CERT_X509_SHA512 structure. If the TimeOfRevocation is non-zero,
+/// the certificate should be considered to be revoked from that time and onwards, and
+/// otherwise the certificate shall be considered to always be revoked.
+///
+#define EFI_CERT_X509_SHA512_GUID \
+  { \
+    0x446dbf63, 0x2502, 0x4cda, {0xbc, 0xfa, 0x24, 0x65, 0xd2, 0xb0, 0xfe, 0x9d } \
+  }
+
+///
+/// This identifies a signature containing a DER-encoded PKCS #7 version 1.5 [RFC2315]
+/// SignedData value.
+///
+#define EFI_CERT_TYPE_PKCS7_GUID \
+  { \
+    0x4aafd29d, 0x68df, 0x49ee, {0x8a, 0xa9, 0x34, 0x7d, 0x37, 0x56, 0x65, 0xa7} \
+  }
+
+//***********************************************************************
+// Image Execution Information Table Definition
+//***********************************************************************
+typedef UINT32 EFI_IMAGE_EXECUTION_ACTION;
+
+#define EFI_IMAGE_EXECUTION_AUTHENTICATION      0x00000007
+#define EFI_IMAGE_EXECUTION_AUTH_UNTESTED       0x00000000
+#define EFI_IMAGE_EXECUTION_AUTH_SIG_FAILED     0x00000001
+#define EFI_IMAGE_EXECUTION_AUTH_SIG_PASSED     0x00000002
+#define EFI_IMAGE_EXECUTION_AUTH_SIG_NOT_FOUND  0x00000003
+#define EFI_IMAGE_EXECUTION_AUTH_SIG_FOUND      0x00000004
+#define EFI_IMAGE_EXECUTION_POLICY_FAILED       0x00000005
+#define EFI_IMAGE_EXECUTION_INITIALIZED         0x00000008
+
+//
+// EFI_IMAGE_EXECUTION_INFO is added to EFI System Configuration Table
+// and assigned the GUID EFI_IMAGE_SECURITY_DATABASE_GUID.
+//
+typedef struct {
+  ///
+  /// Describes the action taken by the firmware regarding this image.
+  ///
+  EFI_IMAGE_EXECUTION_ACTION    Action;
+  ///
+  /// Size of all of the entire structure.
+  ///
+  UINT32                        InfoSize;
+  ///
+  /// If this image was a UEFI device driver (for option ROM, for example) this is the
+  /// null-terminated, user-friendly name for the device. If the image was for an application,
+  /// then this is the name of the application. If this cannot be determined, then a simple
+  /// NULL character should be put in this position.
+  /// CHAR16                    Name[];
+  ///
+
+  ///
+  /// For device drivers, this is the device path of the device for which this device driver
+  /// was intended. In some cases, the driver itself may be stored as part of the system
+  /// firmware, but this field should record the device's path, not the firmware path. For
+  /// applications, this is the device path of the application. If this cannot be determined,
+  /// a simple end-of-path device node should be put in this position.
+  /// EFI_DEVICE_PATH_PROTOCOL  DevicePath;
+  ///
+
+  ///
+  /// Zero or more image signatures. If the image contained no signatures,
+  /// then this field is empty.
+  /// EFI_SIGNATURE_LIST            Signature;
+  /// 
+} EFI_IMAGE_EXECUTION_INFO;
+
+
+typedef struct {
+  ///
+  /// Number of EFI_IMAGE_EXECUTION_INFO structures.
+  ///
+  UINTN                     NumberOfImages;
+  ///
+  /// Number of image instances of EFI_IMAGE_EXECUTION_INFO structures.
+  ///
+  // EFI_IMAGE_EXECUTION_INFO  InformationInfo[]
+} EFI_IMAGE_EXECUTION_INFO_TABLE;
+
+extern EFI_GUID gEfiImageSecurityDatabaseGuid;
+extern EFI_GUID gEfiCertSha256Guid;
+extern EFI_GUID gEfiCertRsa2048Guid;
+extern EFI_GUID gEfiCertRsa2048Sha256Guid;
+extern EFI_GUID gEfiCertSha1Guid;
+extern EFI_GUID gEfiCertRsa2048Sha1Guid;
+extern EFI_GUID gEfiCertX509Guid;
+extern EFI_GUID gEfiCertSha224Guid;
+extern EFI_GUID gEfiCertSha384Guid;
+extern EFI_GUID gEfiCertSha512Guid;
+extern EFI_GUID gEfiCertX509Sha256Guid;
+extern EFI_GUID gEfiCertX509Sha384Guid;
+extern EFI_GUID gEfiCertX509Sha512Guid;
+extern EFI_GUID gEfiCertPkcs7Guid;
+
+#endif
diff --git a/MdePkg/Include/Guid/MdePkgTokenSpace.h b/MdePkg/Include/Guid/MdePkgTokenSpace.h
new file mode 100644
index 000000000000..70896ef67da1
--- /dev/null
+++ b/MdePkg/Include/Guid/MdePkgTokenSpace.h
@@ -0,0 +1,25 @@
+/** @file
+  GUID for MdePkg PCD Token Space 
+
+  Copyright (c) 2009, 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 _MDEPKG_TOKEN_SPACE_GUID_H_
+#define _MDEPKG_TOKEN_SPACE_GUID_H_
+
+#define MDEPKG_TOKEN_SPACE_GUID \
+  { \
+    0x914AEBE7, 0x4635, 0x459b, { 0xAA, 0x1C, 0x11, 0xE2, 0x19, 0xB0, 0x3A, 0x10 } \
+  }
+
+extern EFI_GUID gEfiMdePkgTokenSpaceGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/MemoryAllocationHob.h b/MdePkg/Include/Guid/MemoryAllocationHob.h
new file mode 100644
index 000000000000..788920c4801c
--- /dev/null
+++ b/MdePkg/Include/Guid/MemoryAllocationHob.h
@@ -0,0 +1,34 @@
+/** @file
+  GUIDs for HOBs used in memory allcation
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  GUIDs introduced in PI Version 1.0.
+
+**/
+
+#ifndef __MEMORY_ALLOCATION_GUID_H__
+#define __MEMORY_ALLOCATION_GUID_H__
+
+#define EFI_HOB_MEMORY_ALLOC_BSP_STORE_GUID  \
+  {0x564b33cd, 0xc92a, 0x4593, {0x90, 0xbf, 0x24, 0x73, 0xe4, 0x3c, 0x63, 0x22} };
+
+#define EFI_HOB_MEMORY_ALLOC_STACK_GUID  \
+  {0x4ed4bf27, 0x4092, 0x42e9, {0x80, 0x7d, 0x52, 0x7b, 0x1d, 0x0, 0xc9, 0xbd} }
+
+#define EFI_HOB_MEMORY_ALLOC_MODULE_GUID  \
+  {0xf8e21975, 0x899, 0x4f58, {0xa4, 0xbe, 0x55, 0x25, 0xa9, 0xc6, 0xd7, 0x7a} }
+
+extern EFI_GUID gEfiHobMemoryAllocBspStoreGuid;
+extern EFI_GUID gEfiHobMemoryAllocStackGuid;
+extern EFI_GUID gEfiHobMemoryAllocModuleGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/MemoryAttributesTable.h b/MdePkg/Include/Guid/MemoryAttributesTable.h
new file mode 100644
index 000000000000..1292771c2201
--- /dev/null
+++ b/MdePkg/Include/Guid/MemoryAttributesTable.h
@@ -0,0 +1,34 @@
+/** @file
+  GUIDs used for UEFI Memory Attributes Table in the UEFI 2.6 specification.
+
+  Copyright (c) 2016, 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_MEMORY_ATTRIBUTES_TABLE_H__
+#define __UEFI_MEMORY_ATTRIBUTES_TABLE_H__
+
+#define EFI_MEMORY_ATTRIBUTES_TABLE_GUID {\
+  0xdcfa911d, 0x26eb, 0x469f, {0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20} \
+}
+
+typedef struct {
+  UINT32                Version;
+  UINT32                NumberOfEntries;
+  UINT32                DescriptorSize;
+  UINT32                Reserved;
+//EFI_MEMORY_DESCRIPTOR Entry[1];
+} EFI_MEMORY_ATTRIBUTES_TABLE;
+
+#define EFI_MEMORY_ATTRIBUTES_TABLE_VERSION  0x00000001
+
+extern EFI_GUID gEfiMemoryAttributesTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/MemoryOverwriteControl.h b/MdePkg/Include/Guid/MemoryOverwriteControl.h
new file mode 100644
index 000000000000..d6869a121a6f
--- /dev/null
+++ b/MdePkg/Include/Guid/MemoryOverwriteControl.h
@@ -0,0 +1,76 @@
+/** @file
+  GUID used for MemoryOverwriteRequestControl UEFI variable defined in 
+  TCG Platform Reset Attack Mitigation Specification 1.00.
+  See http://trustedcomputinggroup.org for the latest specification
+
+  The purpose of the MemoryOverwriteRequestControl UEFI variable is to give users (e.g., OS, loader) the ability to 
+  indicate to the platform that secrets are present in memory and that the platform firmware must clear memory upon 
+  a restart. The OS loader should not create the variable. Rather, the  firmware is required to create it. 
+
+  Copyright (c) 2009, 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 _MEMORY_OVERWRITE_CONTROL_DATA_GUID_H_
+#define _MEMORY_OVERWRITE_CONTROL_DATA_GUID_H_
+
+#define MEMORY_ONLY_RESET_CONTROL_GUID \
+  { \
+    0xe20939be, 0x32d4, 0x41be, {0xa1, 0x50, 0x89, 0x7f, 0x85, 0xd4, 0x98, 0x29} \
+  }
+
+///
+///  Variable name is "MemoryOverwriteRequestControl" and it is a 1 byte unsigned value. 
+///  The attributes should be: 
+///  EFI_VARIABLE_NON_VOLATILE | 
+///  EFI_VARIABLE_BOOTSERVICE_ACCESS | 
+///  EFI_VARIABLE_RUNTIME_ACCESS 
+///
+#define MEMORY_OVERWRITE_REQUEST_VARIABLE_NAME L"MemoryOverwriteRequestControl"
+
+///
+/// 0 = Firmware MUST clear the MOR bi
+/// 1 = Firmware MUST set the MOR bit 
+///
+#define MOR_CLEAR_MEMORY_BIT_MASK        0x01
+
+///
+/// 0 = Firmware MAY autodetect a clean shutdown of the Static RTM OS.
+/// 1 = Firmware MUST NOT autodetect a clean shutdown of the Static RTM OS.
+///
+#define MOR_DISABLEAUTODETECT_BIT_MASK   0x10
+
+///
+/// MOR field bit offset
+///
+#define MOR_CLEAR_MEMORY_BIT_OFFSET      0
+#define MOR_DISABLEAUTODETECT_BIT_OFFSET 4
+
+/**
+  Return the ClearMemory bit value 0 or 1.
+
+  @param mor   1 byte value that contains ClearMemory and DisableAutoDetect bit.
+
+  @return ClearMemory bit value
+**/
+#define MOR_CLEAR_MEMORY_VALUE(mor)        (((UINT8)(mor) & MOR_CLEAR_MEMORY_BIT_MASK) >> MOR_CLEAR_MEMORY_BIT_OFFSET)
+
+/**
+  Return the DisableAutoDetect bit value 0 or 1.
+
+  @param mor   1 byte value that contains ClearMemory and DisableAutoDetect bit.
+
+  @return DisableAutoDetect bit value
+**/
+#define MOR_DISABLE_AUTO_DETECT_VALUE(mor) (((UINT8)(mor) & MOR_DISABLEAUTODETECT_BIT_MASK) >> MOR_DISABLEAUTODETECT_BIT_OFFSET)
+
+extern EFI_GUID gEfiMemoryOverwriteControlDataGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/Mps.h b/MdePkg/Include/Guid/Mps.h
new file mode 100644
index 000000000000..4d4692e3be22
--- /dev/null
+++ b/MdePkg/Include/Guid/Mps.h
@@ -0,0 +1,35 @@
+/** @file
+  GUIDs used for MPS entries in the UEFI 2.0 system table
+  ACPI is the primary means of exporting MPS information to the OS. MPS only was
+  included to support Itanium-based platform power on. So don't use it if you don't have too.
+
+  Copyright (c) 2006, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __MPS_GUID_H__
+#define __MPS_GUID_H__
+
+#define EFI_MPS_TABLE_GUID \
+  { \
+    0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+//
+// GUID name defined in spec.
+//
+#define MPS_TABLE_GUID EFI_MPS_TABLE_GUID
+
+extern EFI_GUID gEfiMpsTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/PcAnsi.h b/MdePkg/Include/Guid/PcAnsi.h
new file mode 100644
index 000000000000..7ff878d7f19e
--- /dev/null
+++ b/MdePkg/Include/Guid/PcAnsi.h
@@ -0,0 +1,58 @@
+/** @file
+  Terminal Device Path Vendor Guid.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __PC_ANSI_H__
+#define __PC_ANSI_H__
+
+#define EFI_PC_ANSI_GUID \
+  { \
+    0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_VT_100_GUID \
+  { \
+    0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_VT_100_PLUS_GUID \
+  { \
+    0x7baec70b, 0x57e0, 0x4c76, {0x8e, 0x87, 0x2f, 0x9e, 0x28, 0x08, 0x83, 0x43 } \
+  }
+
+#define EFI_VT_UTF8_GUID \
+  { \
+    0xad15a0d6, 0x8bec, 0x4acf, {0xa0, 0x73, 0xd0, 0x1d, 0xe7, 0x7e, 0x2d, 0x88 } \
+  }
+
+#define DEVICE_PATH_MESSAGING_UART_FLOW_CONTROL \
+  { \
+    0x37499a9d, 0x542f, 0x4c89, {0xa0, 0x26, 0x35, 0xda, 0x14, 0x20, 0x94, 0xe4 } \
+  }
+  
+#define EFI_SAS_DEVICE_PATH_GUID \
+  { \
+    0xd487ddb4, 0x008b, 0x11d9, {0xaf, 0xdc, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d } \
+  }
+
+extern EFI_GUID gEfiPcAnsiGuid;
+extern EFI_GUID gEfiVT100Guid;
+extern EFI_GUID gEfiVT100PlusGuid;
+extern EFI_GUID gEfiVTUTF8Guid;
+extern EFI_GUID gEfiUartDevicePathGuid;
+extern EFI_GUID gEfiSasDevicePathGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/PropertiesTable.h b/MdePkg/Include/Guid/PropertiesTable.h
new file mode 100644
index 000000000000..7fa382686044
--- /dev/null
+++ b/MdePkg/Include/Guid/PropertiesTable.h
@@ -0,0 +1,37 @@
+/** @file
+  GUIDs used for UEFI Properties Table in the UEFI 2.5 specification.
+
+  Copyright (c) 2015, 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 __EFI_PROPERTIES_TABLE_H__
+#define __EFI_PROPERTIES_TABLE_H__
+
+#define EFI_PROPERTIES_TABLE_GUID {\
+  0x880aaca3, 0x4adc, 0x4a04, {0x90, 0x79, 0xb7, 0x47, 0x34, 0x8, 0x25, 0xe5} \
+}
+
+typedef struct {
+  UINT32    Version;
+  UINT32    Length;
+  UINT64    MemoryProtectionAttribute;
+} EFI_PROPERTIES_TABLE;
+
+#define EFI_PROPERTIES_TABLE_VERSION  0x00010000
+
+//
+// Memory attribute (Not defined bit is reserved)
+//
+#define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA        0x1
+
+extern EFI_GUID gEfiPropertiesTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/SalSystemTable.h b/MdePkg/Include/Guid/SalSystemTable.h
new file mode 100644
index 000000000000..8994ee7bdf3f
--- /dev/null
+++ b/MdePkg/Include/Guid/SalSystemTable.h
@@ -0,0 +1,31 @@
+/** @file
+  GUIDs used for SAL system table entries in the EFI system table.
+
+  SAL System Table contains Itanium-based processor centric information about
+  the system.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.0 spec.
+
+**/
+
+#ifndef __SAL_SYSTEM_TABLE_GUID_H__
+#define __SAL_SYSTEM_TABLE_GUID_H__
+
+#define SAL_SYSTEM_TABLE_GUID \
+  { \
+    0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+extern EFI_GUID gEfiSalSystemTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/SmBios.h b/MdePkg/Include/Guid/SmBios.h
new file mode 100644
index 000000000000..05e11b7b63da
--- /dev/null
+++ b/MdePkg/Include/Guid/SmBios.h
@@ -0,0 +1,38 @@
+/** @file
+  GUIDs used to locate the SMBIOS tables in the UEFI 2.5 system table.
+
+  These GUIDs in the system table are the only legal ways to search for and
+  locate the SMBIOS tables. Do not search the 0xF0000 segment to find SMBIOS
+  tables.
+
+  Copyright (c) 2006 - 2015, 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.             
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.5 spec.
+
+**/
+
+#ifndef __SMBIOS_GUID_H__
+#define __SMBIOS_GUID_H__
+
+#define SMBIOS_TABLE_GUID \
+  { \
+    0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define SMBIOS3_TABLE_GUID \
+  { \
+    0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 } \
+  }
+
+extern EFI_GUID       gEfiSmbiosTableGuid;
+extern EFI_GUID       gEfiSmbios3TableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/StatusCodeDataTypeId.h b/MdePkg/Include/Guid/StatusCodeDataTypeId.h
new file mode 100644
index 000000000000..8bbc3315bc62
--- /dev/null
+++ b/MdePkg/Include/Guid/StatusCodeDataTypeId.h
@@ -0,0 +1,789 @@
+/** @file
+  GUID used to identify id for the caller who is initiating the Status Code.
+
+  Copyright (c) 2006 - 2013, 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.
+
+  @par Revision Reference:
+  These GUIDs and structures are defined in UEFI Platform Initialization Specification 1.2 
+  Volume 3: Shared Architectural Elements
+
+**/
+
+#ifndef __PI_STATUS_CODE_DATA_TYPE_ID_GUID_H__
+#define __PI_STATUS_CODE_DATA_TYPE_ID_GUID_H__
+
+#include <PiDxe.h>
+#include <Protocol/DebugSupport.h>
+
+///
+/// Global ID for the EFI_STATUS_CODE_STRING structure
+///
+#define EFI_STATUS_CODE_DATA_TYPE_STRING_GUID \
+  { 0x92D11080, 0x496F, 0x4D95, { 0xBE, 0x7E, 0x03, 0x74, 0x88, 0x38, 0x2B, 0x0A } }
+
+typedef enum {
+  ///
+  /// A NULL-terminated ASCII string.
+  ///
+  EfiStringAscii,
+  ///
+  /// A double NULL-terminated Unicode string.
+  ///
+  EfiStringUnicode,
+  ///
+  /// An EFI_STATUS_CODE_STRING_TOKEN representing the string.  The actual 
+  /// string can be obtained by querying the HII Database
+  ///
+  EfiStringToken
+} EFI_STRING_TYPE;
+ 
+///
+/// Specifies the format of the data in EFI_STATUS_CODE_STRING_DATA.String.
+///
+typedef struct {
+  ///
+  /// The HII package list which contains the string.  Handle is a dynamic value that may
+  /// not be the same for different boots.  Type EFI_HII_HANDLE is defined in
+  /// EFI_HII_DATABASE_PROTOCOL.NewPackageList() in the UEFI Specification.
+  ///
+  EFI_HII_HANDLE  Handle;
+  ///
+  /// When combined with Handle, the string token can be used to retrieve the string.
+  /// Type EFI_STRING_ID is defined in EFI_IFR_OP_HEADER in the UEFI Specification.
+  ///
+  EFI_STRING_ID   Token;
+} EFI_STATUS_CODE_STRING_TOKEN;
+ 
+typedef union {
+  ///
+  /// ASCII formatted string.
+  ///
+  CHAR8                         *Ascii;
+  ///
+  /// Unicode formatted string.
+  ///
+  CHAR16                        *Unicode;
+  ///
+  /// HII handle/token pair.
+  ///
+  EFI_STATUS_CODE_STRING_TOKEN  Hii;
+} EFI_STATUS_CODE_STRING;
+ 
+///
+/// This data type defines a string type of extended data. A string can accompany 
+/// any status code. The string can provide additional information about the 
+/// status code. The string can be ASCII, Unicode, or a Human Interface Infrastructure 
+/// (HII) token/GUID pair.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_STATUS_CODE_STRING_DATA) - HeaderSize, and
+  /// DataHeader.Type should be
+  /// EFI_STATUS_CODE_DATA_TYPE_STRING_GUID.
+  /// 
+  EFI_STATUS_CODE_DATA           DataHeader; 
+  ///
+  /// Specifies the format of the data in String.
+  ///
+  EFI_STRING_TYPE                StringType;
+  ///
+  /// A pointer to the extended data. The data follows the format specified by 
+  /// StringType.
+  ///
+  EFI_STATUS_CODE_STRING         String;
+} EFI_STATUS_CODE_STRING_DATA;
+
+extern EFI_GUID gEfiStatusCodeDataTypeStringGuid;
+
+///
+/// Global ID for the following structures:
+///   - EFI_DEVICE_PATH_EXTENDED_DATA
+///   - EFI_DEVICE_HANDLE_EXTENDED_DATA
+///   - EFI_RESOURCE_ALLOC_FAILURE_ERROR_DATA
+///   - EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA
+///   - EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA
+///   - EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA
+///   - EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA
+///   - EFI_MEMORY_RANGE_EXTENDED_DATA
+///   - EFI_DEBUG_ASSERT_DATA
+///   - EFI_STATUS_CODE_EXCEP_EXTENDED_DATA
+///   - EFI_STATUS_CODE_START_EXTENDED_DATA
+///   - EFI_LEGACY_OPROM_EXTENDED_DATA
+///
+#define EFI_STATUS_CODE_SPECIFIC_DATA_GUID \
+  { 0x335984bd, 0xe805, 0x409a, { 0xb8, 0xf8, 0xd2, 0x7e, 0xce, 0x5f, 0xf7, 0xa6 } }
+
+///
+/// Extended data about the device path, which is used for many errors and 
+/// progress codes to point to the device.
+///
+/// The device path is used to point to the physical device in case there is more than one device
+/// belonging to the same subclass. For example, the system may contain two USB keyboards and one
+/// PS/2* keyboard. The driver that parses the status code can use the device path extended data to
+/// differentiate between the three. The index field is not useful in this case because there is no standard
+/// numbering convention. Device paths are preferred over using device handles because device handles
+/// for a given device can change from one boot to another and do not mean anything beyond Boot
+/// Services time. In certain cases, the bus driver may not create a device handle for a given device if it
+/// detects a critical error. In these cases, the device path extended data can be used to refer to the
+/// device, but there may not be any device handles with an instance of
+/// EFI_DEVICE_PATH_PROTOCOL that matches DevicePath. The variable device path structure
+/// is included in this structure to make it self sufficient.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA). DataHeader.Size should be the size
+  /// of variable-length DevicePath, and DataHeader.Size is zero for a virtual
+  /// device that does not have a device path. DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA                 DataHeader;
+  ///
+  /// The device path to the controller or the hardware device. Note that this parameter is a 
+  /// variable-length device path structure and not a pointer to such a structure. This structure is
+  /// populated only if it is a physical device. For virtual devices, the Size field in DataHeader
+  /// is set to zero and this field is not populated.
+  ///
+  //  EFI_DEVICE_PATH_PROTOCOL         DevicePath;
+} EFI_DEVICE_PATH_EXTENDED_DATA;
+
+///
+/// Device handle Extended Data. Used for many
+/// errors and progress codes to point to the device.
+///
+/// The handle of the device with which the progress or error code is associated. The handle is
+/// guaranteed to be accurate only at the time the status code is reported. Handles are dynamic entities
+/// between boots, so handles cannot be considered to be valid if the system has reset subsequent to the
+/// status code being reported. Handles may be used to determine a wide variety of useful information
+/// about the source of the status code.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_DEVICE_HANDLE_EXTENDED_DATA) - HeaderSize, and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The device handle.
+  ///
+  EFI_HANDLE            Handle;
+} EFI_DEVICE_HANDLE_EXTENDED_DATA;
+
+///
+/// This structure defines extended data describing a PCI resource allocation error.
+///
+/// @par Note: 
+///   The following structure contains variable-length fields and cannot be defined as a C-style
+///   structure.
+///
+/// This extended data conveys details for a PCI resource allocation failure error. See the PCI
+/// specification and the ACPI specification for details on PCI resource allocations and the format for
+/// resource descriptors. This error does not detail why the resource allocation failed. It may be due to a
+/// bad resource request or a lack of available resources to satisfy a valid request. The variable device
+/// path structure and the resource structures are included in this structure to make it self sufficient.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be sizeof
+  /// (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// (DevicePathSize + DevicePathSize + DevicePathSize +
+  /// sizeof(UINT32) + 3 * sizeof (UINT16) ), and DataHeader.Type
+  /// should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA               DataHeader;
+  ///
+  /// The PCI BAR. Applicable only for PCI devices. Ignored for all other devices.
+  ///
+  UINT32                             Bar;
+  ///
+  /// DevicePathSize should be zero if it is a virtual device that is not associated with
+  /// a device path. Otherwise, this parameter is the length of the variable-length
+  /// DevicePath. 
+  ///
+  UINT16                             DevicePathSize;
+  ///
+  /// Represents the size the ReqRes parameter. ReqResSize should be zero if the
+  /// requested resources are not provided as a part of extended data.
+  ///
+  UINT16                             ReqResSize;
+  ///
+  /// Represents the size the AllocRes parameter. AllocResSize should be zero if the
+  /// allocated resources are not provided as a part of extended data.
+  ///
+  UINT16                             AllocResSize;
+  ///
+  /// The device path to the controller or the hardware device that did not get the requested 
+  /// resources. Note that this parameter is the variable-length device path structure and not 
+  /// a pointer to this structure. 
+  ///
+  //  EFI_DEVICE_PATH_PROTOCOL       DevicePath;
+  ///
+  /// The requested resources in the format of an ACPI 2.0 resource descriptor. This
+  /// parameter is not a pointer; it is the complete resource descriptor.
+  ///
+  //  UINT8                          ReqRes[];
+  ///
+  /// The allocated resources in the format of an ACPI 2.0 resource descriptor. This 
+  /// parameter is not a pointer; it is the complete resource descriptor.
+  ///
+  //  UINT8                          AllocRes[];
+} EFI_RESOURCE_ALLOC_FAILURE_ERROR_DATA;
+
+///
+/// This structure provides a calculation for base-10 representations.
+///
+/// Not consistent with PI 1.2 Specification.
+/// This data type is not defined in the PI 1.2 Specification, but is 
+/// required by several of the other data structures in this file.
+///
+typedef struct {
+  ///
+  /// The INT16 number by which to multiply the base-2 representation.
+  ///
+  INT16                            Value;
+  ///
+  /// The INT16 number by which to raise the base-2 calculation. 
+  ///
+  INT16                            Exponent;
+} EFI_EXP_BASE10_DATA;
+
+///
+/// This structure provides the voltage at the time of error. It also provides 
+/// the threshold value indicating the minimum or maximum voltage that is considered 
+/// an error. If the voltage is less then the threshold, the error indicates that the 
+/// voltage fell below the minimum acceptable value. If the voltage is greater then the threshold, 
+/// the error indicates that the voltage rose above the maximum acceptable value.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA) -
+  /// HeaderSize, and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The voltage value at the time of the error.
+  ///
+  EFI_EXP_BASE10_DATA   Voltage;
+  ///
+  /// The voltage threshold.
+  ///
+  EFI_EXP_BASE10_DATA   Threshold;
+} EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA;
+
+///
+/// Microcode Update Extended Error Data
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA) -
+  /// HeaderSize, and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The version of the microcode update from the header.
+  ///
+  UINT32                Version;
+} EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA;
+
+///
+/// This structure provides details about the computing unit timer expiration error.
+/// The timer limit provides the timeout value of the timer prior to expiration.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA) -
+  /// HeaderSize, and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The number of seconds that the computing unit timer was configured to expire.
+  ///
+  EFI_EXP_BASE10_DATA   TimerLimit;
+} EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA;
+
+///
+/// Attribute bits for EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA.Attributes
+/// All other attributes are reserved for future use and must be initialized to 0.
+///
+///@{
+#define EFI_COMPUTING_UNIT_MISMATCH_SPEED       0x0001
+#define EFI_COMPUTING_UNIT_MISMATCH_FSB_SPEED   0x0002
+#define EFI_COMPUTING_UNIT_MISMATCH_FAMILY      0x0004
+#define EFI_COMPUTING_UNIT_MISMATCH_MODEL       0x0008
+#define EFI_COMPUTING_UNIT_MISMATCH_STEPPING    0x0010
+#define EFI_COMPUTING_UNIT_MISMATCH_CACHE_SIZE  0x0020
+#define EFI_COMPUTING_UNIT_MISMATCH_OEM1        0x1000
+#define EFI_COMPUTING_UNIT_MISMATCH_OEM2        0x2000
+#define EFI_COMPUTING_UNIT_MISMATCH_OEM3        0x4000
+#define EFI_COMPUTING_UNIT_MISMATCH_OEM4        0x8000
+///@}
+
+///
+/// This structure defines extended data for processor mismatch errors.
+///
+/// This provides information to indicate which processors mismatch, and how they mismatch. The 
+/// status code contains the instance number of the processor that is in error. This structure's 
+/// Instance indicates the second processor that does not match. This differentiation allows the 
+/// consumer to determine which two processors do not match. The Attributes indicate what 
+/// mismatch is being reported. Because Attributes is a bit field, more than one mismatch can be 
+/// reported with one error code.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_ HOST_PROCESSOR_MISMATCH_ERROR_DATA) -
+  /// HeaderSize , and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The unit number of the computing unit that does not match.
+  ///  
+  UINT32                Instance;
+  /// 
+  /// The attributes describing the failure. 
+  ///  
+  UINT16                Attributes;
+} EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA;
+
+///
+/// This structure provides details about the computing unit thermal failure.
+///
+/// This structure provides the temperature at the time of error. It also provides the threshold value 
+/// indicating the minimum temperature that is considered an error.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_COMPUTING_UNIT_THERMAL_ERROR_DATA) -
+  /// HeaderSize , and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The thermal value at the time of the error.
+  ///
+  EFI_EXP_BASE10_DATA   Temperature;
+  ///
+  /// The thermal threshold.
+  ///
+  EFI_EXP_BASE10_DATA   Threshold;
+} EFI_COMPUTING_UNIT_THERMAL_ERROR_DATA;
+
+///
+/// Enumeration of valid cache types
+///
+typedef enum {
+  EfiInitCacheDataOnly,
+  EfiInitCacheInstrOnly,
+  EfiInitCacheBoth,
+  EfiInitCacheUnspecified
+} EFI_INIT_CACHE_TYPE;
+
+///
+/// Embedded cache init extended data
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_CACHE_INIT_DATA) - HeaderSize , and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The cache level. Starts with 1 for level 1 cache.
+  ///
+  UINT32                Level;
+  ///
+  /// The type of cache.
+  ///
+  EFI_INIT_CACHE_TYPE   Type;
+} EFI_CACHE_INIT_DATA;
+
+///
+///
+///
+typedef UINT32  EFI_CPU_STATE_CHANGE_CAUSE;
+
+///
+/// The reasons that the processor is disabled.  
+/// Used to fill in EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA.Cause.
+///
+///@{
+#define EFI_CPU_CAUSE_INTERNAL_ERROR            0x0001
+#define EFI_CPU_CAUSE_THERMAL_ERROR             0x0002
+#define EFI_CPU_CAUSE_SELFTEST_FAILURE          0x0004
+#define EFI_CPU_CAUSE_PREBOOT_TIMEOUT           0x0008
+#define EFI_CPU_CAUSE_FAILED_TO_START           0x0010
+#define EFI_CPU_CAUSE_CONFIG_ERROR              0x0020
+#define EFI_CPU_CAUSE_USER_SELECTION            0x0080
+#define EFI_CPU_CAUSE_BY_ASSOCIATION            0x0100
+#define EFI_CPU_CAUSE_UNSPECIFIED               0x8000
+///@}
+
+///
+/// This structure provides information about the disabled computing unit.
+///
+/// This structure provides details as to why and how the computing unit was disabled. The causes 
+/// should cover the typical reasons a processor would be disabled. How the processor was disabled is 
+/// important because there are distinct differences between hardware and software disabling.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA) -
+  /// HeaderSize, and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The reason for disabling the processor. 
+  /// 
+  UINT32                Cause;
+  ///
+  /// TRUE if the processor is disabled via software means such as not listing it in the ACPI tables. 
+  /// Such a processor will respond to Interprocessor Interrupts (IPIs). FALSE if the processor is hardware 
+  /// disabled, which means it is invisible to software and will not respond to IPIs.
+  ///
+  BOOLEAN               SoftwareDisabled;
+} EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA;
+
+///
+/// Memory Error Granularity Definition
+///
+typedef UINT8 EFI_MEMORY_ERROR_GRANULARITY;
+
+///
+/// Memory Error Granularities.  Used to fill in EFI_MEMORY_EXTENDED_ERROR_DATA.Granularity.
+///
+///@{
+#define EFI_MEMORY_ERROR_OTHER      0x01
+#define EFI_MEMORY_ERROR_UNKNOWN    0x02
+#define EFI_MEMORY_ERROR_DEVICE     0x03
+#define EFI_MEMORY_ERROR_PARTITION  0x04
+///@}
+
+///
+/// Memory Error Operation Definition
+///
+typedef UINT8 EFI_MEMORY_ERROR_OPERATION;
+
+///
+/// Memory Error Operations.  Used to fill in EFI_MEMORY_EXTENDED_ERROR_DATA.Operation.
+///
+///@{
+#define EFI_MEMORY_OPERATION_OTHER 0x01
+#define EFI_MEMORY_OPERATION_UNKNOWN 0x02
+#define EFI_MEMORY_OPERATION_READ 0x03
+#define EFI_MEMORY_OPERATION_WRITE 0x04
+#define EFI_MEMORY_OPERATION_PARTIAL_WRITE 0x05
+///@}
+
+///
+/// This structure provides specific details about the memory error that was detected. It provides 
+/// enough information so that consumers can identify the exact failure and provides enough 
+/// information to enable corrective action if necessary.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_MEMORY_EXTENDED_ERROR_DATA) - HeaderSize, and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA          DataHeader;
+  ///
+  /// The error granularity type.
+  ///
+  EFI_MEMORY_ERROR_GRANULARITY  Granularity;
+  ///
+  /// The operation that resulted in the error being detected. 
+  ///
+  EFI_MEMORY_ERROR_OPERATION    Operation;
+  ///
+  /// The error syndrome, vendor-specific ECC syndrome, or CRC data associated with 
+  /// the error.  If unknown, should be initialized to 0.
+  /// Inconsistent with specification here:  
+  /// This field in StatusCodes spec0.9 is defined as UINT32, keep code unchanged.
+  ///
+  UINTN                         Syndrome;
+  ///
+  /// The physical address of the error. 
+  ///
+  EFI_PHYSICAL_ADDRESS          Address;
+  ///
+  /// The range, in bytes, within which the error address can be determined.
+  ///
+  UINTN                         Resolution;
+} EFI_MEMORY_EXTENDED_ERROR_DATA;
+
+///
+/// A definition to describe that the operation is performed on multiple devices within the array.
+/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. 
+///
+#define EFI_MULTIPLE_MEMORY_DEVICE_OPERATION 0xfffe
+
+///
+/// A definition to describe that the operation is performed on all devices within the array.
+/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. 
+///
+#define EFI_ALL_MEMORY_DEVICE_OPERATION 0xffff
+
+///
+/// A definition to describe that the operation is performed on multiple arrays.
+/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. 
+///
+#define EFI_MULTIPLE_MEMORY_ARRAY_OPERATION 0xfffe
+
+///
+/// A definition to describe that the operation is performed on all the arrays.
+/// May be used for EFI_STATUS_CODE_DIMM_NUMBER.Array and EFI_STATUS_CODE_DIMM_NUMBER.Device. 
+///
+#define EFI_ALL_MEMORY_ARRAY_OPERATION 0xffff
+
+///
+/// This extended data provides some context that consumers can use to locate a DIMM within the 
+/// overall memory scheme.  
+///
+/// This extended data provides some context that consumers can use to locate a DIMM within the
+/// overall memory scheme. The Array and Device numbers may indicate a specific DIMM, or they
+/// may be populated with the group definitions in "Related Definitions" below.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_STATUS_CODE_DIMM_NUMBER) - HeaderSize, and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The memory array number.
+  ///
+  UINT16                Array;
+  ///
+  /// The device number within that Array.
+  ///
+  UINT16                Device;
+} EFI_STATUS_CODE_DIMM_NUMBER;
+
+///
+/// This structure defines extended data describing memory modules that do not match.
+///
+/// This extended data may be used to convey the specifics of memory modules that do not match.
+/// 
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_MEMORY_MODULE_MISMATCH_ERROR_DATA) -
+  /// HeaderSize, and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  ///
+  EFI_STATUS_CODE_DATA         DataHeader;
+  ///
+  /// The instance number of the memory module that does not match. 
+  ///
+  EFI_STATUS_CODE_DIMM_NUMBER  Instance;
+} EFI_MEMORY_MODULE_MISMATCH_ERROR_DATA;
+
+///
+/// This structure defines extended data describing a memory range.
+///
+/// This extended data may be used to convey the specifics of a memory range.  Ranges are specified 
+/// with a start address and a length.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_MEMORY_RANGE_EXTENDED_DATA) - HeaderSize, and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The starting address of the memory range. 
+  ///
+  EFI_PHYSICAL_ADDRESS  Start;
+  ///
+  /// The length in bytes of the memory range.
+  ///
+  EFI_PHYSICAL_ADDRESS  Length;
+} EFI_MEMORY_RANGE_EXTENDED_DATA;
+
+///
+/// This structure provides the assert information that is typically associated with a debug assertion failing.
+///
+/// The data indicates the location of the assertion that failed in the source code. This information
+/// includes the file name and line number that are necessary to find the failing assertion in source code.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_DEBUG_ASSERT_DATA) - HeaderSize , and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.
+  /// 
+  EFI_STATUS_CODE_DATA         DataHeader;
+  ///
+  /// The line number of the source file where the fault was generated.
+  ///
+  UINT32                       LineNumber;
+  ///
+  /// The size in bytes of FileName.
+  ///
+  UINT32                       FileNameSize;
+  ///
+  /// A pointer to a NULL-terminated ASCII or Unicode string that represents 
+  /// the file name of the source file where the fault was generated.
+  ///
+  EFI_STATUS_CODE_STRING_DATA  *FileName;
+} EFI_DEBUG_ASSERT_DATA;
+
+///
+/// System Context Data EBC/IA32/IPF
+///
+typedef union {
+  ///
+  /// The context of the EBC virtual machine when the exception was generated. Type
+  /// EFI_SYSTEM_CONTEXT_EBC is defined in EFI_DEBUG_SUPPORT_PROTOCOL
+  /// in the UEFI Specification.
+  ///
+  EFI_SYSTEM_CONTEXT_EBC  SystemContextEbc;
+  ///
+  /// The context of the IA-32 processor when the exception was generated. Type
+  /// EFI_SYSTEM_CONTEXT_IA32 is defined in the
+  /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification.
+  ///
+  EFI_SYSTEM_CONTEXT_IA32 SystemContextIa32;
+  ///
+  /// The context of the Itanium(R) processor when the exception was generated. Type
+  /// EFI_SYSTEM_CONTEXT_IPF is defined in the
+  /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification.
+  ///
+  EFI_SYSTEM_CONTEXT_IPF  SystemContextIpf;
+  ///
+  /// The context of the X64 processor when the exception was generated. Type
+  /// EFI_SYSTEM_CONTEXT_X64 is defined in the
+  /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification.
+  ///
+  EFI_SYSTEM_CONTEXT_X64  SystemContextX64; 
+  ///
+  /// The context of the ARM processor when the exception was generated. Type
+  /// EFI_SYSTEM_CONTEXT_ARM is defined in the
+  /// EFI_DEBUG_SUPPORT_PROTOCOL in the UEFI Specification.
+  ///
+  EFI_SYSTEM_CONTEXT_ARM  SystemContextArm;
+} EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT;
+
+///
+/// This structure defines extended data describing a processor exception error.
+///
+/// This extended data allows the processor context that is present at the time of the exception to be
+/// reported with the exception. The format and contents of the context data varies depending on the
+/// processor architecture.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_STATUS_CODE_EXCEP_EXTENDED_DATA) - HeaderSize,
+  /// and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA                  DataHeader;
+  ///
+  /// The system context. 
+  ///
+  EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT  Context;
+} EFI_STATUS_CODE_EXCEP_EXTENDED_DATA;
+
+///
+/// This structure defines extended data describing a call to a driver binding protocol start function.
+///
+/// This extended data records information about a Start() function call. Start() is a member of
+/// the UEFI Driver Binding Protocol.
+///
+typedef struct {
+  /// 
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_STATUS_CODE_START_EXTENDED_DATA) - HeaderSize,
+  /// and DataHeader.Type should be
+  /// EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA           DataHeader;
+  ///
+  /// The controller handle. 
+  ///
+  EFI_HANDLE                     ControllerHandle;
+  ///
+  /// The driver binding handle.
+  ///
+  EFI_HANDLE                     DriverBindingHandle;
+  /// 
+  /// The size of the RemainingDevicePath. It is zero if the Start() function is 
+  /// called with RemainingDevicePath = NULL.  The UEFI Specification allows
+  /// that the Start() function of bus drivers can be called in this way.
+  ///
+  UINT16                         DevicePathSize;
+  ///
+  /// Matches the RemainingDevicePath parameter being passed to the Start() function. 
+  /// Note that this parameter is the variable-length device path and not a pointer 
+  /// to the device path.
+  ///  
+  //  EFI_DEVICE_PATH_PROTOCOL   RemainingDevicePath;
+} EFI_STATUS_CODE_START_EXTENDED_DATA;
+
+///
+/// This structure defines extended data describing a legacy option ROM (OpROM).
+///
+/// The device handle and ROM image base can be used by consumers to determine which option ROM
+/// failed. Due to the black-box nature of legacy option ROMs, the amount of information that can be
+/// obtained may be limited.
+///
+typedef struct {
+  ///
+  /// The data header identifying the data. DataHeader.HeaderSize should be
+  /// sizeof (EFI_STATUS_CODE_DATA), DataHeader.Size should be
+  /// sizeof (EFI_LEGACY_OPROM_EXTENDED_DATA) - HeaderSize, and
+  /// DataHeader.Type should be EFI_STATUS_CODE_SPECIFIC_DATA_GUID.  
+  ///
+  EFI_STATUS_CODE_DATA  DataHeader;
+  ///
+  /// The handle corresponding to the device that this legacy option ROM is being invoked.
+  ///
+  EFI_HANDLE            DeviceHandle;
+  ///
+  /// The base address of the shadowed legacy ROM image.  May or may not point to the shadow RAM area. 
+  ///
+  EFI_PHYSICAL_ADDRESS  RomImageBase;
+} EFI_LEGACY_OPROM_EXTENDED_DATA;
+
+extern EFI_GUID gEfiStatusCodeSpecificDataGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/SystemResourceTable.h b/MdePkg/Include/Guid/SystemResourceTable.h
new file mode 100644
index 000000000000..dc7e16bd241f
--- /dev/null
+++ b/MdePkg/Include/Guid/SystemResourceTable.h
@@ -0,0 +1,125 @@
+/** @file
+  Guid & data structure used for EFI System Resource Table (ESRT)
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  GUIDs defined in UEFI 2.5 spec.
+
+**/
+
+
+#ifndef _SYSTEM_RESOURCE_TABLE_H__
+#define _SYSTEM_RESOURCE_TABLE_H__
+
+#define EFI_SYSTEM_RESOURCE_TABLE_GUID \
+  { \
+    0xb122a263, 0x3661, 0x4f68, {0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 } \
+  }
+
+///
+/// Current Entry Version
+///
+#define EFI_SYSTEM_RESOURCE_TABLE_FIRMWARE_RESOURCE_VERSION  1
+
+///
+/// Firmware Type Definitions
+///
+#define ESRT_FW_TYPE_UNKNOWN         0x00000000
+#define ESRT_FW_TYPE_SYSTEMFIRMWARE  0x00000001
+#define ESRT_FW_TYPE_DEVICEFIRMWARE  0x00000002
+#define ESRT_FW_TYPE_UEFIDRIVER      0x00000003
+
+///
+/// Last Attempt Status Values
+///
+#define LAST_ATTEMPT_STATUS_SUCCESS                       0x00000000
+#define LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL            0x00000001
+#define LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES  0x00000002
+#define LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION       0x00000003
+#define LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT          0x00000004
+#define LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR              0x00000005
+#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_AC              0x00000006
+#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_BATT            0x00000007
+
+typedef struct {
+  ///
+  /// The firmware class field contains a GUID that identifies a firmware component
+  /// that can be updated via UpdateCapsule(). This GUID must be unique within all
+  /// entries of the ESRT.
+  ///
+  EFI_GUID                   FwClass;
+  ///
+  /// Identifies the type of firmware resource.
+  ///
+  UINT32                     FwType;
+  ///
+  /// The firmware version field represents the current version of the firmware
+  /// resource, value must always increase as a larger number represents a newer
+  /// version.
+  ///
+  UINT32                     FwVersion;
+  ///
+  /// The lowest firmware resource version to which a firmware resource can be
+  /// rolled back for the given system/device. Generally this is used to protect
+  /// against known and fixed security issues.
+  ///
+  UINT32                     LowestSupportedFwVersion;
+  ///
+  /// The capsule flags field contains the CapsuleGuid flags (bits 0- 15) as defined
+  /// in the EFI_CAPSULE_HEADER that will be set in the capsule header.
+  ///
+  UINT32                     CapsuleFlags;
+  ///
+  /// The last attempt version field describes the last firmware version for which
+  /// an update was attempted (uses the same format as Firmware Version).
+  /// Last Attempt Version is updated each time an UpdateCapsule() is attempted for
+  /// an ESRT entry and is preserved across reboots (non-volatile). However, in
+  /// cases where the attempt version is not recorded due to limitations in the
+  /// update process, the field shall set to zero after a failed update. Similarly,
+  /// in the case of a removable device, this value is set to 0 in cases where the
+  /// device has not been updated since being added to the system.
+  ///
+  UINT32                     LastAttemptVersion;
+  ///
+  /// The last attempt status field describes the result of the last firmware update
+  /// attempt for the firmware resource entry.
+  /// LastAttemptStatus is updated each time an UpdateCapsule() is attempted for an
+  /// ESRT entry and is preserved across reboots (non-volatile).
+  /// If a firmware update has never been attempted or is unknown, for example after
+  /// fresh insertion of a removable device, LastAttemptStatus must be set to Success.
+  ///
+  UINT32                     LastAttemptStatus;
+} EFI_SYSTEM_RESOURCE_ENTRY;
+
+typedef struct {
+  ///
+  /// The number of firmware resources in the table, must not be zero.
+  ///
+  UINT32                     FwResourceCount;
+  ///
+  /// The maximum number of resource array entries that can be within the table
+  /// without reallocating the table, must not be zero.
+  ///
+  UINT32                     FwResourceCountMax;
+  ///
+  /// The version of the EFI_SYSTEM_RESOURCE_ENTRY entities used in this table.
+  /// This field should be set to 1.
+  ///
+  UINT64                     FwResourceVersion;
+  ///
+  /// Array of EFI_SYSTEM_RESOURCE_ENTRY
+  ///
+  //EFI_SYSTEM_RESOURCE_ENTRY  Entries[];
+} EFI_SYSTEM_RESOURCE_TABLE;
+
+extern EFI_GUID gEfiSystemResourceTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/VectorHandoffTable.h b/MdePkg/Include/Guid/VectorHandoffTable.h
new file mode 100644
index 000000000000..256b34550f4b
--- /dev/null
+++ b/MdePkg/Include/Guid/VectorHandoffTable.h
@@ -0,0 +1,33 @@
+/** @file
+  GUID for system configuration table entry that points to the table
+  in case an entity in DXE wishes to update/change the vector table contents. 
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  GUID defined in PI 1.2.1 spec.
+**/
+
+#ifndef __EFI_VECTOR_HANDOFF_TABLE_H__
+#define __EFI_VECTOR_HANDOFF_TABLE_H__
+
+#include <Ppi/VectorHandoffInfo.h>
+
+//
+// System configuration table entry that points to the table
+// in case an entity in DXE wishes to update/change the vector
+// table contents.
+//
+#define EFI_VECTOR_HANDOF_TABLE_GUID \
+  { 0x996ec11c, 0x5397, 0x4e73, { 0xb5, 0x8f, 0x82, 0x7e, 0x52, 0x90, 0x6d, 0xef }}
+
+extern EFI_GUID gEfiVectorHandoffTableGuid;
+
+#endif
diff --git a/MdePkg/Include/Guid/WinCertificate.h b/MdePkg/Include/Guid/WinCertificate.h
new file mode 100644
index 000000000000..6dea446ba060
--- /dev/null
+++ b/MdePkg/Include/Guid/WinCertificate.h
@@ -0,0 +1,128 @@
+/** @file
+  GUID for UEFI WIN_CERTIFICATE structure.
+
+  Copyright (c) 2006 - 2012, 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.
+
+  @par Revision Reference:
+  GUID defined in UEFI 2.0 spec.
+**/
+
+#ifndef __EFI_WIN_CERTIFICATE_H__
+#define __EFI_WIN_CERTIFICATE_H__
+
+//
+// _WIN_CERTIFICATE.wCertificateType
+//
+#define WIN_CERT_TYPE_PKCS_SIGNED_DATA 0x0002
+#define WIN_CERT_TYPE_EFI_PKCS115      0x0EF0
+#define WIN_CERT_TYPE_EFI_GUID         0x0EF1
+
+///
+/// The WIN_CERTIFICATE structure is part of the PE/COFF specification.
+///
+typedef struct {
+  ///
+  /// The length of the entire certificate,
+  /// including the length of the header, in bytes.
+  ///
+  UINT32  dwLength;
+  ///
+  /// The revision level of the WIN_CERTIFICATE
+  /// structure. The current revision level is 0x0200.
+  ///
+  UINT16  wRevision;
+  ///
+  /// The certificate type. See WIN_CERT_TYPE_xxx for the UEFI
+  /// certificate types. The UEFI specification reserves the range of
+  /// certificate type values from 0x0EF0 to 0x0EFF.
+  ///
+  UINT16  wCertificateType;
+  ///
+  /// The following is the actual certificate. The format of
+  /// the certificate depends on wCertificateType.
+  ///
+  /// UINT8 bCertificate[ANYSIZE_ARRAY];
+  ///
+} WIN_CERTIFICATE;
+
+///
+/// WIN_CERTIFICATE_UEFI_GUID.CertType
+///
+#define EFI_CERT_TYPE_RSA2048_SHA256_GUID \
+  {0xa7717414, 0xc616, 0x4977, {0x94, 0x20, 0x84, 0x47, 0x12, 0xa7, 0x35, 0xbf } }
+
+///
+/// WIN_CERTIFICATE_UEFI_GUID.CertData
+///
+typedef struct {
+  EFI_GUID  HashType;
+  UINT8     PublicKey[256];
+  UINT8     Signature[256];
+} EFI_CERT_BLOCK_RSA_2048_SHA256;
+
+
+///
+/// Certificate which encapsulates a GUID-specific digital signature
+///
+typedef struct {
+  ///
+  /// This is the standard WIN_CERTIFICATE header, where
+  /// wCertificateType is set to WIN_CERT_TYPE_EFI_GUID.
+  ///
+  WIN_CERTIFICATE   Hdr;
+  ///
+  /// This is the unique id which determines the
+  /// format of the CertData. .
+  ///
+  EFI_GUID          CertType;
+  ///
+  /// The following is the certificate data. The format of
+  /// the data is determined by the CertType.
+  /// If CertType is EFI_CERT_TYPE_RSA2048_SHA256_GUID,
+  /// the CertData will be EFI_CERT_BLOCK_RSA_2048_SHA256 structure.
+  ///
+  UINT8            CertData[1];
+} WIN_CERTIFICATE_UEFI_GUID;
+
+
+///
+/// Certificate which encapsulates the RSASSA_PKCS1-v1_5 digital signature.
+///
+/// The WIN_CERTIFICATE_UEFI_PKCS1_15 structure is derived from
+/// WIN_CERTIFICATE and encapsulate the information needed to
+/// implement the RSASSA-PKCS1-v1_5 digital signature algorithm as
+/// specified in RFC2437.
+///
+typedef struct {
+  ///
+  /// This is the standard WIN_CERTIFICATE header, where
+  /// wCertificateType is set to WIN_CERT_TYPE_UEFI_PKCS1_15.
+  ///
+  WIN_CERTIFICATE Hdr;
+  ///
+  /// This is the hashing algorithm which was performed on the
+  /// UEFI executable when creating the digital signature.
+  ///
+  EFI_GUID        HashAlgorithm;
+  ///
+  /// The following is the actual digital signature. The
+  /// size of the signature is the same size as the key
+  /// (1024-bit key is 128 bytes) and can be determined by
+  /// subtracting the length of the other parts of this header
+  /// from the total length of the certificate as found in
+  /// Hdr.dwLength.
+  ///
+  /// UINT8 Signature[];
+  ///
+} WIN_CERTIFICATE_EFI_PKCS1_15;
+
+extern EFI_GUID gEfiCertTypeRsa2048Sha256Guid;
+
+#endif
diff --git a/MdePkg/Include/Ia32/ProcessorBind.h b/MdePkg/Include/Ia32/ProcessorBind.h
new file mode 100644
index 000000000000..9eb6954706d7
--- /dev/null
+++ b/MdePkg/Include/Ia32/ProcessorBind.h
@@ -0,0 +1,318 @@
+/** @file
+  Processor or Compiler specific defines and types for IA-32 architecture.
+
+Copyright (c) 2006 - 2015, 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices.
+///
+#define MDE_CPU_IA32
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#if defined(__INTEL_COMPILER)
+//
+// Disable ICC's remark #869: "Parameter" was never referenced warning.
+// This is legal ANSI C code so we disable the remark that is turned on with -Wall
+//
+#pragma warning ( disable : 869 )
+
+//
+// Disable ICC's remark #1418: external function definition with no prior declaration.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1418 )
+
+//
+// Disable ICC's remark #1419: external declaration in primary source file
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1419 )
+
+//
+// Disable ICC's remark #593: "Variable" was set but never used.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 593 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+//
+// Disable warning that make it impossible to compile at /W4
+// This only works for Microsoft* tools
+//
+
+//
+// Disabling bitfield type checking warnings.
+//
+#pragma warning ( disable : 4214 )
+
+//
+// Disabling the unreferenced formal parameter warnings.
+//
+#pragma warning ( disable : 4100 )
+
+//
+// Disable slightly different base types warning as CHAR8 * can not be set
+// to a constant string.
+//
+#pragma warning ( disable : 4057 )
+
+//
+// ASSERT(FALSE) or while (TRUE) are legal constructs so suppress this warning
+//
+#pragma warning ( disable : 4127 )
+
+//
+// This warning is caused by functions defined but not used. For precompiled header only.
+//
+#pragma warning ( disable : 4505 )
+
+//
+// This warning is caused by empty (after preprocessing) source file. For precompiled header only.
+//
+#pragma warning ( disable : 4206 )
+
+#if _MSC_VER == 1800 || _MSC_VER == 1900
+
+//
+// Disable these warnings for VS2013.
+//
+
+//
+// This warning is for potentially uninitialized local variable, and it may cause false 
+// positive issues in VS2013 and VS2015 build
+//
+#pragma warning ( disable : 4701 )
+  
+//
+// This warning is for potentially uninitialized local pointer variable, and it may cause 
+// false positive issues in VS2013 and VS2015 build
+//
+#pragma warning ( disable : 4703 )
+  
+#endif
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+  //
+  // use Microsoft C compiler dependent integer width types
+  //
+
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned __int64    UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef __int64             INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned __int32    UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef __int32             INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character.
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value.
+  ///
+  typedef signed char         INT8;
+#else  
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned long long  UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef long long           INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned int        UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef int                 INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef UINT32  UINTN;
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef INT32   INTN;
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x80000000
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC0000000
+
+///
+/// Maximum legal IA-32 address.
+///
+#define MAX_ADDRESS   0xFFFFFFFF
+
+///
+/// Maximum legal IA-32 INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFF)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFF)
+
+///
+/// The stack alignment required for IA-32.
+///
+#define CPU_STACK_ALIGNMENT   sizeof(UINTN)
+
+///
+/// Page allocation granularity for IA-32.
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#elif defined(_MSC_EXTENSIONS)
+  ///
+  /// Microsoft* compiler specific method for EFIAPI calling convention.
+  /// 
+  #define EFIAPI __cdecl  
+#elif defined(__GNUC__)
+  ///
+  /// GCC specific method for EFIAPI calling convention.
+  /// 
+  #define EFIAPI __attribute__((cdecl))  
+#else
+  ///
+  /// The default for a non Microsoft* or GCC compiler is to assume the EFI ABI
+  /// is the standard. 
+  ///
+  #define EFIAPI
+#endif
+
+#if defined(__GNUC__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On IA-32 CPU architectures, these two pointer values are the same, 
+  so the implementation of this macro is very simple.
+  
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+  
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__ _
+#endif
+
+#endif
+
diff --git a/MdePkg/Include/IndustryStandard/Acpi.h b/MdePkg/Include/IndustryStandard/Acpi.h
new file mode 100644
index 000000000000..3d35f599b4e6
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi.h
@@ -0,0 +1,21 @@
+/** @file
+  This file contains the latest ACPI definitions that are
+  consumed by drivers that do not care about ACPI versions.
+
+  Copyright (c) 2006 - 2016, 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 _ACPI_H_
+#define _ACPI_H_
+
+#include <IndustryStandard/Acpi61.h>
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi10.h b/MdePkg/Include/IndustryStandard/Acpi10.h
new file mode 100644
index 000000000000..5a17db6ac570
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi10.h
@@ -0,0 +1,661 @@
+/** @file   
+  ACPI 1.0b definitions from the ACPI Specification, revision 1.0b
+
+Copyright (c) 2006 - 2011, 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 _ACPI_1_0_H_
+#define _ACPI_1_0_H_
+
+#include <IndustryStandard/AcpiAml.h>
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure.
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_COMMON_HEADER;
+
+#pragma pack(1)
+///
+/// The common ACPI description table header.  This structure prefaces most ACPI tables.
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT8   Revision;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT64  OemTableId;
+  UINT32  OemRevision;
+  UINT32  CreatorId;
+  UINT32  CreatorRevision;
+} EFI_ACPI_DESCRIPTION_HEADER;
+#pragma pack()
+
+//
+// Define for Desriptor
+//
+#define ACPI_SMALL_ITEM_FLAG                   0x00
+#define ACPI_LARGE_ITEM_FLAG                   0x01
+
+//
+// Small Item Descriptor Name
+//
+#define ACPI_SMALL_IRQ_DESCRIPTOR_NAME                       0x04
+#define ACPI_SMALL_DMA_DESCRIPTOR_NAME                       0x05
+#define ACPI_SMALL_START_DEPENDENT_DESCRIPTOR_NAME           0x06
+#define ACPI_SMALL_END_DEPENDENT_DESCRIPTOR_NAME             0x07
+#define ACPI_SMALL_IO_PORT_DESCRIPTOR_NAME                   0x08
+#define ACPI_SMALL_FIXED_IO_PORT_DESCRIPTOR_NAME             0x09
+#define ACPI_SMALL_VENDOR_DEFINED_DESCRIPTOR_NAME            0x0E
+#define ACPI_SMALL_END_TAG_DESCRIPTOR_NAME                   0x0F
+
+//
+// Large Item Descriptor Name
+//
+#define ACPI_LARGE_24_BIT_MEMORY_RANGE_DESCRIPTOR_NAME       0x01
+#define ACPI_LARGE_VENDOR_DEFINED_DESCRIPTOR_NAME            0x04
+#define ACPI_LARGE_32_BIT_MEMORY_RANGE_DESCRIPTOR_NAME       0x05
+#define ACPI_LARGE_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR_NAME 0x06
+#define ACPI_LARGE_DWORD_ADDRESS_SPACE_DESCRIPTOR_NAME       0x07
+#define ACPI_LARGE_WORD_ADDRESS_SPACE_DESCRIPTOR_NAME        0x08
+#define ACPI_LARGE_EXTENDED_IRQ_DESCRIPTOR_NAME              0x09
+#define ACPI_LARGE_QWORD_ADDRESS_SPACE_DESCRIPTOR_NAME       0x0A
+
+//
+// Small Item Descriptor Value
+//
+#define ACPI_IRQ_NOFLAG_DESCRIPTOR                0x22
+#define ACPI_IRQ_DESCRIPTOR                       0x23
+#define ACPI_DMA_DESCRIPTOR                       0x2A
+#define ACPI_START_DEPENDENT_DESCRIPTOR           0x30
+#define ACPI_START_DEPENDENT_EX_DESCRIPTOR        0x31
+#define ACPI_END_DEPENDENT_DESCRIPTOR             0x38
+#define ACPI_IO_PORT_DESCRIPTOR                   0x47
+#define ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR    0x4B
+#define ACPI_END_TAG_DESCRIPTOR                   0x79
+
+//
+// Large Item Descriptor Value
+//
+#define ACPI_24_BIT_MEMORY_RANGE_DESCRIPTOR       0x81
+#define ACPI_32_BIT_MEMORY_RANGE_DESCRIPTOR       0x85
+#define ACPI_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR 0x86
+#define ACPI_DWORD_ADDRESS_SPACE_DESCRIPTOR       0x87
+#define ACPI_WORD_ADDRESS_SPACE_DESCRIPTOR        0x88
+#define ACPI_EXTENDED_INTERRUPT_DESCRIPTOR        0x89
+#define ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR       0x8A
+#define ACPI_ADDRESS_SPACE_DESCRIPTOR             0x8A
+
+//
+// Resource Type
+//
+#define ACPI_ADDRESS_SPACE_TYPE_MEM   0x00
+#define ACPI_ADDRESS_SPACE_TYPE_IO    0x01
+#define ACPI_ADDRESS_SPACE_TYPE_BUS   0x02
+
+///
+/// Power Management Timer frequency is fixed at 3.579545MHz.
+///
+#define ACPI_TIMER_FREQUENCY       3579545
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// The commond definition of QWORD, DWORD, and WORD
+/// Address Space Descriptors.
+///
+typedef PACKED struct {
+  UINT8   Desc;
+  UINT16  Len;
+  UINT8   ResType;
+  UINT8   GenFlag;
+  UINT8   SpecificFlag;
+  UINT64  AddrSpaceGranularity;
+  UINT64  AddrRangeMin;
+  UINT64  AddrRangeMax;
+  UINT64  AddrTranslationOffset;
+  UINT64  AddrLen;
+} EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR;
+
+typedef PACKED union {
+  UINT8     Byte;
+  PACKED struct {
+    UINT8 Length : 3;
+    UINT8 Name : 4;
+    UINT8 Type : 1;
+  } Bits;
+} ACPI_SMALL_RESOURCE_HEADER;
+
+typedef PACKED struct {
+  PACKED union {
+    UINT8 Byte;
+    PACKED struct {
+      UINT8 Name : 7;
+      UINT8 Type : 1;
+    }Bits;
+  } Header;
+  UINT16 Length;
+} ACPI_LARGE_RESOURCE_HEADER;
+
+///
+/// IRQ Descriptor.
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT16                       Mask;
+} EFI_ACPI_IRQ_NOFLAG_DESCRIPTOR;
+
+///
+/// IRQ Descriptor.
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT16                       Mask;
+  UINT8                        Information;
+} EFI_ACPI_IRQ_DESCRIPTOR;
+
+///
+/// DMA Descriptor.
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT8                        ChannelMask;
+  UINT8                        Information;
+} EFI_ACPI_DMA_DESCRIPTOR;
+
+///
+/// I/O Port Descriptor
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT8                        Information;
+  UINT16                       BaseAddressMin;
+  UINT16                       BaseAddressMax;
+  UINT8                        Alignment;
+  UINT8                        Length;
+} EFI_ACPI_IO_PORT_DESCRIPTOR;
+
+///
+/// Fixed Location I/O Port Descriptor.
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT16                       BaseAddress;
+  UINT8                        Length;
+} EFI_ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR;
+
+///
+/// 24-Bit Memory Range Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         Information;
+  UINT16                        BaseAddressMin;
+  UINT16                        BaseAddressMax;
+  UINT16                        Alignment;
+  UINT16                        Length;
+} EFI_ACPI_24_BIT_MEMORY_RANGE_DESCRIPTOR;
+
+///
+/// 32-Bit Memory Range Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         Information;
+  UINT32                        BaseAddressMin;
+  UINT32                        BaseAddressMax;
+  UINT32                        Alignment;
+  UINT32                        Length;
+} EFI_ACPI_32_BIT_MEMORY_RANGE_DESCRIPTOR;
+
+///
+/// Fixed 32-Bit Fixed Memory Range Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         Information;
+  UINT32                        BaseAddress;
+  UINT32                        Length;
+} EFI_ACPI_32_BIT_FIXED_MEMORY_RANGE_DESCRIPTOR;
+
+///
+/// QWORD Address Space Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         ResType;
+  UINT8                         GenFlag;
+  UINT8                         SpecificFlag;
+  UINT64                        AddrSpaceGranularity;
+  UINT64                        AddrRangeMin;
+  UINT64                        AddrRangeMax;
+  UINT64                        AddrTranslationOffset;
+  UINT64                        AddrLen;
+} EFI_ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR;
+
+///
+/// DWORD Address Space Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         ResType;
+  UINT8                         GenFlag;
+  UINT8                         SpecificFlag;
+  UINT32                        AddrSpaceGranularity;
+  UINT32                        AddrRangeMin;
+  UINT32                        AddrRangeMax;
+  UINT32                        AddrTranslationOffset;
+  UINT32                        AddrLen;
+} EFI_ACPI_DWORD_ADDRESS_SPACE_DESCRIPTOR;
+
+///
+/// WORD Address Space Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         ResType;
+  UINT8                         GenFlag;
+  UINT8                         SpecificFlag;
+  UINT16                        AddrSpaceGranularity;
+  UINT16                        AddrRangeMin;
+  UINT16                        AddrRangeMax;
+  UINT16                        AddrTranslationOffset;
+  UINT16                        AddrLen;
+} EFI_ACPI_WORD_ADDRESS_SPACE_DESCRIPTOR;
+
+///
+/// Extended Interrupt Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         InterruptVectorFlags;
+  UINT8                         InterruptTableLength;
+  UINT32                        InterruptNumber[1];
+} EFI_ACPI_EXTENDED_INTERRUPT_DESCRIPTOR;
+
+#pragma pack()
+
+///
+/// The End tag identifies an end of resource data.
+///
+typedef struct {
+  UINT8 Desc;
+  UINT8 Checksum;
+} EFI_ACPI_END_TAG_DESCRIPTOR;
+
+//
+// General use definitions
+//
+#define EFI_ACPI_RESERVED_BYTE  0x00
+#define EFI_ACPI_RESERVED_WORD  0x0000
+#define EFI_ACPI_RESERVED_DWORD 0x00000000
+#define EFI_ACPI_RESERVED_QWORD 0x0000000000000000
+
+//
+// Resource Type Specific Flags
+// Ref ACPI specification 6.4.3.5.5
+//
+// Bit [0]    : Write Status, _RW
+//
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_READ_WRITE                (1 << 0)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_READ_ONLY                 (0 << 0)
+//
+// Bit [2:1]  : Memory Attributes, _MEM
+//
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_NON_CACHEABLE             (0 << 1)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_CACHEABLE                 (1 << 1)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_CACHEABLE_WRITE_COMBINING (2 << 1)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_CACHEABLE_PREFETCHABLE    (3 << 1)
+//
+// Bit [4:3]  : Memory Attributes, _MTP
+//
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_ADDRESS_RANGE_MEMORY      (0 << 3)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_ADDRESS_RANGE_RESERVED    (1 << 3)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_ADDRESS_RANGE_ACPI        (2 << 3)
+#define EFI_APCI_MEMORY_RESOURCE_SPECIFIC_FLAG_ADDRESS_RANGE_NVS         (3 << 3)
+//
+// Bit [5]    : Memory to I/O Translation, _TTP
+//
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_TYPE_TRANSLATION          (1 << 5)
+#define EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_TYPE_STATIC               (0 << 5)
+
+//
+// IRQ Information
+// Ref ACPI specification 6.4.2.1
+//
+#define EFI_ACPI_IRQ_SHARABLE_MASK                      0x10
+#define   EFI_ACPI_IRQ_SHARABLE                         0x10
+
+#define EFI_ACPI_IRQ_POLARITY_MASK                      0x08
+#define   EFI_ACPI_IRQ_HIGH_TRUE                        0x00
+#define   EFI_ACPI_IRQ_LOW_FALSE                        0x08
+
+#define EFI_ACPI_IRQ_MODE                               0x01
+#define   EFI_ACPI_IRQ_LEVEL_TRIGGERED                  0x00
+#define   EFI_ACPI_IRQ_EDGE_TRIGGERED                   0x01
+
+//
+// DMA Information
+// Ref ACPI specification 6.4.2.2
+//
+#define EFI_ACPI_DMA_SPEED_TYPE_MASK                    0x60
+#define   EFI_ACPI_DMA_SPEED_TYPE_COMPATIBILITY         0x00
+#define   EFI_ACPI_DMA_SPEED_TYPE_A                     0x20
+#define   EFI_ACPI_DMA_SPEED_TYPE_B                     0x40
+#define   EFI_ACPI_DMA_SPEED_TYPE_F                     0x60
+                                               
+#define EFI_ACPI_DMA_BUS_MASTER_MASK                    0x04
+#define   EFI_ACPI_DMA_BUS_MASTER                       0x04
+
+#define EFI_ACPI_DMA_TRANSFER_TYPE_MASK                 0x03
+#define   EFI_ACPI_DMA_TRANSFER_TYPE_8_BIT              0x00
+#define   EFI_ACPI_DMA_TRANSFER_TYPE_8_BIT_AND_16_BIT   0x01
+#define   EFI_ACPI_DMA_TRANSFER_TYPE_16_BIT             0x10
+
+//
+// IO Information
+// Ref ACPI specification 6.4.2.5
+//
+#define EFI_ACPI_IO_DECODE_MASK                         0x01
+#define   EFI_ACPI_IO_DECODE_16_BIT                     0x01
+#define   EFI_ACPI_IO_DECODE_10_BIT                     0x00
+
+//
+// Memory Information
+// Ref ACPI specification 6.4.3.4
+//
+#define EFI_ACPI_MEMORY_WRITE_STATUS_MASK               0x01
+#define   EFI_ACPI_MEMORY_WRITABLE                      0x01
+#define   EFI_ACPI_MEMORY_NON_WRITABLE                  0x00
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+//
+// ACPI 1.0b table structures
+//
+
+///
+/// Root System Description Pointer Structure.
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Reserved;
+  UINT32  RsdtAddress;
+} EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 1.0b specification).
+///
+#define EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT).
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      FirmwareCtrl;
+  UINT32                      Dsdt;
+  UINT8                       IntModel;
+  UINT8                       Reserved1;
+  UINT16                      SciInt;
+  UINT32                      SmiCmd;
+  UINT8                       AcpiEnable;
+  UINT8                       AcpiDisable;
+  UINT8                       S4BiosReq;
+  UINT8                       Reserved2;
+  UINT32                      Pm1aEvtBlk;
+  UINT32                      Pm1bEvtBlk;
+  UINT32                      Pm1aCntBlk;
+  UINT32                      Pm1bCntBlk;
+  UINT32                      Pm2CntBlk;
+  UINT32                      PmTmrBlk;
+  UINT32                      Gpe0Blk;
+  UINT32                      Gpe1Blk;
+  UINT8                       Pm1EvtLen;
+  UINT8                       Pm1CntLen;
+  UINT8                       Pm2CntLen;
+  UINT8                       PmTmLen;
+  UINT8                       Gpe0BlkLen;
+  UINT8                       Gpe1BlkLen;
+  UINT8                       Gpe1Base;
+  UINT8                       Reserved3;
+  UINT16                      PLvl2Lat;
+  UINT16                      PLvl3Lat;
+  UINT16                      FlushSize;
+  UINT16                      FlushStride;
+  UINT8                       DutyOffset;
+  UINT8                       DutyWidth;
+  UINT8                       DayAlrm;
+  UINT8                       MonAlrm;
+  UINT8                       Century;
+  UINT8                       Reserved4;
+  UINT8                       Reserved5;
+  UINT8                       Reserved6;
+  UINT32                      Flags;
+} EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 1.0b specification).
+///
+#define EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x01
+
+#define EFI_ACPI_1_0_INT_MODE_DUAL_PIC         0
+#define EFI_ACPI_1_0_INT_MODE_MULTIPLE_APIC    1
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_1_0_WBINVD               BIT0
+#define EFI_ACPI_1_0_WBINVD_FLUSH         BIT1
+#define EFI_ACPI_1_0_PROC_C1              BIT2
+#define EFI_ACPI_1_0_P_LVL2_UP            BIT3
+#define EFI_ACPI_1_0_PWR_BUTTON           BIT4
+#define EFI_ACPI_1_0_SLP_BUTTON           BIT5
+#define EFI_ACPI_1_0_FIX_RTC              BIT6
+#define EFI_ACPI_1_0_RTC_S4               BIT7
+#define EFI_ACPI_1_0_TMR_VAL_EXT          BIT8
+#define EFI_ACPI_1_0_DCK_CAP              BIT9
+
+///
+/// Firmware ACPI Control Structure.
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT8   Reserved[40];
+} EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// Firmware Control Structure Feature Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_1_0_S4BIOS_F             BIT0
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform-specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_1_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 1.0b specification).
+///
+#define EFI_ACPI_1_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_1_0_PCAT_COMPAT           BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x05 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_1_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_1_0_IO_APIC                        0x01
+#define EFI_ACPI_1_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_1_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_1_0_LOCAL_APIC_NMI                 0x04
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_1_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_1_0_LOCAL_APIC_ENABLED      BIT0
+
+///
+/// IO APIC Structure.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  SystemVectorBase;
+} EFI_ACPI_1_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterruptVector;
+  UINT16  Flags;
+} EFI_ACPI_1_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Non-Maskable Interrupt Source Structure.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterruptVector;
+} EFI_ACPI_1_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicInti;
+} EFI_ACPI_1_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_1_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer.
+///
+#define EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ')
+
+///
+/// "APIC" Multiple APIC Description Table.
+///
+#define EFI_ACPI_1_0_APIC_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "DSDT" Differentiated System Description Table.
+///
+#define EFI_ACPI_1_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "FACS" Firmware ACPI Control Structure.
+///
+#define EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FACP" Fixed ACPI Description Table.
+///
+#define EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "PSDT" Persistent System Description Table.
+///
+#define EFI_ACPI_1_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RSDT" Root System Description Table.
+///
+#define EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table.
+///
+#define EFI_ACPI_1_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SSDT" Secondary System Description Table.
+///
+#define EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi20.h b/MdePkg/Include/IndustryStandard/Acpi20.h
new file mode 100644
index 000000000000..d84b7db7b7da
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi20.h
@@ -0,0 +1,545 @@
+/** @file   
+  ACPI 2.0 definitions from the ACPI Specification, revision 2.0
+
+  Copyright (c) 2006 - 2011, 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 _ACPI_2_0_H_
+#define _ACPI_2_0_H_
+
+#include <IndustryStandard/Acpi10.h>
+
+//
+// Define for Desriptor
+//
+#define ACPI_LARGE_GENERIC_REGISTER_DESCRIPTOR_NAME          0x02
+
+#define ACPI_GENERIC_REGISTER_DESCRIPTOR          0x82
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// Generic Register Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         AddressSpaceId;
+  UINT8                         RegisterBitWidth;
+  UINT8                         RegisterBitOffset;
+  UINT8                         AddressSize;
+  UINT64                        RegisterAddress;
+} EFI_ACPI_GENERIC_REGISTER_DESCRIPTOR;
+
+#pragma pack()
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 2.0 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   Reserved;
+  UINT64  Address;
+} EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_2_0_SYSTEM_MEMORY              0
+#define EFI_ACPI_2_0_SYSTEM_IO                  1
+#define EFI_ACPI_2_0_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_2_0_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_2_0_SMBUS                      4
+#define EFI_ACPI_2_0_FUNCTIONAL_FIXED_HARDWARE  0x7F
+
+//
+// ACPI 2.0 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_2_0_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT8                                   Reserved2[3];
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+} EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x03
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_2_0_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_2_0_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_2_0_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_2_0_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_2_0_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_2_0_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_2_0_PM_PROFILE_APPLIANCE_PC        6
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_2_0_LEGACY_DEVICES          BIT0
+#define EFI_ACPI_2_0_8042                    BIT1
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_2_0_WBINVD                  BIT0
+#define EFI_ACPI_2_0_WBINVD_FLUSH            BIT1
+#define EFI_ACPI_2_0_PROC_C1                 BIT2
+#define EFI_ACPI_2_0_P_LVL2_UP               BIT3
+#define EFI_ACPI_2_0_PWR_BUTTON              BIT4
+#define EFI_ACPI_2_0_SLP_BUTTON              BIT5
+#define EFI_ACPI_2_0_FIX_RTC                 BIT6
+#define EFI_ACPI_2_0_RTC_S4                  BIT7
+#define EFI_ACPI_2_0_TMR_VAL_EXT             BIT8
+#define EFI_ACPI_2_0_DCK_CAP                 BIT9
+#define EFI_ACPI_2_0_RESET_REG_SUP           BIT10
+#define EFI_ACPI_2_0_SEALED_CASE             BIT11
+#define EFI_ACPI_2_0_HEADLESS                BIT12
+#define EFI_ACPI_2_0_CPU_SW_SLP              BIT13
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved[31];
+} EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x01
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_2_0_S4BIOS_F        BIT0
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_2_0_PCAT_COMPAT          BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x09 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_2_0_IO_APIC                        0x01
+#define EFI_ACPI_2_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_2_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_2_0_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_2_0_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_2_0_IO_SAPIC                       0x06
+#define EFI_ACPI_2_0_PROCESSOR_LOCAL_SAPIC          0x07
+#define EFI_ACPI_2_0_PLATFORM_INTERRUPT_SOURCES     0x08
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_2_0_LOCAL_APIC_ENABLED         BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_2_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_2_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_2_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_2_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_2_0_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_2_0_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+} EFI_ACPI_2_0_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  Reserved;
+} EFI_ACPI_2_0_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_2_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_2_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 2.0 spec.)
+///
+#define EFI_ACPI_2_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ')
+
+///
+/// "SPIC" Multiple SAPIC Description Table
+///
+/// BUGBUG: Don't know where this came from except SR870BN4 uses it.
+/// #define EFI_ACPI_2_0_MULTIPLE_SAPIC_DESCRIPTION_TABLE_SIGNATURE 0x43495053
+///
+#define EFI_ACPI_2_0_MULTIPLE_SAPIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_2_0_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "DBGP" MS Bebug Port Spec
+///
+#define EFI_ACPI_2_0_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_2_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_2_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_2_0_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_2_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_2_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_2_0_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_2_0_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SRAT" Static Resource Affinity Table
+///
+#define EFI_ACPI_2_0_STATIC_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_2_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_2_0_SERVER_PLATFORM_MANAGEMENT_INTERFACE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_2_0_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi30.h b/MdePkg/Include/IndustryStandard/Acpi30.h
new file mode 100644
index 000000000000..d510d8b93469
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi30.h
@@ -0,0 +1,729 @@
+/** @file   
+  ACPI 3.0 definitions from the ACPI Specification Revision 3.0b October 10, 2006
+
+  Copyright (c) 2006 - 2011, 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 _ACPI_3_0_H_
+#define _ACPI_3_0_H_
+
+#include <IndustryStandard/Acpi20.h>
+
+//
+// Define for Desriptor
+//
+#define ACPI_LARGE_EXTENDED_ADDRESS_SPACE_DESCRIPTOR_NAME    0x0B
+
+#define ACPI_EXTENDED_ADDRESS_SPACE_DESCRIPTOR    0x8B
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// Extended Address Space Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         ResType;
+  UINT8                         GenFlag;
+  UINT8                         SpecificFlag;
+  UINT8                         RevisionId;
+  UINT8                         Reserved;
+  UINT64                        AddrSpaceGranularity;
+  UINT64                        AddrRangeMin;
+  UINT64                        AddrRangeMax;
+  UINT64                        AddrTranslationOffset;
+  UINT64                        AddrLen;
+  UINT64                        TypeSpecificAttribute;
+} EFI_ACPI_EXTENDED_ADDRESS_SPACE_DESCRIPTOR;
+
+#pragma pack()
+
+//
+// Memory Type Specific Flags
+//
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_UC  0x0000000000000001
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_WC  0x0000000000000002
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_WT  0x0000000000000004
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_WB  0x0000000000000008
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_UCE 0x0000000000000010
+#define EFI_ACPI_MEMORY_TYPE_SPECIFIC_ATTRIBUTES_NV  0x0000000000008000
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 3.0 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_3_0_SYSTEM_MEMORY              0
+#define EFI_ACPI_3_0_SYSTEM_IO                  1
+#define EFI_ACPI_3_0_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_3_0_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_3_0_SMBUS                      4
+#define EFI_ACPI_3_0_FUNCTIONAL_FIXED_HARDWARE  0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_3_0_UNDEFINED  0
+#define EFI_ACPI_3_0_BYTE       1
+#define EFI_ACPI_3_0_WORD       2
+#define EFI_ACPI_3_0_DWORD      3
+#define EFI_ACPI_3_0_QWORD      4
+
+//
+// ACPI 3.0 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 3.0b spec.)
+///
+#define EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 3.0b) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_3_0_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT8                                   Reserved2[3];
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+} EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x04
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_3_0_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_3_0_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_3_0_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_3_0_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_3_0_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_3_0_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_3_0_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_3_0_PM_PROFILE_PERFORMANCE_SERVER  7
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_3_0_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_3_0_8042                        BIT1
+#define EFI_ACPI_3_0_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_3_0_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_3_0_PCIE_ASPM_CONTROLS          BIT4
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_3_0_WBINVD                                 BIT0
+#define EFI_ACPI_3_0_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_3_0_PROC_C1                                BIT2
+#define EFI_ACPI_3_0_P_LVL2_UP                              BIT3
+#define EFI_ACPI_3_0_PWR_BUTTON                             BIT4
+#define EFI_ACPI_3_0_SLP_BUTTON                             BIT5
+#define EFI_ACPI_3_0_FIX_RTC                                BIT6
+#define EFI_ACPI_3_0_RTC_S4                                 BIT7
+#define EFI_ACPI_3_0_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_3_0_DCK_CAP                                BIT9
+#define EFI_ACPI_3_0_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_3_0_SEALED_CASE                            BIT11
+#define EFI_ACPI_3_0_HEADLESS                               BIT12
+#define EFI_ACPI_3_0_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_3_0_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_3_0_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_3_0_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_3_0_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_3_0_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_3_0_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved[31];
+} EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x01
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_3_0_S4BIOS_F       BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_3_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x02
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_3_0_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x09 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_3_0_IO_APIC                        0x01
+#define EFI_ACPI_3_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_3_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_3_0_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_3_0_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_3_0_IO_SAPIC                       0x06
+#define EFI_ACPI_3_0_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_3_0_PLATFORM_INTERRUPT_SOURCES     0x08
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_3_0_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_3_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_3_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_3_0_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_3_0_POLARITY      (3 << 0)
+#define EFI_ACPI_3_0_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_3_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_3_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_3_0_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_3_0_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_3_0_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_3_0_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_3_0_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_3_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_3_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_3_0_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x02
+
+//
+// SRAT structure types.
+// All other values between 0x02 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_3_0_MEMORY_AFFINITY                      0x01
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT8   Reserved[4];
+} EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_3_0_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_3_0_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_3_0_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_3_0_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_3_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 3.0 spec.)
+///
+#define EFI_ACPI_3_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_3_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_3_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_3_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_3_0_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_3_0_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_3_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_3_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_3_0_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_3_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_3_0_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_3_0_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_3_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_3_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_3_0_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_3_0_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_3_0_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_3_0_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_3_0_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WSPT" Windows Specific Properties Table
+///
+#define EFI_ACPI_3_0_WINDOWS_SPECIFIC_PROPERTIES_TABLE_SIGNATURE  SIGNATURE_32('W', 'S', 'P', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_3_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi40.h b/MdePkg/Include/IndustryStandard/Acpi40.h
new file mode 100644
index 000000000000..94ae5fc56727
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi40.h
@@ -0,0 +1,1309 @@
+/** @file   
+  ACPI 4.0 definitions from the ACPI Specification Revision 4.0a April 5, 2010
+
+  Copyright (c) 2010 - 2011, 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 _ACPI_4_0_H_
+#define _ACPI_4_0_H_
+
+#include <IndustryStandard/Acpi30.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 4.0 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_4_0_SYSTEM_MEMORY              0
+#define EFI_ACPI_4_0_SYSTEM_IO                  1
+#define EFI_ACPI_4_0_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_4_0_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_4_0_SMBUS                      4
+#define EFI_ACPI_4_0_FUNCTIONAL_FIXED_HARDWARE  0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_4_0_UNDEFINED  0
+#define EFI_ACPI_4_0_BYTE       1
+#define EFI_ACPI_4_0_WORD       2
+#define EFI_ACPI_4_0_DWORD      3
+#define EFI_ACPI_4_0_QWORD      4
+
+//
+// ACPI 4.0 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_4_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 4.0b spec.)
+///
+#define EFI_ACPI_4_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 4.0a) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_4_0_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT8                                   Reserved2[3];
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+} EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x04
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_4_0_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_4_0_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_4_0_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_4_0_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_4_0_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_4_0_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_4_0_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_4_0_PM_PROFILE_PERFORMANCE_SERVER  7
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_4_0_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_4_0_8042                        BIT1
+#define EFI_ACPI_4_0_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_4_0_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_4_0_PCIE_ASPM_CONTROLS          BIT4
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_4_0_WBINVD                                 BIT0
+#define EFI_ACPI_4_0_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_4_0_PROC_C1                                BIT2
+#define EFI_ACPI_4_0_P_LVL2_UP                              BIT3
+#define EFI_ACPI_4_0_PWR_BUTTON                             BIT4
+#define EFI_ACPI_4_0_SLP_BUTTON                             BIT5
+#define EFI_ACPI_4_0_FIX_RTC                                BIT6
+#define EFI_ACPI_4_0_RTC_S4                                 BIT7
+#define EFI_ACPI_4_0_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_4_0_DCK_CAP                                BIT9
+#define EFI_ACPI_4_0_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_4_0_SEALED_CASE                            BIT11
+#define EFI_ACPI_4_0_HEADLESS                               BIT12
+#define EFI_ACPI_4_0_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_4_0_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_4_0_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_4_0_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_4_0_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_4_0_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_4_0_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved0[3];
+  UINT32  OspmFlags;
+  UINT8   Reserved1[24];
+} EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x02
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_4_0_S4BIOS_F                     BIT0
+#define EFI_ACPI_4_0_64BIT_WAKE_SUPPORTED_F       BIT1
+
+///
+/// OSPM Enabled Firmware Control Structure Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_4_0_OSPM_64BIT_WAKE__F           BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_4_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_4_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x03
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_4_0_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x0B an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_4_0_IO_APIC                        0x01
+#define EFI_ACPI_4_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_4_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_4_0_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_4_0_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_4_0_IO_SAPIC                       0x06
+#define EFI_ACPI_4_0_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_4_0_PLATFORM_INTERRUPT_SOURCES     0x08
+#define EFI_ACPI_4_0_PROCESSOR_LOCAL_X2APIC         0x09
+#define EFI_ACPI_4_0_LOCAL_X2APIC_NMI               0x0A
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_4_0_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_4_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_4_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_4_0_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_4_0_POLARITY      (3 << 0)
+#define EFI_ACPI_4_0_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_4_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_4_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_4_0_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_4_0_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_4_0_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_4_0_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_4_0_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Processor Local x2APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved[2];
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  AcpiProcessorUid;
+} EFI_ACPI_4_0_PROCESSOR_LOCAL_X2APIC_STRUCTURE;
+
+///
+/// Local x2APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  AcpiProcessorUid;
+  UINT8   LocalX2ApicLint;
+  UINT8   Reserved[3];
+} EFI_ACPI_4_0_LOCAL_X2APIC_NMI_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_4_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_4_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_4_0_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x03
+
+//
+// SRAT structure types.
+// All other values between 0x03 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_4_0_MEMORY_AFFINITY                      0x01
+#define EFI_ACPI_4_0_PROCESSOR_LOCAL_X2APIC_AFFINITY      0x02
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT32  ClockDomain;
+} EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_4_0_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_4_0_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_4_0_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_4_0_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// Processor Local x2APIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved1[2];
+  UINT32  ProximityDomain;
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+  UINT8   Reserved2[4];
+} EFI_ACPI_4_0_PROCESSOR_LOCAL_X2APIC_AFFINITY_STRUCTURE;
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_4_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+///
+/// Corrected Platform Error Polling Table (CPEP)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       Reserved[8];
+} EFI_ACPI_4_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_HEADER;
+
+///
+/// CPEP Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_REVISION 0x01
+
+//
+// CPEP processor structure types.
+//
+#define EFI_ACPI_4_0_CPEP_PROCESSOR_APIC_SAPIC  0x00
+
+///
+/// Corrected Platform Error Polling Processor Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT32  PollingInterval;
+} EFI_ACPI_4_0_CPEP_PROCESSOR_APIC_SAPIC_STRUCTURE;
+
+///
+/// Maximum System Characteristics Table (MSCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      OffsetProxDomInfo;
+  UINT32                      MaximumNumberOfProximityDomains;
+  UINT32                      MaximumNumberOfClockDomains;
+  UINT64                      MaximumPhysicalAddress;
+} EFI_ACPI_4_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_HEADER;
+
+///
+/// MSCT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_REVISION 0x01
+
+///
+/// Maximum Proximity Domain Information Structure Definition
+///
+typedef struct {
+  UINT8   Revision;
+  UINT8   Length;
+  UINT32  ProximityDomainRangeLow;
+  UINT32  ProximityDomainRangeHigh;
+  UINT32  MaximumProcessorCapacity;
+  UINT64  MaximumMemoryCapacity;
+} EFI_ACPI_4_0_MAXIMUM_PROXIMITY_DOMAIN_INFORMATION_STRUCTURE;
+
+///
+/// Boot Error Record Table (BERT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      BootErrorRegionLength;
+  UINT64                      BootErrorRegion;
+} EFI_ACPI_4_0_BOOT_ERROR_RECORD_TABLE_HEADER;
+
+///
+/// BERT Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_BOOT_ERROR_RECORD_TABLE_REVISION 0x01
+
+///
+/// Boot Error Region Block Status Definition
+///
+typedef struct {
+  UINT32       UncorrectableErrorValid:1;
+  UINT32       CorrectableErrorValid:1;
+  UINT32       MultipleUncorrectableErrors:1;
+  UINT32       MultipleCorrectableErrors:1;
+  UINT32       ErrorDataEntryCount:10;
+  UINT32       Reserved:18;
+} EFI_ACPI_4_0_ERROR_BLOCK_STATUS;
+
+///
+/// Boot Error Region Definition
+///
+typedef struct {
+  EFI_ACPI_4_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_4_0_BOOT_ERROR_REGION_STRUCTURE;
+
+//
+// Boot Error Severity types
+//
+#define EFI_ACPI_4_0_ERROR_SEVERITY_CORRECTABLE  0x00
+#define EFI_ACPI_4_0_ERROR_SEVERITY_FATAL        0x01
+#define EFI_ACPI_4_0_ERROR_SEVERITY_CORRECTED    0x02
+#define EFI_ACPI_4_0_ERROR_SEVERITY_NONE         0x03
+
+///
+/// Generic Error Data Entry Definition
+///
+typedef struct {
+  UINT8    SectionType[16];
+  UINT32   ErrorSeverity;
+  UINT16   Revision;
+  UINT8    ValidationBits;
+  UINT8    Flags;
+  UINT32   ErrorDataLength;
+  UINT8    FruId[16];
+  UINT8    FruText[20];
+} EFI_ACPI_4_0_GENERIC_ERROR_DATA_ENTRY_STRUCTURE;
+
+///
+/// Generic Error Data Entry Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_GENERIC_ERROR_DATA_ENTRY_REVISION  0x0201
+
+///
+/// HEST - Hardware Error Source Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ErrorSourceCount;
+} EFI_ACPI_4_0_HARDWARE_ERROR_SOURCE_TABLE_HEADER;
+
+///
+/// HEST Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_HARDWARE_ERROR_SOURCE_TABLE_REVISION 0x01
+
+//
+// Error Source structure types.
+//
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION  0x00
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK  0x01
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_NMI_ERROR                0x02
+#define EFI_ACPI_4_0_PCI_EXPRESS_ROOT_PORT_AER                  0x06
+#define EFI_ACPI_4_0_PCI_EXPRESS_DEVICE_AER                     0x07
+#define EFI_ACPI_4_0_PCI_EXPRESS_BRIDGE_AER                     0x08
+#define EFI_ACPI_4_0_GENERIC_HARDWARE_ERROR                     0x09
+
+//
+// Error Source structure flags.
+//
+#define EFI_ACPI_4_0_ERROR_SOURCE_FLAG_FIRMWARE_FIRST       (1 << 0)
+#define EFI_ACPI_4_0_ERROR_SOURCE_FLAG_GLOBAL               (1 << 1)
+
+///
+/// IA-32 Architecture Machine Check Exception Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT64  GlobalCapabilityInitData;
+  UINT64  GlobalControlInitData;
+  UINT8   NumberOfHardwareBanks;
+  UINT8   Reserved1[7];
+} EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure Definition
+///
+typedef struct {
+  UINT8   BankNumber;
+  UINT8   ClearStatusOnInitialization;
+  UINT8   StatusDataFormat;
+  UINT8   Reserved0;
+  UINT32  ControlRegisterMsrAddress;
+  UINT64  ControlInitData;
+  UINT32  StatusRegisterMsrAddress;
+  UINT32  AddressRegisterMsrAddress;
+  UINT32  MiscRegisterMsrAddress;
+} EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_BANK_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure MCA data format
+///
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_IA32      0x00
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_INTEL64   0x01
+#define EFI_ACPI_4_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_AMD64     0x02
+
+//
+// Hardware Error Notification types. All other values are reserved
+//
+#define EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_POLLED                0x00
+#define EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_EXTERNAL_INTERRUPT    0x01
+#define EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_LOCAL_INTERRUPT       0x02
+#define EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_SCI                   0x03
+#define EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_NMI                   0x04
+
+///
+/// Hardware Error Notification Configuration Write Enable Structure Definition
+///
+typedef struct {
+  UINT16    Type:1;
+  UINT16    PollInterval:1;
+  UINT16    SwitchToPollingThresholdValue:1;
+  UINT16    SwitchToPollingThresholdWindow:1;
+  UINT16    ErrorThresholdValue:1;
+  UINT16    ErrorThresholdWindow:1;
+  UINT16    Reserved:10;
+} EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE;
+
+///
+/// Hardware Error Notification Structure Definition
+///
+typedef struct {
+  UINT8                                                                          Type;
+  UINT8                                                                          Length;
+  EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE  ConfigurationWriteEnable;
+  UINT32                                                                         PollInterval;
+  UINT32                                                                         Vector;
+  UINT32                                                                         SwitchToPollingThresholdValue;
+  UINT32                                                                         SwitchToPollingThresholdWindow;
+  UINT32                                                                         ErrorThresholdValue;
+  UINT32                                                                         ErrorThresholdWindow;
+} EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE;
+
+///
+/// IA-32 Architecture Corrected Machine Check Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT8                                                  Reserved0[2];
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT8                                                  NumberOfHardwareBanks;
+  UINT8                                                  Reserved1[3];
+} EFI_ACPI_4_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK_STRUCTURE;
+
+///
+/// IA-32 Architecture NMI Error Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  MaxRawDataLength;
+} EFI_ACPI_4_0_IA32_ARCHITECTURE_NMI_ERROR_STRUCTURE;
+
+///
+/// PCI Express Root Port AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  RootErrorCommand;
+} EFI_ACPI_4_0_PCI_EXPRESS_ROOT_PORT_AER_STRUCTURE;
+
+///
+/// PCI Express Device AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_4_0_PCI_EXPRESS_DEVICE_AER_STRUCTURE;
+
+///
+/// PCI Express Bridge AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  SecondaryUncorrectableErrorMask;
+  UINT32  SecondaryUncorrectableErrorSeverity;
+  UINT32  SecondaryAdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_4_0_PCI_EXPRESS_BRIDGE_AER_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_4_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+} EFI_ACPI_4_0_GENERIC_HARDWARE_ERROR_SOURCE_STRUCTURE;
+
+///
+/// Generic Error Status Definition
+///
+typedef struct {
+  EFI_ACPI_4_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_4_0_GENERIC_ERROR_STATUS_STRUCTURE;
+
+///
+/// ERST - Error Record Serialization Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      SerializationHeaderSize;
+  UINT8                       Reserved0[4];
+  UINT32                      InstructionEntryCount;
+} EFI_ACPI_4_0_ERROR_RECORD_SERIALIZATION_TABLE_HEADER;
+
+///
+/// ERST Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_ERROR_RECORD_SERIALIZATION_TABLE_REVISION 0x01
+
+///
+/// ERST Serialization Actions
+///
+#define EFI_ACPI_4_0_ERST_BEGIN_WRITE_OPERATION                    0x00
+#define EFI_ACPI_4_0_ERST_BEGIN_READ_OPERATION                     0x01
+#define EFI_ACPI_4_0_ERST_BEGIN_CLEAR_OPERATION                    0x02
+#define EFI_ACPI_4_0_ERST_END_OPERATION                            0x03
+#define EFI_ACPI_4_0_ERST_SET_RECORD_OFFSET                        0x04
+#define EFI_ACPI_4_0_ERST_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_4_0_ERST_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_4_0_ERST_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_4_0_ERST_GET_RECORD_IDENTIFIER                    0x08
+#define EFI_ACPI_4_0_ERST_SET_RECORD_IDENTIFIER                    0x09
+#define EFI_ACPI_4_0_ERST_GET_RECORD_COUNT                         0x0A
+#define EFI_ACPI_4_0_ERST_BEGIN_DUMMY_WRITE_OPERATION              0x0B
+#define EFI_ACPI_4_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE              0x0D
+#define EFI_ACPI_4_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_LENGTH       0x0E
+#define EFI_ACPI_4_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_ATTRIBUTES   0x0F
+
+///
+/// ERST Action Command Status
+///
+#define EFI_ACPI_4_0_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_4_0_EINJ_STATUS_NOT_ENOUGH_SPACE                  0x01
+#define EFI_ACPI_4_0_EINJ_STATUS_HARDWARE_NOT_AVAILABLE            0x02
+#define EFI_ACPI_4_0_EINJ_STATUS_FAILED                            0x03
+#define EFI_ACPI_4_0_EINJ_STATUS_RECORD_STORE_EMPTY                0x04
+#define EFI_ACPI_4_0_EINJ_STATUS_RECORD_NOT_FOUND                  0x05
+
+///
+/// ERST Serialization Instructions
+///
+#define EFI_ACPI_4_0_ERST_READ_REGISTER                            0x00
+#define EFI_ACPI_4_0_ERST_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_4_0_ERST_WRITE_REGISTER                           0x02
+#define EFI_ACPI_4_0_ERST_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_4_0_ERST_NOOP                                     0x04
+#define EFI_ACPI_4_0_ERST_LOAD_VAR1                                0x05
+#define EFI_ACPI_4_0_ERST_LOAD_VAR2                                0x06
+#define EFI_ACPI_4_0_ERST_STORE_VAR1                               0x07
+#define EFI_ACPI_4_0_ERST_ADD                                      0x08
+#define EFI_ACPI_4_0_ERST_SUBTRACT                                 0x09
+#define EFI_ACPI_4_0_ERST_ADD_VALUE                                0x0A
+#define EFI_ACPI_4_0_ERST_SUBTRACT_VALUE                           0x0B
+#define EFI_ACPI_4_0_ERST_STALL                                    0x0C
+#define EFI_ACPI_4_0_ERST_STALL_WHILE_TRUE                         0x0D
+#define EFI_ACPI_4_0_ERST_SKIP_NEXT_INSTRUCTION_IF_TRUE            0x0E
+#define EFI_ACPI_4_0_ERST_GOTO                                     0x0F
+#define EFI_ACPI_4_0_ERST_SET_SRC_ADDRESS_BASE                     0x10
+#define EFI_ACPI_4_0_ERST_SET_DST_ADDRESS_BASE                     0x11
+#define EFI_ACPI_4_0_ERST_MOVE_DATA                                0x12
+
+///
+/// ERST Instruction Flags
+///
+#define EFI_ACPI_4_0_ERST_PRESERVE_REGISTER                        0x01
+
+///
+/// ERST Serialization Instruction Entry
+///
+typedef struct {
+  UINT8                                    SerializationAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_4_0_ERST_SERIALIZATION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ - Error Injection Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      InjectionHeaderSize;
+  UINT8                       InjectionFlags;
+  UINT8                       Reserved0[3];
+  UINT32                      InjectionEntryCount;
+} EFI_ACPI_4_0_ERROR_INJECTION_TABLE_HEADER;
+
+///
+/// EINJ Version (as defined in ACPI 4.0 spec.)
+///
+#define EFI_ACPI_4_0_ERROR_INJECTION_TABLE_REVISION 0x01
+
+///
+/// EINJ Error Injection Actions
+///
+#define EFI_ACPI_4_0_EINJ_BEGIN_INJECTION_OPERATION                0x00
+#define EFI_ACPI_4_0_EINJ_GET_TRIGGER_ERROR_ACTION_TABLE           0x01
+#define EFI_ACPI_4_0_EINJ_SET_ERROR_TYPE                           0x02
+#define EFI_ACPI_4_0_EINJ_GET_ERROR_TYPE                           0x03
+#define EFI_ACPI_4_0_EINJ_END_OPERATION                            0x04
+#define EFI_ACPI_4_0_EINJ_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_4_0_EINJ_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_4_0_EINJ_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_4_0_EINJ_TRIGGER_ERROR                            0xFF
+
+///
+/// EINJ Action Command Status
+///
+#define EFI_ACPI_4_0_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_4_0_EINJ_STATUS_UNKNOWN_FAILURE                   0x01
+#define EFI_ACPI_4_0_EINJ_STATUS_INVALID_ACCESS                    0x02
+
+///
+/// EINJ Error Type Definition
+///
+#define EFI_ACPI_4_0_EINJ_ERROR_PROCESSOR_CORRECTABLE                 (1 << 0)
+#define EFI_ACPI_4_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_NONFATAL      (1 << 1)
+#define EFI_ACPI_4_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_FATAL         (1 << 2)
+#define EFI_ACPI_4_0_EINJ_ERROR_MEMORY_CORRECTABLE                    (1 << 3)
+#define EFI_ACPI_4_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_NONFATAL         (1 << 4)
+#define EFI_ACPI_4_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_FATAL            (1 << 5)
+#define EFI_ACPI_4_0_EINJ_ERROR_PCI_EXPRESS_CORRECTABLE               (1 << 6)
+#define EFI_ACPI_4_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_NONFATAL    (1 << 7)
+#define EFI_ACPI_4_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_FATAL       (1 << 8)
+#define EFI_ACPI_4_0_EINJ_ERROR_PLATFORM_CORRECTABLE                  (1 << 9)
+#define EFI_ACPI_4_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_NONFATAL       (1 << 10)
+#define EFI_ACPI_4_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_FATAL          (1 << 11)
+
+///
+/// EINJ Injection Instructions
+///
+#define EFI_ACPI_4_0_EINJ_READ_REGISTER                            0x00
+#define EFI_ACPI_4_0_EINJ_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_4_0_EINJ_WRITE_REGISTER                           0x02
+#define EFI_ACPI_4_0_EINJ_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_4_0_EINJ_NOOP                                     0x04
+
+///
+/// EINJ Instruction Flags
+///
+#define EFI_ACPI_4_0_EINJ_PRESERVE_REGISTER                        0x01
+
+///
+/// EINJ Injection Instruction Entry
+///
+typedef struct {
+  UINT8                                    InjectionAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_4_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_4_0_EINJ_INJECTION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ Trigger Action Table
+///
+typedef struct {
+  UINT32  HeaderSize;
+  UINT32  Revision;
+  UINT32  TableSize;
+  UINT32  EntryCount;
+} EFI_ACPI_4_0_EINJ_TRIGGER_ACTION_TABLE;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_4_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_4_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BERT" Boot Error Record Table
+///
+#define EFI_ACPI_4_0_BOOT_ERROR_RECORD_TABLE_SIGNATURE  SIGNATURE_32('B', 'E', 'R', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_4_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_4_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_4_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "EINJ" Error Injection Table
+///
+#define EFI_ACPI_4_0_ERROR_INJECTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'I', 'N', 'J')
+
+///
+/// "ERST" Error Record Serialization Table
+///
+#define EFI_ACPI_4_0_ERROR_RECORD_SERIALIZATION_TABLE_SIGNATURE  SIGNATURE_32('E', 'R', 'S', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "HEST" Hardware Error Source Table
+///
+#define EFI_ACPI_4_0_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE  SIGNATURE_32('H', 'E', 'S', 'T')
+
+///
+/// "MSCT" Maximum System Characteristics Table
+///
+#define EFI_ACPI_4_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'C', 'T')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_4_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_4_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_4_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_4_0_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_4_0_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_4_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_4_0_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_4_0_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DMAR" DMA Remapping Table
+///
+#define EFI_ACPI_4_0_DMA_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('D', 'M', 'A', 'R')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_4_0_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_4_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_4_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+///
+/// "IVRS" I/O Virtualization Reporting Structure
+///
+#define EFI_ACPI_4_0_IO_VIRTUALIZATION_REPORTING_STRUCTURE_SIGNATURE  SIGNATURE_32('I', 'V', 'R', 'S')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_4_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "MCHI" Management Controller Host Interface Table
+///
+#define EFI_ACPI_4_0_MANAGEMENT_CONTROLLER_HOST_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'H', 'I')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_4_0_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_4_0_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_4_0_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "UEFI" UEFI ACPI Data Table
+///
+#define EFI_ACPI_4_0_UEFI_ACPI_DATA_TABLE_SIGNATURE  SIGNATURE_32('U', 'E', 'F', 'I')
+
+///
+/// "WAET" Windows ACPI Enlightenment Table
+///
+#define EFI_ACPI_4_0_WINDOWS_ACPI_ENLIGHTENMENT_TABLE_SIGNATURE  SIGNATURE_32('W', 'A', 'E', 'T')
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_4_0_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_4_0_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi50.h b/MdePkg/Include/IndustryStandard/Acpi50.h
new file mode 100644
index 000000000000..a371c9ade1b1
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi50.h
@@ -0,0 +1,2119 @@
+/** @file   
+  ACPI 5.0 definitions from the ACPI Specification Revision 5.0a November 13, 2013.
+
+  Copyright (c) 2014 Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2011 - 2014, 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 _ACPI_5_0_H_
+#define _ACPI_5_0_H_
+
+#include <IndustryStandard/Acpi40.h>
+
+//
+// Define for Desriptor
+//
+#define ACPI_SMALL_FIXED_DMA_DESCRIPTOR_NAME                         0x0A
+#define ACPI_LARGE_GPIO_CONNECTION_DESCRIPTOR_NAME                   0x0C
+#define ACPI_LARGE_GENERIC_SERIAL_BUS_CONNECTION_DESCRIPTOR_NAME     0x0E
+
+#define ACPI_FIXED_DMA_DESCRIPTOR                         0x55
+#define ACPI_GPIO_CONNECTION_DESCRIPTOR                   0x8C
+#define ACPI_GENERIC_SERIAL_BUS_CONNECTION_DESCRIPTOR     0x8E
+
+#pragma pack(1)
+
+///
+/// Generic DMA Descriptor.
+///
+typedef PACKED struct {
+  ACPI_SMALL_RESOURCE_HEADER   Header;
+  UINT16                       DmaRequestLine;
+  UINT16                       DmaChannel;
+  UINT8                        DmaTransferWidth;
+} EFI_ACPI_FIXED_DMA_DESCRIPTOR;
+
+///
+/// GPIO Connection Descriptor
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         RevisionId;
+  UINT8                         ConnectionType;
+  UINT16                        GeneralFlags;
+  UINT16                        InterruptFlags;
+  UINT8                         PinConfiguration;
+  UINT16                        OutputDriveStrength;
+  UINT16                        DebounceTimeout;
+  UINT16                        PinTableOffset;
+  UINT8                         ResourceSourceIndex;
+  UINT16                        ResourceSourceNameOffset;
+  UINT16                        VendorDataOffset;
+  UINT16                        VendorDataLength;
+} EFI_ACPI_GPIO_CONNECTION_DESCRIPTOR;
+
+#define EFI_ACPI_GPIO_CONNECTION_TYPE_INTERRUPT   0x0
+#define EFI_ACPI_GPIO_CONNECTION_TYPE_IO          0x1
+
+///
+/// Serial Bus Resource Descriptor (Generic)
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         RevisionId;
+  UINT8                         ResourceSourceIndex;
+  UINT8                         SerialBusType;
+  UINT8                         GeneralFlags;
+  UINT16                        TypeSpecificFlags;
+  UINT8                         TypeSpecificRevisionId;
+  UINT16                        TypeDataLength;
+// Type specific data
+} EFI_ACPI_SERIAL_BUS_RESOURCE_DESCRIPTOR;
+
+#define EFI_ACPI_SERIAL_BUS_RESOURCE_TYPE_I2C   0x1
+#define EFI_ACPI_SERIAL_BUS_RESOURCE_TYPE_SPI   0x2
+#define EFI_ACPI_SERIAL_BUS_RESOURCE_TYPE_UART  0x3
+
+///
+/// Serial Bus Resource Descriptor (I2C)
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         RevisionId;
+  UINT8                         ResourceSourceIndex;
+  UINT8                         SerialBusType;
+  UINT8                         GeneralFlags;
+  UINT16                        TypeSpecificFlags;
+  UINT8                         TypeSpecificRevisionId;
+  UINT16                        TypeDataLength;
+  UINT32                        ConnectionSpeed;
+  UINT16                        SlaveAddress;
+} EFI_ACPI_SERIAL_BUS_RESOURCE_I2C_DESCRIPTOR;
+
+///
+/// Serial Bus Resource Descriptor (SPI)
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         RevisionId;
+  UINT8                         ResourceSourceIndex;
+  UINT8                         SerialBusType;
+  UINT8                         GeneralFlags;
+  UINT16                        TypeSpecificFlags;
+  UINT8                         TypeSpecificRevisionId;
+  UINT16                        TypeDataLength;
+  UINT32                        ConnectionSpeed;
+  UINT8                         DataBitLength;
+  UINT8                         Phase;
+  UINT8                         Polarity;
+  UINT16                        DeviceSelection;
+} EFI_ACPI_SERIAL_BUS_RESOURCE_SPI_DESCRIPTOR;
+
+///
+/// Serial Bus Resource Descriptor (UART)
+///
+typedef PACKED struct {
+  ACPI_LARGE_RESOURCE_HEADER    Header;
+  UINT8                         RevisionId;
+  UINT8                         ResourceSourceIndex;
+  UINT8                         SerialBusType;
+  UINT8                         GeneralFlags;
+  UINT16                        TypeSpecificFlags;
+  UINT8                         TypeSpecificRevisionId;
+  UINT16                        TypeDataLength;
+  UINT32                        DefaultBaudRate;
+  UINT16                        RxFIFO;
+  UINT16                        TxFIFO;
+  UINT8                         Parity;
+  UINT8                         SerialLinesEnabled;
+} EFI_ACPI_SERIAL_BUS_RESOURCE_UART_DESCRIPTOR;
+
+#pragma pack()
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 5.0 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_5_0_SYSTEM_MEMORY              0
+#define EFI_ACPI_5_0_SYSTEM_IO                  1
+#define EFI_ACPI_5_0_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_5_0_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_5_0_SMBUS                      4
+#define EFI_ACPI_5_0_PLATFORM_COMMUNICATION_CHANNEL  0x0A
+#define EFI_ACPI_5_0_FUNCTIONAL_FIXED_HARDWARE       0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_5_0_UNDEFINED  0
+#define EFI_ACPI_5_0_BYTE       1
+#define EFI_ACPI_5_0_WORD       2
+#define EFI_ACPI_5_0_DWORD      3
+#define EFI_ACPI_5_0_QWORD      4
+
+//
+// ACPI 5.0 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 5.0) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_5_0_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT8                                   Reserved2[3];
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  SleepControlReg;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  SleepStatusReg;
+} EFI_ACPI_5_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x05
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_5_0_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_5_0_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_5_0_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_5_0_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_5_0_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_5_0_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_5_0_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_5_0_PM_PROFILE_PERFORMANCE_SERVER  7
+#define EFI_ACPI_5_0_PM_PROFILE_TABLET              8
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_0_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_5_0_8042                        BIT1
+#define EFI_ACPI_5_0_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_5_0_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_5_0_PCIE_ASPM_CONTROLS          BIT4
+#define EFI_ACPI_5_0_CMOS_RTC_NOT_PRESENT        BIT5
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_0_WBINVD                                 BIT0
+#define EFI_ACPI_5_0_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_5_0_PROC_C1                                BIT2
+#define EFI_ACPI_5_0_P_LVL2_UP                              BIT3
+#define EFI_ACPI_5_0_PWR_BUTTON                             BIT4
+#define EFI_ACPI_5_0_SLP_BUTTON                             BIT5
+#define EFI_ACPI_5_0_FIX_RTC                                BIT6
+#define EFI_ACPI_5_0_RTC_S4                                 BIT7
+#define EFI_ACPI_5_0_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_5_0_DCK_CAP                                BIT9
+#define EFI_ACPI_5_0_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_5_0_SEALED_CASE                            BIT11
+#define EFI_ACPI_5_0_HEADLESS                               BIT12
+#define EFI_ACPI_5_0_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_5_0_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_5_0_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_5_0_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_5_0_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_5_0_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_5_0_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+#define EFI_ACPI_5_0_HW_REDUCED_ACPI                        BIT20
+#define EFI_ACPI_5_0_LOW_POWER_S0_IDLE_CAPABLE              BIT21
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved0[3];
+  UINT32  OspmFlags;
+  UINT8   Reserved1[24];
+} EFI_ACPI_5_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x02
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_0_S4BIOS_F                     BIT0
+#define EFI_ACPI_5_0_64BIT_WAKE_SUPPORTED_F       BIT1
+
+///
+/// OSPM Enabled Firmware Control Structure Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_0_OSPM_64BIT_WAKE_F            BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_5_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_5_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_5_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x03
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_0_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x0D and 0x7F are reserved and
+// will be ignored by OSPM. 0x80 ~ 0xFF are reserved for OEM.
+//
+#define EFI_ACPI_5_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_5_0_IO_APIC                        0x01
+#define EFI_ACPI_5_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_5_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_5_0_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_5_0_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_5_0_IO_SAPIC                       0x06
+#define EFI_ACPI_5_0_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_5_0_PLATFORM_INTERRUPT_SOURCES     0x08
+#define EFI_ACPI_5_0_PROCESSOR_LOCAL_X2APIC         0x09
+#define EFI_ACPI_5_0_LOCAL_X2APIC_NMI               0x0A
+#define EFI_ACPI_5_0_GIC                            0x0B
+#define EFI_ACPI_5_0_GICD                           0x0C
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_5_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_0_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_5_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_5_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_5_0_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_0_POLARITY      (3 << 0)
+#define EFI_ACPI_5_0_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_5_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_5_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_5_0_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_5_0_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_5_0_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_5_0_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_0_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Processor Local x2APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved[2];
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  AcpiProcessorUid;
+} EFI_ACPI_5_0_PROCESSOR_LOCAL_X2APIC_STRUCTURE;
+
+///
+/// Local x2APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  AcpiProcessorUid;
+  UINT8   LocalX2ApicLint;
+  UINT8   Reserved[3];
+} EFI_ACPI_5_0_LOCAL_X2APIC_NMI_STRUCTURE;
+
+///
+/// GIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  GicId;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ParkingProtocolVersion;
+  UINT32  PerformanceInterruptGsiv;
+  UINT64  ParkedAddress;
+  UINT64  PhysicalBaseAddress;
+} EFI_ACPI_5_0_GIC_STRUCTURE;
+
+///
+/// GIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_0_GIC_ENABLED                     BIT0
+#define EFI_ACPI_5_0_PERFORMANCE_INTERRUPT_MODEL     BIT1
+
+///
+/// GIC Distributor Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  SystemVectorBase;
+  UINT32  Reserved2;
+} EFI_ACPI_5_0_GIC_DISTRIBUTOR_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_5_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_5_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT).  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_5_0_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x03
+
+//
+// SRAT structure types.
+// All other values between 0x03 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_5_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_5_0_MEMORY_AFFINITY                      0x01
+#define EFI_ACPI_5_0_PROCESSOR_LOCAL_X2APIC_AFFINITY      0x02
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT32  ClockDomain;
+} EFI_ACPI_5_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_0_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_5_0_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_5_0_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_5_0_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_5_0_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// Processor Local x2APIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved1[2];
+  UINT32  ProximityDomain;
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+  UINT8   Reserved2[4];
+} EFI_ACPI_5_0_PROCESSOR_LOCAL_X2APIC_AFFINITY_STRUCTURE;
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_5_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+///
+/// Corrected Platform Error Polling Table (CPEP)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       Reserved[8];
+} EFI_ACPI_5_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_HEADER;
+
+///
+/// CPEP Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_REVISION 0x01
+
+//
+// CPEP processor structure types.
+//
+#define EFI_ACPI_5_0_CPEP_PROCESSOR_APIC_SAPIC  0x00
+
+///
+/// Corrected Platform Error Polling Processor Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT32  PollingInterval;
+} EFI_ACPI_5_0_CPEP_PROCESSOR_APIC_SAPIC_STRUCTURE;
+
+///
+/// Maximum System Characteristics Table (MSCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      OffsetProxDomInfo;
+  UINT32                      MaximumNumberOfProximityDomains;
+  UINT32                      MaximumNumberOfClockDomains;
+  UINT64                      MaximumPhysicalAddress;
+} EFI_ACPI_5_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_HEADER;
+
+///
+/// MSCT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_REVISION 0x01
+
+///
+/// Maximum Proximity Domain Information Structure Definition
+///
+typedef struct {
+  UINT8   Revision;
+  UINT8   Length;
+  UINT32  ProximityDomainRangeLow;
+  UINT32  ProximityDomainRangeHigh;
+  UINT32  MaximumProcessorCapacity;
+  UINT64  MaximumMemoryCapacity;
+} EFI_ACPI_5_0_MAXIMUM_PROXIMITY_DOMAIN_INFORMATION_STRUCTURE;
+
+///
+/// ACPI RAS Feature Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier[12];
+} EFI_ACPI_5_0_RAS_FEATURE_TABLE;
+
+///
+/// RASF Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_RAS_FEATURE_TABLE_REVISION 0x01
+
+///
+/// ACPI RASF Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT16                      Version;
+  UINT8                       RASCapabilities[16];
+  UINT8                       SetRASCapabilities[16];
+  UINT16                      NumberOfRASFParameterBlocks;
+  UINT32                      SetRASCapabilitiesStatus;
+} EFI_ACPI_5_0_RASF_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI RASF PCC command code
+///
+#define EFI_ACPI_5_0_RASF_PCC_COMMAND_CODE_EXECUTE_RASF_COMMAND  0x01
+
+///
+/// ACPI RASF Platform RAS Capabilities
+///
+#define EFI_ACPI_5_0_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED                          0x01
+#define EFI_ACPI_5_0_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED_AND_EXPOSED_TO_SOFTWARE  0x02
+
+///
+/// ACPI RASF Parameter Block structure for PATROL_SCRUB
+///
+typedef struct {
+  UINT16                      Type;
+  UINT16                      Version;
+  UINT16                      Length;
+  UINT16                      PatrolScrubCommand;
+  UINT64                      RequestedAddressRange[2];
+  UINT64                      ActualAddressRange[2];
+  UINT16                      Flags;
+  UINT8                       RequestedSpeed;
+} EFI_ACPI_5_0_RASF_PATROL_SCRUB_PLATFORM_BLOCK_STRUCTURE;
+
+///
+/// ACPI RASF Patrol Scrub command
+///
+#define EFI_ACPI_5_0_RASF_PATROL_SCRUB_COMMAND_GET_PATROL_PARAMETERS   0x01
+#define EFI_ACPI_5_0_RASF_PATROL_SCRUB_COMMAND_START_PATROL_SCRUBBER   0x02
+#define EFI_ACPI_5_0_RASF_PATROL_SCRUB_COMMAND_STOP_PATROL_SCRUBBER    0x03
+
+///
+/// Memory Power State Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier;
+  UINT8                       Reserved[3];
+// Memory Power Node Structure
+// Memory Power State Characteristics
+} EFI_ACPI_5_0_MEMORY_POWER_STATUS_TABLE;
+
+///
+/// MPST Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_MEMORY_POWER_STATE_TABLE_REVISION 0x01
+
+///
+/// MPST Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT32                      MemoryPowerCommandRegister;
+  UINT32                      MemoryPowerStatusRegister;
+  UINT32                      PowerStateId;
+  UINT32                      MemoryPowerNodeId;
+  UINT64                      MemoryEnergyConsumed;
+  UINT64                      ExpectedAveragePowerComsuned;
+} EFI_ACPI_5_0_MPST_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI MPST PCC command code
+///
+#define EFI_ACPI_5_0_MPST_PCC_COMMAND_CODE_EXECUTE_MPST_COMMAND  0x03
+
+///
+/// ACPI MPST Memory Power command
+///
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_POWER_STATE       0x01
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_COMMAND_SET_MEMORY_POWER_STATE       0x02
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_COMMAND_GET_AVERAGE_POWER_CONSUMED   0x03
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_ENERGY_CONSUMED   0x04
+
+///
+/// MPST Memory Power Node Table
+///
+typedef struct {
+  UINT8                                             PowerStateValue;
+  UINT8                                             PowerStateInformationIndex;
+} EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE;
+
+typedef struct {
+  UINT8                                             Flag;
+  UINT8                                             Reserved;
+  UINT16                                            MemoryPowerNodeId;
+  UINT32                                            Length;
+  UINT64                                            AddressBase;
+  UINT64                                            AddressLength;
+  UINT32                                            NumberOfPowerStates;
+  UINT32                                            NumberOfPhysicalComponents;
+//EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE              MemoryPowerState[NumberOfPowerStates];
+//UINT16                                            PhysicalComponentIdentifier[NumberOfPhysicalComponents];
+} EFI_ACPI_5_0_MPST_MEMORY_POWER_STRUCTURE;
+
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_ENABLE          0x01
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_POWER_MANAGED   0x02
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_HOT_PLUGGABLE   0x04
+
+typedef struct {
+  UINT16                      MemoryPowerNodeCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_5_0_MPST_MEMORY_POWER_NODE_TABLE;
+
+///
+/// MPST Memory Power State Characteristics Table
+///
+typedef struct {
+  UINT8                                             PowerStateStructureID;
+  UINT8                                             Flag;
+  UINT16                                            Reserved;
+  UINT32                                            AveragePowerConsumedInMPS0;
+  UINT32                                            RelativePowerSavingToMPS0;
+  UINT64                                            ExitLatencyToMPS0;
+} EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE;
+
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_MEMORY_CONTENT_PRESERVED              0x01
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_ENTRY   0x02
+#define EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_EXIT    0x04
+
+typedef struct {
+  UINT16                      MemoryPowerStateCharacteristicsCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_5_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_TABLE;
+
+///
+/// Memory Topology Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved;
+} EFI_ACPI_5_0_MEMORY_TOPOLOGY_TABLE;
+
+///
+/// PMTT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_MEMORY_TOPOLOGY_TABLE_REVISION 0x01
+
+///
+/// Common Memory Aggregator Device Structure.
+///
+typedef struct {
+  UINT8                       Type;
+  UINT8                       Reserved;
+  UINT16                      Length;
+  UINT16                      Flags;
+  UINT16                      Reserved1;
+} EFI_ACPI_5_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Memory Aggregator Device Type
+///
+#define EFI_ACPI_5_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_SOCKET            0x1
+#define EFI_ACPI_5_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_MEMORY_CONTROLLER 0x2
+#define EFI_ACPI_5_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_DIMM              0x3
+
+///
+/// Socket Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       SocketIdentifier;
+  UINT16                                                       Reserved;
+//EFI_ACPI_5_0_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  MemoryController[];
+} EFI_ACPI_5_0_PMMT_SOCKET_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// MemoryController Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT32                                                       ReadLatency;
+  UINT32                                                       WriteLatency;
+  UINT32                                                       ReadBandwidth;
+  UINT32                                                       WriteBandwidth;
+  UINT16                                                       OptimalAccessUnit;
+  UINT16                                                       OptimalAccessAlignment;
+  UINT16                                                       Reserved;
+  UINT16                                                       NumberOfProximityDomains;
+//UINT32                                                       ProximityDomain[NumberOfProximityDomains];
+//EFI_ACPI_5_0_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE    PhysicalComponent[];
+} EFI_ACPI_5_0_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// DIMM Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       PhysicalComponentIdentifier;
+  UINT16                                                       Reserved;
+  UINT32                                                       SizeOfDimm;
+  UINT32                                                       SmbiosHandle;
+} EFI_ACPI_5_0_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Boot Graphics Resource Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  ///
+  /// 2-bytes (16 bit) version ID. This value must be 1.
+  ///
+  UINT16                      Version;
+  ///
+  /// 1-byte status field indicating current status about the table.
+  ///     Bits[7:1] = Reserved (must be zero)
+  ///     Bit [0] = Valid. A one indicates the boot image graphic is valid.
+  ///
+  UINT8                       Status;
+  ///
+  /// 1-byte enumerated type field indicating format of the image.
+  ///     0 = Bitmap
+  ///     1 - 255  Reserved (for future use)
+  ///
+  UINT8                       ImageType;
+  ///
+  /// 8-byte (64 bit) physical address pointing to the firmware's in-memory copy
+  /// of the image bitmap.
+  ///
+  UINT64                      ImageAddress;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display X-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetX;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display Y-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetY;
+} EFI_ACPI_5_0_BOOT_GRAPHICS_RESOURCE_TABLE;
+
+///
+/// BGRT Revision
+///
+#define EFI_ACPI_5_0_BOOT_GRAPHICS_RESOURCE_TABLE_REVISION 1
+
+///
+/// BGRT Version
+///
+#define EFI_ACPI_5_0_BGRT_VERSION         0x01
+
+///
+/// BGRT Status
+///
+#define EFI_ACPI_5_0_BGRT_STATUS_NOT_DISPLAYED 0x00
+#define EFI_ACPI_5_0_BGRT_STATUS_DISPLAYED     0x01
+#define EFI_ACPI_5_0_BGRT_STATUS_INVALID       EFI_ACPI_5_0_BGRT_STATUS_NOT_DISPLAYED
+#define EFI_ACPI_5_0_BGRT_STATUS_VALID         EFI_ACPI_5_0_BGRT_STATUS_DISPLAYED
+
+///
+/// BGRT Image Type
+///
+#define EFI_ACPI_5_0_BGRT_IMAGE_TYPE_BMP  0x00
+
+///
+/// FPDT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_FIRMWARE_PERFORMANCE_DATA_TABLE_REVISION 0x01
+
+///
+/// FPDT Performance Record Types
+///
+#define EFI_ACPI_5_0_FPDT_RECORD_TYPE_FIRMWARE_BASIC_BOOT_POINTER      0x0000
+#define EFI_ACPI_5_0_FPDT_RECORD_TYPE_S3_PERFORMANCE_TABLE_POINTER     0x0001
+
+///
+/// FPDT Performance Record Revision
+///
+#define EFI_ACPI_5_0_FPDT_RECORD_REVISION_FIRMWARE_BASIC_BOOT_POINTER  0x01
+#define EFI_ACPI_5_0_FPDT_RECORD_REVISION_S3_PERFORMANCE_TABLE_POINTER 0x01
+
+///
+/// FPDT Runtime Performance Record Types
+///
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_TYPE_S3_RESUME                0x0000
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_TYPE_S3_SUSPEND               0x0001
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_TYPE_FIRMWARE_BASIC_BOOT      0x0002
+
+///
+/// FPDT Runtime Performance Record Revision
+///
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_REVISION_S3_RESUME            0x01
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_REVISION_S3_SUSPEND           0x01
+#define EFI_ACPI_5_0_FPDT_RUNTIME_RECORD_REVISION_FIRMWARE_BASIC_BOOT  0x02
+
+///
+/// FPDT Performance Record header
+///
+typedef struct {
+  UINT16           Type;
+  UINT8            Length;
+  UINT8            Revision;
+} EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER;
+
+///
+/// FPDT Performance Table header
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_5_0_FPDT_PERFORMANCE_TABLE_HEADER;
+
+///
+/// FPDT Firmware Basic Boot Performance Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the Basic Boot Performance Table.
+  ///
+  UINT64                                          BootPerformanceTablePointer;
+} EFI_ACPI_5_0_FPDT_BOOT_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT S3 Performance Table Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the S3 Performance Table.
+  ///
+  UINT64                                          S3PerformanceTablePointer;
+} EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// Timer value logged at the beginning of firmware image execution.
+  /// This may not always be zero or near zero.
+  ///
+  UINT64                                          ResetEnd;
+  ///
+  /// Timer value logged just prior to loading the OS boot loader into memory.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          OsLoaderLoadImageStart;
+  ///
+  /// Timer value logged just prior to launching the previously loaded OS boot loader image.
+  /// For non-UEFI compatible boots, the timer value logged will be just prior
+  /// to the INT 19h handler invocation.
+  ///
+  UINT64                                          OsLoaderStartImageStart;
+  ///
+  /// Timer value logged at the point when the OS loader calls the
+  /// ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesEntry;
+  ///
+  /// Timer value logged at the point just prior towhen the OS loader gaining
+  /// control back from calls the ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesExit;
+} EFI_ACPI_5_0_FPDT_FIRMWARE_BASIC_BOOT_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Table signature
+///
+#define EFI_ACPI_5_0_FPDT_BOOT_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('F', 'B', 'P', 'T')
+
+//
+// FPDT Firmware Basic Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_5_0_FPDT_FIRMWARE_BASIC_BOOT_TABLE;
+
+///
+/// FPDT "S3PT" S3 Performance Table
+///
+#define EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('S', '3', 'P', 'T')
+
+//
+// FPDT Firmware S3 Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_5_0_FPDT_FIRMWARE_S3_BOOT_TABLE;
+
+///
+/// FPDT Basic S3 Resume Performance Record
+///
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// A count of the number of S3 resume cycles since the last full boot sequence.
+  ///
+  UINT32                                          ResumeCount;
+  ///
+  /// Timer recorded at the end of BIOS S3 resume, just prior to handoff to the
+  /// OS waking vector. Only the most recent resume cycle's time is retained.
+  ///
+  UINT64                                          FullResume;
+  ///
+  /// Average timer value of all resume cycles logged since the last full boot
+  /// sequence, including the most recent resume.  Note that the entire log of
+  /// timer values does not need to be retained in order to calculate this average.
+  ///
+  UINT64                                          AverageResume;
+} EFI_ACPI_5_0_FPDT_S3_RESUME_RECORD;
+
+///
+/// FPDT Basic S3 Suspend Performance Record
+///
+typedef struct {
+  EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// Timer value recorded at the OS write to SLP_TYP upon entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendStart;
+  ///
+  /// Timer value recorded at the final firmware write to SLP_TYP (or other
+  /// mechanism) used to trigger hardware entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendEnd;
+} EFI_ACPI_5_0_FPDT_S3_SUSPEND_RECORD;
+
+///
+/// Firmware Performance Record Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+} EFI_ACPI_5_0_FIRMWARE_PERFORMANCE_RECORD_TABLE;
+
+///
+/// Generic Timer Description Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      PhysicalAddress;
+  UINT32                      GlobalFlags;
+  UINT32                      SecurePL1TimerGSIV;
+  UINT32                      SecurePL1TimerFlags;
+  UINT32                      NonSecurePL1TimerGSIV;
+  UINT32                      NonSecurePL1TimerFlags;
+  UINT32                      VirtualTimerGSIV;
+  UINT32                      VirtualTimerFlags;
+  UINT32                      NonSecurePL2TimerGSIV;
+  UINT32                      NonSecurePL2TimerFlags;
+} EFI_ACPI_5_0_GENERIC_TIMER_DESCRIPTION_TABLE;
+
+///
+/// GTDT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Global Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_0_GTDT_GLOBAL_FLAG_MEMORY_MAPPED_BLOCK_PRESENT   BIT0
+#define EFI_ACPI_5_0_GTDT_GLOBAL_FLAG_INTERRUPT_MODE                BIT1
+
+///
+/// Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_0_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_5_0_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+
+///
+/// Boot Error Record Table (BERT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      BootErrorRegionLength;
+  UINT64                      BootErrorRegion;
+} EFI_ACPI_5_0_BOOT_ERROR_RECORD_TABLE_HEADER;
+
+///
+/// BERT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_BOOT_ERROR_RECORD_TABLE_REVISION 0x01
+
+///
+/// Boot Error Region Block Status Definition
+///
+typedef struct {
+  UINT32       UncorrectableErrorValid:1;
+  UINT32       CorrectableErrorValid:1;
+  UINT32       MultipleUncorrectableErrors:1;
+  UINT32       MultipleCorrectableErrors:1;
+  UINT32       ErrorDataEntryCount:10;
+  UINT32       Reserved:18;
+} EFI_ACPI_5_0_ERROR_BLOCK_STATUS;
+
+///
+/// Boot Error Region Definition
+///
+typedef struct {
+  EFI_ACPI_5_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_5_0_BOOT_ERROR_REGION_STRUCTURE;
+
+//
+// Boot Error Severity types
+//
+#define EFI_ACPI_5_0_ERROR_SEVERITY_CORRECTABLE  0x00
+#define EFI_ACPI_5_0_ERROR_SEVERITY_FATAL        0x01
+#define EFI_ACPI_5_0_ERROR_SEVERITY_CORRECTED    0x02
+#define EFI_ACPI_5_0_ERROR_SEVERITY_NONE         0x03
+
+///
+/// Generic Error Data Entry Definition
+///
+typedef struct {
+  UINT8    SectionType[16];
+  UINT32   ErrorSeverity;
+  UINT16   Revision;
+  UINT8    ValidationBits;
+  UINT8    Flags;
+  UINT32   ErrorDataLength;
+  UINT8    FruId[16];
+  UINT8    FruText[20];
+} EFI_ACPI_5_0_GENERIC_ERROR_DATA_ENTRY_STRUCTURE;
+
+///
+/// Generic Error Data Entry Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_GENERIC_ERROR_DATA_ENTRY_REVISION  0x0201
+
+///
+/// HEST - Hardware Error Source Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ErrorSourceCount;
+} EFI_ACPI_5_0_HARDWARE_ERROR_SOURCE_TABLE_HEADER;
+
+///
+/// HEST Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_HARDWARE_ERROR_SOURCE_TABLE_REVISION 0x01
+
+//
+// Error Source structure types.
+//
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION  0x00
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK  0x01
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_NMI_ERROR                0x02
+#define EFI_ACPI_5_0_PCI_EXPRESS_ROOT_PORT_AER                  0x06
+#define EFI_ACPI_5_0_PCI_EXPRESS_DEVICE_AER                     0x07
+#define EFI_ACPI_5_0_PCI_EXPRESS_BRIDGE_AER                     0x08
+#define EFI_ACPI_5_0_GENERIC_HARDWARE_ERROR                     0x09
+
+//
+// Error Source structure flags.
+//
+#define EFI_ACPI_5_0_ERROR_SOURCE_FLAG_FIRMWARE_FIRST       (1 << 0)
+#define EFI_ACPI_5_0_ERROR_SOURCE_FLAG_GLOBAL               (1 << 1)
+
+///
+/// IA-32 Architecture Machine Check Exception Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT64  GlobalCapabilityInitData;
+  UINT64  GlobalControlInitData;
+  UINT8   NumberOfHardwareBanks;
+  UINT8   Reserved1[7];
+} EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure Definition
+///
+typedef struct {
+  UINT8   BankNumber;
+  UINT8   ClearStatusOnInitialization;
+  UINT8   StatusDataFormat;
+  UINT8   Reserved0;
+  UINT32  ControlRegisterMsrAddress;
+  UINT64  ControlInitData;
+  UINT32  StatusRegisterMsrAddress;
+  UINT32  AddressRegisterMsrAddress;
+  UINT32  MiscRegisterMsrAddress;
+} EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_BANK_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure MCA data format
+///
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_IA32      0x00
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_INTEL64   0x01
+#define EFI_ACPI_5_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_AMD64     0x02
+
+//
+// Hardware Error Notification types. All other values are reserved
+//
+#define EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_POLLED                0x00
+#define EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_EXTERNAL_INTERRUPT    0x01
+#define EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_LOCAL_INTERRUPT       0x02
+#define EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_SCI                   0x03
+#define EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_NMI                   0x04
+
+///
+/// Hardware Error Notification Configuration Write Enable Structure Definition
+///
+typedef struct {
+  UINT16    Type:1;
+  UINT16    PollInterval:1;
+  UINT16    SwitchToPollingThresholdValue:1;
+  UINT16    SwitchToPollingThresholdWindow:1;
+  UINT16    ErrorThresholdValue:1;
+  UINT16    ErrorThresholdWindow:1;
+  UINT16    Reserved:10;
+} EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE;
+
+///
+/// Hardware Error Notification Structure Definition
+///
+typedef struct {
+  UINT8                                                                          Type;
+  UINT8                                                                          Length;
+  EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE  ConfigurationWriteEnable;
+  UINT32                                                                         PollInterval;
+  UINT32                                                                         Vector;
+  UINT32                                                                         SwitchToPollingThresholdValue;
+  UINT32                                                                         SwitchToPollingThresholdWindow;
+  UINT32                                                                         ErrorThresholdValue;
+  UINT32                                                                         ErrorThresholdWindow;
+} EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE;
+
+///
+/// IA-32 Architecture Corrected Machine Check Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT8                                                  Reserved0[2];
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT8                                                  NumberOfHardwareBanks;
+  UINT8                                                  Reserved1[3];
+} EFI_ACPI_5_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK_STRUCTURE;
+
+///
+/// IA-32 Architecture NMI Error Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  MaxRawDataLength;
+} EFI_ACPI_5_0_IA32_ARCHITECTURE_NMI_ERROR_STRUCTURE;
+
+///
+/// PCI Express Root Port AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  RootErrorCommand;
+} EFI_ACPI_5_0_PCI_EXPRESS_ROOT_PORT_AER_STRUCTURE;
+
+///
+/// PCI Express Device AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_5_0_PCI_EXPRESS_DEVICE_AER_STRUCTURE;
+
+///
+/// PCI Express Bridge AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  SecondaryUncorrectableErrorMask;
+  UINT32  SecondaryUncorrectableErrorSeverity;
+  UINT32  SecondaryAdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_5_0_PCI_EXPRESS_BRIDGE_AER_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_5_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+} EFI_ACPI_5_0_GENERIC_HARDWARE_ERROR_SOURCE_STRUCTURE;
+
+///
+/// Generic Error Status Definition
+///
+typedef struct {
+  EFI_ACPI_5_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_5_0_GENERIC_ERROR_STATUS_STRUCTURE;
+
+///
+/// ERST - Error Record Serialization Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      SerializationHeaderSize;
+  UINT8                       Reserved0[4];
+  UINT32                      InstructionEntryCount;
+} EFI_ACPI_5_0_ERROR_RECORD_SERIALIZATION_TABLE_HEADER;
+
+///
+/// ERST Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_ERROR_RECORD_SERIALIZATION_TABLE_REVISION 0x01
+
+///
+/// ERST Serialization Actions
+///
+#define EFI_ACPI_5_0_ERST_BEGIN_WRITE_OPERATION                    0x00
+#define EFI_ACPI_5_0_ERST_BEGIN_READ_OPERATION                     0x01
+#define EFI_ACPI_5_0_ERST_BEGIN_CLEAR_OPERATION                    0x02
+#define EFI_ACPI_5_0_ERST_END_OPERATION                            0x03
+#define EFI_ACPI_5_0_ERST_SET_RECORD_OFFSET                        0x04
+#define EFI_ACPI_5_0_ERST_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_5_0_ERST_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_5_0_ERST_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_5_0_ERST_GET_RECORD_IDENTIFIER                    0x08
+#define EFI_ACPI_5_0_ERST_SET_RECORD_IDENTIFIER                    0x09
+#define EFI_ACPI_5_0_ERST_GET_RECORD_COUNT                         0x0A
+#define EFI_ACPI_5_0_ERST_BEGIN_DUMMY_WRITE_OPERATION              0x0B
+#define EFI_ACPI_5_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE              0x0D
+#define EFI_ACPI_5_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_LENGTH       0x0E
+#define EFI_ACPI_5_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_ATTRIBUTES   0x0F
+
+///
+/// ERST Action Command Status
+///
+#define EFI_ACPI_5_0_ERST_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_5_0_ERST_STATUS_NOT_ENOUGH_SPACE                  0x01
+#define EFI_ACPI_5_0_ERST_STATUS_HARDWARE_NOT_AVAILABLE            0x02
+#define EFI_ACPI_5_0_ERST_STATUS_FAILED                            0x03
+#define EFI_ACPI_5_0_ERST_STATUS_RECORD_STORE_EMPTY                0x04
+#define EFI_ACPI_5_0_ERST_STATUS_RECORD_NOT_FOUND                  0x05
+
+///
+/// ERST Serialization Instructions
+///
+#define EFI_ACPI_5_0_ERST_READ_REGISTER                            0x00
+#define EFI_ACPI_5_0_ERST_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_5_0_ERST_WRITE_REGISTER                           0x02
+#define EFI_ACPI_5_0_ERST_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_5_0_ERST_NOOP                                     0x04
+#define EFI_ACPI_5_0_ERST_LOAD_VAR1                                0x05
+#define EFI_ACPI_5_0_ERST_LOAD_VAR2                                0x06
+#define EFI_ACPI_5_0_ERST_STORE_VAR1                               0x07
+#define EFI_ACPI_5_0_ERST_ADD                                      0x08
+#define EFI_ACPI_5_0_ERST_SUBTRACT                                 0x09
+#define EFI_ACPI_5_0_ERST_ADD_VALUE                                0x0A
+#define EFI_ACPI_5_0_ERST_SUBTRACT_VALUE                           0x0B
+#define EFI_ACPI_5_0_ERST_STALL                                    0x0C
+#define EFI_ACPI_5_0_ERST_STALL_WHILE_TRUE                         0x0D
+#define EFI_ACPI_5_0_ERST_SKIP_NEXT_INSTRUCTION_IF_TRUE            0x0E
+#define EFI_ACPI_5_0_ERST_GOTO                                     0x0F
+#define EFI_ACPI_5_0_ERST_SET_SRC_ADDRESS_BASE                     0x10
+#define EFI_ACPI_5_0_ERST_SET_DST_ADDRESS_BASE                     0x11
+#define EFI_ACPI_5_0_ERST_MOVE_DATA                                0x12
+
+///
+/// ERST Instruction Flags
+///
+#define EFI_ACPI_5_0_ERST_PRESERVE_REGISTER                        0x01
+
+///
+/// ERST Serialization Instruction Entry
+///
+typedef struct {
+  UINT8                                    SerializationAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_5_0_ERST_SERIALIZATION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ - Error Injection Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      InjectionHeaderSize;
+  UINT8                       InjectionFlags;
+  UINT8                       Reserved0[3];
+  UINT32                      InjectionEntryCount;
+} EFI_ACPI_5_0_ERROR_INJECTION_TABLE_HEADER;
+
+///
+/// EINJ Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_ERROR_INJECTION_TABLE_REVISION 0x01
+
+///
+/// EINJ Error Injection Actions
+///
+#define EFI_ACPI_5_0_EINJ_BEGIN_INJECTION_OPERATION                0x00
+#define EFI_ACPI_5_0_EINJ_GET_TRIGGER_ERROR_ACTION_TABLE           0x01
+#define EFI_ACPI_5_0_EINJ_SET_ERROR_TYPE                           0x02
+#define EFI_ACPI_5_0_EINJ_GET_ERROR_TYPE                           0x03
+#define EFI_ACPI_5_0_EINJ_END_OPERATION                            0x04
+#define EFI_ACPI_5_0_EINJ_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_5_0_EINJ_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_5_0_EINJ_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_5_0_EINJ_TRIGGER_ERROR                            0xFF
+
+///
+/// EINJ Action Command Status
+///
+#define EFI_ACPI_5_0_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_5_0_EINJ_STATUS_UNKNOWN_FAILURE                   0x01
+#define EFI_ACPI_5_0_EINJ_STATUS_INVALID_ACCESS                    0x02
+
+///
+/// EINJ Error Type Definition
+///
+#define EFI_ACPI_5_0_EINJ_ERROR_PROCESSOR_CORRECTABLE                 (1 << 0)
+#define EFI_ACPI_5_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_NONFATAL      (1 << 1)
+#define EFI_ACPI_5_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_FATAL         (1 << 2)
+#define EFI_ACPI_5_0_EINJ_ERROR_MEMORY_CORRECTABLE                    (1 << 3)
+#define EFI_ACPI_5_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_NONFATAL         (1 << 4)
+#define EFI_ACPI_5_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_FATAL            (1 << 5)
+#define EFI_ACPI_5_0_EINJ_ERROR_PCI_EXPRESS_CORRECTABLE               (1 << 6)
+#define EFI_ACPI_5_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_NONFATAL    (1 << 7)
+#define EFI_ACPI_5_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_FATAL       (1 << 8)
+#define EFI_ACPI_5_0_EINJ_ERROR_PLATFORM_CORRECTABLE                  (1 << 9)
+#define EFI_ACPI_5_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_NONFATAL       (1 << 10)
+#define EFI_ACPI_5_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_FATAL          (1 << 11)
+
+///
+/// EINJ Injection Instructions
+///
+#define EFI_ACPI_5_0_EINJ_READ_REGISTER                            0x00
+#define EFI_ACPI_5_0_EINJ_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_5_0_EINJ_WRITE_REGISTER                           0x02
+#define EFI_ACPI_5_0_EINJ_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_5_0_EINJ_NOOP                                     0x04
+
+///
+/// EINJ Instruction Flags
+///
+#define EFI_ACPI_5_0_EINJ_PRESERVE_REGISTER                        0x01
+
+///
+/// EINJ Injection Instruction Entry
+///
+typedef struct {
+  UINT8                                    InjectionAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_5_0_EINJ_INJECTION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ Trigger Action Table
+///
+typedef struct {
+  UINT32  HeaderSize;
+  UINT32  Revision;
+  UINT32  TableSize;
+  UINT32  EntryCount;
+} EFI_ACPI_5_0_EINJ_TRIGGER_ACTION_TABLE;
+
+///
+/// Platform Communications Channel Table (PCCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Flags;
+  UINT64                      Reserved;
+} EFI_ACPI_5_0_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER;
+
+///
+/// PCCT Version (as defined in ACPI 5.0 spec.)
+///
+#define EFI_ACPI_5_0_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION 0x01
+
+///
+/// PCCT Global Flags
+///
+#define EFI_ACPI_5_0_PCCT_FLAGS_SCI_DOORBELL                      BIT0
+
+//
+// PCCT Subspace type
+//
+#define EFI_ACPI_5_0_PCCT_SUBSPACE_TYPE_GENERIC  0x00
+
+///
+/// PCC Subspace Structure Header
+///
+typedef struct {
+  UINT8        Type;
+  UINT8        Length;
+} EFI_ACPI_5_0_PCCT_SUBSPACE_HEADER;
+
+///
+/// Generic Communications Subspace Structure
+///
+typedef struct {
+  UINT8                                    Type;
+  UINT8                                    Length;
+  UINT8                                    Reserved[6];
+  UINT64                                   BaseAddress;
+  UINT64                                   AddressLength;
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE   DoorbellRegister;
+  UINT64                                   DoorbellPreserve;
+  UINT64                                   DoorbellWrite;
+  UINT32                                   NominalLatency;
+  UINT32                                   MaximumPeriodicAccessRate;
+  UINT16                                   MinimumRequestTurnaroundTime;
+} EFI_ACPI_5_0_PCCT_SUBSPACE_GENERIC;
+
+///
+/// Generic Communications Channel Shared Memory Region
+///
+
+typedef struct {
+  UINT8                                    Command;
+  UINT8                                    Reserved:7;
+  UINT8                                    GenerateSci:1;
+} EFI_ACPI_5_0_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND;
+
+typedef struct {
+  UINT8                                    CommandComplete:1;
+  UINT8                                    SciDoorbell:1;
+  UINT8                                    Error:1;
+  UINT8                                    PlatformNotification:1;
+  UINT8                                    Reserved:4;
+  UINT8                                    Reserved1;
+} EFI_ACPI_5_0_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS;
+
+typedef struct {
+  UINT32                                                    Signature;
+  EFI_ACPI_5_0_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND    Command;
+  EFI_ACPI_5_0_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS     Status;
+} EFI_ACPI_5_0_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_5_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BERT" Boot Error Record Table
+///
+#define EFI_ACPI_5_0_BOOT_ERROR_RECORD_TABLE_SIGNATURE  SIGNATURE_32('B', 'E', 'R', 'T')
+
+///
+/// "BGRT" Boot Graphics Resource Table
+///
+#define EFI_ACPI_5_0_BOOT_GRAPHICS_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('B', 'G', 'R', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_5_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_5_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_5_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "EINJ" Error Injection Table
+///
+#define EFI_ACPI_5_0_ERROR_INJECTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'I', 'N', 'J')
+
+///
+/// "ERST" Error Record Serialization Table
+///
+#define EFI_ACPI_5_0_ERROR_RECORD_SERIALIZATION_TABLE_SIGNATURE  SIGNATURE_32('E', 'R', 'S', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_5_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_5_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FPDT" Firmware Performance Data Table
+///
+#define EFI_ACPI_5_0_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE  SIGNATURE_32('F', 'P', 'D', 'T')
+
+///
+/// "GTDT" Generic Timer Description Table
+///
+#define EFI_ACPI_5_0_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('G', 'T', 'D', 'T')
+
+///
+/// "HEST" Hardware Error Source Table
+///
+#define EFI_ACPI_5_0_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE  SIGNATURE_32('H', 'E', 'S', 'T')
+
+///
+/// "MPST" Memory Power State Table
+///
+#define EFI_ACPI_5_0_MEMORY_POWER_STATE_TABLE_SIGNATURE  SIGNATURE_32('M', 'P', 'S', 'T')
+
+///
+/// "MSCT" Maximum System Characteristics Table
+///
+#define EFI_ACPI_5_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'C', 'T')
+
+///
+/// "PMTT" Platform Memory Topology Table
+///
+#define EFI_ACPI_5_0_PLATFORM_MEMORY_TOPOLOGY_TABLE_SIGNATURE  SIGNATURE_32('P', 'M', 'T', 'T')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_5_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RASF" ACPI RAS Feature Table
+///
+#define EFI_ACPI_5_0_ACPI_RAS_FEATURE_TABLE_SIGNATURE  SIGNATURE_32('R', 'A', 'S', 'F')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_5_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_5_0_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_5_0_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_5_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_5_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_5_0_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "CSRT" MS Core System Resource Table
+///
+#define EFI_ACPI_5_0_CORE_SYSTEM_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('C', 'S', 'R', 'T')
+
+///
+/// "DBG2" MS Debug Port 2 Spec
+///
+#define EFI_ACPI_5_0_DEBUG_PORT_2_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', '2')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_5_0_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DMAR" DMA Remapping Table
+///
+#define EFI_ACPI_5_0_DMA_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('D', 'M', 'A', 'R')
+
+///
+/// "DRTM" Dynamic Root of Trust for Measurement Table
+///
+#define EFI_ACPI_5_0_DYNAMIC_ROOT_OF_TRUST_FOR_MEASUREMENT_TABLE_SIGNATURE  SIGNATURE_32('D', 'R', 'T', 'M')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_5_0_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_5_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_5_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+///
+/// "IVRS" I/O Virtualization Reporting Structure
+///
+#define EFI_ACPI_5_0_IO_VIRTUALIZATION_REPORTING_STRUCTURE_SIGNATURE  SIGNATURE_32('I', 'V', 'R', 'S')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_5_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "MCHI" Management Controller Host Interface Table
+///
+#define EFI_ACPI_5_0_MANAGEMENT_CONTROLLER_HOST_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'H', 'I')
+
+///
+/// "MSDM" MS Data Management Table
+///
+#define EFI_ACPI_5_0_DATA_MANAGEMENT_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'D', 'M')
+
+///
+/// "SLIC" MS Software Licensing Table Specification
+///
+#define EFI_ACPI_5_0_SOFTWARE_LICENSING_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'C')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_5_0_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_5_0_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_5_0_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "TPM2" Trusted Computing Platform 1 Table
+///
+#define EFI_ACPI_5_0_TRUSTED_COMPUTING_PLATFORM_2_TABLE_SIGNATURE  SIGNATURE_32('T', 'P', 'M', '2')
+
+///
+/// "UEFI" UEFI ACPI Data Table
+///
+#define EFI_ACPI_5_0_UEFI_ACPI_DATA_TABLE_SIGNATURE  SIGNATURE_32('U', 'E', 'F', 'I')
+
+///
+/// "WAET" Windows ACPI Emulated Devices Table
+///
+#define EFI_ACPI_5_0_WINDOWS_ACPI_EMULATED_DEVICES_TABLE_SIGNATURE  SIGNATURE_32('W', 'A', 'E', 'T')
+#define EFI_ACPI_5_0_WINDOWS_ACPI_ENLIGHTENMENT_TABLE_SIGNATURE  EFI_ACPI_5_0_WINDOWS_ACPI_EMULATED_DEVICES_TABLE_SIGNATURE
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_5_0_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_5_0_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+///
+/// "WPBT" MS Platform Binary Table
+///
+#define EFI_ACPI_5_0_PLATFORM_BINARY_TABLE_SIGNATURE  SIGNATURE_32('W', 'P', 'B', 'T')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi51.h b/MdePkg/Include/IndustryStandard/Acpi51.h
new file mode 100644
index 000000000000..457706befd82
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi51.h
@@ -0,0 +1,2139 @@
+/** @file   
+  ACPI 5.1 definitions from the ACPI Specification Revision 5.1 Errata B January, 2016.
+
+  Copyright (c) 2014 Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2015 Hewlett Packard Enterprise Development LP<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 _ACPI_5_1_H_
+#define _ACPI_5_1_H_
+
+#include <IndustryStandard/Acpi50.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 5.1 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_5_1_SYSTEM_MEMORY              0
+#define EFI_ACPI_5_1_SYSTEM_IO                  1
+#define EFI_ACPI_5_1_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_5_1_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_5_1_SMBUS                      4
+#define EFI_ACPI_5_1_PLATFORM_COMMUNICATION_CHANNEL  0x0A
+#define EFI_ACPI_5_1_FUNCTIONAL_FIXED_HARDWARE       0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_5_1_UNDEFINED  0
+#define EFI_ACPI_5_1_BYTE       1
+#define EFI_ACPI_5_1_WORD       2
+#define EFI_ACPI_5_1_DWORD      3
+#define EFI_ACPI_5_1_QWORD      4
+
+//
+// ACPI 5.1 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_5_1_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 5.1) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_5_1_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT16                                  ArmBootArch;
+  UINT8                                   MinorVersion;
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  SleepControlReg;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  SleepStatusReg;
+} EFI_ACPI_5_1_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x05
+#define EFI_ACPI_5_1_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION  0x01
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_5_1_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_5_1_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_5_1_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_5_1_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_5_1_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_5_1_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_5_1_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_5_1_PM_PROFILE_PERFORMANCE_SERVER  7
+#define EFI_ACPI_5_1_PM_PROFILE_TABLET              8
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_1_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_5_1_8042                        BIT1
+#define EFI_ACPI_5_1_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_5_1_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_5_1_PCIE_ASPM_CONTROLS          BIT4
+#define EFI_ACPI_5_1_CMOS_RTC_NOT_PRESENT        BIT5
+
+//
+// Fixed ACPI Description Table Arm Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_1_ARM_PSCI_COMPLIANT              BIT0
+#define EFI_ACPI_5_1_ARM_PSCI_USE_HVC                BIT1
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_1_WBINVD                                 BIT0
+#define EFI_ACPI_5_1_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_5_1_PROC_C1                                BIT2
+#define EFI_ACPI_5_1_P_LVL2_UP                              BIT3
+#define EFI_ACPI_5_1_PWR_BUTTON                             BIT4
+#define EFI_ACPI_5_1_SLP_BUTTON                             BIT5
+#define EFI_ACPI_5_1_FIX_RTC                                BIT6
+#define EFI_ACPI_5_1_RTC_S4                                 BIT7
+#define EFI_ACPI_5_1_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_5_1_DCK_CAP                                BIT9
+#define EFI_ACPI_5_1_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_5_1_SEALED_CASE                            BIT11
+#define EFI_ACPI_5_1_HEADLESS                               BIT12
+#define EFI_ACPI_5_1_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_5_1_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_5_1_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_5_1_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_5_1_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_5_1_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_5_1_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+#define EFI_ACPI_5_1_HW_REDUCED_ACPI                        BIT20
+#define EFI_ACPI_5_1_LOW_POWER_S0_IDLE_CAPABLE              BIT21
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved0[3];
+  UINT32  OspmFlags;
+  UINT8   Reserved1[24];
+} EFI_ACPI_5_1_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x02
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_1_S4BIOS_F                     BIT0
+#define EFI_ACPI_5_1_64BIT_WAKE_SUPPORTED_F       BIT1
+
+///
+/// OSPM Enabled Firmware Control Structure Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_1_OSPM_64BIT_WAKE_F            BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_5_1_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_5_1_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_5_1_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x03
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_1_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x0D and 0x7F are reserved and
+// will be ignored by OSPM. 0x80 ~ 0xFF are reserved for OEM.
+//
+#define EFI_ACPI_5_1_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_5_1_IO_APIC                        0x01
+#define EFI_ACPI_5_1_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_5_1_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_5_1_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_5_1_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_5_1_IO_SAPIC                       0x06
+#define EFI_ACPI_5_1_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_5_1_PLATFORM_INTERRUPT_SOURCES     0x08
+#define EFI_ACPI_5_1_PROCESSOR_LOCAL_X2APIC         0x09
+#define EFI_ACPI_5_1_LOCAL_X2APIC_NMI               0x0A
+#define EFI_ACPI_5_1_GIC                            0x0B
+#define EFI_ACPI_5_1_GICD                           0x0C
+#define EFI_ACPI_5_1_GIC_MSI_FRAME                  0x0D
+#define EFI_ACPI_5_1_GICR                           0x0E
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_5_1_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_5_1_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_5_1_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_5_1_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_5_1_POLARITY      (3 << 0)
+#define EFI_ACPI_5_1_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_5_1_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_5_1_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_5_1_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_5_1_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_5_1_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_5_1_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_5_1_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Processor Local x2APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved[2];
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  AcpiProcessorUid;
+} EFI_ACPI_5_1_PROCESSOR_LOCAL_X2APIC_STRUCTURE;
+
+///
+/// Local x2APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  AcpiProcessorUid;
+  UINT8   LocalX2ApicLint;
+  UINT8   Reserved[3];
+} EFI_ACPI_5_1_LOCAL_X2APIC_NMI_STRUCTURE;
+
+///
+/// GIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  CPUInterfaceNumber;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ParkingProtocolVersion;
+  UINT32  PerformanceInterruptGsiv;
+  UINT64  ParkedAddress;
+  UINT64  PhysicalBaseAddress;
+  UINT64  GICV;
+  UINT64  GICH;
+  UINT32  VGICMaintenanceInterrupt;
+  UINT64  GICRBaseAddress;
+  UINT64  MPIDR;
+} EFI_ACPI_5_1_GIC_STRUCTURE;
+
+///
+/// GIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GIC_ENABLED                              BIT0
+#define EFI_ACPI_5_1_PERFORMANCE_INTERRUPT_MODEL              BIT1
+#define EFI_ACPI_5_1_VGIC_MAINTENANCE_INTERRUPT_MODE_FLAGS    BIT2
+
+///
+/// GIC Distributor Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  SystemVectorBase;
+  UINT8   GicVersion;
+  UINT8   Reserved2[3];
+} EFI_ACPI_5_1_GIC_DISTRIBUTOR_STRUCTURE;
+
+///
+/// GIC Version
+///
+#define EFI_ACPI_5_1_GIC_V1                                   0x01
+#define EFI_ACPI_5_1_GIC_V2                                   0x02
+#define EFI_ACPI_5_1_GIC_V3                                   0x03
+#define EFI_ACPI_5_1_GIC_V4                                   0x04
+
+///
+/// GIC MSI Frame Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicMsiFrameId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  Flags;
+  UINT16  SPICount;
+  UINT16  SPIBase;
+} EFI_ACPI_5_1_GIC_MSI_FRAME_STRUCTURE;
+
+///
+/// GIC MSI Frame Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_SPI_COUNT_BASE_SELECT                    BIT0
+
+///
+/// GICR Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  DiscoveryRangeBaseAddress;
+  UINT32  DiscoveryRangeLength;
+} EFI_ACPI_5_1_GICR_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_5_1_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_5_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT).  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_5_1_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x03
+
+//
+// SRAT structure types.
+// All other values between 0x04 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_5_1_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_5_1_MEMORY_AFFINITY                      0x01
+#define EFI_ACPI_5_1_PROCESSOR_LOCAL_X2APIC_AFFINITY      0x02
+#define EFI_ACPI_5_1_GICC_AFFINITY                        0x03
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT32  ClockDomain;
+} EFI_ACPI_5_1_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_5_1_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_5_1_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_5_1_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_5_1_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// Processor Local x2APIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved1[2];
+  UINT32  ProximityDomain;
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+  UINT8   Reserved2[4];
+} EFI_ACPI_5_1_PROCESSOR_LOCAL_X2APIC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+} EFI_ACPI_5_1_GICC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GICC_ENABLED (1 << 0)
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_5_1_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+///
+/// Corrected Platform Error Polling Table (CPEP)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       Reserved[8];
+} EFI_ACPI_5_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_HEADER;
+
+///
+/// CPEP Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_REVISION 0x01
+
+//
+// CPEP processor structure types.
+//
+#define EFI_ACPI_5_1_CPEP_PROCESSOR_APIC_SAPIC  0x00
+
+///
+/// Corrected Platform Error Polling Processor Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT32  PollingInterval;
+} EFI_ACPI_5_1_CPEP_PROCESSOR_APIC_SAPIC_STRUCTURE;
+
+///
+/// Maximum System Characteristics Table (MSCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      OffsetProxDomInfo;
+  UINT32                      MaximumNumberOfProximityDomains;
+  UINT32                      MaximumNumberOfClockDomains;
+  UINT64                      MaximumPhysicalAddress;
+} EFI_ACPI_5_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_HEADER;
+
+///
+/// MSCT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_REVISION 0x01
+
+///
+/// Maximum Proximity Domain Information Structure Definition
+///
+typedef struct {
+  UINT8   Revision;
+  UINT8   Length;
+  UINT32  ProximityDomainRangeLow;
+  UINT32  ProximityDomainRangeHigh;
+  UINT32  MaximumProcessorCapacity;
+  UINT64  MaximumMemoryCapacity;
+} EFI_ACPI_5_1_MAXIMUM_PROXIMITY_DOMAIN_INFORMATION_STRUCTURE;
+
+///
+/// ACPI RAS Feature Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier[12];
+} EFI_ACPI_5_1_RAS_FEATURE_TABLE;
+
+///
+/// RASF Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_RAS_FEATURE_TABLE_REVISION 0x01
+
+///
+/// ACPI RASF Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT16                      Version;
+  UINT8                       RASCapabilities[16];
+  UINT8                       SetRASCapabilities[16];
+  UINT16                      NumberOfRASFParameterBlocks;
+  UINT32                      SetRASCapabilitiesStatus;
+} EFI_ACPI_5_1_RASF_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI RASF PCC command code
+///
+#define EFI_ACPI_5_1_RASF_PCC_COMMAND_CODE_EXECUTE_RASF_COMMAND  0x01
+
+///
+/// ACPI RASF Platform RAS Capabilities
+///
+#define EFI_ACPI_5_1_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED                          0x01
+#define EFI_ACPI_5_1_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED_AND_EXPOSED_TO_SOFTWARE  0x02
+
+///
+/// ACPI RASF Parameter Block structure for PATROL_SCRUB
+///
+typedef struct {
+  UINT16                      Type;
+  UINT16                      Version;
+  UINT16                      Length;
+  UINT16                      PatrolScrubCommand;
+  UINT64                      RequestedAddressRange[2];
+  UINT64                      ActualAddressRange[2];
+  UINT16                      Flags;
+  UINT8                       RequestedSpeed;
+} EFI_ACPI_5_1_RASF_PATROL_SCRUB_PLATFORM_BLOCK_STRUCTURE;
+
+///
+/// ACPI RASF Patrol Scrub command
+///
+#define EFI_ACPI_5_1_RASF_PATROL_SCRUB_COMMAND_GET_PATROL_PARAMETERS   0x01
+#define EFI_ACPI_5_1_RASF_PATROL_SCRUB_COMMAND_START_PATROL_SCRUBBER   0x02
+#define EFI_ACPI_5_1_RASF_PATROL_SCRUB_COMMAND_STOP_PATROL_SCRUBBER    0x03
+
+///
+/// Memory Power State Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier;
+  UINT8                       Reserved[3];
+// Memory Power Node Structure
+// Memory Power State Characteristics
+} EFI_ACPI_5_1_MEMORY_POWER_STATUS_TABLE;
+
+///
+/// MPST Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_MEMORY_POWER_STATE_TABLE_REVISION 0x01
+
+///
+/// MPST Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT32                      MemoryPowerCommandRegister;
+  UINT32                      MemoryPowerStatusRegister;
+  UINT32                      PowerStateId;
+  UINT32                      MemoryPowerNodeId;
+  UINT64                      MemoryEnergyConsumed;
+  UINT64                      ExpectedAveragePowerComsuned;
+} EFI_ACPI_5_1_MPST_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI MPST PCC command code
+///
+#define EFI_ACPI_5_1_MPST_PCC_COMMAND_CODE_EXECUTE_MPST_COMMAND  0x03
+
+///
+/// ACPI MPST Memory Power command
+///
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_POWER_STATE       0x01
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_COMMAND_SET_MEMORY_POWER_STATE       0x02
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_COMMAND_GET_AVERAGE_POWER_CONSUMED   0x03
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_ENERGY_CONSUMED   0x04
+
+///
+/// MPST Memory Power Node Table
+///
+typedef struct {
+  UINT8                                             PowerStateValue;
+  UINT8                                             PowerStateInformationIndex;
+} EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE;
+
+typedef struct {
+  UINT8                                             Flag;
+  UINT8                                             Reserved;
+  UINT16                                            MemoryPowerNodeId;
+  UINT32                                            Length;
+  UINT64                                            AddressBase;
+  UINT64                                            AddressLength;
+  UINT32                                            NumberOfPowerStates;
+  UINT32                                            NumberOfPhysicalComponents;
+//EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE              MemoryPowerState[NumberOfPowerStates];
+//UINT16                                            PhysicalComponentIdentifier[NumberOfPhysicalComponents];
+} EFI_ACPI_5_1_MPST_MEMORY_POWER_STRUCTURE;
+
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_ENABLE          0x01
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_POWER_MANAGED   0x02
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_HOT_PLUGGABLE   0x04
+
+typedef struct {
+  UINT16                      MemoryPowerNodeCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_5_1_MPST_MEMORY_POWER_NODE_TABLE;
+
+///
+/// MPST Memory Power State Characteristics Table
+///
+typedef struct {
+  UINT8                                             PowerStateStructureID;
+  UINT8                                             Flag;
+  UINT16                                            Reserved;
+  UINT32                                            AveragePowerConsumedInMPS0;
+  UINT32                                            RelativePowerSavingToMPS0;
+  UINT64                                            ExitLatencyToMPS0;
+} EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE;
+
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_MEMORY_CONTENT_PRESERVED              0x01
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_ENTRY   0x02
+#define EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_EXIT    0x04
+
+typedef struct {
+  UINT16                      MemoryPowerStateCharacteristicsCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_5_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_TABLE;
+
+///
+/// Memory Topology Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved;
+} EFI_ACPI_5_1_MEMORY_TOPOLOGY_TABLE;
+
+///
+/// PMTT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_MEMORY_TOPOLOGY_TABLE_REVISION 0x01
+
+///
+/// Common Memory Aggregator Device Structure.
+///
+typedef struct {
+  UINT8                       Type;
+  UINT8                       Reserved;
+  UINT16                      Length;
+  UINT16                      Flags;
+  UINT16                      Reserved1;
+} EFI_ACPI_5_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Memory Aggregator Device Type
+///
+#define EFI_ACPI_5_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_SOCKET            0x1
+#define EFI_ACPI_5_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_MEMORY_CONTROLLER 0x2
+#define EFI_ACPI_5_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_DIMM              0x3
+
+///
+/// Socket Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       SocketIdentifier;
+  UINT16                                                       Reserved;
+//EFI_ACPI_5_1_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  MemoryController[];
+} EFI_ACPI_5_1_PMMT_SOCKET_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// MemoryController Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT32                                                       ReadLatency;
+  UINT32                                                       WriteLatency;
+  UINT32                                                       ReadBandwidth;
+  UINT32                                                       WriteBandwidth;
+  UINT16                                                       OptimalAccessUnit;
+  UINT16                                                       OptimalAccessAlignment;
+  UINT16                                                       Reserved;
+  UINT16                                                       NumberOfProximityDomains;
+//UINT32                                                       ProximityDomain[NumberOfProximityDomains];
+//EFI_ACPI_5_1_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE    PhysicalComponent[];
+} EFI_ACPI_5_1_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// DIMM Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_5_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       PhysicalComponentIdentifier;
+  UINT16                                                       Reserved;
+  UINT32                                                       SizeOfDimm;
+  UINT32                                                       SmbiosHandle;
+} EFI_ACPI_5_1_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Boot Graphics Resource Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  ///
+  /// 2-bytes (16 bit) version ID. This value must be 1.
+  ///
+  UINT16                      Version;
+  ///
+  /// 1-byte status field indicating current status about the table.
+  ///     Bits[7:1] = Reserved (must be zero)
+  ///     Bit [0] = Valid. A one indicates the boot image graphic is valid.
+  ///
+  UINT8                       Status;
+  ///
+  /// 1-byte enumerated type field indicating format of the image.
+  ///     0 = Bitmap
+  ///     1 - 255  Reserved (for future use)
+  ///
+  UINT8                       ImageType;
+  ///
+  /// 8-byte (64 bit) physical address pointing to the firmware's in-memory copy
+  /// of the image bitmap.
+  ///
+  UINT64                      ImageAddress;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display X-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetX;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display Y-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetY;
+} EFI_ACPI_5_1_BOOT_GRAPHICS_RESOURCE_TABLE;
+
+///
+/// BGRT Revision
+///
+#define EFI_ACPI_5_1_BOOT_GRAPHICS_RESOURCE_TABLE_REVISION 1
+
+///
+/// BGRT Version
+///
+#define EFI_ACPI_5_1_BGRT_VERSION         0x01
+
+///
+/// BGRT Status
+///
+#define EFI_ACPI_5_1_BGRT_STATUS_NOT_DISPLAYED 0x00
+#define EFI_ACPI_5_1_BGRT_STATUS_DISPLAYED     0x01
+
+///
+/// BGRT Image Type
+///
+#define EFI_ACPI_5_1_BGRT_IMAGE_TYPE_BMP  0x00
+
+///
+/// FPDT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_FIRMWARE_PERFORMANCE_DATA_TABLE_REVISION 0x01
+
+///
+/// FPDT Performance Record Types
+///
+#define EFI_ACPI_5_1_FPDT_RECORD_TYPE_FIRMWARE_BASIC_BOOT_POINTER      0x0000
+#define EFI_ACPI_5_1_FPDT_RECORD_TYPE_S3_PERFORMANCE_TABLE_POINTER     0x0001
+
+///
+/// FPDT Performance Record Revision
+///
+#define EFI_ACPI_5_1_FPDT_RECORD_REVISION_FIRMWARE_BASIC_BOOT_POINTER  0x01
+#define EFI_ACPI_5_1_FPDT_RECORD_REVISION_S3_PERFORMANCE_TABLE_POINTER 0x01
+
+///
+/// FPDT Runtime Performance Record Types
+///
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_TYPE_S3_RESUME                0x0000
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_TYPE_S3_SUSPEND               0x0001
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_TYPE_FIRMWARE_BASIC_BOOT      0x0002
+
+///
+/// FPDT Runtime Performance Record Revision
+///
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_REVISION_S3_RESUME            0x01
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_REVISION_S3_SUSPEND           0x01
+#define EFI_ACPI_5_1_FPDT_RUNTIME_RECORD_REVISION_FIRMWARE_BASIC_BOOT  0x02
+
+///
+/// FPDT Performance Record header
+///
+typedef struct {
+  UINT16           Type;
+  UINT8            Length;
+  UINT8            Revision;
+} EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER;
+
+///
+/// FPDT Performance Table header
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_5_1_FPDT_PERFORMANCE_TABLE_HEADER;
+
+///
+/// FPDT Firmware Basic Boot Performance Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the Basic Boot Performance Table.
+  ///
+  UINT64                                          BootPerformanceTablePointer;
+} EFI_ACPI_5_1_FPDT_BOOT_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT S3 Performance Table Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the S3 Performance Table.
+  ///
+  UINT64                                          S3PerformanceTablePointer;
+} EFI_ACPI_5_1_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Record Structure
+///
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// Timer value logged at the beginning of firmware image execution.
+  /// This may not always be zero or near zero.
+  ///
+  UINT64                                          ResetEnd;
+  ///
+  /// Timer value logged just prior to loading the OS boot loader into memory.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          OsLoaderLoadImageStart;
+  ///
+  /// Timer value logged just prior to launching the previously loaded OS boot loader image.
+  /// For non-UEFI compatible boots, the timer value logged will be just prior
+  /// to the INT 19h handler invocation.
+  ///
+  UINT64                                          OsLoaderStartImageStart;
+  ///
+  /// Timer value logged at the point when the OS loader calls the
+  /// ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesEntry;
+  ///
+  /// Timer value logged at the point just prior towhen the OS loader gaining
+  /// control back from calls the ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesExit;
+} EFI_ACPI_5_1_FPDT_FIRMWARE_BASIC_BOOT_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Table signature
+///
+#define EFI_ACPI_5_1_FPDT_BOOT_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('F', 'B', 'P', 'T')
+
+//
+// FPDT Firmware Basic Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_5_1_FPDT_FIRMWARE_BASIC_BOOT_TABLE;
+
+///
+/// FPDT "S3PT" S3 Performance Table
+///
+#define EFI_ACPI_5_1_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('S', '3', 'P', 'T')
+
+//
+// FPDT Firmware S3 Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_5_1_FPDT_FIRMWARE_S3_BOOT_TABLE;
+
+///
+/// FPDT Basic S3 Resume Performance Record
+///
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// A count of the number of S3 resume cycles since the last full boot sequence.
+  ///
+  UINT32                                          ResumeCount;
+  ///
+  /// Timer recorded at the end of BIOS S3 resume, just prior to handoff to the
+  /// OS waking vector. Only the most recent resume cycle's time is retained.
+  ///
+  UINT64                                          FullResume;
+  ///
+  /// Average timer value of all resume cycles logged since the last full boot
+  /// sequence, including the most recent resume.  Note that the entire log of
+  /// timer values does not need to be retained in order to calculate this average.
+  ///
+  UINT64                                          AverageResume;
+} EFI_ACPI_5_1_FPDT_S3_RESUME_RECORD;
+
+///
+/// FPDT Basic S3 Suspend Performance Record
+///
+typedef struct {
+  EFI_ACPI_5_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// Timer value recorded at the OS write to SLP_TYP upon entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendStart;
+  ///
+  /// Timer value recorded at the final firmware write to SLP_TYP (or other
+  /// mechanism) used to trigger hardware entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendEnd;
+} EFI_ACPI_5_1_FPDT_S3_SUSPEND_RECORD;
+
+///
+/// Firmware Performance Record Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+} EFI_ACPI_5_1_FIRMWARE_PERFORMANCE_RECORD_TABLE;
+
+///
+/// Generic Timer Description Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      CntControlBasePhysicalAddress;
+  UINT32                      Reserved;
+  UINT32                      SecurePL1TimerGSIV;
+  UINT32                      SecurePL1TimerFlags;
+  UINT32                      NonSecurePL1TimerGSIV;
+  UINT32                      NonSecurePL1TimerFlags;
+  UINT32                      VirtualTimerGSIV;
+  UINT32                      VirtualTimerFlags;
+  UINT32                      NonSecurePL2TimerGSIV;
+  UINT32                      NonSecurePL2TimerFlags;
+  UINT64                      CntReadBasePhysicalAddress;
+  UINT32                      PlatformTimerCount;
+  UINT32                      PlatformTimerOffset;
+} EFI_ACPI_5_1_GENERIC_TIMER_DESCRIPTION_TABLE;
+
+///
+/// GTDT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION 0x02
+
+///
+/// Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_5_1_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_5_1_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY          BIT2
+
+///
+/// Platform Timer Type
+///
+#define EFI_ACPI_5_1_GTDT_GT_BLOCK                       0
+#define EFI_ACPI_5_1_GTDT_SBSA_GENERIC_WATCHDOG          1
+
+///
+/// GT Block Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  CntCtlBase;
+  UINT32  GTBlockTimerCount;
+  UINT32  GTBlockTimerOffset;
+} EFI_ACPI_5_1_GTDT_GT_BLOCK_STRUCTURE;
+
+///
+/// GT Block Timer Structure
+///
+typedef struct {
+  UINT8   GTFrameNumber;
+  UINT8   Reserved[3];
+  UINT64  CntBaseX;
+  UINT64  CntEL0BaseX;
+  UINT32  GTxPhysicalTimerGSIV;
+  UINT32  GTxPhysicalTimerFlags;
+  UINT32  GTxVirtualTimerGSIV;
+  UINT32  GTxVirtualTimerFlags;
+  UINT32  GTxCommonFlags;
+} EFI_ACPI_5_1_GTDT_GT_BLOCK_TIMER_STRUCTURE;
+
+///
+/// GT Block Physical Timers and Virtual Timers Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_5_1_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+
+///
+/// Common Flags Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER              BIT0
+#define EFI_ACPI_5_1_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY      BIT1
+
+///
+/// SBSA Generic Watchdog Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  RefreshFramePhysicalAddress;
+  UINT64  WatchdogControlFramePhysicalAddress;
+  UINT32  WatchdogTimerGSIV;
+  UINT32  WatchdogTimerFlags;
+} EFI_ACPI_5_1_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE;
+
+///
+/// SBSA Generic Watchdog Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_5_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_5_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_5_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER                  BIT2
+
+///
+/// Boot Error Record Table (BERT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      BootErrorRegionLength;
+  UINT64                      BootErrorRegion;
+} EFI_ACPI_5_1_BOOT_ERROR_RECORD_TABLE_HEADER;
+
+///
+/// BERT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_BOOT_ERROR_RECORD_TABLE_REVISION 0x01
+
+///
+/// Boot Error Region Block Status Definition
+///
+typedef struct {
+  UINT32       UncorrectableErrorValid:1;
+  UINT32       CorrectableErrorValid:1;
+  UINT32       MultipleUncorrectableErrors:1;
+  UINT32       MultipleCorrectableErrors:1;
+  UINT32       ErrorDataEntryCount:10;
+  UINT32       Reserved:18;
+} EFI_ACPI_5_1_ERROR_BLOCK_STATUS;
+
+///
+/// Boot Error Region Definition
+///
+typedef struct {
+  EFI_ACPI_5_1_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_5_1_BOOT_ERROR_REGION_STRUCTURE;
+
+//
+// Boot Error Severity types
+//
+#define EFI_ACPI_5_1_ERROR_SEVERITY_CORRECTABLE  0x00
+#define EFI_ACPI_5_1_ERROR_SEVERITY_FATAL        0x01
+#define EFI_ACPI_5_1_ERROR_SEVERITY_CORRECTED    0x02
+#define EFI_ACPI_5_1_ERROR_SEVERITY_NONE         0x03
+
+///
+/// Generic Error Data Entry Definition
+///
+typedef struct {
+  UINT8    SectionType[16];
+  UINT32   ErrorSeverity;
+  UINT16   Revision;
+  UINT8    ValidationBits;
+  UINT8    Flags;
+  UINT32   ErrorDataLength;
+  UINT8    FruId[16];
+  UINT8    FruText[20];
+} EFI_ACPI_5_1_GENERIC_ERROR_DATA_ENTRY_STRUCTURE;
+
+///
+/// Generic Error Data Entry Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_GENERIC_ERROR_DATA_ENTRY_REVISION  0x0201
+
+///
+/// HEST - Hardware Error Source Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ErrorSourceCount;
+} EFI_ACPI_5_1_HARDWARE_ERROR_SOURCE_TABLE_HEADER;
+
+///
+/// HEST Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_HARDWARE_ERROR_SOURCE_TABLE_REVISION 0x01
+
+//
+// Error Source structure types.
+//
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION  0x00
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK  0x01
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_NMI_ERROR                0x02
+#define EFI_ACPI_5_1_PCI_EXPRESS_ROOT_PORT_AER                  0x06
+#define EFI_ACPI_5_1_PCI_EXPRESS_DEVICE_AER                     0x07
+#define EFI_ACPI_5_1_PCI_EXPRESS_BRIDGE_AER                     0x08
+#define EFI_ACPI_5_1_GENERIC_HARDWARE_ERROR                     0x09
+
+//
+// Error Source structure flags.
+//
+#define EFI_ACPI_5_1_ERROR_SOURCE_FLAG_FIRMWARE_FIRST       (1 << 0)
+#define EFI_ACPI_5_1_ERROR_SOURCE_FLAG_GLOBAL               (1 << 1)
+
+///
+/// IA-32 Architecture Machine Check Exception Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT64  GlobalCapabilityInitData;
+  UINT64  GlobalControlInitData;
+  UINT8   NumberOfHardwareBanks;
+  UINT8   Reserved1[7];
+} EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure Definition
+///
+typedef struct {
+  UINT8   BankNumber;
+  UINT8   ClearStatusOnInitialization;
+  UINT8   StatusDataFormat;
+  UINT8   Reserved0;
+  UINT32  ControlRegisterMsrAddress;
+  UINT64  ControlInitData;
+  UINT32  StatusRegisterMsrAddress;
+  UINT32  AddressRegisterMsrAddress;
+  UINT32  MiscRegisterMsrAddress;
+} EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_BANK_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure MCA data format
+///
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_IA32      0x00
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_INTEL64   0x01
+#define EFI_ACPI_5_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_AMD64     0x02
+
+//
+// Hardware Error Notification types. All other values are reserved
+//
+#define EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_POLLED                0x00
+#define EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_EXTERNAL_INTERRUPT    0x01
+#define EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_LOCAL_INTERRUPT       0x02
+#define EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_SCI                   0x03
+#define EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_NMI                   0x04
+
+///
+/// Hardware Error Notification Configuration Write Enable Structure Definition
+///
+typedef struct {
+  UINT16    Type:1;
+  UINT16    PollInterval:1;
+  UINT16    SwitchToPollingThresholdValue:1;
+  UINT16    SwitchToPollingThresholdWindow:1;
+  UINT16    ErrorThresholdValue:1;
+  UINT16    ErrorThresholdWindow:1;
+  UINT16    Reserved:10;
+} EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE;
+
+///
+/// Hardware Error Notification Structure Definition
+///
+typedef struct {
+  UINT8                                                                          Type;
+  UINT8                                                                          Length;
+  EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE  ConfigurationWriteEnable;
+  UINT32                                                                         PollInterval;
+  UINT32                                                                         Vector;
+  UINT32                                                                         SwitchToPollingThresholdValue;
+  UINT32                                                                         SwitchToPollingThresholdWindow;
+  UINT32                                                                         ErrorThresholdValue;
+  UINT32                                                                         ErrorThresholdWindow;
+} EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE;
+
+///
+/// IA-32 Architecture Corrected Machine Check Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT8                                                  Reserved0[2];
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT8                                                  NumberOfHardwareBanks;
+  UINT8                                                  Reserved1[3];
+} EFI_ACPI_5_1_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK_STRUCTURE;
+
+///
+/// IA-32 Architecture NMI Error Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  MaxRawDataLength;
+} EFI_ACPI_5_1_IA32_ARCHITECTURE_NMI_ERROR_STRUCTURE;
+
+///
+/// PCI Express Root Port AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  RootErrorCommand;
+} EFI_ACPI_5_1_PCI_EXPRESS_ROOT_PORT_AER_STRUCTURE;
+
+///
+/// PCI Express Device AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_5_1_PCI_EXPRESS_DEVICE_AER_STRUCTURE;
+
+///
+/// PCI Express Bridge AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  SecondaryUncorrectableErrorMask;
+  UINT32  SecondaryUncorrectableErrorSeverity;
+  UINT32  SecondaryAdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_5_1_PCI_EXPRESS_BRIDGE_AER_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_5_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+} EFI_ACPI_5_1_GENERIC_HARDWARE_ERROR_SOURCE_STRUCTURE;
+
+///
+/// Generic Error Status Definition
+///
+typedef struct {
+  EFI_ACPI_5_1_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_5_1_GENERIC_ERROR_STATUS_STRUCTURE;
+
+///
+/// ERST - Error Record Serialization Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      SerializationHeaderSize;
+  UINT8                       Reserved0[4];
+  UINT32                      InstructionEntryCount;
+} EFI_ACPI_5_1_ERROR_RECORD_SERIALIZATION_TABLE_HEADER;
+
+///
+/// ERST Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_ERROR_RECORD_SERIALIZATION_TABLE_REVISION 0x01
+
+///
+/// ERST Serialization Actions
+///
+#define EFI_ACPI_5_1_ERST_BEGIN_WRITE_OPERATION                    0x00
+#define EFI_ACPI_5_1_ERST_BEGIN_READ_OPERATION                     0x01
+#define EFI_ACPI_5_1_ERST_BEGIN_CLEAR_OPERATION                    0x02
+#define EFI_ACPI_5_1_ERST_END_OPERATION                            0x03
+#define EFI_ACPI_5_1_ERST_SET_RECORD_OFFSET                        0x04
+#define EFI_ACPI_5_1_ERST_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_5_1_ERST_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_5_1_ERST_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_5_1_ERST_GET_RECORD_IDENTIFIER                    0x08
+#define EFI_ACPI_5_1_ERST_SET_RECORD_IDENTIFIER                    0x09
+#define EFI_ACPI_5_1_ERST_GET_RECORD_COUNT                         0x0A
+#define EFI_ACPI_5_1_ERST_BEGIN_DUMMY_WRITE_OPERATION              0x0B
+#define EFI_ACPI_5_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE              0x0D
+#define EFI_ACPI_5_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE_LENGTH       0x0E
+#define EFI_ACPI_5_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE_ATTRIBUTES   0x0F
+
+///
+/// ERST Action Command Status
+///
+#define EFI_ACPI_5_1_ERST_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_5_1_ERST_STATUS_NOT_ENOUGH_SPACE                  0x01
+#define EFI_ACPI_5_1_ERST_STATUS_HARDWARE_NOT_AVAILABLE            0x02
+#define EFI_ACPI_5_1_ERST_STATUS_FAILED                            0x03
+#define EFI_ACPI_5_1_ERST_STATUS_RECORD_STORE_EMPTY                0x04
+#define EFI_ACPI_5_1_ERST_STATUS_RECORD_NOT_FOUND                  0x05
+
+///
+/// ERST Serialization Instructions
+///
+#define EFI_ACPI_5_1_ERST_READ_REGISTER                            0x00
+#define EFI_ACPI_5_1_ERST_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_5_1_ERST_WRITE_REGISTER                           0x02
+#define EFI_ACPI_5_1_ERST_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_5_1_ERST_NOOP                                     0x04
+#define EFI_ACPI_5_1_ERST_LOAD_VAR1                                0x05
+#define EFI_ACPI_5_1_ERST_LOAD_VAR2                                0x06
+#define EFI_ACPI_5_1_ERST_STORE_VAR1                               0x07
+#define EFI_ACPI_5_1_ERST_ADD                                      0x08
+#define EFI_ACPI_5_1_ERST_SUBTRACT                                 0x09
+#define EFI_ACPI_5_1_ERST_ADD_VALUE                                0x0A
+#define EFI_ACPI_5_1_ERST_SUBTRACT_VALUE                           0x0B
+#define EFI_ACPI_5_1_ERST_STALL                                    0x0C
+#define EFI_ACPI_5_1_ERST_STALL_WHILE_TRUE                         0x0D
+#define EFI_ACPI_5_1_ERST_SKIP_NEXT_INSTRUCTION_IF_TRUE            0x0E
+#define EFI_ACPI_5_1_ERST_GOTO                                     0x0F
+#define EFI_ACPI_5_1_ERST_SET_SRC_ADDRESS_BASE                     0x10
+#define EFI_ACPI_5_1_ERST_SET_DST_ADDRESS_BASE                     0x11
+#define EFI_ACPI_5_1_ERST_MOVE_DATA                                0x12
+
+///
+/// ERST Instruction Flags
+///
+#define EFI_ACPI_5_1_ERST_PRESERVE_REGISTER                        0x01
+
+///
+/// ERST Serialization Instruction Entry
+///
+typedef struct {
+  UINT8                                    SerializationAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_5_1_ERST_SERIALIZATION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ - Error Injection Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      InjectionHeaderSize;
+  UINT8                       InjectionFlags;
+  UINT8                       Reserved0[3];
+  UINT32                      InjectionEntryCount;
+} EFI_ACPI_5_1_ERROR_INJECTION_TABLE_HEADER;
+
+///
+/// EINJ Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_ERROR_INJECTION_TABLE_REVISION 0x01
+
+///
+/// EINJ Error Injection Actions
+///
+#define EFI_ACPI_5_1_EINJ_BEGIN_INJECTION_OPERATION                0x00
+#define EFI_ACPI_5_1_EINJ_GET_TRIGGER_ERROR_ACTION_TABLE           0x01
+#define EFI_ACPI_5_1_EINJ_SET_ERROR_TYPE                           0x02
+#define EFI_ACPI_5_1_EINJ_GET_ERROR_TYPE                           0x03
+#define EFI_ACPI_5_1_EINJ_END_OPERATION                            0x04
+#define EFI_ACPI_5_1_EINJ_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_5_1_EINJ_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_5_1_EINJ_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_5_1_EINJ_TRIGGER_ERROR                            0xFF
+
+///
+/// EINJ Action Command Status
+///
+#define EFI_ACPI_5_1_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_5_1_EINJ_STATUS_UNKNOWN_FAILURE                   0x01
+#define EFI_ACPI_5_1_EINJ_STATUS_INVALID_ACCESS                    0x02
+
+///
+/// EINJ Error Type Definition
+///
+#define EFI_ACPI_5_1_EINJ_ERROR_PROCESSOR_CORRECTABLE                 (1 << 0)
+#define EFI_ACPI_5_1_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_NONFATAL      (1 << 1)
+#define EFI_ACPI_5_1_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_FATAL         (1 << 2)
+#define EFI_ACPI_5_1_EINJ_ERROR_MEMORY_CORRECTABLE                    (1 << 3)
+#define EFI_ACPI_5_1_EINJ_ERROR_MEMORY_UNCORRECTABLE_NONFATAL         (1 << 4)
+#define EFI_ACPI_5_1_EINJ_ERROR_MEMORY_UNCORRECTABLE_FATAL            (1 << 5)
+#define EFI_ACPI_5_1_EINJ_ERROR_PCI_EXPRESS_CORRECTABLE               (1 << 6)
+#define EFI_ACPI_5_1_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_NONFATAL    (1 << 7)
+#define EFI_ACPI_5_1_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_FATAL       (1 << 8)
+#define EFI_ACPI_5_1_EINJ_ERROR_PLATFORM_CORRECTABLE                  (1 << 9)
+#define EFI_ACPI_5_1_EINJ_ERROR_PLATFORM_UNCORRECTABLE_NONFATAL       (1 << 10)
+#define EFI_ACPI_5_1_EINJ_ERROR_PLATFORM_UNCORRECTABLE_FATAL          (1 << 11)
+
+///
+/// EINJ Injection Instructions
+///
+#define EFI_ACPI_5_1_EINJ_READ_REGISTER                            0x00
+#define EFI_ACPI_5_1_EINJ_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_5_1_EINJ_WRITE_REGISTER                           0x02
+#define EFI_ACPI_5_1_EINJ_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_5_1_EINJ_NOOP                                     0x04
+
+///
+/// EINJ Instruction Flags
+///
+#define EFI_ACPI_5_1_EINJ_PRESERVE_REGISTER                        0x01
+
+///
+/// EINJ Injection Instruction Entry
+///
+typedef struct {
+  UINT8                                    InjectionAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_5_1_EINJ_INJECTION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ Trigger Action Table
+///
+typedef struct {
+  UINT32  HeaderSize;
+  UINT32  Revision;
+  UINT32  TableSize;
+  UINT32  EntryCount;
+} EFI_ACPI_5_1_EINJ_TRIGGER_ACTION_TABLE;
+
+///
+/// Platform Communications Channel Table (PCCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Flags;
+  UINT64                      Reserved;
+} EFI_ACPI_5_1_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER;
+
+///
+/// PCCT Version (as defined in ACPI 5.1 spec.)
+///
+#define EFI_ACPI_5_1_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION 0x01
+
+///
+/// PCCT Global Flags
+///
+#define EFI_ACPI_5_1_PCCT_FLAGS_SCI_DOORBELL                      BIT0
+
+//
+// PCCT Subspace type
+//
+#define EFI_ACPI_5_1_PCCT_SUBSPACE_TYPE_GENERIC  0x00
+
+///
+/// PCC Subspace Structure Header
+///
+typedef struct {
+  UINT8        Type;
+  UINT8        Length;
+} EFI_ACPI_5_1_PCCT_SUBSPACE_HEADER;
+
+///
+/// Generic Communications Subspace Structure
+///
+typedef struct {
+  UINT8                                    Type;
+  UINT8                                    Length;
+  UINT8                                    Reserved[6];
+  UINT64                                   BaseAddress;
+  UINT64                                   AddressLength;
+  EFI_ACPI_5_1_GENERIC_ADDRESS_STRUCTURE   DoorbellRegister;
+  UINT64                                   DoorbellPreserve;
+  UINT64                                   DoorbellWrite;
+  UINT32                                   NominalLatency;
+  UINT32                                   MaximumPeriodicAccessRate;
+  UINT16                                   MinimumRequestTurnaroundTime;
+} EFI_ACPI_5_1_PCCT_SUBSPACE_GENERIC;
+
+///
+/// Generic Communications Channel Shared Memory Region
+///
+
+typedef struct {
+  UINT8                                    Command;
+  UINT8                                    Reserved:7;
+  UINT8                                    GenerateSci:1;
+} EFI_ACPI_5_1_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND;
+
+typedef struct {
+  UINT8                                    CommandComplete:1;
+  UINT8                                    SciDoorbell:1;
+  UINT8                                    Error:1;
+  UINT8                                    PlatformNotification:1;  
+  UINT8                                    Reserved:4;
+  UINT8                                    Reserved1;
+} EFI_ACPI_5_1_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS;
+
+typedef struct {
+  UINT32                                                    Signature;
+  EFI_ACPI_5_1_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND    Command;
+  EFI_ACPI_5_1_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS     Status;
+} EFI_ACPI_5_1_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_5_1_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_5_1_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BERT" Boot Error Record Table
+///
+#define EFI_ACPI_5_1_BOOT_ERROR_RECORD_TABLE_SIGNATURE  SIGNATURE_32('B', 'E', 'R', 'T')
+
+///
+/// "BGRT" Boot Graphics Resource Table
+///
+#define EFI_ACPI_5_1_BOOT_GRAPHICS_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('B', 'G', 'R', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_5_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_5_1_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_5_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "EINJ" Error Injection Table
+///
+#define EFI_ACPI_5_1_ERROR_INJECTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'I', 'N', 'J')
+
+///
+/// "ERST" Error Record Serialization Table
+///
+#define EFI_ACPI_5_1_ERROR_RECORD_SERIALIZATION_TABLE_SIGNATURE  SIGNATURE_32('E', 'R', 'S', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_5_1_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_5_1_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FPDT" Firmware Performance Data Table
+///
+#define EFI_ACPI_5_1_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE  SIGNATURE_32('F', 'P', 'D', 'T')
+
+///
+/// "GTDT" Generic Timer Description Table
+///
+#define EFI_ACPI_5_1_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('G', 'T', 'D', 'T')
+
+///
+/// "HEST" Hardware Error Source Table
+///
+#define EFI_ACPI_5_1_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE  SIGNATURE_32('H', 'E', 'S', 'T')
+
+///
+/// "MPST" Memory Power State Table
+///
+#define EFI_ACPI_5_1_MEMORY_POWER_STATE_TABLE_SIGNATURE  SIGNATURE_32('M', 'P', 'S', 'T')
+
+///
+/// "MSCT" Maximum System Characteristics Table
+///
+#define EFI_ACPI_5_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'C', 'T')
+
+///
+/// "PMTT" Platform Memory Topology Table
+///
+#define EFI_ACPI_5_1_PLATFORM_MEMORY_TOPOLOGY_TABLE_SIGNATURE  SIGNATURE_32('P', 'M', 'T', 'T')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_5_1_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RASF" ACPI RAS Feature Table
+///
+#define EFI_ACPI_5_1_ACPI_RAS_FEATURE_TABLE_SIGNATURE  SIGNATURE_32('R', 'A', 'S', 'F')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_5_1_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_5_1_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_5_1_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_5_1_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_5_1_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_5_1_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_5_1_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "CSRT" MS Core System Resource Table
+///
+#define EFI_ACPI_5_1_CORE_SYSTEM_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('C', 'S', 'R', 'T')
+
+///
+/// "DBG2" MS Debug Port 2 Spec
+///
+#define EFI_ACPI_5_1_DEBUG_PORT_2_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', '2')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_5_1_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DMAR" DMA Remapping Table
+///
+#define EFI_ACPI_5_1_DMA_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('D', 'M', 'A', 'R')
+
+///
+/// "DRTM" Dynamic Root of Trust for Measurement Table
+///
+#define EFI_ACPI_5_1_DYNAMIC_ROOT_OF_TRUST_FOR_MEASUREMENT_TABLE_SIGNATURE  SIGNATURE_32('D', 'R', 'T', 'M')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_5_1_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_5_1_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_5_1_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+///
+/// "IVRS" I/O Virtualization Reporting Structure
+///
+#define EFI_ACPI_5_1_IO_VIRTUALIZATION_REPORTING_STRUCTURE_SIGNATURE  SIGNATURE_32('I', 'V', 'R', 'S')
+
+///
+/// "LPIT" Low Power Idle Table
+///
+#define EFI_ACPI_5_1_IO_LOW_POWER_IDLE_TABLE_STRUCTURE_SIGNATURE  SIGNATURE_32('L', 'P', 'I', 'T')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_5_1_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "MCHI" Management Controller Host Interface Table
+///
+#define EFI_ACPI_5_1_MANAGEMENT_CONTROLLER_HOST_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'H', 'I')
+
+///
+/// "MSDM" MS Data Management Table
+///
+#define EFI_ACPI_5_1_DATA_MANAGEMENT_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'D', 'M')
+
+///
+/// "SLIC" MS Software Licensing Table Specification
+///
+#define EFI_ACPI_5_1_SOFTWARE_LICENSING_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'C')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_5_1_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_5_1_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_5_1_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "TPM2" Trusted Computing Platform 1 Table
+///
+#define EFI_ACPI_5_1_TRUSTED_COMPUTING_PLATFORM_2_TABLE_SIGNATURE  SIGNATURE_32('T', 'P', 'M', '2')
+
+///
+/// "UEFI" UEFI ACPI Data Table
+///
+#define EFI_ACPI_5_1_UEFI_ACPI_DATA_TABLE_SIGNATURE  SIGNATURE_32('U', 'E', 'F', 'I')
+
+///
+/// "WAET" Windows ACPI Emulated Devices Table
+///
+#define EFI_ACPI_5_1_WINDOWS_ACPI_EMULATED_DEVICES_TABLE_SIGNATURE  SIGNATURE_32('W', 'A', 'E', 'T')
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_5_1_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_5_1_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+///
+/// "WPBT" MS Platform Binary Table
+///
+#define EFI_ACPI_5_1_PLATFORM_BINARY_TABLE_SIGNATURE  SIGNATURE_32('W', 'P', 'B', 'T')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi60.h b/MdePkg/Include/IndustryStandard/Acpi60.h
new file mode 100644
index 000000000000..478697cceb48
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi60.h
@@ -0,0 +1,2346 @@
+/** @file   
+  ACPI 6.0 definitions from the ACPI Specification Revision 6.0 Errata A January, 2016.
+
+  Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<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 _ACPI_6_0_H_
+#define _ACPI_6_0_H_
+
+#include <IndustryStandard/Acpi51.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 6.0 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_6_0_SYSTEM_MEMORY              0
+#define EFI_ACPI_6_0_SYSTEM_IO                  1
+#define EFI_ACPI_6_0_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_6_0_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_6_0_SMBUS                      4
+#define EFI_ACPI_6_0_PLATFORM_COMMUNICATION_CHANNEL  0x0A
+#define EFI_ACPI_6_0_FUNCTIONAL_FIXED_HARDWARE       0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_6_0_UNDEFINED  0
+#define EFI_ACPI_6_0_BYTE       1
+#define EFI_ACPI_6_0_WORD       2
+#define EFI_ACPI_6_0_DWORD      3
+#define EFI_ACPI_6_0_QWORD      4
+
+//
+// ACPI 6.0 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_6_0_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 6.0) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_6_0_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT16                                  ArmBootArch;
+  UINT8                                   MinorVersion;
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  SleepControlReg;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  SleepStatusReg;
+  UINT64                                  HypervisorVendorIdentity;
+} EFI_ACPI_6_0_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x06
+#define EFI_ACPI_6_0_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION  0x00
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_6_0_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_6_0_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_6_0_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_6_0_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_6_0_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_6_0_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_6_0_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_6_0_PM_PROFILE_PERFORMANCE_SERVER  7
+#define EFI_ACPI_6_0_PM_PROFILE_TABLET              8
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_0_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_6_0_8042                        BIT1
+#define EFI_ACPI_6_0_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_6_0_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_6_0_PCIE_ASPM_CONTROLS          BIT4
+#define EFI_ACPI_6_0_CMOS_RTC_NOT_PRESENT        BIT5
+
+//
+// Fixed ACPI Description Table Arm Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_0_ARM_PSCI_COMPLIANT              BIT0
+#define EFI_ACPI_6_0_ARM_PSCI_USE_HVC                BIT1
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_0_WBINVD                                 BIT0
+#define EFI_ACPI_6_0_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_6_0_PROC_C1                                BIT2
+#define EFI_ACPI_6_0_P_LVL2_UP                              BIT3
+#define EFI_ACPI_6_0_PWR_BUTTON                             BIT4
+#define EFI_ACPI_6_0_SLP_BUTTON                             BIT5
+#define EFI_ACPI_6_0_FIX_RTC                                BIT6
+#define EFI_ACPI_6_0_RTC_S4                                 BIT7
+#define EFI_ACPI_6_0_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_6_0_DCK_CAP                                BIT9
+#define EFI_ACPI_6_0_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_6_0_SEALED_CASE                            BIT11
+#define EFI_ACPI_6_0_HEADLESS                               BIT12
+#define EFI_ACPI_6_0_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_6_0_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_6_0_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_6_0_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_6_0_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_6_0_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_6_0_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+#define EFI_ACPI_6_0_HW_REDUCED_ACPI                        BIT20
+#define EFI_ACPI_6_0_LOW_POWER_S0_IDLE_CAPABLE              BIT21
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved0[3];
+  UINT32  OspmFlags;
+  UINT8   Reserved1[24];
+} EFI_ACPI_6_0_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x02
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_0_S4BIOS_F                     BIT0
+#define EFI_ACPI_6_0_64BIT_WAKE_SUPPORTED_F       BIT1
+
+///
+/// OSPM Enabled Firmware Control Structure Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_0_OSPM_64BIT_WAKE_F            BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_6_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_6_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_6_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 6.0 Errata A spec.)
+///
+#define EFI_ACPI_6_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x04
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_0_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x0D and 0x7F are reserved and
+// will be ignored by OSPM. 0x80 ~ 0xFF are reserved for OEM.
+//
+#define EFI_ACPI_6_0_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_6_0_IO_APIC                        0x01
+#define EFI_ACPI_6_0_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_6_0_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_6_0_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_6_0_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_6_0_IO_SAPIC                       0x06
+#define EFI_ACPI_6_0_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_6_0_PLATFORM_INTERRUPT_SOURCES     0x08
+#define EFI_ACPI_6_0_PROCESSOR_LOCAL_X2APIC         0x09
+#define EFI_ACPI_6_0_LOCAL_X2APIC_NMI               0x0A
+#define EFI_ACPI_6_0_GIC                            0x0B
+#define EFI_ACPI_6_0_GICD                           0x0C
+#define EFI_ACPI_6_0_GIC_MSI_FRAME                  0x0D
+#define EFI_ACPI_6_0_GICR                           0x0E
+#define EFI_ACPI_6_0_GIC_ITS                        0x0F
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorUid;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_6_0_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_6_0_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_6_0_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_6_0_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_0_POLARITY      (3 << 0)
+#define EFI_ACPI_6_0_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_6_0_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorUid;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_6_0_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_6_0_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_6_0_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_6_0_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_6_0_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_0_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Processor Local x2APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved[2];
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  AcpiProcessorUid;
+} EFI_ACPI_6_0_PROCESSOR_LOCAL_X2APIC_STRUCTURE;
+
+///
+/// Local x2APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  AcpiProcessorUid;
+  UINT8   LocalX2ApicLint;
+  UINT8   Reserved[3];
+} EFI_ACPI_6_0_LOCAL_X2APIC_NMI_STRUCTURE;
+
+///
+/// GIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  CPUInterfaceNumber;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ParkingProtocolVersion;
+  UINT32  PerformanceInterruptGsiv;
+  UINT64  ParkedAddress;
+  UINT64  PhysicalBaseAddress;
+  UINT64  GICV;
+  UINT64  GICH;
+  UINT32  VGICMaintenanceInterrupt;
+  UINT64  GICRBaseAddress;
+  UINT64  MPIDR;
+  UINT8   ProcessorPowerEfficiencyClass;
+  UINT8   Reserved2[3];
+} EFI_ACPI_6_0_GIC_STRUCTURE;
+
+///
+/// GIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GIC_ENABLED                              BIT0
+#define EFI_ACPI_6_0_PERFORMANCE_INTERRUPT_MODEL              BIT1
+#define EFI_ACPI_6_0_VGIC_MAINTENANCE_INTERRUPT_MODE_FLAGS    BIT2
+
+///
+/// GIC Distributor Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  SystemVectorBase;
+  UINT8   GicVersion;
+  UINT8   Reserved2[3];
+} EFI_ACPI_6_0_GIC_DISTRIBUTOR_STRUCTURE;
+
+///
+/// GIC Version
+///
+#define EFI_ACPI_6_0_GIC_V1                                   0x01
+#define EFI_ACPI_6_0_GIC_V2                                   0x02
+#define EFI_ACPI_6_0_GIC_V3                                   0x03
+#define EFI_ACPI_6_0_GIC_V4                                   0x04
+
+///
+/// GIC MSI Frame Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicMsiFrameId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  Flags;
+  UINT16  SPICount;
+  UINT16  SPIBase;
+} EFI_ACPI_6_0_GIC_MSI_FRAME_STRUCTURE;
+
+///
+/// GIC MSI Frame Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_SPI_COUNT_BASE_SELECT                    BIT0
+
+///
+/// GICR Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  DiscoveryRangeBaseAddress;
+  UINT32  DiscoveryRangeLength;
+} EFI_ACPI_6_0_GICR_STRUCTURE;
+
+///
+/// GIC Interrupt Translation Service Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  GicItsId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  Reserved2;
+} EFI_ACPI_6_0_GIC_ITS_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_6_0_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_6_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT).  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_6_0_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x03
+
+//
+// SRAT structure types.
+// All other values between 0x04 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_6_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_6_0_MEMORY_AFFINITY                      0x01
+#define EFI_ACPI_6_0_PROCESSOR_LOCAL_X2APIC_AFFINITY      0x02
+#define EFI_ACPI_6_0_GICC_AFFINITY                        0x03
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT32  ClockDomain;
+} EFI_ACPI_6_0_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_6_0_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_6_0_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_6_0_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_6_0_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// Processor Local x2APIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved1[2];
+  UINT32  ProximityDomain;
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+  UINT8   Reserved2[4];
+} EFI_ACPI_6_0_PROCESSOR_LOCAL_X2APIC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+} EFI_ACPI_6_0_GICC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GICC_ENABLED (1 << 0)
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_6_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+///
+/// Corrected Platform Error Polling Table (CPEP)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       Reserved[8];
+} EFI_ACPI_6_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_HEADER;
+
+///
+/// CPEP Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_REVISION 0x01
+
+//
+// CPEP processor structure types.
+//
+#define EFI_ACPI_6_0_CPEP_PROCESSOR_APIC_SAPIC  0x00
+
+///
+/// Corrected Platform Error Polling Processor Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT32  PollingInterval;
+} EFI_ACPI_6_0_CPEP_PROCESSOR_APIC_SAPIC_STRUCTURE;
+
+///
+/// Maximum System Characteristics Table (MSCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      OffsetProxDomInfo;
+  UINT32                      MaximumNumberOfProximityDomains;
+  UINT32                      MaximumNumberOfClockDomains;
+  UINT64                      MaximumPhysicalAddress;
+} EFI_ACPI_6_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_HEADER;
+
+///
+/// MSCT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_REVISION 0x01
+
+///
+/// Maximum Proximity Domain Information Structure Definition
+///
+typedef struct {
+  UINT8   Revision;
+  UINT8   Length;
+  UINT32  ProximityDomainRangeLow;
+  UINT32  ProximityDomainRangeHigh;
+  UINT32  MaximumProcessorCapacity;
+  UINT64  MaximumMemoryCapacity;
+} EFI_ACPI_6_0_MAXIMUM_PROXIMITY_DOMAIN_INFORMATION_STRUCTURE;
+
+///
+/// ACPI RAS Feature Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier[12];
+} EFI_ACPI_6_0_RAS_FEATURE_TABLE;
+
+///
+/// RASF Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_RAS_FEATURE_TABLE_REVISION 0x01
+
+///
+/// ACPI RASF Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT16                      Version;
+  UINT8                       RASCapabilities[16];
+  UINT8                       SetRASCapabilities[16];
+  UINT16                      NumberOfRASFParameterBlocks;
+  UINT32                      SetRASCapabilitiesStatus;
+} EFI_ACPI_6_0_RASF_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI RASF PCC command code
+///
+#define EFI_ACPI_6_0_RASF_PCC_COMMAND_CODE_EXECUTE_RASF_COMMAND  0x01
+
+///
+/// ACPI RASF Platform RAS Capabilities
+///
+#define EFI_ACPI_6_0_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED                          0x01
+#define EFI_ACPI_6_0_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED_AND_EXPOSED_TO_SOFTWARE  0x02
+
+///
+/// ACPI RASF Parameter Block structure for PATROL_SCRUB
+///
+typedef struct {
+  UINT16                      Type;
+  UINT16                      Version;
+  UINT16                      Length;
+  UINT16                      PatrolScrubCommand;
+  UINT64                      RequestedAddressRange[2];
+  UINT64                      ActualAddressRange[2];
+  UINT16                      Flags;
+  UINT8                       RequestedSpeed;
+} EFI_ACPI_6_0_RASF_PATROL_SCRUB_PLATFORM_BLOCK_STRUCTURE;
+
+///
+/// ACPI RASF Patrol Scrub command
+///
+#define EFI_ACPI_6_0_RASF_PATROL_SCRUB_COMMAND_GET_PATROL_PARAMETERS   0x01
+#define EFI_ACPI_6_0_RASF_PATROL_SCRUB_COMMAND_START_PATROL_SCRUBBER   0x02
+#define EFI_ACPI_6_0_RASF_PATROL_SCRUB_COMMAND_STOP_PATROL_SCRUBBER    0x03
+
+///
+/// Memory Power State Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier;
+  UINT8                       Reserved[3];
+// Memory Power Node Structure
+// Memory Power State Characteristics
+} EFI_ACPI_6_0_MEMORY_POWER_STATUS_TABLE;
+
+///
+/// MPST Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_MEMORY_POWER_STATE_TABLE_REVISION 0x01
+
+///
+/// MPST Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT32                      MemoryPowerCommandRegister;
+  UINT32                      MemoryPowerStatusRegister;
+  UINT32                      PowerStateId;
+  UINT32                      MemoryPowerNodeId;
+  UINT64                      MemoryEnergyConsumed;
+  UINT64                      ExpectedAveragePowerComsuned;
+} EFI_ACPI_6_0_MPST_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI MPST PCC command code
+///
+#define EFI_ACPI_6_0_MPST_PCC_COMMAND_CODE_EXECUTE_MPST_COMMAND  0x03
+
+///
+/// ACPI MPST Memory Power command
+///
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_POWER_STATE       0x01
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_COMMAND_SET_MEMORY_POWER_STATE       0x02
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_COMMAND_GET_AVERAGE_POWER_CONSUMED   0x03
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_ENERGY_CONSUMED   0x04
+
+///
+/// MPST Memory Power Node Table
+///
+typedef struct {
+  UINT8                                             PowerStateValue;
+  UINT8                                             PowerStateInformationIndex;
+} EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE;
+
+typedef struct {
+  UINT8                                             Flag;
+  UINT8                                             Reserved;
+  UINT16                                            MemoryPowerNodeId;
+  UINT32                                            Length;
+  UINT64                                            AddressBase;
+  UINT64                                            AddressLength;
+  UINT32                                            NumberOfPowerStates;
+  UINT32                                            NumberOfPhysicalComponents;
+//EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE              MemoryPowerState[NumberOfPowerStates];
+//UINT16                                            PhysicalComponentIdentifier[NumberOfPhysicalComponents];
+} EFI_ACPI_6_0_MPST_MEMORY_POWER_STRUCTURE;
+
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_ENABLE          0x01
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_POWER_MANAGED   0x02
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STRUCTURE_FLAG_HOT_PLUGGABLE   0x04
+
+typedef struct {
+  UINT16                      MemoryPowerNodeCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_6_0_MPST_MEMORY_POWER_NODE_TABLE;
+
+///
+/// MPST Memory Power State Characteristics Table
+///
+typedef struct {
+  UINT8                                             PowerStateStructureID;
+  UINT8                                             Flag;
+  UINT16                                            Reserved;
+  UINT32                                            AveragePowerConsumedInMPS0;
+  UINT32                                            RelativePowerSavingToMPS0;
+  UINT64                                            ExitLatencyToMPS0;
+} EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE;
+
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_MEMORY_CONTENT_PRESERVED              0x01
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_ENTRY   0x02
+#define EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_EXIT    0x04
+
+typedef struct {
+  UINT16                      MemoryPowerStateCharacteristicsCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_6_0_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_TABLE;
+
+///
+/// Memory Topology Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved;
+} EFI_ACPI_6_0_MEMORY_TOPOLOGY_TABLE;
+
+///
+/// PMTT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_MEMORY_TOPOLOGY_TABLE_REVISION 0x01
+
+///
+/// Common Memory Aggregator Device Structure.
+///
+typedef struct {
+  UINT8                       Type;
+  UINT8                       Reserved;
+  UINT16                      Length;
+  UINT16                      Flags;
+  UINT16                      Reserved1;
+} EFI_ACPI_6_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Memory Aggregator Device Type
+///
+#define EFI_ACPI_6_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_SOCKET            0x1
+#define EFI_ACPI_6_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_MEMORY_CONTROLLER 0x2
+#define EFI_ACPI_6_0_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_DIMM              0x3
+
+///
+/// Socket Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       SocketIdentifier;
+  UINT16                                                       Reserved;
+//EFI_ACPI_6_0_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  MemoryController[];
+} EFI_ACPI_6_0_PMMT_SOCKET_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// MemoryController Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT32                                                       ReadLatency;
+  UINT32                                                       WriteLatency;
+  UINT32                                                       ReadBandwidth;
+  UINT32                                                       WriteBandwidth;
+  UINT16                                                       OptimalAccessUnit;
+  UINT16                                                       OptimalAccessAlignment;
+  UINT16                                                       Reserved;
+  UINT16                                                       NumberOfProximityDomains;
+//UINT32                                                       ProximityDomain[NumberOfProximityDomains];
+//EFI_ACPI_6_0_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE    PhysicalComponent[];
+} EFI_ACPI_6_0_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// DIMM Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_0_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       PhysicalComponentIdentifier;
+  UINT16                                                       Reserved;
+  UINT32                                                       SizeOfDimm;
+  UINT32                                                       SmbiosHandle;
+} EFI_ACPI_6_0_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Boot Graphics Resource Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  ///
+  /// 2-bytes (16 bit) version ID. This value must be 1.
+  ///
+  UINT16                      Version;
+  ///
+  /// 1-byte status field indicating current status about the table.
+  ///     Bits[7:1] = Reserved (must be zero)
+  ///     Bit [0] = Valid. A one indicates the boot image graphic is valid.
+  ///
+  UINT8                       Status;
+  ///
+  /// 1-byte enumerated type field indicating format of the image.
+  ///     0 = Bitmap
+  ///     1 - 255  Reserved (for future use)
+  ///
+  UINT8                       ImageType;
+  ///
+  /// 8-byte (64 bit) physical address pointing to the firmware's in-memory copy
+  /// of the image bitmap.
+  ///
+  UINT64                      ImageAddress;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display X-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetX;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display Y-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetY;
+} EFI_ACPI_6_0_BOOT_GRAPHICS_RESOURCE_TABLE;
+
+///
+/// BGRT Revision
+///
+#define EFI_ACPI_6_0_BOOT_GRAPHICS_RESOURCE_TABLE_REVISION 1
+
+///
+/// BGRT Version
+///
+#define EFI_ACPI_6_0_BGRT_VERSION         0x01
+
+///
+/// BGRT Status
+///
+#define EFI_ACPI_6_0_BGRT_STATUS_NOT_DISPLAYED 0x00
+#define EFI_ACPI_6_0_BGRT_STATUS_DISPLAYED     0x01
+
+///
+/// BGRT Image Type
+///
+#define EFI_ACPI_6_0_BGRT_IMAGE_TYPE_BMP  0x00
+
+///
+/// FPDT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_FIRMWARE_PERFORMANCE_DATA_TABLE_REVISION 0x01
+
+///
+/// FPDT Performance Record Types
+///
+#define EFI_ACPI_6_0_FPDT_RECORD_TYPE_FIRMWARE_BASIC_BOOT_POINTER      0x0000
+#define EFI_ACPI_6_0_FPDT_RECORD_TYPE_S3_PERFORMANCE_TABLE_POINTER     0x0001
+
+///
+/// FPDT Performance Record Revision
+///
+#define EFI_ACPI_6_0_FPDT_RECORD_REVISION_FIRMWARE_BASIC_BOOT_POINTER  0x01
+#define EFI_ACPI_6_0_FPDT_RECORD_REVISION_S3_PERFORMANCE_TABLE_POINTER 0x01
+
+///
+/// FPDT Runtime Performance Record Types
+///
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_TYPE_S3_RESUME                0x0000
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_TYPE_S3_SUSPEND               0x0001
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_TYPE_FIRMWARE_BASIC_BOOT      0x0002
+
+///
+/// FPDT Runtime Performance Record Revision
+///
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_REVISION_S3_RESUME            0x01
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_REVISION_S3_SUSPEND           0x01
+#define EFI_ACPI_6_0_FPDT_RUNTIME_RECORD_REVISION_FIRMWARE_BASIC_BOOT  0x02
+
+///
+/// FPDT Performance Record header
+///
+typedef struct {
+  UINT16           Type;
+  UINT8            Length;
+  UINT8            Revision;
+} EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER;
+
+///
+/// FPDT Performance Table header
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_6_0_FPDT_PERFORMANCE_TABLE_HEADER;
+
+///
+/// FPDT Firmware Basic Boot Performance Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the Basic Boot Performance Table.
+  ///
+  UINT64                                          BootPerformanceTablePointer;
+} EFI_ACPI_6_0_FPDT_BOOT_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT S3 Performance Table Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the S3 Performance Table.
+  ///
+  UINT64                                          S3PerformanceTablePointer;
+} EFI_ACPI_6_0_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// Timer value logged at the beginning of firmware image execution.
+  /// This may not always be zero or near zero.
+  ///
+  UINT64                                          ResetEnd;
+  ///
+  /// Timer value logged just prior to loading the OS boot loader into memory.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          OsLoaderLoadImageStart;
+  ///
+  /// Timer value logged just prior to launching the previously loaded OS boot loader image.
+  /// For non-UEFI compatible boots, the timer value logged will be just prior
+  /// to the INT 19h handler invocation.
+  ///
+  UINT64                                          OsLoaderStartImageStart;
+  ///
+  /// Timer value logged at the point when the OS loader calls the
+  /// ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesEntry;
+  ///
+  /// Timer value logged at the point just prior towhen the OS loader gaining
+  /// control back from calls the ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesExit;
+} EFI_ACPI_6_0_FPDT_FIRMWARE_BASIC_BOOT_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Table signature
+///
+#define EFI_ACPI_6_0_FPDT_BOOT_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('F', 'B', 'P', 'T')
+
+//
+// FPDT Firmware Basic Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_6_0_FPDT_FIRMWARE_BASIC_BOOT_TABLE;
+
+///
+/// FPDT "S3PT" S3 Performance Table
+///
+#define EFI_ACPI_6_0_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('S', '3', 'P', 'T')
+
+//
+// FPDT Firmware S3 Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_6_0_FPDT_FIRMWARE_S3_BOOT_TABLE;
+
+///
+/// FPDT Basic S3 Resume Performance Record
+///
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// A count of the number of S3 resume cycles since the last full boot sequence.
+  ///
+  UINT32                                          ResumeCount;
+  ///
+  /// Timer recorded at the end of BIOS S3 resume, just prior to handoff to the
+  /// OS waking vector. Only the most recent resume cycle's time is retained.
+  ///
+  UINT64                                          FullResume;
+  ///
+  /// Average timer value of all resume cycles logged since the last full boot
+  /// sequence, including the most recent resume.  Note that the entire log of
+  /// timer values does not need to be retained in order to calculate this average.
+  ///
+  UINT64                                          AverageResume;
+} EFI_ACPI_6_0_FPDT_S3_RESUME_RECORD;
+
+///
+/// FPDT Basic S3 Suspend Performance Record
+///
+typedef struct {
+  EFI_ACPI_6_0_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// Timer value recorded at the OS write to SLP_TYP upon entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendStart;
+  ///
+  /// Timer value recorded at the final firmware write to SLP_TYP (or other
+  /// mechanism) used to trigger hardware entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendEnd;
+} EFI_ACPI_6_0_FPDT_S3_SUSPEND_RECORD;
+
+///
+/// Firmware Performance Record Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+} EFI_ACPI_6_0_FIRMWARE_PERFORMANCE_RECORD_TABLE;
+
+///
+/// Generic Timer Description Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      CntControlBasePhysicalAddress;
+  UINT32                      Reserved;
+  UINT32                      SecurePL1TimerGSIV;
+  UINT32                      SecurePL1TimerFlags;
+  UINT32                      NonSecurePL1TimerGSIV;
+  UINT32                      NonSecurePL1TimerFlags;
+  UINT32                      VirtualTimerGSIV;
+  UINT32                      VirtualTimerFlags;
+  UINT32                      NonSecurePL2TimerGSIV;
+  UINT32                      NonSecurePL2TimerFlags;
+  UINT64                      CntReadBasePhysicalAddress;
+  UINT32                      PlatformTimerCount;
+  UINT32                      PlatformTimerOffset;
+} EFI_ACPI_6_0_GENERIC_TIMER_DESCRIPTION_TABLE;
+
+///
+/// GTDT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION 0x02
+
+///
+/// Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_0_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_6_0_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY          BIT2
+
+///
+/// Platform Timer Type
+///
+#define EFI_ACPI_6_0_GTDT_GT_BLOCK                       0
+#define EFI_ACPI_6_0_GTDT_SBSA_GENERIC_WATCHDOG          1
+
+///
+/// GT Block Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  CntCtlBase;
+  UINT32  GTBlockTimerCount;
+  UINT32  GTBlockTimerOffset;
+} EFI_ACPI_6_0_GTDT_GT_BLOCK_STRUCTURE;
+
+///
+/// GT Block Timer Structure
+///
+typedef struct {
+  UINT8   GTFrameNumber;
+  UINT8   Reserved[3];
+  UINT64  CntBaseX;
+  UINT64  CntEL0BaseX;
+  UINT32  GTxPhysicalTimerGSIV;
+  UINT32  GTxPhysicalTimerFlags;
+  UINT32  GTxVirtualTimerGSIV;
+  UINT32  GTxVirtualTimerFlags;
+  UINT32  GTxCommonFlags;
+} EFI_ACPI_6_0_GTDT_GT_BLOCK_TIMER_STRUCTURE;
+
+///
+/// GT Block Physical Timers and Virtual Timers Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_0_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+
+///
+/// Common Flags Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER              BIT0
+#define EFI_ACPI_6_0_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY      BIT1
+
+///
+/// SBSA Generic Watchdog Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  RefreshFramePhysicalAddress;
+  UINT64  WatchdogControlFramePhysicalAddress;
+  UINT32  WatchdogTimerGSIV;
+  UINT32  WatchdogTimerFlags;
+} EFI_ACPI_6_0_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE;
+
+///
+/// SBSA Generic Watchdog Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_0_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_0_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_6_0_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER                  BIT2
+
+//
+// NVDIMM Firmware Interface Table definition.
+//
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER    Header;
+  UINT32                         Reserved;
+} EFI_ACPI_6_0_NVDIMM_FIRMWARE_INTERFACE_TABLE;
+
+//
+// NFIT Version (as defined in ACPI 6.0 spec.)
+//
+#define EFI_ACPI_6_0_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION 0x1
+
+//
+// Definition for NFIT Table Structure Types
+//
+#define EFI_ACPI_6_0_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE              0
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_TO_SYSTEM_ADDRESS_RANGE_MAP_STRUCTURE_TYPE  1
+#define EFI_ACPI_6_0_NFIT_INTERLEAVE_STRUCTURE_TYPE                                 2
+#define EFI_ACPI_6_0_NFIT_SMBIOS_MANAGEMENT_INFORMATION_STRUCTURE_TYPE              3
+#define EFI_ACPI_6_0_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE_TYPE                      4
+#define EFI_ACPI_6_0_NFIT_NVDIMM_BLOCK_DATA_WINDOW_REGION_STRUCTURE_TYPE            5
+#define EFI_ACPI_6_0_NFIT_FLUSH_HINT_ADDRESS_STRUCTURE_TYPE                         6
+
+//
+// Definition for NFIT Structure Header
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+} EFI_ACPI_6_0_NFIT_STRUCTURE_HEADER;
+
+//
+// Definition for System Physical Address Range Structure
+//
+#define EFI_ACPI_6_0_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_FLAGS_CONTROL_REGION_FOR_MANAGEMENT      BIT0
+#define EFI_ACPI_6_0_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_FLAGS_PROXIMITY_DOMAIN_VALID             BIT1
+#define EFI_ACPI_6_0_NFIT_GUID_VOLATILE_MEMORY_REGION                             { 0x7305944F, 0xFDDA, 0x44E3, { 0xB1, 0x6C, 0x3F, 0x22, 0xD2, 0x52, 0xE5, 0xD0 }}
+#define EFI_ACPI_6_0_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION          { 0x66F0D379, 0xB4F3, 0x4074, { 0xAC, 0x43, 0x0D, 0x33, 0x18, 0xB7, 0x8C, 0xDB }}
+#define EFI_ACPI_6_0_NFIT_GUID_NVDIMM_CONTROL_REGION                              { 0x92F701F6, 0x13B4, 0x405D, { 0x91, 0x0B, 0x29, 0x93, 0x67, 0xE8, 0x23, 0x4C }}
+#define EFI_ACPI_6_0_NFIT_GUID_NVDIMM_BLOCK_DATA_WINDOW_REGION                    { 0x91AF0530, 0x5D86, 0x470E, { 0xA6, 0xB0, 0x0A, 0x2D, 0xB9, 0x40, 0x82, 0x49 }}
+#define EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGION_VOLATILE   { 0x77AB535A, 0x45FC, 0x624B, { 0x55, 0x60, 0xF7, 0xB2, 0x81, 0xD1, 0xF9, 0x6E }}
+#define EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION_VOLATILE     { 0x3D5ABD30, 0x4175, 0x87CE, { 0x6D, 0x64, 0xD2, 0xAD, 0xE5, 0x23, 0xC4, 0xBB }}
+#define EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGION_PERSISTENT { 0x5CEA02C9, 0x4D07, 0x69D3, { 0x26, 0x9F ,0x44, 0x96, 0xFB, 0xE0, 0x96, 0xF9 }}
+#define EFI_ACPI_6_0_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION_PERSISTENT   { 0x08018188, 0x42CD, 0xBB48, { 0x10, 0x0F, 0x53, 0x87, 0xD5, 0x3D, 0xED, 0x3D }}
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      SPARangeStructureIndex;
+  UINT16                                      Flags;
+  UINT32                                      Reserved_8;
+  UINT32                                      ProximityDomain;
+  GUID                                        AddressRangeTypeGUID;
+  UINT64                                      SystemPhysicalAddressRangeBase;
+  UINT64                                      SystemPhysicalAddressRangeLength;
+  UINT64                                      AddressRangeMemoryMappingAttribute;
+} EFI_ACPI_6_0_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE;
+
+//
+// Definition for Memory Device to System Physical Address Range Mapping Structure
+//
+typedef struct {
+  UINT32                                      DIMMNumber:4;
+  UINT32                                      MemoryChannelNumber:4;
+  UINT32                                      MemoryControllerID:4;
+  UINT32                                      SocketID:4;
+  UINT32                                      NodeControllerID:12;
+  UINT32                                      Reserved_28:4;
+} EFI_ACPI_6_0_NFIT_DEVICE_HANDLE;
+
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_PREVIOUS_SAVE_FAIL                                      BIT0
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_LAST_RESTORE_FAIL                                       BIT1
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_PLATFORM_FLUSH_FAIL                                     BIT2
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_NOT_ARMED_PRIOR_TO_OSPM_HAND_OFF                        BIT3
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_SMART_HEALTH_EVENTS_PRIOR_OSPM_HAND_OFF                 BIT4
+#define EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_STATE_FLAGS_FIRMWARE_ENABLED_TO_NOTIFY_OSPM_ON_SMART_HEALTH_EVENTS  BIT5
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  EFI_ACPI_6_0_NFIT_DEVICE_HANDLE             NFITDeviceHandle;
+  UINT16                                      MemoryDevicePhysicalID;
+  UINT16                                      MemoryDeviceRegionID;
+  UINT16                                      SPARangeStructureIndex ;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT64                                      MemoryDeviceRegionSize;
+  UINT64                                      RegionOffset;
+  UINT64                                      MemoryDevicePhysicalAddressRegionBase;
+  UINT16                                      InterleaveStructureIndex;
+  UINT16                                      InterleaveWays;
+  UINT16                                      MemoryDeviceStateFlags;
+  UINT16                                      Reserved_46;
+} EFI_ACPI_6_0_NFIT_MEMORY_DEVICE_TO_SYSTEM_ADDRESS_RANGE_MAP_STRUCTURE;
+
+//
+// Definition for Interleave Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      InterleaveStructureIndex;
+  UINT16                                      Reserved_6;
+  UINT32                                      NumberOfLines;
+  UINT32                                      LineSize;
+//UINT32                                      LineOffset[NumberOfLines];
+} EFI_ACPI_6_0_NFIT_INTERLEAVE_STRUCTURE;
+
+//
+// Definition for SMBIOS Management Information Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT32                                      Reserved_4;
+//UINT8                                       Data[];
+} EFI_ACPI_6_0_NFIT_SMBIOS_MANAGEMENT_INFORMATION_STRUCTURE;
+
+//
+// Definition for NVDIMM Control Region Structure
+//
+#define EFI_ACPI_6_0_NFIT_NVDIMM_CONTROL_REGION_FLAGS_BLOCK_DATA_WINDOWS_BUFFERED    BIT0
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT16                                      VendorID;
+  UINT16                                      DeviceID;
+  UINT16                                      RevisionID;
+  UINT16                                      SubsystemVendorID;
+  UINT16                                      SubsystemDeviceID;
+  UINT16                                      SubsystemRevisionID;
+  UINT8                                       Reserved_18[6];
+  UINT32                                      SerialNumber;
+  UINT16                                      RegionFormatInterfaceCode;
+  UINT16                                      NumberOfBlockControlWindows;
+  UINT64                                      SizeOfBlockControlWindow;
+  UINT64                                      CommandRegisterOffsetInBlockControlWindow;
+  UINT64                                      SizeOfCommandRegisterInBlockControlWindows;
+  UINT64                                      StatusRegisterOffsetInBlockControlWindow;
+  UINT64                                      SizeOfStatusRegisterInBlockControlWindows;
+  UINT16                                      NVDIMMControlRegionFlag;
+  UINT8                                       Reserved_74[6];
+} EFI_ACPI_6_0_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE;
+
+//
+// Definition for NVDIMM Block Data Window Region Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT16                                      NumberOfBlockDataWindows;
+  UINT64                                      BlockDataWindowStartOffset;
+  UINT64                                      SizeOfBlockDataWindow;
+  UINT64                                      BlockAccessibleMemoryCapacity;
+  UINT64                                      BeginningAddressOfFirstBlockInBlockAccessibleMemory;
+} EFI_ACPI_6_0_NFIT_NVDIMM_BLOCK_DATA_WINDOW_REGION_STRUCTURE;
+
+//
+// Definition for Flush Hint Address Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  EFI_ACPI_6_0_NFIT_DEVICE_HANDLE             NFITDeviceHandle;
+  UINT16                                      NumberOfFlushHintAddresses;
+  UINT8                                       Reserved_10[6];
+//UINT64                                      FlushHintAddress[NumberOfFlushHintAddresses];
+} EFI_ACPI_6_0_NFIT_FLUSH_HINT_ADDRESS_STRUCTURE;
+
+///
+/// Boot Error Record Table (BERT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      BootErrorRegionLength;
+  UINT64                      BootErrorRegion;
+} EFI_ACPI_6_0_BOOT_ERROR_RECORD_TABLE_HEADER;
+
+///
+/// BERT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_BOOT_ERROR_RECORD_TABLE_REVISION 0x01
+
+///
+/// Boot Error Region Block Status Definition
+///
+typedef struct {
+  UINT32       UncorrectableErrorValid:1;
+  UINT32       CorrectableErrorValid:1;
+  UINT32       MultipleUncorrectableErrors:1;
+  UINT32       MultipleCorrectableErrors:1;
+  UINT32       ErrorDataEntryCount:10;
+  UINT32       Reserved:18;
+} EFI_ACPI_6_0_ERROR_BLOCK_STATUS;
+
+///
+/// Boot Error Region Definition
+///
+typedef struct {
+  EFI_ACPI_6_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_6_0_BOOT_ERROR_REGION_STRUCTURE;
+
+//
+// Boot Error Severity types
+//
+#define EFI_ACPI_6_0_ERROR_SEVERITY_CORRECTABLE  0x00
+#define EFI_ACPI_6_0_ERROR_SEVERITY_FATAL        0x01
+#define EFI_ACPI_6_0_ERROR_SEVERITY_CORRECTED    0x02
+#define EFI_ACPI_6_0_ERROR_SEVERITY_NONE         0x03
+
+///
+/// Generic Error Data Entry Definition
+///
+typedef struct {
+  UINT8    SectionType[16];
+  UINT32   ErrorSeverity;
+  UINT16   Revision;
+  UINT8    ValidationBits;
+  UINT8    Flags;
+  UINT32   ErrorDataLength;
+  UINT8    FruId[16];
+  UINT8    FruText[20];
+} EFI_ACPI_6_0_GENERIC_ERROR_DATA_ENTRY_STRUCTURE;
+
+///
+/// Generic Error Data Entry Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_GENERIC_ERROR_DATA_ENTRY_REVISION  0x0201
+
+///
+/// HEST - Hardware Error Source Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ErrorSourceCount;
+} EFI_ACPI_6_0_HARDWARE_ERROR_SOURCE_TABLE_HEADER;
+
+///
+/// HEST Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_HARDWARE_ERROR_SOURCE_TABLE_REVISION 0x01
+
+//
+// Error Source structure types.
+//
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION  0x00
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK  0x01
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_NMI_ERROR                0x02
+#define EFI_ACPI_6_0_PCI_EXPRESS_ROOT_PORT_AER                  0x06
+#define EFI_ACPI_6_0_PCI_EXPRESS_DEVICE_AER                     0x07
+#define EFI_ACPI_6_0_PCI_EXPRESS_BRIDGE_AER                     0x08
+#define EFI_ACPI_6_0_GENERIC_HARDWARE_ERROR                     0x09
+
+//
+// Error Source structure flags.
+//
+#define EFI_ACPI_6_0_ERROR_SOURCE_FLAG_FIRMWARE_FIRST       (1 << 0)
+#define EFI_ACPI_6_0_ERROR_SOURCE_FLAG_GLOBAL               (1 << 1)
+
+///
+/// IA-32 Architecture Machine Check Exception Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT64  GlobalCapabilityInitData;
+  UINT64  GlobalControlInitData;
+  UINT8   NumberOfHardwareBanks;
+  UINT8   Reserved1[7];
+} EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure Definition
+///
+typedef struct {
+  UINT8   BankNumber;
+  UINT8   ClearStatusOnInitialization;
+  UINT8   StatusDataFormat;
+  UINT8   Reserved0;
+  UINT32  ControlRegisterMsrAddress;
+  UINT64  ControlInitData;
+  UINT32  StatusRegisterMsrAddress;
+  UINT32  AddressRegisterMsrAddress;
+  UINT32  MiscRegisterMsrAddress;
+} EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_BANK_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure MCA data format
+///
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_IA32      0x00
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_INTEL64   0x01
+#define EFI_ACPI_6_0_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_AMD64     0x02
+
+//
+// Hardware Error Notification types. All other values are reserved
+//
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_POLLED                0x00
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_EXTERNAL_INTERRUPT    0x01
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_LOCAL_INTERRUPT       0x02
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_SCI                   0x03
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_NMI                   0x04
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_CMCI                  0x05
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_MCE                   0x06
+#define EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_GPIO_SIGNAL           0x07
+
+///
+/// Hardware Error Notification Configuration Write Enable Structure Definition
+///
+typedef struct {
+  UINT16    Type:1;
+  UINT16    PollInterval:1;
+  UINT16    SwitchToPollingThresholdValue:1;
+  UINT16    SwitchToPollingThresholdWindow:1;
+  UINT16    ErrorThresholdValue:1;
+  UINT16    ErrorThresholdWindow:1;
+  UINT16    Reserved:10;
+} EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE;
+
+///
+/// Hardware Error Notification Structure Definition
+///
+typedef struct {
+  UINT8                                                                          Type;
+  UINT8                                                                          Length;
+  EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE  ConfigurationWriteEnable;
+  UINT32                                                                         PollInterval;
+  UINT32                                                                         Vector;
+  UINT32                                                                         SwitchToPollingThresholdValue;
+  UINT32                                                                         SwitchToPollingThresholdWindow;
+  UINT32                                                                         ErrorThresholdValue;
+  UINT32                                                                         ErrorThresholdWindow;
+} EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE;
+
+///
+/// IA-32 Architecture Corrected Machine Check Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT8                                                  Reserved0[2];
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT8                                                  NumberOfHardwareBanks;
+  UINT8                                                  Reserved1[3];
+} EFI_ACPI_6_0_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK_STRUCTURE;
+
+///
+/// IA-32 Architecture NMI Error Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  MaxRawDataLength;
+} EFI_ACPI_6_0_IA32_ARCHITECTURE_NMI_ERROR_STRUCTURE;
+
+///
+/// PCI Express Root Port AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  RootErrorCommand;
+} EFI_ACPI_6_0_PCI_EXPRESS_ROOT_PORT_AER_STRUCTURE;
+
+///
+/// PCI Express Device AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_6_0_PCI_EXPRESS_DEVICE_AER_STRUCTURE;
+
+///
+/// PCI Express Bridge AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  SecondaryUncorrectableErrorMask;
+  UINT32  SecondaryUncorrectableErrorSeverity;
+  UINT32  SecondaryAdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_6_0_PCI_EXPRESS_BRIDGE_AER_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_6_0_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+} EFI_ACPI_6_0_GENERIC_HARDWARE_ERROR_SOURCE_STRUCTURE;
+
+///
+/// Generic Error Status Definition
+///
+typedef struct {
+  EFI_ACPI_6_0_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_6_0_GENERIC_ERROR_STATUS_STRUCTURE;
+
+///
+/// ERST - Error Record Serialization Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      SerializationHeaderSize;
+  UINT8                       Reserved0[4];
+  UINT32                      InstructionEntryCount;
+} EFI_ACPI_6_0_ERROR_RECORD_SERIALIZATION_TABLE_HEADER;
+
+///
+/// ERST Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_ERROR_RECORD_SERIALIZATION_TABLE_REVISION 0x01
+
+///
+/// ERST Serialization Actions
+///
+#define EFI_ACPI_6_0_ERST_BEGIN_WRITE_OPERATION                    0x00
+#define EFI_ACPI_6_0_ERST_BEGIN_READ_OPERATION                     0x01
+#define EFI_ACPI_6_0_ERST_BEGIN_CLEAR_OPERATION                    0x02
+#define EFI_ACPI_6_0_ERST_END_OPERATION                            0x03
+#define EFI_ACPI_6_0_ERST_SET_RECORD_OFFSET                        0x04
+#define EFI_ACPI_6_0_ERST_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_6_0_ERST_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_6_0_ERST_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_6_0_ERST_GET_RECORD_IDENTIFIER                    0x08
+#define EFI_ACPI_6_0_ERST_SET_RECORD_IDENTIFIER                    0x09
+#define EFI_ACPI_6_0_ERST_GET_RECORD_COUNT                         0x0A
+#define EFI_ACPI_6_0_ERST_BEGIN_DUMMY_WRITE_OPERATION              0x0B
+#define EFI_ACPI_6_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE              0x0D
+#define EFI_ACPI_6_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_LENGTH       0x0E
+#define EFI_ACPI_6_0_ERST_GET_ERROR_LOG_ADDRESS_RANGE_ATTRIBUTES   0x0F
+
+///
+/// ERST Action Command Status
+///
+#define EFI_ACPI_6_0_ERST_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_6_0_ERST_STATUS_NOT_ENOUGH_SPACE                  0x01
+#define EFI_ACPI_6_0_ERST_STATUS_HARDWARE_NOT_AVAILABLE            0x02
+#define EFI_ACPI_6_0_ERST_STATUS_FAILED                            0x03
+#define EFI_ACPI_6_0_ERST_STATUS_RECORD_STORE_EMPTY                0x04
+#define EFI_ACPI_6_0_ERST_STATUS_RECORD_NOT_FOUND                  0x05
+
+///
+/// ERST Serialization Instructions
+///
+#define EFI_ACPI_6_0_ERST_READ_REGISTER                            0x00
+#define EFI_ACPI_6_0_ERST_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_6_0_ERST_WRITE_REGISTER                           0x02
+#define EFI_ACPI_6_0_ERST_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_6_0_ERST_NOOP                                     0x04
+#define EFI_ACPI_6_0_ERST_LOAD_VAR1                                0x05
+#define EFI_ACPI_6_0_ERST_LOAD_VAR2                                0x06
+#define EFI_ACPI_6_0_ERST_STORE_VAR1                               0x07
+#define EFI_ACPI_6_0_ERST_ADD                                      0x08
+#define EFI_ACPI_6_0_ERST_SUBTRACT                                 0x09
+#define EFI_ACPI_6_0_ERST_ADD_VALUE                                0x0A
+#define EFI_ACPI_6_0_ERST_SUBTRACT_VALUE                           0x0B
+#define EFI_ACPI_6_0_ERST_STALL                                    0x0C
+#define EFI_ACPI_6_0_ERST_STALL_WHILE_TRUE                         0x0D
+#define EFI_ACPI_6_0_ERST_SKIP_NEXT_INSTRUCTION_IF_TRUE            0x0E
+#define EFI_ACPI_6_0_ERST_GOTO                                     0x0F
+#define EFI_ACPI_6_0_ERST_SET_SRC_ADDRESS_BASE                     0x10
+#define EFI_ACPI_6_0_ERST_SET_DST_ADDRESS_BASE                     0x11
+#define EFI_ACPI_6_0_ERST_MOVE_DATA                                0x12
+
+///
+/// ERST Instruction Flags
+///
+#define EFI_ACPI_6_0_ERST_PRESERVE_REGISTER                        0x01
+
+///
+/// ERST Serialization Instruction Entry
+///
+typedef struct {
+  UINT8                                    SerializationAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_6_0_ERST_SERIALIZATION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ - Error Injection Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      InjectionHeaderSize;
+  UINT8                       InjectionFlags;
+  UINT8                       Reserved0[3];
+  UINT32                      InjectionEntryCount;
+} EFI_ACPI_6_0_ERROR_INJECTION_TABLE_HEADER;
+
+///
+/// EINJ Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_ERROR_INJECTION_TABLE_REVISION 0x01
+
+///
+/// EINJ Error Injection Actions
+///
+#define EFI_ACPI_6_0_EINJ_BEGIN_INJECTION_OPERATION                0x00
+#define EFI_ACPI_6_0_EINJ_GET_TRIGGER_ERROR_ACTION_TABLE           0x01
+#define EFI_ACPI_6_0_EINJ_SET_ERROR_TYPE                           0x02
+#define EFI_ACPI_6_0_EINJ_GET_ERROR_TYPE                           0x03
+#define EFI_ACPI_6_0_EINJ_END_OPERATION                            0x04
+#define EFI_ACPI_6_0_EINJ_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_6_0_EINJ_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_6_0_EINJ_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_6_0_EINJ_TRIGGER_ERROR                            0xFF
+
+///
+/// EINJ Action Command Status
+///
+#define EFI_ACPI_6_0_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_6_0_EINJ_STATUS_UNKNOWN_FAILURE                   0x01
+#define EFI_ACPI_6_0_EINJ_STATUS_INVALID_ACCESS                    0x02
+
+///
+/// EINJ Error Type Definition
+///
+#define EFI_ACPI_6_0_EINJ_ERROR_PROCESSOR_CORRECTABLE                 (1 << 0)
+#define EFI_ACPI_6_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_NONFATAL      (1 << 1)
+#define EFI_ACPI_6_0_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_FATAL         (1 << 2)
+#define EFI_ACPI_6_0_EINJ_ERROR_MEMORY_CORRECTABLE                    (1 << 3)
+#define EFI_ACPI_6_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_NONFATAL         (1 << 4)
+#define EFI_ACPI_6_0_EINJ_ERROR_MEMORY_UNCORRECTABLE_FATAL            (1 << 5)
+#define EFI_ACPI_6_0_EINJ_ERROR_PCI_EXPRESS_CORRECTABLE               (1 << 6)
+#define EFI_ACPI_6_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_NONFATAL    (1 << 7)
+#define EFI_ACPI_6_0_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_FATAL       (1 << 8)
+#define EFI_ACPI_6_0_EINJ_ERROR_PLATFORM_CORRECTABLE                  (1 << 9)
+#define EFI_ACPI_6_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_NONFATAL       (1 << 10)
+#define EFI_ACPI_6_0_EINJ_ERROR_PLATFORM_UNCORRECTABLE_FATAL          (1 << 11)
+
+///
+/// EINJ Injection Instructions
+///
+#define EFI_ACPI_6_0_EINJ_READ_REGISTER                            0x00
+#define EFI_ACPI_6_0_EINJ_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_6_0_EINJ_WRITE_REGISTER                           0x02
+#define EFI_ACPI_6_0_EINJ_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_6_0_EINJ_NOOP                                     0x04
+
+///
+/// EINJ Instruction Flags
+///
+#define EFI_ACPI_6_0_EINJ_PRESERVE_REGISTER                        0x01
+
+///
+/// EINJ Injection Instruction Entry
+///
+typedef struct {
+  UINT8                                    InjectionAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_6_0_EINJ_INJECTION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ Trigger Action Table
+///
+typedef struct {
+  UINT32  HeaderSize;
+  UINT32  Revision;
+  UINT32  TableSize;
+  UINT32  EntryCount;
+} EFI_ACPI_6_0_EINJ_TRIGGER_ACTION_TABLE;
+
+///
+/// Platform Communications Channel Table (PCCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Flags;
+  UINT64                      Reserved;
+} EFI_ACPI_6_0_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER;
+
+///
+/// PCCT Version (as defined in ACPI 6.0 spec.)
+///
+#define EFI_ACPI_6_0_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION 0x01
+
+///
+/// PCCT Global Flags
+///
+#define EFI_ACPI_6_0_PCCT_FLAGS_SCI_DOORBELL                      BIT0
+
+//
+// PCCT Subspace type
+//
+#define EFI_ACPI_6_0_PCCT_SUBSPACE_TYPE_GENERIC  0x00
+
+///
+/// PCC Subspace Structure Header
+///
+typedef struct {
+  UINT8        Type;
+  UINT8        Length;
+} EFI_ACPI_6_0_PCCT_SUBSPACE_HEADER;
+
+///
+/// Generic Communications Subspace Structure
+///
+typedef struct {
+  UINT8                                    Type;
+  UINT8                                    Length;
+  UINT8                                    Reserved[6];
+  UINT64                                   BaseAddress;
+  UINT64                                   AddressLength;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE   DoorbellRegister;
+  UINT64                                   DoorbellPreserve;
+  UINT64                                   DoorbellWrite;
+  UINT32                                   NominalLatency;
+  UINT32                                   MaximumPeriodicAccessRate;
+  UINT16                                   MinimumRequestTurnaroundTime;
+} EFI_ACPI_6_0_PCCT_SUBSPACE_GENERIC;
+
+///
+/// Generic Communications Channel Shared Memory Region
+///
+
+typedef struct {
+  UINT8                                    Command;
+  UINT8                                    Reserved:7;
+  UINT8                                    GenerateSci:1;
+} EFI_ACPI_6_0_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND;
+
+typedef struct {
+  UINT8                                    CommandComplete:1;
+  UINT8                                    SciDoorbell:1;
+  UINT8                                    Error:1;
+  UINT8                                    PlatformNotification:1;  
+  UINT8                                    Reserved:4;
+  UINT8                                    Reserved1;
+} EFI_ACPI_6_0_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS;
+
+typedef struct {
+  UINT32                                                    Signature;
+  EFI_ACPI_6_0_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND    Command;
+  EFI_ACPI_6_0_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS     Status;
+} EFI_ACPI_6_0_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_6_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_6_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BERT" Boot Error Record Table
+///
+#define EFI_ACPI_6_0_BOOT_ERROR_RECORD_TABLE_SIGNATURE  SIGNATURE_32('B', 'E', 'R', 'T')
+
+///
+/// "BGRT" Boot Graphics Resource Table
+///
+#define EFI_ACPI_6_0_BOOT_GRAPHICS_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('B', 'G', 'R', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_6_0_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_6_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_6_0_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "EINJ" Error Injection Table
+///
+#define EFI_ACPI_6_0_ERROR_INJECTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'I', 'N', 'J')
+
+///
+/// "ERST" Error Record Serialization Table
+///
+#define EFI_ACPI_6_0_ERROR_RECORD_SERIALIZATION_TABLE_SIGNATURE  SIGNATURE_32('E', 'R', 'S', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_6_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_6_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FPDT" Firmware Performance Data Table
+///
+#define EFI_ACPI_6_0_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE  SIGNATURE_32('F', 'P', 'D', 'T')
+
+///
+/// "GTDT" Generic Timer Description Table
+///
+#define EFI_ACPI_6_0_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('G', 'T', 'D', 'T')
+
+///
+/// "HEST" Hardware Error Source Table
+///
+#define EFI_ACPI_6_0_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE  SIGNATURE_32('H', 'E', 'S', 'T')
+
+///
+/// "MPST" Memory Power State Table
+///
+#define EFI_ACPI_6_0_MEMORY_POWER_STATE_TABLE_SIGNATURE  SIGNATURE_32('M', 'P', 'S', 'T')
+
+///
+/// "MSCT" Maximum System Characteristics Table
+///
+#define EFI_ACPI_6_0_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'C', 'T')
+
+///
+/// "NFIT" NVDIMM Firmware Interface Table
+///
+#define EFI_ACPI_6_0_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE  SIGNATURE_32('N', 'F', 'I', 'T')
+
+///
+/// "PMTT" Platform Memory Topology Table
+///
+#define EFI_ACPI_6_0_PLATFORM_MEMORY_TOPOLOGY_TABLE_SIGNATURE  SIGNATURE_32('P', 'M', 'T', 'T')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_6_0_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RASF" ACPI RAS Feature Table
+///
+#define EFI_ACPI_6_0_ACPI_RAS_FEATURE_TABLE_SIGNATURE  SIGNATURE_32('R', 'A', 'S', 'F')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_6_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_6_0_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_6_0_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_6_0_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_6_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_6_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_6_0_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "CSRT" MS Core System Resource Table
+///
+#define EFI_ACPI_6_0_CORE_SYSTEM_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('C', 'S', 'R', 'T')
+
+///
+/// "DBG2" MS Debug Port 2 Spec
+///
+#define EFI_ACPI_6_0_DEBUG_PORT_2_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', '2')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_6_0_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DMAR" DMA Remapping Table
+///
+#define EFI_ACPI_6_0_DMA_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('D', 'M', 'A', 'R')
+
+///
+/// "DRTM" Dynamic Root of Trust for Measurement Table
+///
+#define EFI_ACPI_6_0_DYNAMIC_ROOT_OF_TRUST_FOR_MEASUREMENT_TABLE_SIGNATURE  SIGNATURE_32('D', 'R', 'T', 'M')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_6_0_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_6_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_6_0_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+///
+/// "IORT" I/O Remapping Table
+///
+#define EFI_ACPI_6_0_IO_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('I', 'O', 'R', 'T')
+
+///
+/// "IVRS" I/O Virtualization Reporting Structure
+///
+#define EFI_ACPI_6_0_IO_VIRTUALIZATION_REPORTING_STRUCTURE_SIGNATURE  SIGNATURE_32('I', 'V', 'R', 'S')
+
+///
+/// "LPIT" Low Power Idle Table
+///
+#define EFI_ACPI_6_0_LOW_POWER_IDLE_TABLE_STRUCTURE_SIGNATURE  SIGNATURE_32('L', 'P', 'I', 'T')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_6_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "MCHI" Management Controller Host Interface Table
+///
+#define EFI_ACPI_6_0_MANAGEMENT_CONTROLLER_HOST_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'H', 'I')
+
+///
+/// "MSDM" MS Data Management Table
+///
+#define EFI_ACPI_6_0_DATA_MANAGEMENT_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'D', 'M')
+
+///
+/// "SLIC" MS Software Licensing Table Specification
+///
+#define EFI_ACPI_6_0_SOFTWARE_LICENSING_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'C')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_6_0_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_6_0_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "STAO" _STA Override Table
+///
+#define EFI_ACPI_6_0_STA_OVERRIDE_TABLE_SIGNATURE  SIGNATURE_32('S', 'T', 'A', 'O')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_6_0_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "TPM2" Trusted Computing Platform 1 Table
+///
+#define EFI_ACPI_6_0_TRUSTED_COMPUTING_PLATFORM_2_TABLE_SIGNATURE  SIGNATURE_32('T', 'P', 'M', '2')
+
+///
+/// "UEFI" UEFI ACPI Data Table
+///
+#define EFI_ACPI_6_0_UEFI_ACPI_DATA_TABLE_SIGNATURE  SIGNATURE_32('U', 'E', 'F', 'I')
+
+///
+/// "WAET" Windows ACPI Emulated Devices Table
+///
+#define EFI_ACPI_6_0_WINDOWS_ACPI_EMULATED_DEVICES_TABLE_SIGNATURE  SIGNATURE_32('W', 'A', 'E', 'T')
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_6_0_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_6_0_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+///
+/// "WPBT" MS Platform Binary Table
+///
+#define EFI_ACPI_6_0_PLATFORM_BINARY_TABLE_SIGNATURE  SIGNATURE_32('W', 'P', 'B', 'T')
+
+///
+/// "XENV" Xen Project Table
+///
+#define EFI_ACPI_6_0_XEN_PROJECT_TABLE_SIGNATURE  SIGNATURE_32('X', 'E', 'N', 'V')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Acpi61.h b/MdePkg/Include/IndustryStandard/Acpi61.h
new file mode 100644
index 000000000000..954e61d2a19f
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Acpi61.h
@@ -0,0 +1,2378 @@
+/** @file   
+  ACPI 6.1 definitions from the ACPI Specification Revision 6.1 January, 2016.
+
+  Copyright (c) 2016 - 2017, Intel Corporation. All rights reserved.<BR>
+ (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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 _ACPI_6_1_H_
+#define _ACPI_6_1_H_
+
+#include <IndustryStandard/Acpi60.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// ACPI 6.1 Generic Address Space definition
+///
+typedef struct {
+  UINT8   AddressSpaceId;
+  UINT8   RegisterBitWidth;
+  UINT8   RegisterBitOffset;
+  UINT8   AccessSize;
+  UINT64  Address;
+} EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE;
+
+//
+// Generic Address Space Address IDs
+//
+#define EFI_ACPI_6_1_SYSTEM_MEMORY              0
+#define EFI_ACPI_6_1_SYSTEM_IO                  1
+#define EFI_ACPI_6_1_PCI_CONFIGURATION_SPACE    2
+#define EFI_ACPI_6_1_EMBEDDED_CONTROLLER        3
+#define EFI_ACPI_6_1_SMBUS                      4
+#define EFI_ACPI_6_1_PLATFORM_COMMUNICATION_CHANNEL  0x0A
+#define EFI_ACPI_6_1_FUNCTIONAL_FIXED_HARDWARE       0x7F
+
+//
+// Generic Address Space Access Sizes
+//
+#define EFI_ACPI_6_1_UNDEFINED  0
+#define EFI_ACPI_6_1_BYTE       1
+#define EFI_ACPI_6_1_WORD       2
+#define EFI_ACPI_6_1_DWORD      3
+#define EFI_ACPI_6_1_QWORD      4
+
+//
+// ACPI 6.1 table structures
+//
+
+///
+/// Root System Description Pointer Structure
+///
+typedef struct {
+  UINT64  Signature;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT8   Revision;
+  UINT32  RsdtAddress;
+  UINT32  Length;
+  UINT64  XsdtAddress;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved[3];
+} EFI_ACPI_6_1_ROOT_SYSTEM_DESCRIPTION_POINTER;
+
+///
+/// RSD_PTR Revision (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION 0x02  ///< ACPISpec (Revision 6.1) says current value is 2
+
+///
+/// Common table header, this prefaces all ACPI tables, including FACS, but
+/// excluding the RSD PTR structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_6_1_COMMON_HEADER;
+
+//
+// Root System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT32 table pointers.
+//
+
+///
+/// RSDT Revision (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_ROOT_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+//
+// Extended System Description Table
+// No definition needed as it is a common description table header, the same with 
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a variable number of UINT64 table pointers.
+//
+
+///
+/// XSDT Revision (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_EXTENDED_SYSTEM_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Fixed ACPI Description Table Structure (FADT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  FirmwareCtrl;
+  UINT32                                  Dsdt;
+  UINT8                                   Reserved0;
+  UINT8                                   PreferredPmProfile;
+  UINT16                                  SciInt;
+  UINT32                                  SmiCmd;
+  UINT8                                   AcpiEnable;
+  UINT8                                   AcpiDisable;
+  UINT8                                   S4BiosReq;
+  UINT8                                   PstateCnt;
+  UINT32                                  Pm1aEvtBlk;
+  UINT32                                  Pm1bEvtBlk;
+  UINT32                                  Pm1aCntBlk;
+  UINT32                                  Pm1bCntBlk;
+  UINT32                                  Pm2CntBlk;
+  UINT32                                  PmTmrBlk;
+  UINT32                                  Gpe0Blk;
+  UINT32                                  Gpe1Blk;
+  UINT8                                   Pm1EvtLen;
+  UINT8                                   Pm1CntLen;
+  UINT8                                   Pm2CntLen;
+  UINT8                                   PmTmrLen;
+  UINT8                                   Gpe0BlkLen;
+  UINT8                                   Gpe1BlkLen;
+  UINT8                                   Gpe1Base;
+  UINT8                                   CstCnt;
+  UINT16                                  PLvl2Lat;
+  UINT16                                  PLvl3Lat;
+  UINT16                                  FlushSize;
+  UINT16                                  FlushStride;
+  UINT8                                   DutyOffset;
+  UINT8                                   DutyWidth;
+  UINT8                                   DayAlrm;
+  UINT8                                   MonAlrm;
+  UINT8                                   Century;
+  UINT16                                  IaPcBootArch;
+  UINT8                                   Reserved1;
+  UINT32                                  Flags;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  ResetReg;
+  UINT8                                   ResetValue;
+  UINT16                                  ArmBootArch;
+  UINT8                                   MinorVersion;
+  UINT64                                  XFirmwareCtrl;
+  UINT64                                  XDsdt;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPm1aEvtBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPm1bEvtBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPm1aCntBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPm1bCntBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPm2CntBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XPmTmrBlk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XGpe0Blk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  XGpe1Blk;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  SleepControlReg;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  SleepStatusReg;
+  UINT64                                  HypervisorVendorIdentity;
+} EFI_ACPI_6_1_FIXED_ACPI_DESCRIPTION_TABLE;
+
+///
+/// FADT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_FIXED_ACPI_DESCRIPTION_TABLE_REVISION  0x06
+#define EFI_ACPI_6_1_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION  0x01
+
+//
+// Fixed ACPI Description Table Preferred Power Management Profile
+//
+#define EFI_ACPI_6_1_PM_PROFILE_UNSPECIFIED         0
+#define EFI_ACPI_6_1_PM_PROFILE_DESKTOP             1
+#define EFI_ACPI_6_1_PM_PROFILE_MOBILE              2
+#define EFI_ACPI_6_1_PM_PROFILE_WORKSTATION         3
+#define EFI_ACPI_6_1_PM_PROFILE_ENTERPRISE_SERVER   4
+#define EFI_ACPI_6_1_PM_PROFILE_SOHO_SERVER         5
+#define EFI_ACPI_6_1_PM_PROFILE_APPLIANCE_PC        6
+#define EFI_ACPI_6_1_PM_PROFILE_PERFORMANCE_SERVER  7
+#define EFI_ACPI_6_1_PM_PROFILE_TABLET              8
+
+//
+// Fixed ACPI Description Table Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_1_LEGACY_DEVICES              BIT0
+#define EFI_ACPI_6_1_8042                        BIT1
+#define EFI_ACPI_6_1_VGA_NOT_PRESENT             BIT2
+#define EFI_ACPI_6_1_MSI_NOT_SUPPORTED           BIT3
+#define EFI_ACPI_6_1_PCIE_ASPM_CONTROLS          BIT4
+#define EFI_ACPI_6_1_CMOS_RTC_NOT_PRESENT        BIT5
+
+//
+// Fixed ACPI Description Table Arm Boot Architecture Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_1_ARM_PSCI_COMPLIANT              BIT0
+#define EFI_ACPI_6_1_ARM_PSCI_USE_HVC                BIT1
+
+//
+// Fixed ACPI Description Table Fixed Feature Flags
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_1_WBINVD                                 BIT0
+#define EFI_ACPI_6_1_WBINVD_FLUSH                           BIT1
+#define EFI_ACPI_6_1_PROC_C1                                BIT2
+#define EFI_ACPI_6_1_P_LVL2_UP                              BIT3
+#define EFI_ACPI_6_1_PWR_BUTTON                             BIT4
+#define EFI_ACPI_6_1_SLP_BUTTON                             BIT5
+#define EFI_ACPI_6_1_FIX_RTC                                BIT6
+#define EFI_ACPI_6_1_RTC_S4                                 BIT7
+#define EFI_ACPI_6_1_TMR_VAL_EXT                            BIT8
+#define EFI_ACPI_6_1_DCK_CAP                                BIT9
+#define EFI_ACPI_6_1_RESET_REG_SUP                          BIT10
+#define EFI_ACPI_6_1_SEALED_CASE                            BIT11
+#define EFI_ACPI_6_1_HEADLESS                               BIT12
+#define EFI_ACPI_6_1_CPU_SW_SLP                             BIT13
+#define EFI_ACPI_6_1_PCI_EXP_WAK                            BIT14
+#define EFI_ACPI_6_1_USE_PLATFORM_CLOCK                     BIT15
+#define EFI_ACPI_6_1_S4_RTC_STS_VALID                       BIT16
+#define EFI_ACPI_6_1_REMOTE_POWER_ON_CAPABLE                BIT17
+#define EFI_ACPI_6_1_FORCE_APIC_CLUSTER_MODEL               BIT18
+#define EFI_ACPI_6_1_FORCE_APIC_PHYSICAL_DESTINATION_MODE   BIT19
+#define EFI_ACPI_6_1_HW_REDUCED_ACPI                        BIT20
+#define EFI_ACPI_6_1_LOW_POWER_S0_IDLE_CAPABLE              BIT21
+
+///
+/// Firmware ACPI Control Structure
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT32  HardwareSignature;
+  UINT32  FirmwareWakingVector;
+  UINT32  GlobalLock;
+  UINT32  Flags;
+  UINT64  XFirmwareWakingVector;
+  UINT8   Version;
+  UINT8   Reserved0[3];
+  UINT32  OspmFlags;
+  UINT8   Reserved1[24];
+} EFI_ACPI_6_1_FIRMWARE_ACPI_CONTROL_STRUCTURE;
+
+///
+/// FACS Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION  0x02
+
+///
+/// Firmware Control Structure Feature Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_1_S4BIOS_F                     BIT0
+#define EFI_ACPI_6_1_64BIT_WAKE_SUPPORTED_F       BIT1
+
+///
+/// OSPM Enabled Firmware Control Structure Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_1_OSPM_64BIT_WAKE_F            BIT0
+
+//
+// Differentiated System Description Table,
+// Secondary System Description Table
+// and Persistent System Description Table,
+// no definition needed as they are common description table header, the same with
+// EFI_ACPI_DESCRIPTION_HEADER, followed by a definition block.
+//
+#define EFI_ACPI_6_1_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION   0x02
+#define EFI_ACPI_6_1_SECONDARY_SYSTEM_DESCRIPTION_TABLE_REVISION        0x02
+
+///
+/// Multiple APIC Description Table header definition.  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      LocalApicAddress;
+  UINT32                      Flags;
+} EFI_ACPI_6_1_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER;
+
+///
+/// MADT Revision (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION 0x04
+
+///
+/// Multiple APIC Flags
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_1_PCAT_COMPAT         BIT0
+
+//
+// Multiple APIC Description Table APIC structure types
+// All other values between 0x0D and 0x7F are reserved and
+// will be ignored by OSPM. 0x80 ~ 0xFF are reserved for OEM.
+//
+#define EFI_ACPI_6_1_PROCESSOR_LOCAL_APIC           0x00
+#define EFI_ACPI_6_1_IO_APIC                        0x01
+#define EFI_ACPI_6_1_INTERRUPT_SOURCE_OVERRIDE      0x02
+#define EFI_ACPI_6_1_NON_MASKABLE_INTERRUPT_SOURCE  0x03
+#define EFI_ACPI_6_1_LOCAL_APIC_NMI                 0x04
+#define EFI_ACPI_6_1_LOCAL_APIC_ADDRESS_OVERRIDE    0x05
+#define EFI_ACPI_6_1_IO_SAPIC                       0x06
+#define EFI_ACPI_6_1_LOCAL_SAPIC                    0x07
+#define EFI_ACPI_6_1_PLATFORM_INTERRUPT_SOURCES     0x08
+#define EFI_ACPI_6_1_PROCESSOR_LOCAL_X2APIC         0x09
+#define EFI_ACPI_6_1_LOCAL_X2APIC_NMI               0x0A
+#define EFI_ACPI_6_1_GIC                            0x0B
+#define EFI_ACPI_6_1_GICD                           0x0C
+#define EFI_ACPI_6_1_GIC_MSI_FRAME                  0x0D
+#define EFI_ACPI_6_1_GICR                           0x0E
+#define EFI_ACPI_6_1_GIC_ITS                        0x0F
+
+//
+// APIC Structure Definitions
+//
+
+///
+/// Processor Local APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorUid;
+  UINT8   ApicId;
+  UINT32  Flags;
+} EFI_ACPI_6_1_PROCESSOR_LOCAL_APIC_STRUCTURE;
+
+///
+/// Local APIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_LOCAL_APIC_ENABLED        BIT0
+
+///
+/// IO APIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  IoApicAddress;
+  UINT32  GlobalSystemInterruptBase;
+} EFI_ACPI_6_1_IO_APIC_STRUCTURE;
+
+///
+/// Interrupt Source Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Bus;
+  UINT8   Source;
+  UINT32  GlobalSystemInterrupt;
+  UINT16  Flags;
+} EFI_ACPI_6_1_INTERRUPT_SOURCE_OVERRIDE_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+  UINT8   CpeiProcessorOverride;
+  UINT8   Reserved[31];
+} EFI_ACPI_6_1_PLATFORM_INTERRUPT_APIC_STRUCTURE;
+
+//
+// MPS INTI flags.
+// All other bits are reserved and must be set to 0.
+//
+#define EFI_ACPI_6_1_POLARITY      (3 << 0)
+#define EFI_ACPI_6_1_TRIGGER_MODE  (3 << 2)
+
+///
+/// Non-Maskable Interrupt Source Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  GlobalSystemInterrupt;
+} EFI_ACPI_6_1_NON_MASKABLE_INTERRUPT_SOURCE_STRUCTURE;
+
+///
+/// Local APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorUid;
+  UINT16  Flags;
+  UINT8   LocalApicLint;
+} EFI_ACPI_6_1_LOCAL_APIC_NMI_STRUCTURE;
+
+///
+/// Local APIC Address Override Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  LocalApicAddress;
+} EFI_ACPI_6_1_LOCAL_APIC_ADDRESS_OVERRIDE_STRUCTURE;
+
+///
+/// IO SAPIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   IoApicId;
+  UINT8   Reserved;
+  UINT32  GlobalSystemInterruptBase;
+  UINT64  IoSapicAddress;
+} EFI_ACPI_6_1_IO_SAPIC_STRUCTURE;
+
+///
+/// Local SAPIC Structure
+/// This struct followed by a null-terminated ASCII string - ACPI Processor UID String
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   AcpiProcessorId;
+  UINT8   LocalSapicId;
+  UINT8   LocalSapicEid;
+  UINT8   Reserved[3];
+  UINT32  Flags;
+  UINT32  ACPIProcessorUIDValue;
+} EFI_ACPI_6_1_PROCESSOR_LOCAL_SAPIC_STRUCTURE;
+
+///
+/// Platform Interrupt Sources Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT8   InterruptType;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT8   IoSapicVector;
+  UINT32  GlobalSystemInterrupt;
+  UINT32  PlatformInterruptSourceFlags;
+} EFI_ACPI_6_1_PLATFORM_INTERRUPT_SOURCES_STRUCTURE;
+
+///
+/// Platform Interrupt Source Flags.
+/// All other bits are reserved and must be set to 0.
+///
+#define EFI_ACPI_6_1_CPEI_PROCESSOR_OVERRIDE          BIT0
+
+///
+/// Processor Local x2APIC Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved[2];
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  AcpiProcessorUid;
+} EFI_ACPI_6_1_PROCESSOR_LOCAL_X2APIC_STRUCTURE;
+
+///
+/// Local x2APIC NMI Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Flags;
+  UINT32  AcpiProcessorUid;
+  UINT8   LocalX2ApicLint;
+  UINT8   Reserved[3];
+} EFI_ACPI_6_1_LOCAL_X2APIC_NMI_STRUCTURE;
+
+///
+/// GIC Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  CPUInterfaceNumber;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ParkingProtocolVersion;
+  UINT32  PerformanceInterruptGsiv;
+  UINT64  ParkedAddress;
+  UINT64  PhysicalBaseAddress;
+  UINT64  GICV;
+  UINT64  GICH;
+  UINT32  VGICMaintenanceInterrupt;
+  UINT64  GICRBaseAddress;
+  UINT64  MPIDR;
+  UINT8   ProcessorPowerEfficiencyClass;
+  UINT8   Reserved2[3];
+} EFI_ACPI_6_1_GIC_STRUCTURE;
+
+///
+/// GIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GIC_ENABLED                              BIT0
+#define EFI_ACPI_6_1_PERFORMANCE_INTERRUPT_MODEL              BIT1
+#define EFI_ACPI_6_1_VGIC_MAINTENANCE_INTERRUPT_MODE_FLAGS    BIT2
+
+///
+/// GIC Distributor Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  SystemVectorBase;
+  UINT8   GicVersion;
+  UINT8   Reserved2[3];
+} EFI_ACPI_6_1_GIC_DISTRIBUTOR_STRUCTURE;
+
+///
+/// GIC Version
+///
+#define EFI_ACPI_6_1_GIC_V1                                   0x01
+#define EFI_ACPI_6_1_GIC_V2                                   0x02
+#define EFI_ACPI_6_1_GIC_V3                                   0x03
+#define EFI_ACPI_6_1_GIC_V4                                   0x04
+
+///
+/// GIC MSI Frame Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved1;
+  UINT32  GicMsiFrameId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  Flags;
+  UINT16  SPICount;
+  UINT16  SPIBase;
+} EFI_ACPI_6_1_GIC_MSI_FRAME_STRUCTURE;
+
+///
+/// GIC MSI Frame Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_SPI_COUNT_BASE_SELECT                    BIT0
+
+///
+/// GICR Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT64  DiscoveryRangeBaseAddress;
+  UINT32  DiscoveryRangeLength;
+} EFI_ACPI_6_1_GICR_STRUCTURE;
+
+///
+/// GIC Interrupt Translation Service Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT16  Reserved;
+  UINT32  GicItsId;
+  UINT64  PhysicalBaseAddress;
+  UINT32  Reserved2;
+} EFI_ACPI_6_1_GIC_ITS_STRUCTURE;
+
+///
+/// Smart Battery Description Table (SBST)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      WarningEnergyLevel;
+  UINT32                      LowEnergyLevel;
+  UINT32                      CriticalEnergyLevel;
+} EFI_ACPI_6_1_SMART_BATTERY_DESCRIPTION_TABLE;
+
+///
+/// SBST Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_SMART_BATTERY_DESCRIPTION_TABLE_REVISION 0x01
+
+///
+/// Embedded Controller Boot Resources Table (ECDT)
+/// The table is followed by a null terminated ASCII string that contains
+/// a fully qualified reference to the name space object.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  EcControl;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  EcData;
+  UINT32                                  Uid;
+  UINT8                                   GpeBit;
+} EFI_ACPI_6_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE;
+
+///
+/// ECDT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_REVISION  0x01
+
+///
+/// System Resource Affinity Table (SRAT).  The rest of the table
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved1;  ///< Must be set to 1
+  UINT64                      Reserved2;
+} EFI_ACPI_6_1_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER;
+
+///
+/// SRAT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION  0x03
+
+//
+// SRAT structure types.
+// All other values between 0x04 an 0xFF are reserved and
+// will be ignored by OSPM.
+//
+#define EFI_ACPI_6_1_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY  0x00
+#define EFI_ACPI_6_1_MEMORY_AFFINITY                      0x01
+#define EFI_ACPI_6_1_PROCESSOR_LOCAL_X2APIC_AFFINITY      0x02
+#define EFI_ACPI_6_1_GICC_AFFINITY                        0x03
+
+///
+/// Processor Local APIC/SAPIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProximityDomain7To0;
+  UINT8   ApicId;
+  UINT32  Flags;
+  UINT8   LocalSapicEid;
+  UINT8   ProximityDomain31To8[3];
+  UINT32  ClockDomain;
+} EFI_ACPI_6_1_PROCESSOR_LOCAL_APIC_SAPIC_AFFINITY_STRUCTURE;
+
+///
+/// Local APIC/SAPIC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_PROCESSOR_LOCAL_APIC_SAPIC_ENABLED (1 << 0)
+
+///
+/// Memory Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT16  Reserved1;
+  UINT32  AddressBaseLow;
+  UINT32  AddressBaseHigh;
+  UINT32  LengthLow;
+  UINT32  LengthHigh;
+  UINT32  Reserved2;
+  UINT32  Flags;
+  UINT64  Reserved3;
+} EFI_ACPI_6_1_MEMORY_AFFINITY_STRUCTURE;
+
+//
+// Memory Flags.  All other bits are reserved and must be 0.
+//
+#define EFI_ACPI_6_1_MEMORY_ENABLED       (1 << 0)
+#define EFI_ACPI_6_1_MEMORY_HOT_PLUGGABLE (1 << 1)
+#define EFI_ACPI_6_1_MEMORY_NONVOLATILE   (1 << 2)
+
+///
+/// Processor Local x2APIC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   Reserved1[2];
+  UINT32  ProximityDomain;
+  UINT32  X2ApicId;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+  UINT8   Reserved2[4];
+} EFI_ACPI_6_1_PROCESSOR_LOCAL_X2APIC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Affinity Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT32  ProximityDomain;
+  UINT32  AcpiProcessorUid;
+  UINT32  Flags;
+  UINT32  ClockDomain;
+} EFI_ACPI_6_1_GICC_AFFINITY_STRUCTURE;
+
+///
+/// GICC Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GICC_ENABLED (1 << 0)
+
+///
+/// System Locality Distance Information Table (SLIT).
+/// The rest of the table is a matrix.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      NumberOfSystemLocalities;
+} EFI_ACPI_6_1_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER;
+
+///
+/// SLIT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION  0x01
+
+///
+/// Corrected Platform Error Polling Table (CPEP)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       Reserved[8];
+} EFI_ACPI_6_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_HEADER;
+
+///
+/// CPEP Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_REVISION 0x01
+
+//
+// CPEP processor structure types.
+//
+#define EFI_ACPI_6_1_CPEP_PROCESSOR_APIC_SAPIC  0x00
+
+///
+/// Corrected Platform Error Polling Processor Structure Definition
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Length;
+  UINT8   ProcessorId;
+  UINT8   ProcessorEid;
+  UINT32  PollingInterval;
+} EFI_ACPI_6_1_CPEP_PROCESSOR_APIC_SAPIC_STRUCTURE;
+
+///
+/// Maximum System Characteristics Table (MSCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      OffsetProxDomInfo;
+  UINT32                      MaximumNumberOfProximityDomains;
+  UINT32                      MaximumNumberOfClockDomains;
+  UINT64                      MaximumPhysicalAddress;
+} EFI_ACPI_6_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_HEADER;
+
+///
+/// MSCT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_REVISION 0x01
+
+///
+/// Maximum Proximity Domain Information Structure Definition
+///
+typedef struct {
+  UINT8   Revision;
+  UINT8   Length;
+  UINT32  ProximityDomainRangeLow;
+  UINT32  ProximityDomainRangeHigh;
+  UINT32  MaximumProcessorCapacity;
+  UINT64  MaximumMemoryCapacity;
+} EFI_ACPI_6_1_MAXIMUM_PROXIMITY_DOMAIN_INFORMATION_STRUCTURE;
+
+///
+/// ACPI RAS Feature Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier[12];
+} EFI_ACPI_6_1_RAS_FEATURE_TABLE;
+
+///
+/// RASF Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_RAS_FEATURE_TABLE_REVISION 0x01
+
+///
+/// ACPI RASF Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT16                      Version;
+  UINT8                       RASCapabilities[16];
+  UINT8                       SetRASCapabilities[16];
+  UINT16                      NumberOfRASFParameterBlocks;
+  UINT32                      SetRASCapabilitiesStatus;
+} EFI_ACPI_6_1_RASF_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI RASF PCC command code
+///
+#define EFI_ACPI_6_1_RASF_PCC_COMMAND_CODE_EXECUTE_RASF_COMMAND  0x01
+
+///
+/// ACPI RASF Platform RAS Capabilities
+///
+#define EFI_ACPI_6_1_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED                          0x01
+#define EFI_ACPI_6_1_RASF_PLATFORM_RAS_CAPABILITY_HARDWARE_BASED_PATROL_SCRUB_SUPPOTED_AND_EXPOSED_TO_SOFTWARE  0x02
+
+///
+/// ACPI RASF Parameter Block structure for PATROL_SCRUB
+///
+typedef struct {
+  UINT16                      Type;
+  UINT16                      Version;
+  UINT16                      Length;
+  UINT16                      PatrolScrubCommand;
+  UINT64                      RequestedAddressRange[2];
+  UINT64                      ActualAddressRange[2];
+  UINT16                      Flags;
+  UINT8                       RequestedSpeed;
+} EFI_ACPI_6_1_RASF_PATROL_SCRUB_PLATFORM_BLOCK_STRUCTURE;
+
+///
+/// ACPI RASF Patrol Scrub command
+///
+#define EFI_ACPI_6_1_RASF_PATROL_SCRUB_COMMAND_GET_PATROL_PARAMETERS   0x01
+#define EFI_ACPI_6_1_RASF_PATROL_SCRUB_COMMAND_START_PATROL_SCRUBBER   0x02
+#define EFI_ACPI_6_1_RASF_PATROL_SCRUB_COMMAND_STOP_PATROL_SCRUBBER    0x03
+
+///
+/// Memory Power State Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT8                       PlatformCommunicationChannelIdentifier;
+  UINT8                       Reserved[3];
+// Memory Power Node Structure
+// Memory Power State Characteristics
+} EFI_ACPI_6_1_MEMORY_POWER_STATUS_TABLE;
+
+///
+/// MPST Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_MEMORY_POWER_STATE_TABLE_REVISION 0x01
+
+///
+/// MPST Platform Communication Channel Shared Memory Region definition.
+///
+typedef struct {
+  UINT32                      Signature;
+  UINT16                      Command;
+  UINT16                      Status;
+  UINT32                      MemoryPowerCommandRegister;
+  UINT32                      MemoryPowerStatusRegister;
+  UINT32                      PowerStateId;
+  UINT32                      MemoryPowerNodeId;
+  UINT64                      MemoryEnergyConsumed;
+  UINT64                      ExpectedAveragePowerComsuned;
+} EFI_ACPI_6_1_MPST_PLATFORM_COMMUNICATION_CHANNEL_SHARED_MEMORY_REGION;
+
+///
+/// ACPI MPST PCC command code
+///
+#define EFI_ACPI_6_1_MPST_PCC_COMMAND_CODE_EXECUTE_MPST_COMMAND  0x03
+
+///
+/// ACPI MPST Memory Power command
+///
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_POWER_STATE       0x01
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_COMMAND_SET_MEMORY_POWER_STATE       0x02
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_COMMAND_GET_AVERAGE_POWER_CONSUMED   0x03
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_COMMAND_GET_MEMORY_ENERGY_CONSUMED   0x04
+
+///
+/// MPST Memory Power Node Table
+///
+typedef struct {
+  UINT8                                             PowerStateValue;
+  UINT8                                             PowerStateInformationIndex;
+} EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE;
+
+typedef struct {
+  UINT8                                             Flag;
+  UINT8                                             Reserved;
+  UINT16                                            MemoryPowerNodeId;
+  UINT32                                            Length;
+  UINT64                                            AddressBase;
+  UINT64                                            AddressLength;
+  UINT32                                            NumberOfPowerStates;
+  UINT32                                            NumberOfPhysicalComponents;
+//EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE              MemoryPowerState[NumberOfPowerStates];
+//UINT16                                            PhysicalComponentIdentifier[NumberOfPhysicalComponents];
+} EFI_ACPI_6_1_MPST_MEMORY_POWER_STRUCTURE;
+
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_ENABLE          0x01
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_POWER_MANAGED   0x02
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STRUCTURE_FLAG_HOT_PLUGGABLE   0x04
+
+typedef struct {
+  UINT16                      MemoryPowerNodeCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_6_1_MPST_MEMORY_POWER_NODE_TABLE;
+
+///
+/// MPST Memory Power State Characteristics Table
+///
+typedef struct {
+  UINT8                                             PowerStateStructureID;
+  UINT8                                             Flag;
+  UINT16                                            Reserved;
+  UINT32                                            AveragePowerConsumedInMPS0;
+  UINT32                                            RelativePowerSavingToMPS0;
+  UINT64                                            ExitLatencyToMPS0;
+} EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE;
+
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_MEMORY_CONTENT_PRESERVED              0x01
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_ENTRY   0x02
+#define EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_STRUCTURE_FLAG_AUTONOMOUS_MEMORY_POWER_STATE_EXIT    0x04
+
+typedef struct {
+  UINT16                      MemoryPowerStateCharacteristicsCount;
+  UINT8                       Reserved[2];
+} EFI_ACPI_6_1_MPST_MEMORY_POWER_STATE_CHARACTERISTICS_TABLE;
+
+///
+/// Memory Topology Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Reserved;
+} EFI_ACPI_6_1_MEMORY_TOPOLOGY_TABLE;
+
+///
+/// PMTT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_MEMORY_TOPOLOGY_TABLE_REVISION 0x01
+
+///
+/// Common Memory Aggregator Device Structure.
+///
+typedef struct {
+  UINT8                       Type;
+  UINT8                       Reserved;
+  UINT16                      Length;
+  UINT16                      Flags;
+  UINT16                      Reserved1;
+} EFI_ACPI_6_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Memory Aggregator Device Type
+///
+#define EFI_ACPI_6_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_SOCKET            0x1
+#define EFI_ACPI_6_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_MEMORY_CONTROLLER 0x2
+#define EFI_ACPI_6_1_PMMT_MEMORY_AGGREGATOR_DEVICE_TYPE_DIMM              0x3
+
+///
+/// Socket Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       SocketIdentifier;
+  UINT16                                                       Reserved;
+//EFI_ACPI_6_1_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  MemoryController[];
+} EFI_ACPI_6_1_PMMT_SOCKET_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// MemoryController Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT32                                                       ReadLatency;
+  UINT32                                                       WriteLatency;
+  UINT32                                                       ReadBandwidth;
+  UINT32                                                       WriteBandwidth;
+  UINT16                                                       OptimalAccessUnit;
+  UINT16                                                       OptimalAccessAlignment;
+  UINT16                                                       Reserved;
+  UINT16                                                       NumberOfProximityDomains;
+//UINT32                                                       ProximityDomain[NumberOfProximityDomains];
+//EFI_ACPI_6_1_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE    PhysicalComponent[];
+} EFI_ACPI_6_1_PMMT_MEMORY_CONTROLLER_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// DIMM Memory Aggregator Device Structure.
+///
+typedef struct {
+  EFI_ACPI_6_1_PMMT_COMMON_MEMORY_AGGREGATOR_DEVICE_STRUCTURE  Header;
+  UINT16                                                       PhysicalComponentIdentifier;
+  UINT16                                                       Reserved;
+  UINT32                                                       SizeOfDimm;
+  UINT32                                                       SmbiosHandle;
+} EFI_ACPI_6_1_PMMT_DIMM_MEMORY_AGGREGATOR_DEVICE_STRUCTURE;
+
+///
+/// Boot Graphics Resource Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  ///
+  /// 2-bytes (16 bit) version ID. This value must be 1.
+  ///
+  UINT16                      Version;
+  ///
+  /// 1-byte status field indicating current status about the table.
+  ///     Bits[7:1] = Reserved (must be zero)
+  ///     Bit [0] = Valid. A one indicates the boot image graphic is valid.
+  ///
+  UINT8                       Status;
+  ///
+  /// 1-byte enumerated type field indicating format of the image.
+  ///     0 = Bitmap
+  ///     1 - 255  Reserved (for future use)
+  ///
+  UINT8                       ImageType;
+  ///
+  /// 8-byte (64 bit) physical address pointing to the firmware's in-memory copy
+  /// of the image bitmap.
+  ///
+  UINT64                      ImageAddress;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display X-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetX;
+  ///
+  /// A 4-byte (32-bit) unsigned long describing the display Y-offset of the boot image.
+  /// (X, Y) display offset of the top left corner of the boot image.
+  /// The top left corner of the display is at offset (0, 0).
+  ///
+  UINT32                      ImageOffsetY;
+} EFI_ACPI_6_1_BOOT_GRAPHICS_RESOURCE_TABLE;
+
+///
+/// BGRT Revision
+///
+#define EFI_ACPI_6_1_BOOT_GRAPHICS_RESOURCE_TABLE_REVISION 1
+
+///
+/// BGRT Version
+///
+#define EFI_ACPI_6_1_BGRT_VERSION         0x01
+
+///
+/// BGRT Status
+///
+#define EFI_ACPI_6_1_BGRT_STATUS_NOT_DISPLAYED 0x00
+#define EFI_ACPI_6_1_BGRT_STATUS_DISPLAYED     0x01
+
+///
+/// BGRT Image Type
+///
+#define EFI_ACPI_6_1_BGRT_IMAGE_TYPE_BMP  0x00
+
+///
+/// FPDT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_FIRMWARE_PERFORMANCE_DATA_TABLE_REVISION 0x01
+
+///
+/// FPDT Performance Record Types
+///
+#define EFI_ACPI_6_1_FPDT_RECORD_TYPE_FIRMWARE_BASIC_BOOT_POINTER      0x0000
+#define EFI_ACPI_6_1_FPDT_RECORD_TYPE_S3_PERFORMANCE_TABLE_POINTER     0x0001
+
+///
+/// FPDT Performance Record Revision
+///
+#define EFI_ACPI_6_1_FPDT_RECORD_REVISION_FIRMWARE_BASIC_BOOT_POINTER  0x01
+#define EFI_ACPI_6_1_FPDT_RECORD_REVISION_S3_PERFORMANCE_TABLE_POINTER 0x01
+
+///
+/// FPDT Runtime Performance Record Types
+///
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_TYPE_S3_RESUME                0x0000
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_TYPE_S3_SUSPEND               0x0001
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_TYPE_FIRMWARE_BASIC_BOOT      0x0002
+
+///
+/// FPDT Runtime Performance Record Revision
+///
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_REVISION_S3_RESUME            0x01
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_REVISION_S3_SUSPEND           0x01
+#define EFI_ACPI_6_1_FPDT_RUNTIME_RECORD_REVISION_FIRMWARE_BASIC_BOOT  0x02
+
+///
+/// FPDT Performance Record header
+///
+typedef struct {
+  UINT16           Type;
+  UINT8            Length;
+  UINT8            Revision;
+} EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER;
+
+///
+/// FPDT Performance Table header
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+} EFI_ACPI_6_1_FPDT_PERFORMANCE_TABLE_HEADER;
+
+///
+/// FPDT Firmware Basic Boot Performance Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the Basic Boot Performance Table.
+  ///
+  UINT64                                          BootPerformanceTablePointer;
+} EFI_ACPI_6_1_FPDT_BOOT_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT S3 Performance Table Pointer Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// 64-bit processor-relative physical address of the S3 Performance Table.
+  ///
+  UINT64                                          S3PerformanceTablePointer;
+} EFI_ACPI_6_1_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Record Structure
+///
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  UINT32                                          Reserved;
+  ///
+  /// Timer value logged at the beginning of firmware image execution.
+  /// This may not always be zero or near zero.
+  ///
+  UINT64                                          ResetEnd;
+  ///
+  /// Timer value logged just prior to loading the OS boot loader into memory.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          OsLoaderLoadImageStart;
+  ///
+  /// Timer value logged just prior to launching the previously loaded OS boot loader image.
+  /// For non-UEFI compatible boots, the timer value logged will be just prior
+  /// to the INT 19h handler invocation.
+  ///
+  UINT64                                          OsLoaderStartImageStart;
+  ///
+  /// Timer value logged at the point when the OS loader calls the
+  /// ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesEntry;
+  ///
+  /// Timer value logged at the point just prior towhen the OS loader gaining
+  /// control back from calls the ExitBootServices function for UEFI compatible firmware.
+  /// For non-UEFI compatible boots, this field must be zero.
+  ///
+  UINT64                                          ExitBootServicesExit;
+} EFI_ACPI_6_1_FPDT_FIRMWARE_BASIC_BOOT_RECORD;
+
+///
+/// FPDT Firmware Basic Boot Performance Table signature
+///
+#define EFI_ACPI_6_1_FPDT_BOOT_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('F', 'B', 'P', 'T')
+
+//
+// FPDT Firmware Basic Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_6_1_FPDT_FIRMWARE_BASIC_BOOT_TABLE;
+
+///
+/// FPDT "S3PT" S3 Performance Table
+///
+#define EFI_ACPI_6_1_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE  SIGNATURE_32('S', '3', 'P', 'T')
+
+//
+// FPDT Firmware S3 Boot Performance Table
+//
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_TABLE_HEADER      Header;
+  //
+  // one or more Performance Records.
+  //
+} EFI_ACPI_6_1_FPDT_FIRMWARE_S3_BOOT_TABLE;
+
+///
+/// FPDT Basic S3 Resume Performance Record
+///
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// A count of the number of S3 resume cycles since the last full boot sequence.
+  ///
+  UINT32                                          ResumeCount;
+  ///
+  /// Timer recorded at the end of BIOS S3 resume, just prior to handoff to the
+  /// OS waking vector. Only the most recent resume cycle's time is retained.
+  ///
+  UINT64                                          FullResume;
+  ///
+  /// Average timer value of all resume cycles logged since the last full boot
+  /// sequence, including the most recent resume.  Note that the entire log of
+  /// timer values does not need to be retained in order to calculate this average.
+  ///
+  UINT64                                          AverageResume;
+} EFI_ACPI_6_1_FPDT_S3_RESUME_RECORD;
+
+///
+/// FPDT Basic S3 Suspend Performance Record
+///
+typedef struct {
+  EFI_ACPI_6_1_FPDT_PERFORMANCE_RECORD_HEADER     Header;
+  ///
+  /// Timer value recorded at the OS write to SLP_TYP upon entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendStart;
+  ///
+  /// Timer value recorded at the final firmware write to SLP_TYP (or other
+  /// mechanism) used to trigger hardware entry to S3.
+  /// Only the most recent suspend cycle's timer value is retained.
+  ///
+  UINT64                                          SuspendEnd;
+} EFI_ACPI_6_1_FPDT_S3_SUSPEND_RECORD;
+
+///
+/// Firmware Performance Record Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+} EFI_ACPI_6_1_FIRMWARE_PERFORMANCE_RECORD_TABLE;
+
+///
+/// Generic Timer Description Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT64                      CntControlBasePhysicalAddress;
+  UINT32                      Reserved;
+  UINT32                      SecurePL1TimerGSIV;
+  UINT32                      SecurePL1TimerFlags;
+  UINT32                      NonSecurePL1TimerGSIV;
+  UINT32                      NonSecurePL1TimerFlags;
+  UINT32                      VirtualTimerGSIV;
+  UINT32                      VirtualTimerFlags;
+  UINT32                      NonSecurePL2TimerGSIV;
+  UINT32                      NonSecurePL2TimerFlags;
+  UINT64                      CntReadBasePhysicalAddress;
+  UINT32                      PlatformTimerCount;
+  UINT32                      PlatformTimerOffset;
+} EFI_ACPI_6_1_GENERIC_TIMER_DESCRIPTION_TABLE;
+
+///
+/// GTDT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION 0x02
+
+///
+/// Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_1_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_6_1_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY          BIT2
+
+///
+/// Platform Timer Type
+///
+#define EFI_ACPI_6_1_GTDT_GT_BLOCK                       0
+#define EFI_ACPI_6_1_GTDT_SBSA_GENERIC_WATCHDOG          1
+
+///
+/// GT Block Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  CntCtlBase;
+  UINT32  GTBlockTimerCount;
+  UINT32  GTBlockTimerOffset;
+} EFI_ACPI_6_1_GTDT_GT_BLOCK_STRUCTURE;
+
+///
+/// GT Block Timer Structure
+///
+typedef struct {
+  UINT8   GTFrameNumber;
+  UINT8   Reserved[3];
+  UINT64  CntBaseX;
+  UINT64  CntEL0BaseX;
+  UINT32  GTxPhysicalTimerGSIV;
+  UINT32  GTxPhysicalTimerFlags;
+  UINT32  GTxVirtualTimerGSIV;
+  UINT32  GTxVirtualTimerFlags;
+  UINT32  GTxCommonFlags;
+} EFI_ACPI_6_1_GTDT_GT_BLOCK_TIMER_STRUCTURE;
+
+///
+/// GT Block Physical Timers and Virtual Timers Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_1_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+
+///
+/// Common Flags Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER              BIT0
+#define EFI_ACPI_6_1_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY      BIT1
+
+///
+/// SBSA Generic Watchdog Structure
+///
+typedef struct {
+  UINT8   Type;
+  UINT16  Length;
+  UINT8   Reserved;
+  UINT64  RefreshFramePhysicalAddress;
+  UINT64  WatchdogControlFramePhysicalAddress;
+  UINT32  WatchdogTimerGSIV;
+  UINT32  WatchdogTimerFlags;
+} EFI_ACPI_6_1_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE;
+
+///
+/// SBSA Generic Watchdog Timer Flags.  All other bits are reserved and must be 0.
+///
+#define EFI_ACPI_6_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE          BIT0
+#define EFI_ACPI_6_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY      BIT1
+#define EFI_ACPI_6_1_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER                  BIT2
+
+//
+// NVDIMM Firmware Interface Table definition.
+//
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER    Header;
+  UINT32                         Reserved;
+} EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE;
+
+//
+// NFIT Version (as defined in ACPI 6.1 spec.)
+//
+#define EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION 0x1
+
+//
+// Definition for NFIT Table Structure Types
+//
+#define EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE              0
+#define EFI_ACPI_6_1_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE_TYPE                      1
+#define EFI_ACPI_6_1_NFIT_INTERLEAVE_STRUCTURE_TYPE                                 2
+#define EFI_ACPI_6_1_NFIT_SMBIOS_MANAGEMENT_INFORMATION_STRUCTURE_TYPE              3
+#define EFI_ACPI_6_1_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE_TYPE                      4
+#define EFI_ACPI_6_1_NFIT_NVDIMM_BLOCK_DATA_WINDOW_REGION_STRUCTURE_TYPE            5
+#define EFI_ACPI_6_1_NFIT_FLUSH_HINT_ADDRESS_STRUCTURE_TYPE                         6
+
+//
+// Definition for NFIT Structure Header
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+} EFI_ACPI_6_1_NFIT_STRUCTURE_HEADER;
+
+//
+// Definition for System Physical Address Range Structure
+//
+#define EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_FLAGS_CONTROL_REGION_FOR_MANAGEMENT      BIT0
+#define EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_FLAGS_PROXIMITY_DOMAIN_VALID             BIT1
+#define EFI_ACPI_6_1_NFIT_GUID_VOLATILE_MEMORY_REGION                             { 0x7305944F, 0xFDDA, 0x44E3, { 0xB1, 0x6C, 0x3F, 0x22, 0xD2, 0x52, 0xE5, 0xD0 }}
+#define EFI_ACPI_6_1_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION          { 0x66F0D379, 0xB4F3, 0x4074, { 0xAC, 0x43, 0x0D, 0x33, 0x18, 0xB7, 0x8C, 0xDB }}
+#define EFI_ACPI_6_1_NFIT_GUID_NVDIMM_CONTROL_REGION                              { 0x92F701F6, 0x13B4, 0x405D, { 0x91, 0x0B, 0x29, 0x93, 0x67, 0xE8, 0x23, 0x4C }}
+#define EFI_ACPI_6_1_NFIT_GUID_NVDIMM_BLOCK_DATA_WINDOW_REGION                    { 0x91AF0530, 0x5D86, 0x470E, { 0xA6, 0xB0, 0x0A, 0x2D, 0xB9, 0x40, 0x82, 0x49 }}
+#define EFI_ACPI_6_1_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGION_VOLATILE   { 0x77AB535A, 0x45FC, 0x624B, { 0x55, 0x60, 0xF7, 0xB2, 0x81, 0xD1, 0xF9, 0x6E }}
+#define EFI_ACPI_6_1_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION_VOLATILE     { 0x3D5ABD30, 0x4175, 0x87CE, { 0x6D, 0x64, 0xD2, 0xAD, 0xE5, 0x23, 0xC4, 0xBB }}
+#define EFI_ACPI_6_1_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_DISK_REGION_PERSISTENT { 0x5CEA02C9, 0x4D07, 0x69D3, { 0x26, 0x9F ,0x44, 0x96, 0xFB, 0xE0, 0x96, 0xF9 }}
+#define EFI_ACPI_6_1_NFIT_GUID_RAM_DISK_SUPPORTING_VIRTUAL_CD_REGION_PERSISTENT   { 0x08018188, 0x42CD, 0xBB48, { 0x10, 0x0F, 0x53, 0x87, 0xD5, 0x3D, 0xED, 0x3D ]}
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      SPARangeStructureIndex;
+  UINT16                                      Flags;
+  UINT32                                      Reserved_8;
+  UINT32                                      ProximityDomain;
+  GUID                                        AddressRangeTypeGUID;
+  UINT64                                      SystemPhysicalAddressRangeBase;
+  UINT64                                      SystemPhysicalAddressRangeLength;
+  UINT64                                      AddressRangeMemoryMappingAttribute;
+} EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE;
+
+//
+// Definition for Memory Device to System Physical Address Range Mapping Structure
+//
+typedef struct {
+  UINT32                                      DIMMNumber:4;
+  UINT32                                      MemoryChannelNumber:4;
+  UINT32                                      MemoryControllerID:4;
+  UINT32                                      SocketID:4;
+  UINT32                                      NodeControllerID:12;
+  UINT32                                      Reserved_28:4;
+} EFI_ACPI_6_1_NFIT_DEVICE_HANDLE;
+
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_PREVIOUS_SAVE_FAIL                                      BIT0
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_LAST_RESTORE_FAIL                                       BIT1
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_PLATFORM_FLUSH_FAIL                                     BIT2
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_NOT_ARMED_PRIOR_TO_OSPM_HAND_OFF                        BIT3
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_SMART_HEALTH_EVENTS_PRIOR_OSPM_HAND_OFF                 BIT4
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_FIRMWARE_ENABLED_TO_NOTIFY_OSPM_ON_SMART_HEALTH_EVENTS  BIT5
+#define EFI_ACPI_6_1_NFIT_MEMORY_DEVICE_STATE_FLAGS_FIRMWARE_NOT_MAP_NVDIMM_TO_SPA                          BIT6
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  EFI_ACPI_6_1_NFIT_DEVICE_HANDLE             NFITDeviceHandle;
+  UINT16                                      NVDIMMPhysicalID;
+  UINT16                                      NVDIMMRegionID;
+  UINT16                                      SPARangeStructureIndex ;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT64                                      NVDIMMRegionSize;
+  UINT64                                      RegionOffset;
+  UINT64                                      NVDIMMPhysicalAddressRegionBase;
+  UINT16                                      InterleaveStructureIndex;
+  UINT16                                      InterleaveWays;
+  UINT16                                      NVDIMMStateFlags;
+  UINT16                                      Reserved_46;
+} EFI_ACPI_6_1_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE;
+
+//
+// Definition for Interleave Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      InterleaveStructureIndex;
+  UINT16                                      Reserved_6;
+  UINT32                                      NumberOfLines;
+  UINT32                                      LineSize;
+//UINT32                                      LineOffset[NumberOfLines];
+} EFI_ACPI_6_1_NFIT_INTERLEAVE_STRUCTURE;
+
+//
+// Definition for SMBIOS Management Information Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT32                                      Reserved_4;
+//UINT8                                       Data[];
+} EFI_ACPI_6_1_NFIT_SMBIOS_MANAGEMENT_INFORMATION_STRUCTURE;
+
+//
+// Definition for NVDIMM Control Region Structure
+//
+#define EFI_ACPI_6_1_NFIT_NVDIMM_CONTROL_REGION_VALID_FIELDS_MANUFACTURING           BIT0
+
+#define EFI_ACPI_6_1_NFIT_NVDIMM_CONTROL_REGION_FLAGS_BLOCK_DATA_WINDOWS_BUFFERED    BIT0
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT16                                      VendorID;
+  UINT16                                      DeviceID;
+  UINT16                                      RevisionID;
+  UINT16                                      SubsystemVendorID;
+  UINT16                                      SubsystemDeviceID;
+  UINT16                                      SubsystemRevisionID;
+  UINT8                                       ValidFields;
+  UINT8                                       ManufacturingLocation;
+  UINT16                                      ManufacturingDate;
+  UINT8                                       Reserved_22[2];
+  UINT32                                      SerialNumber;
+  UINT16                                      RegionFormatInterfaceCode;
+  UINT16                                      NumberOfBlockControlWindows;
+  UINT64                                      SizeOfBlockControlWindow;
+  UINT64                                      CommandRegisterOffsetInBlockControlWindow;
+  UINT64                                      SizeOfCommandRegisterInBlockControlWindows;
+  UINT64                                      StatusRegisterOffsetInBlockControlWindow;
+  UINT64                                      SizeOfStatusRegisterInBlockControlWindows;
+  UINT16                                      NVDIMMControlRegionFlag;
+  UINT8                                       Reserved_74[6];
+} EFI_ACPI_6_1_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE;
+
+//
+// Definition for NVDIMM Block Data Window Region Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  UINT16                                      NVDIMMControlRegionStructureIndex;
+  UINT16                                      NumberOfBlockDataWindows;
+  UINT64                                      BlockDataWindowStartOffset;
+  UINT64                                      SizeOfBlockDataWindow;
+  UINT64                                      BlockAccessibleMemoryCapacity;
+  UINT64                                      BeginningAddressOfFirstBlockInBlockAccessibleMemory;
+} EFI_ACPI_6_1_NFIT_NVDIMM_BLOCK_DATA_WINDOW_REGION_STRUCTURE;
+
+//
+// Definition for Flush Hint Address Structure
+//
+typedef struct {
+  UINT16                                      Type;
+  UINT16                                      Length;
+  EFI_ACPI_6_1_NFIT_DEVICE_HANDLE             NFITDeviceHandle;
+  UINT16                                      NumberOfFlushHintAddresses;
+  UINT8                                       Reserved_10[6];
+//UINT64                                      FlushHintAddress[NumberOfFlushHintAddresses];
+} EFI_ACPI_6_1_NFIT_FLUSH_HINT_ADDRESS_STRUCTURE;
+
+///
+/// Boot Error Record Table (BERT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      BootErrorRegionLength;
+  UINT64                      BootErrorRegion;
+} EFI_ACPI_6_1_BOOT_ERROR_RECORD_TABLE_HEADER;
+
+///
+/// BERT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_BOOT_ERROR_RECORD_TABLE_REVISION 0x01
+
+///
+/// Boot Error Region Block Status Definition
+///
+typedef struct {
+  UINT32       UncorrectableErrorValid:1;
+  UINT32       CorrectableErrorValid:1;
+  UINT32       MultipleUncorrectableErrors:1;
+  UINT32       MultipleCorrectableErrors:1;
+  UINT32       ErrorDataEntryCount:10;
+  UINT32       Reserved:18;
+} EFI_ACPI_6_1_ERROR_BLOCK_STATUS;
+
+///
+/// Boot Error Region Definition
+///
+typedef struct {
+  EFI_ACPI_6_1_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_6_1_BOOT_ERROR_REGION_STRUCTURE;
+
+//
+// Boot Error Severity types
+//
+#define EFI_ACPI_6_1_ERROR_SEVERITY_CORRECTABLE  0x00
+#define EFI_ACPI_6_1_ERROR_SEVERITY_FATAL        0x01
+#define EFI_ACPI_6_1_ERROR_SEVERITY_CORRECTED    0x02
+#define EFI_ACPI_6_1_ERROR_SEVERITY_NONE         0x03
+
+///
+/// Generic Error Data Entry Definition
+///
+typedef struct {
+  UINT8    SectionType[16];
+  UINT32   ErrorSeverity;
+  UINT16   Revision;
+  UINT8    ValidationBits;
+  UINT8    Flags;
+  UINT32   ErrorDataLength;
+  UINT8    FruId[16];
+  UINT8    FruText[20];
+  UINT8    Timestamp[8];
+} EFI_ACPI_6_1_GENERIC_ERROR_DATA_ENTRY_STRUCTURE;
+
+///
+/// Generic Error Data Entry Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_GENERIC_ERROR_DATA_ENTRY_REVISION  0x0300
+
+///
+/// HEST - Hardware Error Source Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ErrorSourceCount;
+} EFI_ACPI_6_1_HARDWARE_ERROR_SOURCE_TABLE_HEADER;
+
+///
+/// HEST Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_HARDWARE_ERROR_SOURCE_TABLE_REVISION 0x01
+
+//
+// Error Source structure types.
+//
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION  0x00
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK  0x01
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_NMI_ERROR                0x02
+#define EFI_ACPI_6_1_PCI_EXPRESS_ROOT_PORT_AER                  0x06
+#define EFI_ACPI_6_1_PCI_EXPRESS_DEVICE_AER                     0x07
+#define EFI_ACPI_6_1_PCI_EXPRESS_BRIDGE_AER                     0x08
+#define EFI_ACPI_6_1_GENERIC_HARDWARE_ERROR                     0x09
+#define EFI_ACPI_6_1_GENERIC_HARDWARE_ERROR_VERSION_2           0x0A
+
+//
+// Error Source structure flags.
+//
+#define EFI_ACPI_6_1_ERROR_SOURCE_FLAG_FIRMWARE_FIRST       (1 << 0)
+#define EFI_ACPI_6_1_ERROR_SOURCE_FLAG_GLOBAL               (1 << 1)
+
+///
+/// IA-32 Architecture Machine Check Exception Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT64  GlobalCapabilityInitData;
+  UINT64  GlobalControlInitData;
+  UINT8   NumberOfHardwareBanks;
+  UINT8   Reserved1[7];
+} EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_EXCEPTION_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure Definition
+///
+typedef struct {
+  UINT8   BankNumber;
+  UINT8   ClearStatusOnInitialization;
+  UINT8   StatusDataFormat;
+  UINT8   Reserved0;
+  UINT32  ControlRegisterMsrAddress;
+  UINT64  ControlInitData;
+  UINT32  StatusRegisterMsrAddress;
+  UINT32  AddressRegisterMsrAddress;
+  UINT32  MiscRegisterMsrAddress;
+} EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_BANK_STRUCTURE;
+
+///
+/// IA-32 Architecture Machine Check Bank Structure MCA data format
+///
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_IA32      0x00
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_INTEL64   0x01
+#define EFI_ACPI_6_1_IA32_ARCHITECTURE_MACHINE_CHECK_ERROR_DATA_FORMAT_AMD64     0x02
+
+//
+// Hardware Error Notification types. All other values are reserved
+//
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_POLLED                0x00
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_EXTERNAL_INTERRUPT    0x01
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_LOCAL_INTERRUPT       0x02
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_SCI                   0x03
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_NMI                   0x04
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_CMCI                  0x05
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_MCE                   0x06
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_GPIO_SIGNAL           0x07
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_ARMV8_SEA             0x08
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_ARMV8_SEI             0x09
+#define EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_GSIV                  0x0A
+
+///
+/// Hardware Error Notification Configuration Write Enable Structure Definition
+///
+typedef struct {
+  UINT16    Type:1;
+  UINT16    PollInterval:1;
+  UINT16    SwitchToPollingThresholdValue:1;
+  UINT16    SwitchToPollingThresholdWindow:1;
+  UINT16    ErrorThresholdValue:1;
+  UINT16    ErrorThresholdWindow:1;
+  UINT16    Reserved:10;
+} EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE;
+
+///
+/// Hardware Error Notification Structure Definition
+///
+typedef struct {
+  UINT8                                                                          Type;
+  UINT8                                                                          Length;
+  EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_CONFIGURATION_WRITE_ENABLE_STRUCTURE  ConfigurationWriteEnable;
+  UINT32                                                                         PollInterval;
+  UINT32                                                                         Vector;
+  UINT32                                                                         SwitchToPollingThresholdValue;
+  UINT32                                                                         SwitchToPollingThresholdWindow;
+  UINT32                                                                         ErrorThresholdValue;
+  UINT32                                                                         ErrorThresholdWindow;
+} EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE;
+
+///
+/// IA-32 Architecture Corrected Machine Check Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT8                                                  Reserved0[2];
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT8                                                  NumberOfHardwareBanks;
+  UINT8                                                  Reserved1[3];
+} EFI_ACPI_6_1_IA32_ARCHITECTURE_CORRECTED_MACHINE_CHECK_STRUCTURE;
+
+///
+/// IA-32 Architecture NMI Error Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  MaxRawDataLength;
+} EFI_ACPI_6_1_IA32_ARCHITECTURE_NMI_ERROR_STRUCTURE;
+
+///
+/// PCI Express Root Port AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  RootErrorCommand;
+} EFI_ACPI_6_1_PCI_EXPRESS_ROOT_PORT_AER_STRUCTURE;
+
+///
+/// PCI Express Device AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_6_1_PCI_EXPRESS_DEVICE_AER_STRUCTURE;
+
+///
+/// PCI Express Bridge AER Structure Definition
+///
+typedef struct {
+  UINT16  Type;
+  UINT16  SourceId;
+  UINT8   Reserved0[2];
+  UINT8   Flags;
+  UINT8   Enabled;
+  UINT32  NumberOfRecordsToPreAllocate;
+  UINT32  MaxSectionsPerRecord;
+  UINT32  Bus;
+  UINT16  Device;
+  UINT16  Function;
+  UINT16  DeviceControl;
+  UINT8   Reserved1[2];
+  UINT32  UncorrectableErrorMask;
+  UINT32  UncorrectableErrorSeverity;
+  UINT32  CorrectableErrorMask;
+  UINT32  AdvancedErrorCapabilitiesAndControl;
+  UINT32  SecondaryUncorrectableErrorMask;
+  UINT32  SecondaryUncorrectableErrorSeverity;
+  UINT32  SecondaryAdvancedErrorCapabilitiesAndControl;
+} EFI_ACPI_6_1_PCI_EXPRESS_BRIDGE_AER_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+} EFI_ACPI_6_1_GENERIC_HARDWARE_ERROR_SOURCE_STRUCTURE;
+
+///
+/// Generic Hardware Error Source Version 2 Structure Definition
+///
+typedef struct {
+  UINT16                                                 Type;
+  UINT16                                                 SourceId;
+  UINT16                                                 RelatedSourceId;
+  UINT8                                                  Flags;
+  UINT8                                                  Enabled;
+  UINT32                                                 NumberOfRecordsToPreAllocate;
+  UINT32                                                 MaxSectionsPerRecord;
+  UINT32                                                 MaxRawDataLength;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE                 ErrorStatusAddress;
+  EFI_ACPI_6_1_HARDWARE_ERROR_NOTIFICATION_STRUCTURE     NotificationStructure;
+  UINT32                                                 ErrorStatusBlockLength;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE                 ReadAckRegister;
+  UINT64                                                 ReadAckPreserve;
+  UINT64                                                 ReadAckWrite;
+} EFI_ACPI_6_1_GENERIC_HARDWARE_ERROR_SOURCE_VERSION_2_STRUCTURE;
+
+///
+/// Generic Error Status Definition
+///
+typedef struct {
+  EFI_ACPI_6_1_ERROR_BLOCK_STATUS              BlockStatus;
+  UINT32                                       RawDataOffset;
+  UINT32                                       RawDataLength;
+  UINT32                                       DataLength;
+  UINT32                                       ErrorSeverity;
+} EFI_ACPI_6_1_GENERIC_ERROR_STATUS_STRUCTURE;
+
+///
+/// ERST - Error Record Serialization Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      SerializationHeaderSize;
+  UINT8                       Reserved0[4];
+  UINT32                      InstructionEntryCount;
+} EFI_ACPI_6_1_ERROR_RECORD_SERIALIZATION_TABLE_HEADER;
+
+///
+/// ERST Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_ERROR_RECORD_SERIALIZATION_TABLE_REVISION 0x01
+
+///
+/// ERST Serialization Actions
+///
+#define EFI_ACPI_6_1_ERST_BEGIN_WRITE_OPERATION                    0x00
+#define EFI_ACPI_6_1_ERST_BEGIN_READ_OPERATION                     0x01
+#define EFI_ACPI_6_1_ERST_BEGIN_CLEAR_OPERATION                    0x02
+#define EFI_ACPI_6_1_ERST_END_OPERATION                            0x03
+#define EFI_ACPI_6_1_ERST_SET_RECORD_OFFSET                        0x04
+#define EFI_ACPI_6_1_ERST_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_6_1_ERST_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_6_1_ERST_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_6_1_ERST_GET_RECORD_IDENTIFIER                    0x08
+#define EFI_ACPI_6_1_ERST_SET_RECORD_IDENTIFIER                    0x09
+#define EFI_ACPI_6_1_ERST_GET_RECORD_COUNT                         0x0A
+#define EFI_ACPI_6_1_ERST_BEGIN_DUMMY_WRITE_OPERATION              0x0B
+#define EFI_ACPI_6_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE              0x0D
+#define EFI_ACPI_6_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE_LENGTH       0x0E
+#define EFI_ACPI_6_1_ERST_GET_ERROR_LOG_ADDRESS_RANGE_ATTRIBUTES   0x0F
+#define EFI_ACPI_6_1_ERST_GET_EXECUTE_OPERATION_TIMINGS            0x10
+
+///
+/// ERST Action Command Status
+///
+#define EFI_ACPI_6_1_ERST_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_6_1_ERST_STATUS_NOT_ENOUGH_SPACE                  0x01
+#define EFI_ACPI_6_1_ERST_STATUS_HARDWARE_NOT_AVAILABLE            0x02
+#define EFI_ACPI_6_1_ERST_STATUS_FAILED                            0x03
+#define EFI_ACPI_6_1_ERST_STATUS_RECORD_STORE_EMPTY                0x04
+#define EFI_ACPI_6_1_ERST_STATUS_RECORD_NOT_FOUND                  0x05
+
+///
+/// ERST Serialization Instructions
+///
+#define EFI_ACPI_6_1_ERST_READ_REGISTER                            0x00
+#define EFI_ACPI_6_1_ERST_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_6_1_ERST_WRITE_REGISTER                           0x02
+#define EFI_ACPI_6_1_ERST_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_6_1_ERST_NOOP                                     0x04
+#define EFI_ACPI_6_1_ERST_LOAD_VAR1                                0x05
+#define EFI_ACPI_6_1_ERST_LOAD_VAR2                                0x06
+#define EFI_ACPI_6_1_ERST_STORE_VAR1                               0x07
+#define EFI_ACPI_6_1_ERST_ADD                                      0x08
+#define EFI_ACPI_6_1_ERST_SUBTRACT                                 0x09
+#define EFI_ACPI_6_1_ERST_ADD_VALUE                                0x0A
+#define EFI_ACPI_6_1_ERST_SUBTRACT_VALUE                           0x0B
+#define EFI_ACPI_6_1_ERST_STALL                                    0x0C
+#define EFI_ACPI_6_1_ERST_STALL_WHILE_TRUE                         0x0D
+#define EFI_ACPI_6_1_ERST_SKIP_NEXT_INSTRUCTION_IF_TRUE            0x0E
+#define EFI_ACPI_6_1_ERST_GOTO                                     0x0F
+#define EFI_ACPI_6_1_ERST_SET_SRC_ADDRESS_BASE                     0x10
+#define EFI_ACPI_6_1_ERST_SET_DST_ADDRESS_BASE                     0x11
+#define EFI_ACPI_6_1_ERST_MOVE_DATA                                0x12
+
+///
+/// ERST Instruction Flags
+///
+#define EFI_ACPI_6_1_ERST_PRESERVE_REGISTER                        0x01
+
+///
+/// ERST Serialization Instruction Entry
+///
+typedef struct {
+  UINT8                                    SerializationAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_6_1_ERST_SERIALIZATION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ - Error Injection Table
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      InjectionHeaderSize;
+  UINT8                       InjectionFlags;
+  UINT8                       Reserved0[3];
+  UINT32                      InjectionEntryCount;
+} EFI_ACPI_6_1_ERROR_INJECTION_TABLE_HEADER;
+
+///
+/// EINJ Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_ERROR_INJECTION_TABLE_REVISION 0x01
+
+///
+/// EINJ Error Injection Actions
+///
+#define EFI_ACPI_6_1_EINJ_BEGIN_INJECTION_OPERATION                0x00
+#define EFI_ACPI_6_1_EINJ_GET_TRIGGER_ERROR_ACTION_TABLE           0x01
+#define EFI_ACPI_6_1_EINJ_SET_ERROR_TYPE                           0x02
+#define EFI_ACPI_6_1_EINJ_GET_ERROR_TYPE                           0x03
+#define EFI_ACPI_6_1_EINJ_END_OPERATION                            0x04
+#define EFI_ACPI_6_1_EINJ_EXECUTE_OPERATION                        0x05
+#define EFI_ACPI_6_1_EINJ_CHECK_BUSY_STATUS                        0x06
+#define EFI_ACPI_6_1_EINJ_GET_COMMAND_STATUS                       0x07
+#define EFI_ACPI_6_1_EINJ_TRIGGER_ERROR                            0xFF
+
+///
+/// EINJ Action Command Status
+///
+#define EFI_ACPI_6_1_EINJ_STATUS_SUCCESS                           0x00
+#define EFI_ACPI_6_1_EINJ_STATUS_UNKNOWN_FAILURE                   0x01
+#define EFI_ACPI_6_1_EINJ_STATUS_INVALID_ACCESS                    0x02
+
+///
+/// EINJ Error Type Definition
+///
+#define EFI_ACPI_6_1_EINJ_ERROR_PROCESSOR_CORRECTABLE                 (1 << 0)
+#define EFI_ACPI_6_1_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_NONFATAL      (1 << 1)
+#define EFI_ACPI_6_1_EINJ_ERROR_PROCESSOR_UNCORRECTABLE_FATAL         (1 << 2)
+#define EFI_ACPI_6_1_EINJ_ERROR_MEMORY_CORRECTABLE                    (1 << 3)
+#define EFI_ACPI_6_1_EINJ_ERROR_MEMORY_UNCORRECTABLE_NONFATAL         (1 << 4)
+#define EFI_ACPI_6_1_EINJ_ERROR_MEMORY_UNCORRECTABLE_FATAL            (1 << 5)
+#define EFI_ACPI_6_1_EINJ_ERROR_PCI_EXPRESS_CORRECTABLE               (1 << 6)
+#define EFI_ACPI_6_1_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_NONFATAL    (1 << 7)
+#define EFI_ACPI_6_1_EINJ_ERROR_PCI_EXPRESS_UNCORRECTABLE_FATAL       (1 << 8)
+#define EFI_ACPI_6_1_EINJ_ERROR_PLATFORM_CORRECTABLE                  (1 << 9)
+#define EFI_ACPI_6_1_EINJ_ERROR_PLATFORM_UNCORRECTABLE_NONFATAL       (1 << 10)
+#define EFI_ACPI_6_1_EINJ_ERROR_PLATFORM_UNCORRECTABLE_FATAL          (1 << 11)
+
+///
+/// EINJ Injection Instructions
+///
+#define EFI_ACPI_6_1_EINJ_READ_REGISTER                            0x00
+#define EFI_ACPI_6_1_EINJ_READ_REGISTER_VALUE                      0x01
+#define EFI_ACPI_6_1_EINJ_WRITE_REGISTER                           0x02
+#define EFI_ACPI_6_1_EINJ_WRITE_REGISTER_VALUE                     0x03
+#define EFI_ACPI_6_1_EINJ_NOOP                                     0x04
+
+///
+/// EINJ Instruction Flags
+///
+#define EFI_ACPI_6_1_EINJ_PRESERVE_REGISTER                        0x01
+
+///
+/// EINJ Injection Instruction Entry
+///
+typedef struct {
+  UINT8                                    InjectionAction;
+  UINT8                                    Instruction;
+  UINT8                                    Flags;
+  UINT8                                    Reserved0;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE   RegisterRegion;
+  UINT64                                   Value;
+  UINT64                                   Mask;
+} EFI_ACPI_6_1_EINJ_INJECTION_INSTRUCTION_ENTRY;
+
+///
+/// EINJ Trigger Action Table
+///
+typedef struct {
+  UINT32  HeaderSize;
+  UINT32  Revision;
+  UINT32  TableSize;
+  UINT32  EntryCount;
+} EFI_ACPI_6_1_EINJ_TRIGGER_ACTION_TABLE;
+
+///
+/// Platform Communications Channel Table (PCCT)
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      Flags;
+  UINT64                      Reserved;
+} EFI_ACPI_6_1_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER;
+
+///
+/// PCCT Version (as defined in ACPI 6.1 spec.)
+///
+#define EFI_ACPI_6_1_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION 0x01
+
+///
+/// PCCT Global Flags
+///
+#define EFI_ACPI_6_1_PCCT_FLAGS_SCI_DOORBELL                      BIT0
+
+//
+// PCCT Subspace type
+//
+#define EFI_ACPI_6_1_PCCT_SUBSPACE_TYPE_GENERIC  0x00
+
+///
+/// PCC Subspace Structure Header
+///
+typedef struct {
+  UINT8        Type;
+  UINT8        Length;
+} EFI_ACPI_6_1_PCCT_SUBSPACE_HEADER;
+
+///
+/// Generic Communications Subspace Structure
+///
+typedef struct {
+  UINT8                                    Type;
+  UINT8                                    Length;
+  UINT8                                    Reserved[6];
+  UINT64                                   BaseAddress;
+  UINT64                                   AddressLength;
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE   DoorbellRegister;
+  UINT64                                   DoorbellPreserve;
+  UINT64                                   DoorbellWrite;
+  UINT32                                   NominalLatency;
+  UINT32                                   MaximumPeriodicAccessRate;
+  UINT16                                   MinimumRequestTurnaroundTime;
+} EFI_ACPI_6_1_PCCT_SUBSPACE_GENERIC;
+
+///
+/// Generic Communications Channel Shared Memory Region
+///
+
+typedef struct {
+  UINT8                                    Command;
+  UINT8                                    Reserved:7;
+  UINT8                                    GenerateSci:1;
+} EFI_ACPI_6_1_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND;
+
+typedef struct {
+  UINT8                                    CommandComplete:1;
+  UINT8                                    SciDoorbell:1;
+  UINT8                                    Error:1;
+  UINT8                                    PlatformNotification:1;  
+  UINT8                                    Reserved:4;
+  UINT8                                    Reserved1;
+} EFI_ACPI_6_1_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS;
+
+typedef struct {
+  UINT32                                                    Signature;
+  EFI_ACPI_6_1_PCCT_GENERIC_SHARED_MEMORY_REGION_COMMAND    Command;
+  EFI_ACPI_6_1_PCCT_GENERIC_SHARED_MEMORY_REGION_STATUS     Status;
+} EFI_ACPI_6_1_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER;
+
+//
+// Known table signatures
+//
+
+///
+/// "RSD PTR " Root System Description Pointer
+///
+#define EFI_ACPI_6_1_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE  SIGNATURE_64('R', 'S', 'D', ' ', 'P', 'T', 'R', ' ') 
+
+///
+/// "APIC" Multiple APIC Description Table
+///
+#define EFI_ACPI_6_1_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('A', 'P', 'I', 'C')
+
+///
+/// "BERT" Boot Error Record Table
+///
+#define EFI_ACPI_6_1_BOOT_ERROR_RECORD_TABLE_SIGNATURE  SIGNATURE_32('B', 'E', 'R', 'T')
+
+///
+/// "BGRT" Boot Graphics Resource Table
+///
+#define EFI_ACPI_6_1_BOOT_GRAPHICS_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('B', 'G', 'R', 'T')
+
+///
+/// "CPEP" Corrected Platform Error Polling Table
+///
+#define EFI_ACPI_6_1_CORRECTED_PLATFORM_ERROR_POLLING_TABLE_SIGNATURE  SIGNATURE_32('C', 'P', 'E', 'P')
+
+///
+/// "DSDT" Differentiated System Description Table
+///
+#define EFI_ACPI_6_1_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('D', 'S', 'D', 'T')
+
+///
+/// "ECDT" Embedded Controller Boot Resources Table
+///
+#define EFI_ACPI_6_1_EMBEDDED_CONTROLLER_BOOT_RESOURCES_TABLE_SIGNATURE  SIGNATURE_32('E', 'C', 'D', 'T')
+
+///
+/// "EINJ" Error Injection Table
+///
+#define EFI_ACPI_6_1_ERROR_INJECTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'I', 'N', 'J')
+
+///
+/// "ERST" Error Record Serialization Table
+///
+#define EFI_ACPI_6_1_ERROR_RECORD_SERIALIZATION_TABLE_SIGNATURE  SIGNATURE_32('E', 'R', 'S', 'T')
+
+///
+/// "FACP" Fixed ACPI Description Table
+///
+#define EFI_ACPI_6_1_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'P')
+
+///
+/// "FACS" Firmware ACPI Control Structure
+///
+#define EFI_ACPI_6_1_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE  SIGNATURE_32('F', 'A', 'C', 'S')
+
+///
+/// "FPDT" Firmware Performance Data Table
+///
+#define EFI_ACPI_6_1_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE  SIGNATURE_32('F', 'P', 'D', 'T')
+
+///
+/// "GTDT" Generic Timer Description Table
+///
+#define EFI_ACPI_6_1_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('G', 'T', 'D', 'T')
+
+///
+/// "HEST" Hardware Error Source Table
+///
+#define EFI_ACPI_6_1_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE  SIGNATURE_32('H', 'E', 'S', 'T')
+
+///
+/// "MPST" Memory Power State Table
+///
+#define EFI_ACPI_6_1_MEMORY_POWER_STATE_TABLE_SIGNATURE  SIGNATURE_32('M', 'P', 'S', 'T')
+
+///
+/// "MSCT" Maximum System Characteristics Table
+///
+#define EFI_ACPI_6_1_MAXIMUM_SYSTEM_CHARACTERISTICS_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'C', 'T')
+
+///
+/// "NFIT" NVDIMM Firmware Interface Table
+///
+#define EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE  SIGNATURE_32('N', 'F', 'I', 'T')
+
+///
+/// "PMTT" Platform Memory Topology Table
+///
+#define EFI_ACPI_6_1_PLATFORM_MEMORY_TOPOLOGY_TABLE_SIGNATURE  SIGNATURE_32('P', 'M', 'T', 'T')
+
+///
+/// "PSDT" Persistent System Description Table
+///
+#define EFI_ACPI_6_1_PERSISTENT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('P', 'S', 'D', 'T')
+
+///
+/// "RASF" ACPI RAS Feature Table
+///
+#define EFI_ACPI_6_1_ACPI_RAS_FEATURE_TABLE_SIGNATURE  SIGNATURE_32('R', 'A', 'S', 'F')
+
+///
+/// "RSDT" Root System Description Table
+///
+#define EFI_ACPI_6_1_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('R', 'S', 'D', 'T')
+
+///
+/// "SBST" Smart Battery Specification Table
+///
+#define EFI_ACPI_6_1_SMART_BATTERY_SPECIFICATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'B', 'S', 'T')
+
+///
+/// "SLIT" System Locality Information Table
+///
+#define EFI_ACPI_6_1_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'T')
+
+///
+/// "SRAT" System Resource Affinity Table
+///
+#define EFI_ACPI_6_1_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE  SIGNATURE_32('S', 'R', 'A', 'T')
+
+///
+/// "SSDT" Secondary System Description Table
+///
+#define EFI_ACPI_6_1_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'S', 'D', 'T')
+
+///
+/// "XSDT" Extended System Description Table
+///
+#define EFI_ACPI_6_1_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('X', 'S', 'D', 'T')
+
+///
+/// "BOOT" MS Simple Boot Spec
+///
+#define EFI_ACPI_6_1_SIMPLE_BOOT_FLAG_TABLE_SIGNATURE  SIGNATURE_32('B', 'O', 'O', 'T')
+
+///
+/// "CSRT" MS Core System Resource Table
+///
+#define EFI_ACPI_6_1_CORE_SYSTEM_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('C', 'S', 'R', 'T')
+
+///
+/// "DBG2" MS Debug Port 2 Spec
+///
+#define EFI_ACPI_6_1_DEBUG_PORT_2_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', '2')
+
+///
+/// "DBGP" MS Debug Port Spec
+///
+#define EFI_ACPI_6_1_DEBUG_PORT_TABLE_SIGNATURE  SIGNATURE_32('D', 'B', 'G', 'P')
+
+///
+/// "DMAR" DMA Remapping Table
+///
+#define EFI_ACPI_6_1_DMA_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('D', 'M', 'A', 'R')
+
+///
+/// "DRTM" Dynamic Root of Trust for Measurement Table
+///
+#define EFI_ACPI_6_1_DYNAMIC_ROOT_OF_TRUST_FOR_MEASUREMENT_TABLE_SIGNATURE  SIGNATURE_32('D', 'R', 'T', 'M')
+
+///
+/// "ETDT" Event Timer Description Table
+///
+#define EFI_ACPI_6_1_EVENT_TIMER_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('E', 'T', 'D', 'T')
+
+///
+/// "HPET" IA-PC High Precision Event Timer Table
+///
+#define EFI_ACPI_6_1_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE  SIGNATURE_32('H', 'P', 'E', 'T')
+
+///
+/// "iBFT" iSCSI Boot Firmware Table
+///
+#define EFI_ACPI_6_1_ISCSI_BOOT_FIRMWARE_TABLE_SIGNATURE  SIGNATURE_32('i', 'B', 'F', 'T')
+
+///
+/// "IORT" I/O Remapping Table
+///
+#define EFI_ACPI_6_1_IO_REMAPPING_TABLE_SIGNATURE  SIGNATURE_32('I', 'O', 'R', 'T')
+
+///
+/// "IVRS" I/O Virtualization Reporting Structure
+///
+#define EFI_ACPI_6_1_IO_VIRTUALIZATION_REPORTING_STRUCTURE_SIGNATURE  SIGNATURE_32('I', 'V', 'R', 'S')
+
+///
+/// "LPIT" Low Power Idle Table
+///
+#define EFI_ACPI_6_1_LOW_POWER_IDLE_TABLE_STRUCTURE_SIGNATURE  SIGNATURE_32('L', 'P', 'I', 'T')
+
+///
+/// "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table
+///
+#define EFI_ACPI_6_1_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'F', 'G')
+
+///
+/// "MCHI" Management Controller Host Interface Table
+///
+#define EFI_ACPI_6_1_MANAGEMENT_CONTROLLER_HOST_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('M', 'C', 'H', 'I')
+
+///
+/// "MSDM" MS Data Management Table
+///
+#define EFI_ACPI_6_1_DATA_MANAGEMENT_TABLE_SIGNATURE  SIGNATURE_32('M', 'S', 'D', 'M')
+
+///
+/// "SLIC" MS Software Licensing Table Specification
+///
+#define EFI_ACPI_6_1_SOFTWARE_LICENSING_TABLE_SIGNATURE  SIGNATURE_32('S', 'L', 'I', 'C')
+
+///
+/// "SPCR" Serial Port Concole Redirection Table
+///
+#define EFI_ACPI_6_1_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'C', 'R')
+
+///
+/// "SPMI" Server Platform Management Interface Table
+///
+#define EFI_ACPI_6_1_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE  SIGNATURE_32('S', 'P', 'M', 'I')
+
+///
+/// "STAO" _STA Override Table
+///
+#define EFI_ACPI_6_1_STA_OVERRIDE_TABLE_SIGNATURE  SIGNATURE_32('S', 'T', 'A', 'O')
+
+///
+/// "TCPA" Trusted Computing Platform Alliance Capabilities Table
+///
+#define EFI_ACPI_6_1_TRUSTED_COMPUTING_PLATFORM_ALLIANCE_CAPABILITIES_TABLE_SIGNATURE  SIGNATURE_32('T', 'C', 'P', 'A')
+
+///
+/// "TPM2" Trusted Computing Platform 1 Table
+///
+#define EFI_ACPI_6_1_TRUSTED_COMPUTING_PLATFORM_2_TABLE_SIGNATURE  SIGNATURE_32('T', 'P', 'M', '2')
+
+///
+/// "UEFI" UEFI ACPI Data Table
+///
+#define EFI_ACPI_6_1_UEFI_ACPI_DATA_TABLE_SIGNATURE  SIGNATURE_32('U', 'E', 'F', 'I')
+
+///
+/// "WAET" Windows ACPI Emulated Devices Table
+///
+#define EFI_ACPI_6_1_WINDOWS_ACPI_EMULATED_DEVICES_TABLE_SIGNATURE  SIGNATURE_32('W', 'A', 'E', 'T')
+
+///
+/// "WDAT" Watchdog Action Table
+///
+#define EFI_ACPI_6_1_WATCHDOG_ACTION_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'A', 'T')
+
+///
+/// "WDRT" Watchdog Resource Table
+///
+#define EFI_ACPI_6_1_WATCHDOG_RESOURCE_TABLE_SIGNATURE  SIGNATURE_32('W', 'D', 'R', 'T')
+
+///
+/// "WPBT" MS Platform Binary Table
+///
+#define EFI_ACPI_6_1_PLATFORM_BINARY_TABLE_SIGNATURE  SIGNATURE_32('W', 'P', 'B', 'T')
+
+///
+/// "XENV" Xen Project Table
+///
+#define EFI_ACPI_6_1_XEN_PROJECT_TABLE_SIGNATURE  SIGNATURE_32('X', 'E', 'N', 'V')
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/AcpiAml.h b/MdePkg/Include/IndustryStandard/AcpiAml.h
new file mode 100644
index 000000000000..19d9684943eb
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/AcpiAml.h
@@ -0,0 +1,175 @@
+/** @file
+  This file contains AML code definition in the latest ACPI spec.
+
+  Copyright (c) 2011, 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 _ACPI_AML_H_
+#define _ACPI_AML_H_
+
+//
+// ACPI AML definition
+//
+
+//
+// Primary OpCode
+//
+#define AML_ZERO_OP                  0x00
+#define AML_ONE_OP                   0x01
+#define AML_ALIAS_OP                 0x06
+#define AML_NAME_OP                  0x08
+#define AML_BYTE_PREFIX              0x0a
+#define AML_WORD_PREFIX              0x0b
+#define AML_DWORD_PREFIX             0x0c
+#define AML_STRING_PREFIX            0x0d
+#define AML_QWORD_PREFIX             0x0e
+#define AML_SCOPE_OP                 0x10
+#define AML_BUFFER_OP                0x11
+#define AML_PACKAGE_OP               0x12
+#define AML_VAR_PACKAGE_OP           0x13
+#define AML_METHOD_OP                0x14
+#define AML_DUAL_NAME_PREFIX         0x2e
+#define AML_MULTI_NAME_PREFIX        0x2f
+#define AML_NAME_CHAR_A              0x41
+#define AML_NAME_CHAR_B              0x42
+#define AML_NAME_CHAR_C              0x43
+#define AML_NAME_CHAR_D              0x44
+#define AML_NAME_CHAR_E              0x45
+#define AML_NAME_CHAR_F              0x46
+#define AML_NAME_CHAR_G              0x47
+#define AML_NAME_CHAR_H              0x48
+#define AML_NAME_CHAR_I              0x49
+#define AML_NAME_CHAR_J              0x4a
+#define AML_NAME_CHAR_K              0x4b
+#define AML_NAME_CHAR_L              0x4c
+#define AML_NAME_CHAR_M              0x4d
+#define AML_NAME_CHAR_N              0x4e
+#define AML_NAME_CHAR_O              0x4f
+#define AML_NAME_CHAR_P              0x50
+#define AML_NAME_CHAR_Q              0x51
+#define AML_NAME_CHAR_R              0x52
+#define AML_NAME_CHAR_S              0x53
+#define AML_NAME_CHAR_T              0x54
+#define AML_NAME_CHAR_U              0x55
+#define AML_NAME_CHAR_V              0x56
+#define AML_NAME_CHAR_W              0x57
+#define AML_NAME_CHAR_X              0x58
+#define AML_NAME_CHAR_Y              0x59
+#define AML_NAME_CHAR_Z              0x5a
+#define AML_ROOT_CHAR                0x5c
+#define AML_PARENT_PREFIX_CHAR       0x5e
+#define AML_NAME_CHAR__              0x5f
+#define AML_LOCAL0                   0x60
+#define AML_LOCAL1                   0x61
+#define AML_LOCAL2                   0x62
+#define AML_LOCAL3                   0x63
+#define AML_LOCAL4                   0x64
+#define AML_LOCAL5                   0x65
+#define AML_LOCAL6                   0x66
+#define AML_LOCAL7                   0x67
+#define AML_ARG0                     0x68
+#define AML_ARG1                     0x69
+#define AML_ARG2                     0x6a
+#define AML_ARG3                     0x6b
+#define AML_ARG4                     0x6c
+#define AML_ARG5                     0x6d
+#define AML_ARG6                     0x6e
+#define AML_STORE_OP                 0x70
+#define AML_REF_OF_OP                0x71
+#define AML_ADD_OP                   0x72
+#define AML_CONCAT_OP                0x73
+#define AML_SUBTRACT_OP              0x74
+#define AML_INCREMENT_OP             0x75
+#define AML_DECREMENT_OP             0x76
+#define AML_MULTIPLY_OP              0x77
+#define AML_DIVIDE_OP                0x78
+#define AML_SHIFT_LEFT_OP            0x79
+#define AML_SHIFT_RIGHT_OP           0x7a
+#define AML_AND_OP                   0x7b
+#define AML_NAND_OP                  0x7c
+#define AML_OR_OP                    0x7d
+#define AML_NOR_OP                   0x7e
+#define AML_XOR_OP                   0x7f
+#define AML_NOT_OP                   0x80
+#define AML_FIND_SET_LEFT_BIT_OP     0x81
+#define AML_FIND_SET_RIGHT_BIT_OP    0x82
+#define AML_DEREF_OF_OP              0x83
+#define AML_CONCAT_RES_OP            0x84
+#define AML_MOD_OP                   0x85
+#define AML_NOTIFY_OP                0x86
+#define AML_SIZE_OF_OP               0x87
+#define AML_INDEX_OP                 0x88
+#define AML_MATCH_OP                 0x89
+#define AML_CREATE_DWORD_FIELD_OP    0x8a
+#define AML_CREATE_WORD_FIELD_OP     0x8b
+#define AML_CREATE_BYTE_FIELD_OP     0x8c
+#define AML_CREATE_BIT_FIELD_OP      0x8d
+#define AML_OBJECT_TYPE_OP           0x8e
+#define AML_CREATE_QWORD_FIELD_OP    0x8f
+#define AML_LAND_OP                  0x90
+#define AML_LOR_OP                   0x91
+#define AML_LNOT_OP                  0x92
+#define AML_LEQUAL_OP                0x93
+#define AML_LGREATER_OP              0x94
+#define AML_LLESS_OP                 0x95
+#define AML_TO_BUFFER_OP             0x96
+#define AML_TO_DEC_STRING_OP         0x97
+#define AML_TO_HEX_STRING_OP         0x98
+#define AML_TO_INTEGER_OP            0x99
+#define AML_TO_STRING_OP             0x9c
+#define AML_COPY_OBJECT_OP           0x9d
+#define AML_MID_OP                   0x9e
+#define AML_CONTINUE_OP              0x9f
+#define AML_IF_OP                    0xa0
+#define AML_ELSE_OP                  0xa1
+#define AML_WHILE_OP                 0xa2
+#define AML_NOOP_OP                  0xa3
+#define AML_RETURN_OP                0xa4
+#define AML_BREAK_OP                 0xa5
+#define AML_BREAK_POINT_OP           0xcc
+#define AML_ONES_OP                  0xff
+
+//
+// Extended OpCode
+//
+#define AML_EXT_OP                   0x5b
+
+#define AML_EXT_MUTEX_OP             0x01
+#define AML_EXT_EVENT_OP             0x02
+#define AML_EXT_COND_REF_OF_OP       0x12
+#define AML_EXT_CREATE_FIELD_OP      0x13
+#define AML_EXT_LOAD_TABLE_OP        0x1f
+#define AML_EXT_LOAD_OP              0x20
+#define AML_EXT_STALL_OP             0x21
+#define AML_EXT_SLEEP_OP             0x22
+#define AML_EXT_ACQUIRE_OP           0x23
+#define AML_EXT_SIGNAL_OP            0x24
+#define AML_EXT_WAIT_OP              0x25
+#define AML_EXT_RESET_OP             0x26
+#define AML_EXT_RELEASE_OP           0x27
+#define AML_EXT_FROM_BCD_OP          0x28
+#define AML_EXT_TO_BCD_OP            0x29
+#define AML_EXT_UNLOAD_OP            0x2a
+#define AML_EXT_REVISION_OP          0x30
+#define AML_EXT_DEBUG_OP             0x31
+#define AML_EXT_FATAL_OP             0x32
+#define AML_EXT_TIMER_OP             0x33
+#define AML_EXT_REGION_OP            0x80
+#define AML_EXT_FIELD_OP             0x81
+#define AML_EXT_DEVICE_OP            0x82
+#define AML_EXT_PROCESSOR_OP         0x83
+#define AML_EXT_POWER_RES_OP         0x84
+#define AML_EXT_THERMAL_ZONE_OP      0x85
+#define AML_EXT_INDEX_FIELD_OP       0x86
+#define AML_EXT_BANK_FIELD_OP        0x87
+#define AML_EXT_DATA_REGION_OP       0x88
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/AlertStandardFormatTable.h b/MdePkg/Include/IndustryStandard/AlertStandardFormatTable.h
new file mode 100644
index 000000000000..e7658541a3e4
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/AlertStandardFormatTable.h
@@ -0,0 +1,146 @@
+/** @file   
+  ACPI Alert Standard Format Description Table ASF! as described in the ASF2.0 Specification
+
+  Copyright (c) 2006 - 2008, 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 _ALERT_STANDARD_FORMAT_TABLE_H_
+#define _ALERT_STANDARD_FORMAT_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack (1)
+
+///
+/// Information Record header that appears at the beginning of each record
+///
+typedef struct {
+  UINT8                                Type;
+  UINT8                                Reserved;
+  UINT16                               RecordLength;
+} EFI_ACPI_ASF_RECORD_HEADER;
+
+///
+/// This structure contains information that identifies the system's type 
+/// and configuration
+///
+typedef struct {
+  EFI_ACPI_ASF_RECORD_HEADER           RecordHeader;
+  UINT8                                MinWatchDogResetValue;
+  UINT8                                MinPollingInterval;
+  UINT16                               SystemID;
+  UINT32                               IANAManufactureID;
+  UINT8                                FeatureFlags;
+  UINT8                                Reserved[3];
+} EFI_ACPI_ASF_INFO;
+
+///
+/// ASF Alert Data
+///
+typedef struct {
+  UINT8                                DeviceAddress;
+  UINT8                                Command;
+  UINT8                                DataMask;
+  UINT8                                CompareValue;
+  UINT8                                EventSenseType;
+  UINT8                                EventType;
+  UINT8                                EventOffset;
+  UINT8                                EventSourceType;
+  UINT8                                EventSeverity;
+  UINT8                                SensorNumber;
+  UINT8                                Entity;
+  UINT8                                EntityInstance;
+} EFI_ACPI_ASF_ALERTDATA;
+
+///
+/// Alert sensors definition
+///
+typedef struct {
+  EFI_ACPI_ASF_RECORD_HEADER           RecordHeader;
+  UINT8                                AssertionEventBitMask;
+  UINT8                                DeassertionEventBitMask;
+  UINT8                                NumberOfAlerts;
+  UINT8                                ArrayElementLength; ///< For ASF version 1.0 and later, this filed is set to 0x0C
+  ///
+  /// EFI_ACPI_ASF_ALERTDATA           DeviceArray[ANYSIZE_ARRAY];
+  ///
+} EFI_ACPI_ASF_ALRT;
+
+///
+/// Alert Control Data
+///
+typedef struct {
+  UINT8                                Function;
+  UINT8                                DeviceAddress;
+  UINT8                                Command;
+  UINT8                                DataValue;
+} EFI_ACPI_ASF_CONTROLDATA;       
+
+///
+/// Alert Remote Control System Actions
+///
+typedef struct {
+  EFI_ACPI_ASF_RECORD_HEADER           RecordHeader;
+  UINT8                                NumberOfControls;
+  UINT8                                ArrayElementLength; ///< For ASF version 1.0 and later, this filed is set to 0x4
+  UINT16                               RctlReserved;
+  ///
+  /// EFI_ACPI_ASF_CONTROLDATA;        DeviceArray[ANYSIZE_ARRAY];
+  ///
+} EFI_ACPI_ASF_RCTL;
+
+
+///
+/// Remote Control Capabilities
+///
+typedef struct {
+  EFI_ACPI_ASF_RECORD_HEADER           RecordHeader;
+  UINT8                                RemoteControlCapabilities[7];
+  UINT8                                RMCPCompletionCode;
+  UINT32                               RMCPIANA;
+  UINT8                                RMCPSpecialCommand;
+  UINT8                                RMCPSpecialCommandParameter[2];
+  UINT8                                RMCPBootOptions[2];
+  UINT8                                RMCPOEMParameters[2];
+} EFI_ACPI_ASF_RMCP;
+
+///
+/// SMBus Devices with fixed addresses
+///
+typedef struct {
+  EFI_ACPI_ASF_RECORD_HEADER           RecordHeader;
+  UINT8                                SEEPROMAddress;
+  UINT8                                NumberOfDevices;
+  ///
+  /// UINT8                            FixedSmbusAddresses[ANYSIZE_ARRAY];
+  ///
+} EFI_ACPI_ASF_ADDR;
+
+///
+/// ASF! Description Table Header
+///
+typedef EFI_ACPI_DESCRIPTION_HEADER EFI_ACPI_ASF_DESCRIPTION_HEADER;
+
+///
+/// The revision stored in ASF! DESCRIPTION TABLE as BCD value
+///
+#define EFI_ACPI_2_0_ASF_DESCRIPTION_TABLE_REVISION   0x20
+
+///
+/// "ASF!" ASF Description Table Signature
+///
+#define EFI_ACPI_ASF_DESCRIPTION_TABLE_SIGNATURE  SIGNATURE_32 ('A', 'S', 'F', '!')
+
+#pragma pack ()
+
+#endif // _ALERT_STANDARD_FORMAT_TABLE_H
diff --git a/MdePkg/Include/IndustryStandard/Atapi.h b/MdePkg/Include/IndustryStandard/Atapi.h
new file mode 100644
index 000000000000..cb1fae429f09
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Atapi.h
@@ -0,0 +1,857 @@
+/** @file
+  This file contains just some basic definitions that are needed by drivers
+  that dealing with ATA/ATAPI interface.
+
+Copyright (c) 2007 - 2016, 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 _ATAPI_H_
+#define _ATAPI_H_
+
+#pragma pack(1)
+
+///
+/// ATA5_IDENTIFY_DATA is defined in ATA-5.
+/// (This structure is provided mainly for backward-compatibility support.
+/// Old drivers may reference fields that are marked "obsolete" in 
+/// ATA_IDENTIFY_DATA, which currently conforms to ATA-8.) 
+///
+typedef struct {    
+  UINT16  config;             ///< General Configuration.
+  UINT16  cylinders;          ///< Number of Cylinders.
+  UINT16  reserved_2; 
+  UINT16  heads;              ///< Number of logical heads. 
+  UINT16  vendor_data1; 
+  UINT16  vendor_data2; 
+  UINT16  sectors_per_track; 
+  UINT16  vendor_specific_7_9[3]; 
+  CHAR8   SerialNo[20];       ///< ASCII  
+  UINT16  vendor_specific_20_21[2];  
+  UINT16  ecc_bytes_available;    
+  CHAR8   FirmwareVer[8];     ///< ASCII  
+  CHAR8   ModelName[40];      ///< ASCII    
+  UINT16  multi_sector_cmd_max_sct_cnt; 
+  UINT16  reserved_48; 
+  UINT16  capabilities; 
+  UINT16  reserved_50;     
+  UINT16  pio_cycle_timing;    
+  UINT16  reserved_52;             
+  UINT16  field_validity;     
+  UINT16  current_cylinders; 
+  UINT16  current_heads; 
+  UINT16  current_sectors;    
+  UINT16  CurrentCapacityLsb; 
+  UINT16  CurrentCapacityMsb;     
+  UINT16  reserved_59;     
+  UINT16  user_addressable_sectors_lo; 
+  UINT16  user_addressable_sectors_hi; 
+  UINT16  reserved_62;     
+  UINT16  multi_word_dma_mode;    
+  UINT16  advanced_pio_modes; 
+  UINT16  min_multi_word_dma_cycle_time; 
+  UINT16  rec_multi_word_dma_cycle_time; 
+  UINT16  min_pio_cycle_time_without_flow_control; 
+  UINT16  min_pio_cycle_time_with_flow_control; 
+  UINT16  reserved_69_79[11];     
+  UINT16  major_version_no; 
+  UINT16  minor_version_no; 
+  UINT16  command_set_supported_82;    ///< word 82 
+  UINT16  command_set_supported_83;    ///< word 83 
+  UINT16  command_set_feature_extn;    ///< word 84 
+  UINT16  command_set_feature_enb_85;  ///< word 85 
+  UINT16  command_set_feature_enb_86;  ///< word 86 
+  UINT16  command_set_feature_default; ///< word 87 
+  UINT16  ultra_dma_mode;              ///< word 88 
+  UINT16  reserved_89_127[39]; 
+  UINT16  security_status; 
+  UINT16  vendor_data_129_159[31]; 
+  UINT16  reserved_160_255[96]; 
+} ATA5_IDENTIFY_DATA;
+
+///
+/// ATA_IDENTIFY_DATA strictly complies with ATA/ATAPI-8 Spec
+/// to define the data returned by an ATA device upon successful
+/// completion of the ATA IDENTIFY_DEVICE command.
+///
+typedef struct {
+  UINT16  config;                                  ///< General Configuration.
+  UINT16  obsolete_1;
+  UINT16  specific_config;                         ///< Specific Configuration.
+  UINT16  obsolete_3;
+  UINT16  retired_4_5[2]; 
+  UINT16  obsolete_6;
+  UINT16  cfa_reserved_7_8[2];
+  UINT16  retired_9; 
+  CHAR8   SerialNo[20];                            ///< word 10~19
+  UINT16  retired_20_21[2];  
+  UINT16  obsolete_22;    
+  CHAR8   FirmwareVer[8];                          ///< word 23~26
+  CHAR8   ModelName[40];                           ///< word 27~46
+  UINT16  multi_sector_cmd_max_sct_cnt;
+  UINT16  trusted_computing_support; 
+  UINT16  capabilities_49;
+  UINT16  capabilities_50;
+  UINT16  obsolete_51_52[2];           
+  UINT16  field_validity;     
+  UINT16  obsolete_54_58[5];     
+  UINT16  multi_sector_setting;
+  UINT16  user_addressable_sectors_lo; 
+  UINT16  user_addressable_sectors_hi; 
+  UINT16  obsolete_62;     
+  UINT16  multi_word_dma_mode;    
+  UINT16  advanced_pio_modes; 
+  UINT16  min_multi_word_dma_cycle_time; 
+  UINT16  rec_multi_word_dma_cycle_time; 
+  UINT16  min_pio_cycle_time_without_flow_control; 
+  UINT16  min_pio_cycle_time_with_flow_control; 
+  UINT16  additional_supported;                    ///< word 69
+  UINT16  reserved_70;
+  UINT16  reserved_71_74[4];                       ///< Reserved for IDENTIFY PACKET DEVICE cmd.
+  UINT16  queue_depth;     
+  UINT16  serial_ata_capabilities;
+  UINT16  reserved_77;                             ///< Reserved for Serial ATA
+  UINT16  serial_ata_features_supported;
+  UINT16  serial_ata_features_enabled;
+  UINT16  major_version_no; 
+  UINT16  minor_version_no; 
+  UINT16  command_set_supported_82;                ///< word 82
+  UINT16  command_set_supported_83;                ///< word 83
+  UINT16  command_set_feature_extn;                ///< word 84
+  UINT16  command_set_feature_enb_85;              ///< word 85
+  UINT16  command_set_feature_enb_86;              ///< word 86
+  UINT16  command_set_feature_default;             ///< word 87
+  UINT16  ultra_dma_mode;                          ///< word 88 
+  UINT16  time_for_security_erase_unit; 
+  UINT16  time_for_enhanced_security_erase_unit;
+  UINT16  advanced_power_management_level;
+  UINT16  master_password_identifier;
+  UINT16  hardware_configuration_test_result;
+  UINT16  obsolete_94;
+  UINT16  stream_minimum_request_size;
+  UINT16  streaming_transfer_time_for_dma;
+  UINT16  streaming_access_latency_for_dma_and_pio;
+  UINT16  streaming_performance_granularity[2];    ///< word 98~99
+  UINT16  maximum_lba_for_48bit_addressing[4];     ///< word 100~103
+  UINT16  streaming_transfer_time_for_pio;
+  UINT16  max_no_of_512byte_blocks_per_data_set_cmd;
+  UINT16  phy_logic_sector_support;                ///< word 106
+  UINT16  interseek_delay_for_iso7779;
+  UINT16  world_wide_name[4];                      ///< word 108~111
+  UINT16  reserved_for_128bit_wwn_112_115[4];
+  UINT16  reserved_for_technical_report;
+  UINT16  logic_sector_size_lo;                    ///< word 117
+  UINT16  logic_sector_size_hi;                    ///< word 118
+  UINT16  features_and_command_sets_supported_ext; ///< word 119
+  UINT16  features_and_command_sets_enabled_ext;   ///< word 120
+  UINT16  reserved_121_126[6];
+  UINT16  obsolete_127;
+  UINT16  security_status;                         ///< word 128
+  UINT16  vendor_specific_129_159[31]; 
+  UINT16  cfa_power_mode;                          ///< word 160
+  UINT16  reserved_for_compactflash_161_167[7];
+  UINT16  device_nominal_form_factor;
+  UINT16  is_data_set_cmd_supported;
+  CHAR8   additional_product_identifier[8];
+  UINT16  reserved_174_175[2];
+  CHAR8   media_serial_number[60];                 ///< word 176~205
+  UINT16  sct_command_transport;                   ///< word 206
+  UINT16  reserved_207_208[2];
+  UINT16  alignment_logic_in_phy_blocks;           ///< word 209
+  UINT16  write_read_verify_sector_count_mode3[2]; ///< word 210~211
+  UINT16  verify_sector_count_mode2[2];
+  UINT16  nv_cache_capabilities;
+  UINT16  nv_cache_size_in_logical_block_lsw;      ///< word 215
+  UINT16  nv_cache_size_in_logical_block_msw;      ///< word 216
+  UINT16  nominal_media_rotation_rate;
+  UINT16  reserved_218;
+  UINT16  nv_cache_options;                        ///< word 219
+  UINT16  write_read_verify_mode;                  ///< word 220
+  UINT16  reserved_221;
+  UINT16  transport_major_revision_number;
+  UINT16  transport_minor_revision_number;
+  UINT16  reserved_224_229[6];
+  UINT64  extended_no_of_addressable_sectors;
+  UINT16  min_number_per_download_microcode_mode3; ///< word 234
+  UINT16  max_number_per_download_microcode_mode3; ///< word 235
+  UINT16  reserved_236_254[19];
+  UINT16  integrity_word;
+} ATA_IDENTIFY_DATA;
+
+///
+/// ATAPI_IDENTIFY_DATA strictly complies with ATA/ATAPI-8 Spec
+/// to define the data returned by an ATAPI device upon successful
+/// completion of the ATA IDENTIFY_PACKET_DEVICE command.
+///
+typedef struct {
+  UINT16  config;                                  ///< General Configuration.
+  UINT16  reserved_1;
+  UINT16  specific_config;                         ///< Specific Configuration.
+  UINT16  reserved_3_9[7];
+  CHAR8   SerialNo[20];                            ///< word 10~19
+  UINT16  reserved_20_22[3];
+  CHAR8   FirmwareVer[8];                          ///< word 23~26
+  CHAR8   ModelName[40];                           ///< word 27~46
+  UINT16  reserved_47_48[2];
+  UINT16  capabilities_49;
+  UINT16  capabilities_50;
+  UINT16  obsolete_51;
+  UINT16  reserved_52;
+  UINT16  field_validity;                          ///< word 53
+  UINT16  reserved_54_61[8];
+  UINT16  dma_dir;
+  UINT16  multi_word_dma_mode;                     ///< word 63
+  UINT16  advanced_pio_modes;                      ///< word 64
+  UINT16  min_multi_word_dma_cycle_time;
+  UINT16  rec_multi_word_dma_cycle_time;
+  UINT16  min_pio_cycle_time_without_flow_control;
+  UINT16  min_pio_cycle_time_with_flow_control;
+  UINT16  reserved_69_70[2];
+  UINT16  obsolete_71_72[2];
+  UINT16  reserved_73_74[2];
+  UINT16  obsolete_75;
+  UINT16  serial_ata_capabilities;
+  UINT16  reserved_77;                             ///< Reserved for Serial ATA
+  UINT16  serial_ata_features_supported;
+  UINT16  serial_ata_features_enabled;
+  UINT16  major_version_no;                        ///< word 80
+  UINT16  minor_version_no;                        ///< word 81
+  UINT16  cmd_set_support_82;
+  UINT16  cmd_set_support_83;
+  UINT16  cmd_feature_support;
+  UINT16  cmd_feature_enable_85;
+  UINT16  cmd_feature_enable_86;
+  UINT16  cmd_feature_default;
+  UINT16  ultra_dma_select;
+  UINT16  time_required_for_sec_erase;             ///< word 89
+  UINT16  time_required_for_enhanced_sec_erase;    ///< word 90
+  UINT16  advanced_power_management_level;
+  UINT16  master_pwd_revison_code;
+  UINT16  hardware_reset_result;                   ///< word 93
+  UINT16  obsolete_94;
+  UINT16  reserved_95_107[13];
+  UINT16  world_wide_name[4];                      ///< word 108~111
+  UINT16  reserved_for_128bit_wwn_112_115[4];
+  UINT16  reserved_116_118[3];  
+  UINT16  command_and_feature_sets_supported;      ///< word 119
+  UINT16  command_and_feature_sets_supported_enabled;
+  UINT16  reserved_121_124[4];
+  UINT16  atapi_byte_count_0_behavior;             ///< word 125
+  UINT16  obsolete_126_127[2];
+  UINT16  security_status;
+  UINT16  reserved_129_159[31];
+  UINT16  cfa_reserved_160_175[16];
+  UINT16  reserved_176_221[46];
+  UINT16  transport_major_version;
+  UINT16  transport_minor_version;
+  UINT16  reserved_224_254[31];
+  UINT16  integrity_word;
+} ATAPI_IDENTIFY_DATA;
+
+
+///
+/// Standard Quiry Data format, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 peripheral_type;
+  UINT8 RMB;
+  UINT8 version;
+  UINT8 response_data_format;
+  UINT8 addnl_length;     ///< n - 4, Numbers of bytes following this one.
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 reserved_7;
+  UINT8 vendor_info[8];
+  UINT8 product_id[16];
+  UINT8 product_revision_level[4];
+  UINT8 vendor_specific_36_55[55 - 36 + 1];
+  UINT8 reserved_56_95[95 - 56 + 1];
+  ///
+  /// Vendor-specific parameters fields. The sizeof (ATAPI_INQUIRY_DATA) is 254
+  /// since allocation_length is one byte in ATAPI_INQUIRY_CMD.
+  ///
+  UINT8 vendor_specific_96_253[253 - 96 + 1];
+} ATAPI_INQUIRY_DATA;
+
+///
+/// Request Sense Standard Data, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 error_code : 7;
+  UINT8 valid : 1;
+  UINT8 reserved_1;
+  UINT8 sense_key : 4;
+  UINT8 reserved_2 : 1;
+  UINT8 Vendor_specifc_1 : 3;
+  UINT8 vendor_specific_3;
+  UINT8 vendor_specific_4;
+  UINT8 vendor_specific_5;
+  UINT8 vendor_specific_6;
+  UINT8 addnl_sense_length;           ///< n - 7
+  UINT8 vendor_specific_8;
+  UINT8 vendor_specific_9;
+  UINT8 vendor_specific_10;
+  UINT8 vendor_specific_11;
+  UINT8 addnl_sense_code;             ///< mandatory
+  UINT8 addnl_sense_code_qualifier;   ///< mandatory
+  UINT8 field_replaceable_unit_code;  ///< optional
+  UINT8 sense_key_specific_15 : 7;
+  UINT8 SKSV : 1;
+  UINT8 sense_key_specific_16;
+  UINT8 sense_key_specific_17;
+} ATAPI_REQUEST_SENSE_DATA;
+
+///
+/// READ CAPACITY Data, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 LastLba3;
+  UINT8 LastLba2;
+  UINT8 LastLba1;
+  UINT8 LastLba0;
+  UINT8 BlockSize3;
+  UINT8 BlockSize2;
+  UINT8 BlockSize1;
+  UINT8 BlockSize0;
+} ATAPI_READ_CAPACITY_DATA;
+
+///
+/// Capacity List Header + Current/Maximum Capacity Descriptor,
+/// defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 reserved_0;
+  UINT8 reserved_1;
+  UINT8 reserved_2;
+  UINT8 Capacity_Length;
+  UINT8 LastLba3;
+  UINT8 LastLba2;
+  UINT8 LastLba1;
+  UINT8 LastLba0;
+  UINT8 DesCode : 2;
+  UINT8 reserved_9 : 6;
+  UINT8 BlockSize2;
+  UINT8 BlockSize1;
+  UINT8 BlockSize0;
+} ATAPI_READ_FORMAT_CAPACITY_DATA;
+
+///
+/// Test Unit Ready Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1;
+  UINT8 reserved_2;
+  UINT8 reserved_3;
+  UINT8 reserved_4;
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 reserved_7;
+  UINT8 reserved_8;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_TEST_UNIT_READY_CMD;
+
+///
+/// INQUIRY Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1 : 5;
+  UINT8 lun : 3;
+  UINT8 page_code;        ///< defined in SFF8090i, V6
+  UINT8 reserved_3;
+  UINT8 allocation_length;
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 reserved_7;
+  UINT8 reserved_8;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_INQUIRY_CMD;
+
+///
+/// REQUEST SENSE Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1 : 5;
+  UINT8 lun : 3;
+  UINT8 reserved_2;
+  UINT8 reserved_3;
+  UINT8 allocation_length;
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 reserved_7;
+  UINT8 reserved_8;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_REQUEST_SENSE_CMD;
+
+///
+/// READ (10) Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1 : 5;
+  UINT8 lun : 3;
+  UINT8 Lba0;
+  UINT8 Lba1;
+  UINT8 Lba2;
+  UINT8 Lba3;
+  UINT8 reserved_6;
+  UINT8 TranLen0;
+  UINT8 TranLen1;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_READ10_CMD;
+
+///
+/// READ Format Capacity Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1 : 5;
+  UINT8 lun : 3;
+  UINT8 reserved_2;
+  UINT8 reserved_3;
+  UINT8 reserved_4;
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 allocation_length_hi;
+  UINT8 allocation_length_lo;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_READ_FORMAT_CAP_CMD;
+
+///
+/// MODE SENSE Command, defined in SFF-8070i(ATAPI Removable Rewritable Specification).
+///
+typedef struct {
+  UINT8 opcode;
+  UINT8 reserved_1 : 5;
+  UINT8 lun : 3;
+  UINT8 page_code : 6;
+  UINT8 page_control : 2;
+  UINT8 reserved_3;
+  UINT8 reserved_4;
+  UINT8 reserved_5;
+  UINT8 reserved_6;
+  UINT8 parameter_list_length_hi;
+  UINT8 parameter_list_length_lo;
+  UINT8 reserved_9;
+  UINT8 reserved_10;
+  UINT8 reserved_11;
+} ATAPI_MODE_SENSE_CMD;
+
+///
+/// ATAPI_PACKET_COMMAND is not defined in the ATA specification.
+/// We add it here for the convenience of ATA/ATAPI module writers. 
+///
+typedef union {
+  UINT16                    Data16[6];
+  ATAPI_TEST_UNIT_READY_CMD TestUnitReady;
+  ATAPI_READ10_CMD          Read10;
+  ATAPI_REQUEST_SENSE_CMD   RequestSence;
+  ATAPI_INQUIRY_CMD         Inquiry;
+  ATAPI_MODE_SENSE_CMD      ModeSense;
+  ATAPI_READ_FORMAT_CAP_CMD ReadFormatCapacity;
+} ATAPI_PACKET_COMMAND;
+
+#pragma pack()
+
+
+#define ATAPI_MAX_DMA_EXT_CMD_SECTORS                   0x10000
+#define ATAPI_MAX_DMA_CMD_SECTORS                       0x100
+
+//  ATA/ATAPI Signature equates
+#define ATA_SIGNATURE                                   0x0101       ///< defined in ACS-3  
+#define ATAPI_SIGNATURE                                 0xeb14       ///< defined in ACS-3
+#define ATAPI_SIGNATURE_32                              0xeb140101   ///< defined in ACS-3
+
+//  Spin Up Configuration definitions
+#define ATA_SPINUP_CFG_REQUIRED_IDD_INCOMPLETE          0x37c8   ///< defined in ACS-3
+#define ATA_SPINUP_CFG_REQUIRED_IDD_COMPLETE            0x738c   ///< defined in ACS-3
+#define ATA_SPINUP_CFG_NOT_REQUIRED_IDD_INCOMPLETE      0x8c73   ///< defined in ACS-3
+#define ATA_SPINUP_CFG_NOT_REQUIRED_IDD_COMPLETE        0xc837   ///< defined in ACS-3
+
+//
+// ATA Packet Command Code
+//
+#define ATA_CMD_FORMAT_UNIT                             0x04   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_SOFT_RESET                              0x08   ///< defined from ATA-3
+#define ATA_CMD_PACKET                                  0xA0   ///< defined from ATA-3
+#define ATA_CMD_IDENTIFY_DEVICE                         0xA1   ///< defined from ATA-3
+#define ATA_CMD_SERVICE                                 0xA2   ///< defined from ATA-3
+#define ATA_CMD_TEST_UNIT_READY                         0x00   ///< defined from ATA-1
+#define ATA_CMD_REQUEST_SENSE                           0x03   ///< defined from ATA-4
+#define ATA_CMD_INQUIRY                                 0x12   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_READ_FORMAT_CAPACITY                    0x23   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_READ_CAPACITY                           0x25   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_READ_10                                 0x28   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_WRITE_10                                0x2A   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_ATAPI_SEEK                              0x2B   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_WRITE_AND_VERIFY                        0x2E   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_VERIFY                                  0x2F   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_READ_12                                 0xA8   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_WRITE_12                                0xAA   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_START_STOP_UNIT                         0x1B   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_PREVENT_ALLOW_MEDIA_REMOVAL             0x1E   ///< defined in ATAPI Removable Rewritable Media Devcies
+#define ATA_CMD_MODE_SELECT                             0x55   ///< defined in ATAPI Removable Rewritable Media Devcies
+
+#define ATA_CMD_MODE_SENSE                              0x5A   ///< defined in ATAPI Removable Rewritable Media Devcies
+    #define ATA_PAGE_CODE_READ_WRITE_ERROR                  0x01   ///< defined in ATAPI Removable Rewritable Media Devcies
+    #define ATA_PAGE_CODE_CACHING_PAGE                      0x08   ///< defined in ATAPI Removable Rewritable Media Devcies
+    #define ATA_PAGE_CODE_REMOVABLE_BLOCK_CAPABILITIES      0x1B   ///< defined in ATAPI Removable Rewritable Media Devcies
+    #define ATA_PAGE_CODE_TIMER_PROTECT_PAGE                0x1C   ///< defined in ATAPI Removable Rewritable Media Devcies
+    #define ATA_PAGE_CODE_RETURN_ALL_PAGES                  0x3F   ///< defined in ATAPI Removable Rewritable Media Devcies
+
+#define ATA_CMD_GET_CONFIGURATION                       0x46   ///< defined in ATAPI Multimedia Devices
+   #define ATA_GCCD_RT_FIELD_VALUE_ALL                      0x00   ///< defined in ATAPI Multimedia Devices
+   #define ATA_GCCD_RT_FIELD_VALUE_CURRENT                  0x01   ///< defined in ATAPI Multimedia Devices
+   #define ATA_GCCD_RT_FIELD_VALUE_SINGLE                   0x02   ///< defined in ATAPI Multimedia Devices 
+   #define ATA_GCCD_RT_FIELD_VALUE_RESERVED                 0x03   ///< defined in ATAPI Multimedia Devices 
+   
+   #define ATA_FEATURE_LIST_PROFILE_LIST                    0x0000   ///< defined in ATAPI Multimedia Devices
+   #define ATA_FEATURE_LIST_CORE                            0x0001   ///< defined in ATAPI Multimedia Devices   
+   #define ATA_FEATURE_LIST_MORPHING                        0x0002   ///< defined in ATAPI Multimedia Devices
+   #define ATA_FEATURE_LIST_REMOVEABLE_MEDIUM               0x0003   ///< defined in ATAPI Multimedia Devices
+   #define ATA_FEATURE_LIST_WRITE_PROTECT                   0x0004   ///< defined in ATAPI Multimedia Devices
+
+///
+/// Start/Stop and Eject Operations
+///
+///@{
+#define ATA_CMD_SUBOP_STOP_DISC                         0x00   ///< Stop the Disc
+#define ATA_CMD_SUBOP_START_DISC                        0x01   ///< Start the Disc and acquire the format type
+#define ATA_CMD_SUBOP_EJECT_DISC                        0x02   ///< Eject the Disc if possible
+#define ATA_CMD_SUBOP_CLOSE_TRAY                        0x03   ///< Load the Disc (Close Tray)
+///@}
+
+//
+// ATA Commands Code
+//
+
+//
+// Class 1: PIO Data-In Commands
+//
+#define ATA_CMD_IDENTIFY_DRIVE                          0xec   ///< defined from ATA-3
+#define ATA_CMD_READ_BUFFER                             0xe4   ///< defined from ATA-1
+#define ATA_CMD_READ_SECTORS                            0x20   ///< defined from ATA-1     
+#define ATA_CMD_READ_SECTORS_WITH_RETRY                 0x21   ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_READ_LONG                               0x22   ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_READ_LONG_WITH_RETRY                    0x23   ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_READ_SECTORS_EXT                        0x24   ///< defined from ATA-6
+#define ATA_CMD_READ_MULTIPLE                           0xc4   ///< defined in ACS-3  
+#define ATA_CMD_READ_MULTIPLE_EXT                       0x29   ///< defined in ACS-3  
+#define ATA_CMD_READ_LOG_EXT                            0x2f   ///< defined in ACS-3  
+
+//
+// Class 2: PIO Data-Out Commands
+//
+#define ATA_CMD_FORMAT_TRACK                            0x50  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_WRITE_BUFFER                            0xe8  ///< defined from ATA-1  
+#define ATA_CMD_WRITE_SECTORS                           0x30  ///< defined from ATA-1
+#define ATA_CMD_WRITE_SECTORS_WITH_RETRY                0x31  ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_WRITE_LONG                              0x32  ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_WRITE_LONG_WITH_RETRY                   0x33  ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_WRITE_VERIFY                            0x3c  ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_WRITE_SECTORS_EXT                       0x34  ///< defined from ATA-6
+#define ATA_CMD_WRITE_MULTIPLE                          0xc5  ///< defined in ACS-3  
+#define ATA_CMD_WRITE_MULTIPLE_EXT                      0x39  ///< defined in ACS-3  
+
+//
+// Class 3 No Data Command
+//
+#define ATA_CMD_ACK_MEDIA_CHANGE                        0xdb  ///< defined from ATA-1, obsoleted from ATA-5 
+#define ATA_CMD_BOOT_POST_BOOT                          0xdc  ///< defined from ATA-1, obsoleted from ATA-3
+#define ATA_CMD_BOOT_PRE_BOOT                           0xdd  ///< defined from ATA-1, obsoleted from ATA-3
+#define ATA_CMD_CHECK_POWER_MODE                        0x98  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_CHECK_POWER_MODE_ALIAS                  0xe5  ///< defined from ATA-1
+#define ATA_CMD_DOOR_LOCK                               0xde  ///< defined from ATA-1
+#define ATA_CMD_DOOR_UNLOCK                             0xdf  ///< defined from ATA-1
+#define ATA_CMD_EXEC_DRIVE_DIAG                         0x90  ///< defined from ATA-1
+#define ATA_CMD_IDLE_ALIAS                              0x97  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_IDLE                                    0xe3  ///< defined from ATA-1
+#define ATA_CMD_IDLE_IMMEDIATE                          0x95  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_IDLE_IMMEDIATE_ALIAS                    0xe1  ///< defined from ATA-1
+#define ATA_CMD_INIT_DRIVE_PARAM                        0x91  ///< defined from ATA-1, obsoleted from ATA-6
+#define ATA_CMD_RECALIBRATE                             0x10  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_READ_DRIVE_STATE                        0xe9  ///< defined from ATA-1, obsoleted from ATA-3
+#define ATA_CMD_SET_MULTIPLE_MODE                       0xC6  ///< defined from ATA-2
+#define ATA_CMD_READ_VERIFY                             0x40  ///< defined from ATA-1
+#define ATA_CMD_READ_VERIFY_WITH_RETRY                  0x41  ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_SEEK                                    0x70  ///< defined from ATA-1
+#define ATA_CMD_SET_FEATURES                            0xef  ///< defined from ATA-1
+#define ATA_CMD_STANDBY                                 0x96  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_STANDBY_ALIAS                           0xe2  ///< defined from ATA-1
+#define ATA_CMD_STANDBY_IMMEDIATE                       0x94  ///< defined from ATA-1, obsoleted from ATA-4
+#define ATA_CMD_STANDBY_IMMEDIATE_ALIAS                 0xe0  ///< defined from ATA-1
+#define ATA_CMD_SLEEP                                   0xe6  ///< defined in ACS-3  
+#define ATA_CMD_READ_NATIVE_MAX_ADDRESS                 0xf8  ///< defined in ATA-6  
+#define ATA_CMD_READ_NATIVE_MAX_ADDRESS_EXT             0x27  ///< defined in ATA-6  
+
+//
+// Set Features Sub Command
+//
+#define ATA_SUB_CMD_ENABLE_VOLATILE_WRITE_CACHE             0x02   ///< defined in ACS-3 
+#define ATA_SUB_CMD_SET_TRANSFER_MODE                       0x03   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_APM                              0x05   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_PUIS                             0x06   ///< defined in ACS-3 
+#define ATA_SUB_CMD_PUIS_SET_DEVICE_SPINUP                  0x07   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_WRITE_READ_VERIFY                0x0b   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_SATA_FEATURE                     0x10   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_MEDIA_STATUS_NOTIFICATION       0x31   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_FREE_FALL_CONTROL                0x41   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ACOUSTIC_MANAGEMENT_ENABLE              0x42   ///< defined in ACS-3 
+#define ATA_SUB_CMD_SET_MAX_HOST_INTERFACE_SECTOR_TIMES     0x43   ///< defined in ACS-3 
+#define ATA_SUB_CMD_EXTENDED_POWER_CONDITIONS               0x4a   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_READ_LOOK_AHEAD                 0x55   ///< defined in ACS-3 
+#define ATA_SUB_CMD_EN_DIS_DSN_FEATURE                      0x63   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_REVERT_TO_POWER_ON_DEFAULTS     0x66   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_VOLATILE_WRITE_CACHE            0x82   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_APM                             0x85   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_PUIS                            0x86   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_WRITE_READ_VERIFY               0x8b   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_SATA_FEATURE                    0x90   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_MEDIA_STATUS_NOTIFICATION        0x95   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_READ_LOOK_AHEAD                  0xaa   ///< defined in ACS-3 
+#define ATA_SUB_CMD_DISABLE_FREE_FALL_CONTROL               0xc1   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ACOUSTIC_MANAGEMENT_DISABLE             0xc2   ///< defined in ACS-3 
+#define ATA_SUB_CMD_EN_DIS_SENSE_DATA_REPORTING             0xc3   ///< defined in ACS-3 
+#define ATA_SUB_CMD_ENABLE_REVERT_TO_POWER_ON_DEFAULTS      0xcc   ///< defined in ACS-3 
+
+//
+// S.M.A.R.T
+//
+#define ATA_CMD_SMART                                   0xb0  ///< defined from ATA-3
+#define ATA_CONSTANT_C2                                 0xc2  ///< reserved
+#define ATA_CONSTANT_4F                                 0x4f  ///< reserved
+
+#define ATA_SMART_READ_DATA                             0xd0   ///< defined in ACS-3 
+
+#define ATA_SMART_AUTOSAVE                              0xd2  ///< defined in ACS-3 
+    #define ATA_AUTOSAVE_DISABLE_ATTR                       0x00
+    #define ATA_AUTOSAVE_ENABLE_ATTR                        0xf1
+
+#define ATA_SMART_EXECUTE_OFFLINE_IMMEDIATE             0xd4  ///< defined in ACS-3 
+    #define ATA_EXECUTE_SMART_OFFLINE_ROUTINE               0x00  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_OFFLINE_SHORT_SELFTEST        0x01  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_OFFLINE_EXTENDED_SELFTEST     0x02  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_OFFLINE_CONVEYANCE_SELFTEST   0x03  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_OFFLINE_SELECTIVE_SELFTEST    0x04  ///< defined in ACS-3
+    #define ATA_SMART_ABORT_SELF_TEST_SUBROUTINE            0x7f  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_CAPTIVE_SHORT_SELFTEST        0x81  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_CAPTIVE_EXTENDED_SELFTEST     0x82  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_CAPTIVE_CONVEYANCE_SELFTEST   0x83  ///< defined in ACS-3
+    #define ATA_EXECUTE_SMART_CAPTIVE_SELECTIVE_SELFTEST    0x84  ///< defined in ACS-3
+
+#define ATA_SMART_READLOG                               0xd5  ///< defined in ACS-3 
+#define ATA_SMART_WRITELOG                              0xd6  ///< defined in ACS-3 
+#define ATA_SMART_ENABLE_OPERATION                      0xd8  ///< reserved
+#define ATA_SMART_DISABLE_OPERATION                     0xd9  ///< defined in ACS-3 
+#define ATA_SMART_RETURN_STATUS                         0xda  ///< defined from ATA-3
+
+#define ATA_SMART_THRESHOLD_NOT_EXCEEDED_VALUE              0xc24f  ///< defined in ACS-3 
+#define ATA_SMART_THRESHOLD_EXCEEDED_VALUE                  0x2cf4  ///< defined in ACS-3 
+
+// SMART Log Definitions
+#define ATA_SMART_LOG_DIRECTORY                             0x00  ///< defined in ACS-3 
+#define ATA_SMART_SUM_SMART_ERROR_LOG                       0x01  ///< defined in ACS-3 
+#define ATA_SMART_COMP_SMART_ERROR_LOG                      0x02  ///< defined in ACS-3 
+#define ATA_SMART_EXT_COMP_SMART_ERROR_LOG                  0x03  ///< defined in ACS-3 
+#define ATA_SMART_SMART_SELFTEST_LOG                        0x06  ///< defined in ACS-3 
+#define ATA_SMART_EXT_SMART_SELFTEST_LOG                    0x07  ///< defined in ACS-3 
+#define ATA_SMART_SELECTIVE_SELFTEST_LOG                    0x09  ///< defined in ACS-3 
+#define ATA_SMART_HOST_VENDOR_SPECIFIC                      0x80  ///< defined in ACS-3 
+#define ATA_SMART_DEVICE_VENDOR_SPECIFIC                    0xa0  ///< defined in ACS-3 
+
+//
+// Class 4: DMA Command
+//
+#define ATA_CMD_READ_DMA                                0xc8   ///< defined from ATA-1
+#define ATA_CMD_READ_DMA_WITH_RETRY                     0xc9   ///< defined from ATA-1, obsoleted from ATA-5
+#define ATA_CMD_READ_DMA_EXT                            0x25   ///< defined from ATA-6
+#define ATA_CMD_WRITE_DMA                               0xca   ///< defined from ATA-1
+#define ATA_CMD_WRITE_DMA_WITH_RETRY                    0xcb   ///< defined from ATA-1, obsoleted from ATA-
+#define ATA_CMD_WRITE_DMA_EXT                           0x35   ///< defined from ATA-6
+  
+//
+//  ATA Security commands
+//
+#define ATA_CMD_SECURITY_SET_PASSWORD                   0xf1  ///< defined in ACS-3 
+#define ATA_CMD_SECURITY_UNLOCK                         0xf2  ///< defined in ACS-3 
+#define ATA_CMD_SECURITY_ERASE_PREPARE                  0xf3  ///< defined in ACS-3 
+#define ATA_CMD_SECURITY_ERASE_UNIT                     0xf4  ///< defined in ACS-3 
+#define ATA_CMD_SECURITY_FREEZE_LOCK                    0xf5  ///< defined in ACS-3 
+#define ATA_CMD_SECURITY_DISABLE_PASSWORD               0xf6  ///< defined in ACS-3 
+
+#define ATA_SECURITY_BUFFER_LENGTH                          512  ///< defined in ACS-3 
+
+//
+//  ATA Device Config Overlay
+//
+#define ATA_CMD_DEV_CONFIG_OVERLAY                      0xb1   ///< defined from ATA-6
+    #define ATA_CMD_DEV_CONFIG_RESTORE_FEATURE              0xc0   ///< defined from ATA-6
+    #define ATA_CMD_DEV_CONFIG_FREEZELOCK_FEATURE           0xc1   ///< defined from ATA-6
+    #define ATA_CMD_DEV_CONFIG_IDENTIFY_FEATURE             0xc2   ///< defined from ATA-6
+    #define ATA_CMD_DEV_CONFIG_SET_FEATURE                  0xc3   ///< defined from ATA-6
+
+//
+//  ATA Trusted Computing Feature Set Commands
+//
+#define ATA_CMD_TRUSTED_NON_DATA                        0x5b  ///< defined in ACS-3 
+#define ATA_CMD_TRUSTED_RECEIVE                         0x5c  ///< defined in ACS-3 
+#define ATA_CMD_TRUSTED_RECEIVE_DMA                     0x5d  ///< defined in ACS-3 
+#define ATA_CMD_TRUSTED_SEND                            0x5e  ///< defined in ACS-3 
+#define ATA_CMD_TRUSTED_SEND_DMA                        0x5f  ///< defined in ACS-3 
+
+//
+//  ATA Trusted Receive Fields
+//
+#define ATA_TR_RETURN_SECURITY_PROTOCOL_INFORMATION     0x00  ///< defined in ACS-3 
+#define ATA_TR_SECURITY_PROTOCOL_JEDEC_RESERVED         0xec  ///< defined in ACS-3 
+#define ATA_TR_SECURITY_PROTOCOL_SDCARD_RESERVED        0xed  ///< defined in ACS-3 
+#define ATA_TR_SECURITY_PROTOCOL_IEEE1667_RESERVED      0xee  ///< defined in ACS-3 
+
+//
+//  Equates used for Acoustic Flags
+//
+#define ATA_ACOUSTIC_LEVEL_BYPASS                       0xff   ///< defined from ATA-6
+#define ATA_ACOUSTIC_LEVEL_MAXIMUM_PERFORMANCE          0xfe   ///< defined from ATA-6
+#define ATA_ACOUSTIC_LEVEL_QUIET                        0x80   ///< defined from ATA-6
+    	
+//
+//  Equates used for DiPM Support
+//
+#define ATA_CMD_DIPM_SUB                                0x03   // defined in ACS-3 : Count value in SetFeature identification : 03h  Device-initiated interface power state transitions 
+    #define ATA_DIPM_ENABLE                                 0x10   // defined in ACS-3 
+    #define ATA_DIPM_DISABLE                                0x90   // defined in ACS-3 
+
+//
+//  Equates used for DevSleep Support
+//
+#define ATA_CMD_DEVSLEEP_SUB                            0x09   // defined in SATA 3.2 Gold Spec :  Count value in SetFeature identification : 09h  Device Sleep 
+    #define ATA_DEVSLEEP_ENABLE                             0x10   // defined in SATA 3.2 Gold Spec
+    #define ATA_DEVSLEEP_DISABLE                            0x90   // defined in SATA 3.2 Gold Spec
+
+#define ATA_DEVSLP_EXIT_TIMEOUT                             20 // MDAT - 20 ms
+#define ATA_DEVSLP_MINIMUM_DETECTION_TIME                   10 // DMDT - 10 us
+#define ATA_DEVSLP_MINIMUM_ASSERTION_TIME                   10 // DETO - 10 ms
+
+//
+//  Set MAX Commands
+//
+#define ATA_CMD_SET_MAX_ADDRESS_EXT                     0x37   ///< defined from ATA-6
+#define ATA_CMD_SET_MAX_ADDRESS                         0xf9   ///< defined from ATA-6
+    #define ATA_SET_MAX_SET_PASSWORD                        0x01   ///< defined from ATA-6
+    #define ATA_SET_MAX_LOCK                                0x02   ///< defined from ATA-6
+    #define ATA_SET_MAX_UNLOCK                              0x03   ///< defined from ATA-6
+    #define ATA_SET_MAX_FREEZE_LOCK                         0x04   ///< defined from ATA-6
+
+///
+/// Default content of device control register, disable INT,
+/// Bit3 is set to 1 according ATA-1
+///
+#define ATA_DEFAULT_CTL                                 (0x0a)  
+///
+/// Default context of Device/Head Register,
+/// Bit7 and Bit5 are set to 1 for back-compatibilities.
+///
+#define ATA_DEFAULT_CMD                                 (0xa0)
+
+#define ATAPI_MAX_BYTE_COUNT                            (0xfffe)
+
+#define ATA_REQUEST_SENSE_ERROR                         (0x70) ///< defined in SFF-8070i
+
+//
+// Sense Key, Additional Sense Codes and Additional Sense Code Qualifier
+// defined in MultiMedia Commands (MMC, MMC-2) 
+//
+// Sense Key 
+//
+#define ATA_SK_NO_SENSE                                 (0x0)
+#define ATA_SK_RECOVERY_ERROR                           (0x1)
+#define ATA_SK_NOT_READY                                (0x2)
+#define ATA_SK_MEDIUM_ERROR                             (0x3)
+#define ATA_SK_HARDWARE_ERROR                           (0x4)
+#define ATA_SK_ILLEGAL_REQUEST                          (0x5)
+#define ATA_SK_UNIT_ATTENTION                           (0x6)
+#define ATA_SK_DATA_PROTECT                             (0x7)
+#define ATA_SK_BLANK_CHECK                              (0x8)
+#define ATA_SK_VENDOR_SPECIFIC                          (0x9)
+#define ATA_SK_RESERVED_A                               (0xA)
+#define ATA_SK_ABORT                                    (0xB)
+#define ATA_SK_RESERVED_C                               (0xC)
+#define ATA_SK_OVERFLOW                                 (0xD)
+#define ATA_SK_MISCOMPARE                               (0xE)
+#define ATA_SK_RESERVED_F                               (0xF)
+
+//
+// Additional Sense Codes
+//
+#define ATA_ASC_NOT_READY                               (0x04)
+#define ATA_ASC_MEDIA_ERR1                              (0x10)
+#define ATA_ASC_MEDIA_ERR2                              (0x11)
+#define ATA_ASC_MEDIA_ERR3                              (0x14)
+#define ATA_ASC_MEDIA_ERR4                              (0x30)
+#define ATA_ASC_MEDIA_UPSIDE_DOWN                       (0x06)
+#define ATA_ASC_INVALID_CMD                             (0x20)
+#define ATA_ASC_LBA_OUT_OF_RANGE                        (0x21)
+#define ATA_ASC_INVALID_FIELD                           (0x24)
+#define ATA_ASC_WRITE_PROTECTED                         (0x27)
+#define ATA_ASC_MEDIA_CHANGE                            (0x28)
+#define ATA_ASC_RESET                                   (0x29)  ///< Power On Reset or Bus Reset occurred.
+#define ATA_ASC_ILLEGAL_FIELD                           (0x26)
+#define ATA_ASC_NO_MEDIA                                (0x3A)
+#define ATA_ASC_ILLEGAL_MODE_FOR_THIS_TRACK             (0x64)
+
+//
+// Additional Sense Code Qualifier
+//
+#define ATA_ASCQ_IN_PROGRESS                            (0x01)
+
+//
+// Error Register
+//  
+#define ATA_ERRREG_BBK                                  BIT7  ///< Bad block detected      defined from ATA-1, obsoleted from ATA-2
+#define ATA_ERRREG_UNC                                  BIT6  ///< Uncorrectable Data      defined from ATA-1, obsoleted from ATA-4
+#define ATA_ERRREG_MC                                   BIT5  ///< Media Change            defined from ATA-1, obsoleted from ATA-4
+#define ATA_ERRREG_IDNF                                 BIT4  ///< ID Not Found            defined from ATA-1, obsoleted from ATA-4
+#define ATA_ERRREG_MCR                                  BIT3  ///< Media Change Requested  defined from ATA-1, obsoleted from ATA-4
+#define ATA_ERRREG_ABRT                                 BIT2  ///< Aborted Command         defined from ATA-1
+#define ATA_ERRREG_TK0NF                                BIT1  ///< Track 0 Not Found       defined from ATA-1, obsoleted from ATA-4
+#define ATA_ERRREG_AMNF                                 BIT0  ///< Address Mark Not Found  defined from ATA-1, obsoleted from ATA-4
+
+//
+// Status Register
+//
+#define ATA_STSREG_BSY                                  BIT7  ///< Controller Busy         defined from ATA-1
+#define ATA_STSREG_DRDY                                 BIT6  ///< Drive Ready             defined from ATA-1
+#define ATA_STSREG_DWF                                  BIT5  ///< Drive Write Fault       defined from ATA-1, obsoleted from ATA-4
+#define ATA_STSREG_DF                                   BIT5  ///< Drive Fault             defined from ATA-6
+#define ATA_STSREG_DSC                                  BIT4  ///< Disk Seek Complete      defined from ATA-1, obsoleted from ATA-4
+#define ATA_STSREG_DRQ                                  BIT3  ///< Data Request            defined from ATA-1
+#define ATA_STSREG_CORR                                 BIT2  ///< Corrected Data          defined from ATA-1, obsoleted from ATA-4
+#define ATA_STSREG_IDX                                  BIT1  ///< Index                   defined from ATA-1, obsoleted from ATA-4
+#define ATA_STSREG_ERR                                  BIT0  ///< Error                   defined from ATA-1
+
+//
+// Device Control Register
+//
+#define ATA_CTLREG_SRST                                 BIT2  ///< Software Reset.
+#define ATA_CTLREG_IEN_L                                BIT1  ///< Interrupt Enable #.
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Bluetooth.h b/MdePkg/Include/IndustryStandard/Bluetooth.h
new file mode 100644
index 000000000000..f4b7372d5482
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Bluetooth.h
@@ -0,0 +1,47 @@
+/** @file
+  This file contains the Bluetooth definitions that are consumed by drivers.
+  These definitions are from Bluetooth Core Specification Version 4.0 June, 2010
+
+  Copyright (c) 2015, 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 _BLUETOOTH_H_
+#define _BLUETOOTH_H_
+
+#pragma pack(1)
+
+///
+/// BLUETOOTH_ADDRESS
+///
+typedef struct {
+  ///
+  /// 48bit Bluetooth device address.
+  ///
+  UINT8      Address[6];
+} BLUETOOTH_ADDRESS;
+
+///
+/// BLUETOOTH_CLASS_OF_DEVICE. See Bluetooth specification for detail.
+///
+typedef struct {
+  UINT8      FormatType:2;
+  UINT8      MinorDeviceClass: 6;
+  UINT16     MajorDeviceClass: 5;
+  UINT16     MajorServiceClass:11;
+} BLUETOOTH_CLASS_OF_DEVICE;
+
+#pragma pack()
+
+#define BLUETOOTH_HCI_COMMAND_LOCAL_READABLE_NAME_MAX_SIZE    248
+
+#define BLUETOOTH_HCI_LINK_KEY_SIZE                           16
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Bmp.h b/MdePkg/Include/IndustryStandard/Bmp.h
new file mode 100644
index 000000000000..25393911c42c
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Bmp.h
@@ -0,0 +1,48 @@
+/** @file
+  This file defines BMP file header data structures.
+
+Copyright (c) 2006 - 2011, 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 _BMP_H_
+#define _BMP_H_
+
+#pragma pack(1)
+
+typedef struct {
+  UINT8   Blue;
+  UINT8   Green;
+  UINT8   Red;
+  UINT8   Reserved;
+} BMP_COLOR_MAP;
+
+typedef struct {
+  CHAR8         CharB;
+  CHAR8         CharM;
+  UINT32        Size;
+  UINT16        Reserved[2];
+  UINT32        ImageOffset;
+  UINT32        HeaderSize;
+  UINT32        PixelWidth;
+  UINT32        PixelHeight;
+  UINT16        Planes;          ///< Must be 1
+  UINT16        BitPerPixel;     ///< 1, 4, 8, or 24
+  UINT32        CompressionType;
+  UINT32        ImageSize;       ///< Compressed image size in bytes
+  UINT32        XPixelsPerMeter;
+  UINT32        YPixelsPerMeter;
+  UINT32        NumberOfColors;
+  UINT32        ImportantColors;
+} BMP_IMAGE_HEADER;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/DebugPort2Table.h b/MdePkg/Include/IndustryStandard/DebugPort2Table.h
new file mode 100644
index 000000000000..03331069fc29
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/DebugPort2Table.h
@@ -0,0 +1,79 @@
+/** @file   
+  ACPI debug port 2 table definition, defined at 
+  Microsoft DebugPort2Specification.
+
+  Copyright (c) 2012, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2012 - 2016, ARM Limited. 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 _DEBUG_PORT_2_TABLE_H_
+#define _DEBUG_PORT_2_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+//
+// Debug Device Information structure.
+//
+typedef struct {
+  UINT8                                     Revision;
+  UINT16                                    Length;
+  UINT8                                     NumberofGenericAddressRegisters;
+  UINT16                                    NameSpaceStringLength;
+  UINT16                                    NameSpaceStringOffset;
+  UINT16                                    OemDataLength;
+  UINT16                                    OemDataOffset;
+  UINT16                                    PortType;
+  UINT16                                    PortSubtype;
+  UINT8                                     Reserved[2];
+  UINT16                                    BaseAddressRegisterOffset;
+  UINT16                                    AddressSizeOffset;
+} EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT;
+
+#define EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION      0x00
+
+#define EFI_ACPI_DBG2_PORT_TYPE_SERIAL                                                 0x8000
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_FULL_16550                                 0x0000
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_16550_SUBSET_COMPATIBLE_WITH_MS_DBGP_SPEC  0x0001
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_PL011_UART                             0x0003
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_SBSA_GENERIC_UART_2X                   0x000d
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_SBSA_GENERIC_UART                      0x000e
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_DCC                                        0x000f
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_BCM2835_UART                               0x0010
+#define EFI_ACPI_DBG2_PORT_TYPE_1394                                                   0x8001
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_1394_STANDARD                                     0x0000
+#define EFI_ACPI_DBG2_PORT_TYPE_USB                                                    0x8002
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_USB_XHCI                                          0x0000
+#define   EFI_ACPI_DBG2_PORT_SUBTYPE_USB_EHCI                                          0x0001
+#define EFI_ACPI_DBG2_PORT_TYPE_NET                                                    0x8003
+
+//
+// Debug Port 2 Table definition.
+//
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER               Header;
+  UINT32                                    OffsetDbgDeviceInfo;
+  UINT32                                    NumberDbgDeviceInfo;
+} EFI_ACPI_DEBUG_PORT_2_DESCRIPTION_TABLE;
+
+#pragma pack()
+
+//
+// DBG2 Revision (defined in spec)
+//
+#define EFI_ACPI_DEBUG_PORT_2_TABLE_REVISION      0x00
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/DebugPortTable.h b/MdePkg/Include/IndustryStandard/DebugPortTable.h
new file mode 100644
index 000000000000..99791c513311
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/DebugPortTable.h
@@ -0,0 +1,50 @@
+/** @file   
+  ACPI debug port table definition, defined at 
+  Microsoft DebugPortSpecification.
+
+  Copyright (c) 2012, 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 _DEBUG_PORT_TABLE_H_
+#define _DEBUG_PORT_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+//
+// Debug Port Table definition.
+//
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER               Header;
+  UINT8                                     InterfaceType;
+  UINT8                                     Reserved_37[3];
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE    BaseAddress;
+} EFI_ACPI_DEBUG_PORT_DESCRIPTION_TABLE;
+
+#pragma pack()
+
+//
+// DBGP Revision (defined in spec)
+//
+#define EFI_ACPI_DEBUG_PORT_TABLE_REVISION      0x01
+
+//
+// Interface Type
+//
+#define EFI_ACPI_DBGP_INTERFACE_TYPE_FULL_16550                                 0
+#define EFI_ACPI_DBGP_INTERFACE_TYPE_16550_SUBSET_COMPATIBLE_WITH_MS_DBGP_SPEC  1
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Dhcp.h b/MdePkg/Include/IndustryStandard/Dhcp.h
new file mode 100644
index 000000000000..9f09753624e4
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Dhcp.h
@@ -0,0 +1,282 @@
+/** @file
+  This file contains the DHCPv4 and DHCPv6 option definitions and other configuration.
+  They are used to carry additional information and parameters in DHCP messages.
+
+  Copyright (c) 2016, 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 _DHCP_H_
+#define _DHCP_H_
+
+///
+/// Dynamic Host Configuration Protocol for IPv4 (DHCPv4)
+///
+/// Dhcpv4 Options, definitions from RFC 2132
+///
+#define DHCP4_TAG_PAD                0    /// Pad Option
+#define DHCP4_TAG_EOP                255  /// End Option
+#define DHCP4_TAG_NETMASK            1    /// Subnet Mask
+#define DHCP4_TAG_TIME_OFFSET        2    /// Time Offset from UTC
+#define DHCP4_TAG_ROUTER             3    /// Router option,
+#define DHCP4_TAG_TIME_SERVER        4    /// Time Server
+#define DHCP4_TAG_NAME_SERVER        5    /// Name Server
+#define DHCP4_TAG_DNS_SERVER         6    /// Domain Name Server
+#define DHCP4_TAG_LOG_SERVER         7    /// Log Server
+#define DHCP4_TAG_COOKIE_SERVER      8    /// Cookie Server
+#define DHCP4_TAG_LPR_SERVER         9    /// LPR Print Server
+#define DHCP4_TAG_IMPRESS_SERVER     10   /// Impress Server
+#define DHCP4_TAG_RL_SERVER          11   /// Resource Location Server
+#define DHCP4_TAG_HOSTNAME           12   /// Host Name
+#define DHCP4_TAG_BOOTFILE_LEN       13   /// Boot File Size
+#define DHCP4_TAG_DUMP               14   /// Merit Dump File
+#define DHCP4_TAG_DOMAINNAME         15   /// Domain Name
+#define DHCP4_TAG_SWAP_SERVER        16   /// Swap Server
+#define DHCP4_TAG_ROOTPATH           17   /// Root path
+#define DHCP4_TAG_EXTEND_PATH        18   /// Extensions Path
+#define DHCP4_TAG_IPFORWARD          19   /// IP Forwarding Enable/Disable
+#define DHCP4_TAG_NONLOCAL_SRR       20   /// on-Local Source Routing Enable/Disable
+#define DHCP4_TAG_POLICY_SRR         21   /// Policy Filter
+#define DHCP4_TAG_EMTU               22   /// Maximum Datagram Reassembly Size
+#define DHCP4_TAG_TTL                23   /// Default IP Time-to-live
+#define DHCP4_TAG_PATHMTU_AGE        24   /// Path MTU Aging Timeout
+#define DHCP4_TAG_PATHMTU_PLATEAU    25   /// Path MTU Plateau Table
+#define DHCP4_TAG_IFMTU              26   /// Interface MTU
+#define DHCP4_TAG_SUBNET_LOCAL       27   /// All Subnets are Local
+#define DHCP4_TAG_BROADCAST          28   /// Broadcast Address
+#define DHCP4_TAG_DISCOVER_MASK      29   /// Perform Mask Discovery
+#define DHCP4_TAG_SUPPLY_MASK        30   /// Mask Supplier
+#define DHCP4_TAG_DISCOVER_ROUTE     31   /// Perform Router Discovery
+#define DHCP4_TAG_ROUTER_SOLICIT     32   /// Router Solicitation Address
+#define DHCP4_TAG_STATIC_ROUTE       33   /// Static Route
+#define DHCP4_TAG_TRAILER            34   /// Trailer Encapsulation
+#define DHCP4_TAG_ARPAGE             35   /// ARP Cache Timeout
+#define DHCP4_TAG_ETHER_ENCAP        36   /// Ethernet Encapsulation
+#define DHCP4_TAG_TCP_TTL            37   /// TCP Default TTL
+#define DHCP4_TAG_KEEP_INTERVAL      38   /// TCP Keepalive Interval
+#define DHCP4_TAG_KEEP_GARBAGE       39   /// TCP Keepalive Garbage
+#define DHCP4_TAG_NIS_DOMAIN         40   /// Network Information Service Domain
+#define DHCP4_TAG_NIS_SERVER         41   /// Network Information Servers
+#define DHCP4_TAG_NTP_SERVER         42   /// Network Time Protocol Servers
+#define DHCP4_TAG_VENDOR             43   /// Vendor Specific Information
+#define DHCP4_TAG_NBNS               44   /// NetBIOS over TCP/IP Name Server
+#define DHCP4_TAG_NBDD               45   /// NetBIOS Datagram Distribution Server
+#define DHCP4_TAG_NBTYPE             46   /// NetBIOS over TCP/IP Node Type
+#define DHCP4_TAG_NBSCOPE            47   /// NetBIOS over TCP/IP Scope
+#define DHCP4_TAG_XFONT              48   /// X Window System Font Server
+#define DHCP4_TAG_XDM                49   /// X Window System Display Manager
+#define DHCP4_TAG_REQUEST_IP         50   /// Requested IP Address
+#define DHCP4_TAG_LEASE              51   /// IP Address Lease Time
+#define DHCP4_TAG_OVERLOAD           52   /// Option Overload
+#define DHCP4_TAG_MSG_TYPE           53   /// DHCP Message Type
+#define DHCP4_TAG_SERVER_ID          54   /// Server Identifier
+#define DHCP4_TAG_PARA_LIST          55   /// Parameter Request List
+#define DHCP4_TAG_MESSAGE            56   /// Message
+#define DHCP4_TAG_MAXMSG             57   /// Maximum DHCP Message Size
+#define DHCP4_TAG_T1                 58   /// Renewal (T1) Time Value
+#define DHCP4_TAG_T2                 59   /// Rebinding (T2) Time Value
+#define DHCP4_TAG_VENDOR_CLASS_ID    60   /// Vendor class identifier
+#define DHCP4_TAG_CLIENT_ID          61   /// Client-identifier
+#define DHCP4_TAG_NISPLUS            64   /// Network Information Service+ Domain
+#define DHCP4_TAG_NISPLUS_SERVER     65   /// Network Information Service+ Servers
+#define DHCP4_TAG_TFTP               66   /// TFTP server name
+#define DHCP4_TAG_BOOTFILE           67   /// Bootfile name
+#define DHCP4_TAG_MOBILEIP           68   /// Mobile IP Home Agent
+#define DHCP4_TAG_SMTP               69   /// Simple Mail Transport Protocol Server
+#define DHCP4_TAG_POP3               70   /// Post Office Protocol (POP3) Server
+#define DHCP4_TAG_NNTP               71   /// Network News Transport Protocol Server
+#define DHCP4_TAG_WWW                72   /// Default World Wide Web (WWW) Server
+#define DHCP4_TAG_FINGER             73   /// Default Finger Server
+#define DHCP4_TAG_IRC                74   /// Default Internet Relay Chat (IRC) Server
+#define DHCP4_TAG_STTALK             75   /// StreetTalk Server
+#define DHCP4_TAG_STDA               76   /// StreetTalk Directory Assistance Server
+#define DHCP4_TAG_USER_CLASS_ID      77   /// User class identifier
+#define DHCP4_TAG_ARCH               93   /// Client System Architecture Type, RFC 4578
+#define DHCP4_TAG_UNDI               94   /// Client Network Interface Identifier, RFC 4578
+#define DHCP4_TAG_UUID               97   /// Client Machine Identifier, RFC 4578
+#define DHCP4_TAG_CLASSLESS_ROUTE    121  /// Classless Route
+
+
+///
+/// Dynamic Host Configuration Protocol for IPv6 (DHCPv6)
+///
+/// Enumeration of Dhcp6 message type, refers to section-5.3 of rfc-3315.
+///
+typedef enum {
+  Dhcp6MsgSolicit               = 1,
+  Dhcp6MsgAdvertise             = 2,
+  Dhcp6MsgRequest               = 3,
+  Dhcp6MsgConfirm               = 4,
+  Dhcp6MsgRenew                 = 5,
+  Dhcp6MsgRebind                = 6,
+  Dhcp6MsgReply                 = 7,
+  Dhcp6MsgRelease               = 8,
+  Dhcp6MsgDecline               = 9,
+  Dhcp6MsgReconfigure           = 10,
+  Dhcp6MsgInfoRequest           = 11
+} DHCP6_MSG_TYPE;
+
+///
+/// Enumeration of option code in Dhcp6 packet, refers to section-24.3 of rfc-3315.
+///
+typedef enum {
+  Dhcp6OptClientId              = 1,
+  Dhcp6OptServerId              = 2,
+  Dhcp6OptIana                  = 3,
+  Dhcp6OptIata                  = 4,
+  Dhcp6OptIaAddr                = 5,
+  Dhcp6OptRequestOption         = 6,
+  Dhcp6OptPreference            = 7,
+  Dhcp6OptElapsedTime           = 8,
+  Dhcp6OptReplayMessage         = 9,
+  Dhcp6OptAuthentication        = 11,
+  Dhcp6OptServerUnicast         = 12,
+  Dhcp6OptStatusCode            = 13,
+  Dhcp6OptRapidCommit           = 14,
+  Dhcp6OptUserClass             = 15,
+  Dhcp6OptVendorClass           = 16,
+  Dhcp6OptVendorInfo            = 17,
+  Dhcp6OptInterfaceId           = 18,
+  Dhcp6OptReconfigMessage       = 19,
+  Dhcp6OptReconfigureAccept     = 20
+} DHCP6_OPT_CODE;
+
+///
+/// Enumeration of status code recorded by IANA, refers to section-24.4 of rfc-3315.
+///
+typedef enum {
+  Dhcp6StsSuccess               = 0,
+  Dhcp6StsUnspecFail            = 1,
+  Dhcp6StsNoAddrsAvail          = 2,
+  Dhcp6StsNoBinding             = 3,
+  Dhcp6StsNotOnLink             = 4,
+  Dhcp6StsUseMulticast          = 5
+} DHCP6_STS_CODE;
+
+///
+/// Enumeration of Duid type recorded by IANA, refers to section-24.5 of rfc-3315.
+///
+typedef enum {
+  Dhcp6DuidTypeLlt              = 1,
+  Dhcp6DuidTypeEn               = 2,
+  Dhcp6DuidTypeLl               = 3,
+  Dhcp6DuidTypeUuid             = 4
+} DHCP6_DUID_TYPE;
+
+/// Transmission and Retransmission Parameters
+/// This section presents a table of values used to describe the message
+/// transmission behavior of clients and servers.
+///
+/// Transmit parameters of solicit message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_SOL_MAX_DELAY       1
+#define DHCP6_SOL_IRT             1
+#define DHCP6_SOL_MRC             0
+#define DHCP6_SOL_MRT             120
+#define DHCP6_SOL_MRD             0
+///
+/// Transmit parameters of request message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_REQ_IRT             1
+#define DHCP6_REQ_MRC             10
+#define DHCP6_REQ_MRT             30
+#define DHCP6_REQ_MRD             0
+///
+/// Transmit parameters of confirm message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_CNF_MAX_DELAY       1
+#define DHCP6_CNF_IRT             1
+#define DHCP6_CNF_MRC             0
+#define DHCP6_CNF_MRT             4
+#define DHCP6_CNF_MRD             10
+///
+/// Transmit parameters of renew message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_REN_IRT             10
+#define DHCP6_REN_MRC             0
+#define DHCP6_REN_MRT             600
+#define DHCP6_REN_MRD             0
+///
+/// Transmit parameters of rebind message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_REB_IRT             10
+#define DHCP6_REB_MRC             0
+#define DHCP6_REB_MRT             600
+#define DHCP6_REB_MRD             0
+///
+/// Transmit parameters of information request message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_INF_MAX_DELAY       1
+#define DHCP6_INF_IRT             1
+#define DHCP6_INF_MRC             0
+#define DHCP6_INF_MRT             120
+#define DHCP6_INF_MRD             0
+///
+/// Transmit parameters of release message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_REL_IRT             1
+#define DHCP6_REL_MRC             5
+#define DHCP6_REL_MRT             0
+#define DHCP6_REL_MRD             0
+///
+/// Transmit parameters of decline message, refers to section-5.5 of rfc-3315.
+///
+#define DHCP6_DEC_IRT             1
+#define DHCP6_DEC_MRC             5
+#define DHCP6_DEC_MRT             0
+#define DHCP6_DEC_MRD             0
+
+////
+//// DHCPv6 Options, definitions from RFC 3315,RFC 5970 and RFC 3646.
+////
+#define DHCP6_OPT_CLIENT_ID         1    /// Client Identifier Option
+#define DHCP6_OPT_SERVER_ID         2    /// Server Identifier Option
+#define DHCP6_OPT_IA_NA             3    /// The Identity Association for Non-temporary Addresses option
+#define DHCP6_OPT_IA_TA             4    /// The Identity Association for the Temporary Addresses
+#define DHCP6_OPT_IAADDR            5    /// IA Address option
+#define DHCP6_OPT_ORO               6    /// Request option
+#define DHCP6_OPT_PREFERENCE        7    /// Preference option
+#define DHCP6_OPT_ELAPSED_TIME      8    /// Elapsed Time Option
+#define DHCP6_OPT_REPLAY_MSG        9    /// Relay Message option
+#define DHCP6_OPT_AUTH              11   /// Authentication option
+#define DHCP6_OPT_UNICAST           12   /// Server Unicast Option
+#define DHCP6_OPT_STATUS_CODE       13   /// Status Code Option
+#define DHCP6_OPT_RAPID_COMMIT      14   /// Rapid Commit option
+#define DHCP6_OPT_USER_CLASS        15   /// User Class option
+#define DHCP6_OPT_VENDOR_CLASS      16   /// Vendor Class Option
+#define DHCP6_OPT_VENDOR_OPTS       17   /// Vendor-specific Information Option
+#define DHCP6_OPT_INTERFACE_ID      18   /// Interface-Id Option
+#define DHCP6_OPT_RECONFIG_MSG      19   /// Reconfigure Message Option
+#define DHCP6_OPT_RECONFIG_ACCEPT   20   /// Reconfigure Accept Option
+#define DHCP6_OPT_DNS_SERVERS       23   /// DNS Configuration options, RFC 3646
+#define DHCP6_OPT_BOOT_FILE_URL     59   /// Assigned by IANA, RFC 5970
+#define DHCP6_OPT_BOOT_FILE_PARAM   60   /// Assigned by IANA, RFC 5970
+#define DHCP6_OPT_ARCH              61   /// Assigned by IANA, RFC 5970
+#define DHCP6_OPT_UNDI              62   /// Assigned by IANA, RFC 5970
+
+///
+/// Processor Architecture Types
+/// These identifiers are defined by IETF:
+/// http://www.ietf.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xml
+///
+#define PXE_CLIENT_ARCH_X86_BIOS         0x0000    /// x86 BIOS for PXE
+#define PXE_CLIENT_ARCH_IPF              0x0002    /// Itanium for PXE
+#define PXE_CLIENT_ARCH_IA32             0x0006    /// x86 uefi for PXE
+#define PXE_CLIENT_ARCH_X64              0x0007    /// x64 uefi for PXE
+#define PXE_CLIENT_ARCH_EBC              0x0009    /// EBC for PXE
+#define PXE_CLIENT_ARCH_ARM              0x000A    /// Arm uefi 32 for PXE
+#define PXE_CLIENT_ARCH_AARCH64          0x000B    /// Arm uefi 64 for PXE
+
+#define HTTP_CLIENT_ARCH_IA32            0x000F    /// x86 uefi boot from http
+#define HTTP_CLIENT_ARCH_X64             0x0010    /// x64 uefi boot from http
+#define HTTP_CLIENT_ARCH_EBC             0x0011    /// EBC boot from http
+#define HTTP_CLIENT_ARCH_ARM             0x0012    /// Arm uefi 32 boot from http
+#define HTTP_CLIENT_ARCH_AARCH64         0x0013    /// Arm uefi 64 boot from http
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/DmaRemappingReportingTable.h b/MdePkg/Include/IndustryStandard/DmaRemappingReportingTable.h
new file mode 100644
index 000000000000..9c9afb358c4f
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/DmaRemappingReportingTable.h
@@ -0,0 +1,261 @@
+/** @file
+  DMA Remapping Reporting (DMAR) ACPI table definition from Intel(R)
+  Virtualization Technology for Directed I/O (VT-D) Architecture Specification.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+    - Intel(R) Virtualization Technology for Directed I/O (VT-D) Architecture
+      Specification v2.4, Dated June 2016.
+      http://www.intel.com/content/dam/www/public/us/en/documents/product-specifications/vt-directed-io-spec.pdf
+
+  @par Glossary:
+    - HPET - High Precision Event Timer
+    - NUMA - Non-uniform Memory Access
+**/
+#ifndef _DMA_REMAPPING_REPORTING_TABLE_H_
+#define _DMA_REMAPPING_REPORTING_TABLE_H_
+
+#pragma pack(1)
+
+///
+/// DMA-Remapping Reporting Structure definitions from section 8.1
+///@{
+#define EFI_ACPI_DMAR_REVISION                    0x01
+
+#define EFI_ACPI_DMAR_FLAGS_INTR_REMAP            BIT0
+#define EFI_ACPI_DMAR_FLAGS_X2APIC_OPT_OUT        BIT1
+///@}
+
+///
+/// Remapping Structure Types definitions from section 8.2
+///@{
+#define EFI_ACPI_DMAR_TYPE_DRHD                   0x00
+#define EFI_ACPI_DMAR_TYPE_RMRR                   0x01
+#define EFI_ACPI_DMAR_TYPE_ATSR                   0x02
+#define EFI_ACPI_DMAR_TYPE_RHSA                   0x03
+#define EFI_ACPI_DMAR_TYPE_ANDD                   0x04
+///@}
+
+///
+/// DMA-Remapping Hardware Unit definitions from section 8.3
+///
+#define EFI_ACPI_DMAR_DRHD_FLAGS_INCLUDE_PCI_ALL  BIT0
+
+///
+/// DMA-Remapping Device Scope Entry Structure definitions from section 8.3.1
+///@{
+#define EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_PCI_ENDPOINT           0x01
+#define EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_PCI_BRIDGE             0x02
+#define EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_IOAPIC                 0x03
+#define EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_MSI_CAPABLE_HPET       0x04
+#define EFI_ACPI_DEVICE_SCOPE_ENTRY_TYPE_ACPI_NAMESPACE_DEVICE  0x05
+///@}
+
+///
+/// Root Port ATS Capability Reporting Structure definitions from section 8.5
+///
+#define EFI_ACPI_DMAR_ATSR_FLAGS_ALL_PORTS                      BIT0
+
+///
+/// Definition for DMA Remapping Structure Header
+///
+typedef struct {
+  UINT16        Type;
+  UINT16        Length;
+} EFI_ACPI_DMAR_STRUCTURE_HEADER;
+
+///
+/// Definition for DMA-Remapping PCI Path
+///
+typedef struct {
+  UINT8         Device;
+  UINT8         Function;
+} EFI_ACPI_DMAR_PCI_PATH;
+
+///
+/// Device Scope Structure is defined in section 8.3.1
+///
+typedef struct {
+  UINT8         Type;
+  UINT8         Length;
+  UINT16        Reserved2;
+  UINT8         EnumerationId;
+  UINT8         StartBusNumber;
+} EFI_ACPI_DMAR_DEVICE_SCOPE_STRUCTURE_HEADER;
+
+/**
+  DMA-remapping hardware unit definition (DRHD) structure is defined in
+  section 8.3. This uniquely represents a remapping hardware unit present
+  in the platform. There must be at least one instance of this structure
+  for each PCI segment in the platform.
+**/
+typedef struct {
+  EFI_ACPI_DMAR_STRUCTURE_HEADER  Header;
+  /**
+    - Bit[0]: INCLUDE_PCI_ALL
+              - If Set, this remapping hardware unit has under its scope all
+                PCI compatible devices in the specified Segment, except devices
+                reported under the scope of other remapping hardware units for
+                the same Segment.
+              - If Clear, this remapping hardware unit has under its scope only
+                devices in the specified Segment that are explicitly identified
+                through the DeviceScope field.
+    - Bits[7:1] Reserved.
+  **/
+  UINT8                           Flags;
+  UINT8                           Reserved;
+  ///
+  /// The PCI Segment associated with this unit.
+  ///
+  UINT16                          SegmentNumber;
+  ///
+  /// Base address of remapping hardware register-set for this unit.
+  ///
+  UINT64                          RegisterBaseAddress;
+} EFI_ACPI_DMAR_DRHD_HEADER;
+
+/**
+  Reserved Memory Region Reporting Structure (RMRR) is described in section 8.4
+  Reserved memory ranges that may be DMA targets may be reported through the
+  RMRR structures, along with the devices that requires access to the specified
+  reserved memory region.
+**/
+typedef struct {
+  EFI_ACPI_DMAR_STRUCTURE_HEADER  Header;
+  UINT8                           Reserved[2];
+  ///
+  /// PCI Segment Number associated with devices identified through
+  /// the Device Scope field.
+  ///
+  UINT16                          SegmentNumber;
+  ///
+  /// Base address of 4KB-aligned reserved memory region
+  ///
+  UINT64                          ReservedMemoryRegionBaseAddress;
+  /**
+    Last address of the reserved memory region. Value in this field must be
+    greater than the value in Reserved Memory Region Base Address field.
+    The reserved memory region size (Limit - Base + 1) must be an integer
+    multiple of 4KB.
+  **/
+  UINT64                          ReservedMemoryRegionLimitAddress;
+} EFI_ACPI_DMAR_RMRR_HEADER;
+
+/**
+  Root Port ATS Capability Reporting (ATSR) structure is defined in section 8.5.
+  This structure is applicable only for platforms supporting Device-TLBs as
+  reported through the Extended Capability Register. For each PCI Segment in
+  the platform that supports Device-TLBs, BIOS provides an ATSR structure. The
+  ATSR structures identifies PCI-Express Root-Ports supporting Address
+  Translation Services (ATS) transactions. Software must enable ATS on endpoint
+  devices behind a Root Port only if the Root Port is reported as supporting
+  ATS transactions.
+**/
+typedef struct {
+  EFI_ACPI_DMAR_STRUCTURE_HEADER  Header;
+  /**
+    - Bit[0]: ALL_PORTS:
+              - If Set, indicates all PCI Express Root Ports in the specified
+                PCI Segment supports ATS transactions.
+              - If Clear, indicates ATS transactions are supported only on
+                Root Ports identified through the Device Scope field.
+    - Bits[7:1] Reserved.
+  **/
+  UINT8                           Flags;
+  UINT8                           Reserved;
+  ///
+  /// The PCI Segment associated with this ATSR structure
+  ///
+  UINT16                          SegmentNumber;
+} EFI_ACPI_DMAR_ATSR_HEADER;
+
+/**
+  Remapping Hardware Static Affinity (RHSA) is an optional structure defined
+  in section 8.6. This is intended to be used only on NUMA platforms with
+  Remapping hardware units and memory spanned across multiple nodes.
+  When used, there must be a RHSA structure for each Remapping hardware unit
+  reported through DRHD structure.
+**/
+typedef struct {
+  EFI_ACPI_DMAR_STRUCTURE_HEADER  Header;
+  UINT8                           Reserved[4];
+  ///
+  /// Register Base Address of this Remap hardware unit reported in the
+  /// corresponding DRHD structure.
+  ///
+  UINT64                          RegisterBaseAddress;
+  ///
+  /// Proximity Domain to which the Remap hardware unit identified by the
+  /// Register Base Address field belongs.
+  ///
+  UINT32                          ProximityDomain;
+} EFI_ACPI_DMAR_RHSA_HEADER;
+
+/**
+  An ACPI Name-space Device Declaration (ANDD) structure is defined in section
+  8.7 and uniquely represents an ACPI name-space enumerated device capable of
+  issuing DMA requests in the platform. ANDD structures are used in conjunction
+  with Device-Scope entries of type ACPI_NAMESPACE_DEVICE.
+**/
+typedef struct {
+  EFI_ACPI_DMAR_STRUCTURE_HEADER  Header;
+  UINT8                           Reserved[3];
+  /**
+    Each ACPI device enumerated through an ANDD structure must have a unique
+    value for this field. To report an ACPI device with ACPI Device Number
+    value of X, under the scope of a DRHD unit, a Device-Scope entry of type
+    ACPI_NAMESPACE_DEVICE is used with value of X in the Enumeration ID field.
+    The Start Bus Number and Path fields in the Device-Scope together
+    provides the 16-bit source-id allocated by platform for the ACPI device.
+  **/
+  UINT8                           AcpiDeviceNumber;
+} EFI_ACPI_DMAR_ANDD_HEADER;
+
+/**
+  DMA Remapping Reporting Structure Header as defined in section 8.1
+  This header will be followed by list of Remapping Structures listed below
+    - DMA Remapping Hardware Unit Definition (DRHD)
+    - Reserved Memory Region Reporting (RMRR)
+    - Root Port ATS Capability Reporting (ATSR)
+    - Remapping Hardware Static Affinity (RHSA)
+    - ACPI Name-space Device Declaration (ANDD)
+  These structure types must by reported in numerical order.
+  i.e., All remapping structures of type 0 (DRHD) enumerated before remapping
+  structures of type 1 (RMRR), and so forth.
+**/
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER     Header;
+  /**
+    This field indicates the maximum DMA physical addressability supported by
+    this platform. The system address map reported by the BIOS indicates what
+    portions of this addresses are populated. The Host Address Width (HAW) of
+    the platform is computed as (N+1), where N is the value reported in this
+    field.
+    For example, for a platform supporting 40 bits of physical addressability,
+    the value of 100111b is reported in this field.
+  **/
+  UINT8                           HostAddressWidth;
+  /**
+    - Bit[0]:   INTR_REMAP - If Clear, the platform does not support interrupt
+                remapping. If Set, the platform supports interrupt remapping.
+    - Bit[1]:   X2APIC_OPT_OUT - For firmware compatibility reasons, platform
+                firmware may Set this field to request system software to opt
+                out of enabling Extended xAPIC (X2APIC) mode. This field is
+                valid only when the INTR_REMAP field (bit 0) is Set.
+    - Bits[7:2] Reserved.
+  **/
+  UINT8                           Flags;
+  UINT8                           Reserved[10];
+} EFI_ACPI_DMAR_HEADER;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/ElTorito.h b/MdePkg/Include/IndustryStandard/ElTorito.h
new file mode 100644
index 000000000000..3a3d018ac7d3
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/ElTorito.h
@@ -0,0 +1,147 @@
+/** @file
+  ElTorito Partitions Format Definition. 
+  This file includes some defintions from 
+  1. "El Torito" Bootable CD-ROM Format Specification, Version 1.0.
+  2. Volume and File Structure of CDROM for Information Interchange, 
+     Standard ECMA-119. (IS0 9660)
+
+Copyright (c) 2006 - 2008, 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 _ELTORITO_H_
+#define _ELTORITO_H_
+
+//
+// CDROM_VOLUME_DESCRIPTOR.Types, defined in ISO 9660
+//
+#define CDVOL_TYPE_STANDARD 0x0
+#define CDVOL_TYPE_CODED    0x1
+#define CDVOL_TYPE_END      0xFF
+
+///
+/// CDROM_VOLUME_DESCRIPTOR.Id
+///
+#define CDVOL_ID  "CD001"
+
+///
+/// CDROM_VOLUME_DESCRIPTOR.SystemId
+///
+#define CDVOL_ELTORITO_ID "EL TORITO SPECIFICATION"
+
+//
+// Indicator types
+//
+#define ELTORITO_ID_CATALOG               0x01
+#define ELTORITO_ID_SECTION_BOOTABLE      0x88
+#define ELTORITO_ID_SECTION_NOT_BOOTABLE  0x00
+#define ELTORITO_ID_SECTION_HEADER        0x90
+#define ELTORITO_ID_SECTION_HEADER_FINAL  0x91
+
+//
+// ELTORITO_CATALOG.Boot.MediaTypes
+//
+#define ELTORITO_NO_EMULATION 0x00
+#define ELTORITO_12_DISKETTE  0x01
+#define ELTORITO_14_DISKETTE  0x02
+#define ELTORITO_28_DISKETTE  0x03
+#define ELTORITO_HARD_DISK    0x04
+
+
+#pragma pack(1)
+
+/// 
+/// CD-ROM Volume Descriptor
+/// 
+typedef union { 
+  struct {
+    UINT8   Type;     
+    CHAR8   Id[5];           ///< "CD001"    
+    CHAR8   Reserved[82];
+  } Unknown;
+
+  ///
+  /// Boot Record Volume Descriptor, defined in "El Torito" Specification.
+  ///
+  struct {
+    UINT8   Type;            ///< Must be 0
+    CHAR8   Id[5];           ///< "CD001" 
+    UINT8   Version;         ///< Must be 1 
+    CHAR8   SystemId[32];    ///< "EL TORITO SPECIFICATION" 
+    CHAR8   Unused[32];      ///< Must be 0 
+    UINT8   EltCatalog[4];   ///< Absolute pointer to first sector of Boot Catalog
+    CHAR8   Unused2[13];     ///< Must be 0
+  } BootRecordVolume;
+ 
+  ///
+  /// Primary Volumn Descriptor, defined in ISO 9660.
+  ///
+  struct {
+    UINT8   Type; 
+    CHAR8   Id[5];           ///< "CD001"
+    UINT8   Version; 
+    UINT8   Unused;          ///< Must be 0
+    CHAR8   SystemId[32];    
+    CHAR8   VolumeId[32];    
+    UINT8   Unused2[8];      ///< Must be 0 
+    UINT32  VolSpaceSize[2]; ///< the number of Logical Blocks
+  } PrimaryVolume;
+
+} CDROM_VOLUME_DESCRIPTOR; 
+
+///
+/// Catalog Entry
+///
+typedef union {
+  struct {
+    CHAR8       Reserved[0x20];
+  } Unknown;
+
+  ///
+  /// Catalog validation entry (Catalog header)
+  ///
+  struct {
+    UINT8   Indicator;       ///< Must be 01
+    UINT8   PlatformId;
+    UINT16  Reserved;
+    CHAR8   ManufacId[24];
+    UINT16  Checksum;
+    UINT16  Id55AA;
+  } Catalog;
+
+  ///
+  /// Initial/Default Entry or Section Entry
+  ///
+  struct {
+    UINT8   Indicator;       ///< 88 = Bootable, 00 = Not Bootable
+    UINT8   MediaType : 4;
+    UINT8   Reserved1 : 4;   ///< Must be 0
+    UINT16  LoadSegment;
+    UINT8   SystemType;
+    UINT8   Reserved2;       ///< Must be 0
+    UINT16  SectorCount;
+    UINT32  Lba;
+  } Boot;
+
+  ///
+  /// Section Header Entry
+  ///
+  struct {
+    UINT8   Indicator;       ///< 90 - Header, more header follw, 91 - Final Header
+    UINT8   PlatformId;
+    UINT16  SectionEntries;  ///< Number of section entries following this header
+    CHAR8   Id[28];
+  } Section;
+
+} ELTORITO_CATALOG;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Emmc.h b/MdePkg/Include/IndustryStandard/Emmc.h
new file mode 100644
index 000000000000..ad0ca55d7783
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Emmc.h
@@ -0,0 +1,297 @@
+/** @file
+  Header file for eMMC support.
+
+  This header file contains some definitions defined in EMMC4.5/EMMC5.0 spec.
+
+  Copyright (c) 2015, 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 __EMMC_H__
+#define __EMMC_H__
+
+//
+// EMMC command index
+//
+#define  EMMC_GO_IDLE_STATE           0
+#define  EMMC_SEND_OP_COND            1
+#define  EMMC_ALL_SEND_CID            2
+#define  EMMC_SET_RELATIVE_ADDR       3
+#define  EMMC_SET_DSR                 4
+#define  EMMC_SLEEP_AWAKE             5
+#define  EMMC_SWITCH                  6
+#define  EMMC_SELECT_DESELECT_CARD    7
+#define  EMMC_SEND_EXT_CSD            8
+#define  EMMC_SEND_CSD                9
+#define  EMMC_SEND_CID                10
+#define  EMMC_STOP_TRANSMISSION       12
+#define  EMMC_SEND_STATUS             13
+#define  EMMC_BUSTEST_R               14
+#define  EMMC_GO_INACTIVE_STATE       15
+#define  EMMC_SET_BLOCKLEN            16
+#define  EMMC_READ_SINGLE_BLOCK       17
+#define  EMMC_READ_MULTIPLE_BLOCK     18
+#define  EMMC_BUSTEST_W               19
+#define  EMMC_SEND_TUNING_BLOCK       21
+#define  EMMC_SET_BLOCK_COUNT         23
+#define  EMMC_WRITE_BLOCK             24
+#define  EMMC_WRITE_MULTIPLE_BLOCK    25
+#define  EMMC_PROGRAM_CID             26
+#define  EMMC_PROGRAM_CSD             27
+#define  EMMC_SET_WRITE_PROT          28
+#define  EMMC_CLR_WRITE_PROT          29
+#define  EMMC_SEND_WRITE_PROT         30
+#define  EMMC_SEND_WRITE_PROT_TYPE    31
+#define  EMMC_ERASE_GROUP_START       35
+#define  EMMC_ERASE_GROUP_END         36
+#define  EMMC_ERASE                   38
+#define  EMMC_FAST_IO                 39
+#define  EMMC_GO_IRQ_STATE            40
+#define  EMMC_LOCK_UNLOCK             42
+#define  EMMC_SET_TIME                49
+#define  EMMC_PROTOCOL_RD             53
+#define  EMMC_PROTOCOL_WR             54
+#define  EMMC_APP_CMD                 55
+#define  EMMC_GEN_CMD                 56
+
+typedef enum {
+  EmmcPartitionUserData              = 0,
+  EmmcPartitionBoot1                 = 1,
+  EmmcPartitionBoot2                 = 2,
+  EmmcPartitionRPMB                  = 3,
+  EmmcPartitionGP1                   = 4,
+  EmmcPartitionGP2                   = 5,
+  EmmcPartitionGP3                   = 6,
+  EmmcPartitionGP4                   = 7,
+  EmmcPartitionUnknown
+} EMMC_PARTITION_TYPE;
+
+#pragma pack(1)
+typedef struct {
+  UINT8   NotUsed:1;                              // Not used [0:0]
+  UINT8   Crc:7;                                  // CRC [7:1]
+  UINT8   ManufacturingDate;                      // Manufacturing date [15:8]
+  UINT8   ProductSerialNumber[4];                 // Product serial number [47:16]
+  UINT8   ProductRevision;                        // Product revision [55:48]
+  UINT8   ProductName[6];                         // Product name [103:56]
+  UINT8   OemId;                                  // OEM/Application ID [111:104]
+  UINT8   DeviceType:2;                           // Device/BGA [113:112]
+  UINT8   Reserved:6;                             // Reserved [119:114]
+  UINT8   ManufacturerId;                         // Manufacturer ID [127:120]
+} EMMC_CID;
+
+typedef struct {
+  UINT32  NotUsed:1;                              // Not used [0:0]
+  UINT32  Crc:7;                                  // CRC [7:1]
+  UINT32  Ecc:2;                                  // ECC code [9:8]
+  UINT32  FileFormat:2;                           // File format [11:10]
+  UINT32  TmpWriteProtect:1;                      // Temporary write protection [12:12]
+  UINT32  PermWriteProtect:1;                     // Permanent write protection [13:13]
+  UINT32  Copy:1;                                 // Copy flag (OTP) [14:14]
+  UINT32  FileFormatGrp:1;                        // File format group [15:15]
+  UINT32  ContentProtApp:1;                       // Content protection application [16:16]
+  UINT32  Reserved:4;                             // Reserved [20:17]
+  UINT32  WriteBlPartial:1;                       // Partial blocks for write allowed [21:21]
+  UINT32  WriteBlLen:4;                           // Max. write data block length [25:22]
+  UINT32  R2WFactor:3;                            // Write speed factor [28:26]
+  UINT32  DefaultEcc:2;                           // Manufacturer default ECC [30:29]
+  UINT32  WpGrpEnable:1;                          // Write protect group enable [31:31]
+
+  UINT32  WpGrpSize:5;                            // Write protect group size [36:32]
+  UINT32  EraseGrpMult:5;                         // Erase group size multiplier [41:37]
+  UINT32  EraseGrpSize:5;                         // Erase group size [46:42]
+  UINT32  CSizeMult:3;                            // Device size multiplier [49:47]
+  UINT32  VddWCurrMax:3;                          // Max. write current @ VDD max [52:50]
+  UINT32  VddWCurrMin:3;                          // Max. write current @ VDD min [55:53]
+  UINT32  VddRCurrMax:3;                          // Max. read current @ VDD max [58:56]
+  UINT32  VddRCurrMin:3;                          // Max. read current @ VDD min [61:59]
+  UINT32  CSizeLow:2;                             // Device size low two bits [63:62]
+
+  UINT32  CSizeHigh:10;                           // Device size high eight bits [73:64]
+  UINT32  Reserved1:2;                            // Reserved [75:74]
+  UINT32  DsrImp:1;                               // DSR implemented [76:76]
+  UINT32  ReadBlkMisalign:1;                      // Read block misalignment [77:77]
+  UINT32  WriteBlkMisalign:1;                     // Write block misalignment [78:78]
+  UINT32  ReadBlPartial:1;                        // Partial blocks for read allowed [79:79]
+  UINT32  ReadBlLen:4;                            // Max. read data block length [83:80]
+  UINT32  Ccc:12;                                 // Device command classes [95:84]
+
+  UINT32  TranSpeed:8;                            // Max. bus clock frequency [103:96]
+  UINT32  Nsac:8;                                 // Data read access-time 2 in CLK cycles (NSAC*100) [111:104]
+  UINT32  Taac:8;                                 // Data read access-time 1 [119:112]
+  UINT32  Reserved2:2;                            // Reserved [121:120]
+  UINT32  SpecVers:4;                             // System specification version [125:122]
+  UINT32  CsdStructure:2;                         // CSD structure [127:126]
+} EMMC_CSD;
+
+typedef struct {
+  //
+  // Modes Segment
+  //
+  UINT8   Reserved[16];                           // Reserved [15:0]
+  UINT8   SecureRemovalType;                      // Secure Removal Type R/W & R [16]
+  UINT8   ProductStateAwarenessEnablement;        // Product state awareness enablement R/W/E & R [17]
+  UINT8   MaxPreLoadingDataSize[4];               // Max pre loading data size R [21:18]
+  UINT8   PreLoadingDataSize[4];                  // Pre loading data size R/W/EP [25:22]
+  UINT8   FfuStatus;                              // FFU status R [26]
+  UINT8   Reserved1[2];                           // Reserved [28:27]
+  UINT8   ModeOperationCodes;                     // Mode operation codes W/EP [29]
+  UINT8   ModeConfig;                             // Mode config R/W/EP [30]
+  UINT8   Reserved2;                              // Reserved [31]
+  UINT8   FlushCache;                             // Flushing of the cache W/EP [32]
+  UINT8   CacheCtrl;                              // Control to turn the Cache ON/OFF R/W/EP [33]
+  UINT8   PowerOffNotification;                   // Power Off Notification R/W/EP [34]
+  UINT8   PackedFailureIndex;                     // Packed command failure index R [35]
+  UINT8   PackedCommandStatus;                    // Packed command status R [36]
+  UINT8   ContextConf[15];                        // Context configuration R/W/EP [51:37]
+  UINT8   ExtPartitionsAttribute[2];              // Extended Partitions Attribute R/W [53:52]
+  UINT8   ExceptionEventsStatus[2];               // Exception events status R [55:54]
+  UINT8   ExceptionEventsCtrl[2];                 // Exception events control R/W/EP [57:56]
+  UINT8   DyncapNeeded;                           // Number of addressed group to be Released R [58]
+  UINT8   Class6Ctrl;                             // Class 6 commands control R/W/EP [59]
+  UINT8   IniTimeoutEmu;                          // 1st initialization after disabling sector size emulation R [60]
+  UINT8   DataSectorSize;                         // Sector size R [61]
+  UINT8   UseNativeSector;                        // Sector size emulation R/W [62]
+  UINT8   NativeSectorSize;                       // Native sector size R [63]
+  UINT8   VendorSpecificField[64];                // Vendor Specific Fields <vendor specific> [127:64]
+  UINT8   Reserved3[2];                           // Reserved [129:128]
+  UINT8   ProgramCidCsdDdrSupport;                // Program CID/CSD in DDR mode support R [130]
+  UINT8   PeriodicWakeup;                         // Periodic Wake-up R/W/E [131]
+  UINT8   TcaseSupport;                           // Package Case Temperature is controlled W/EP [132]
+  UINT8   ProductionStateAwareness;               // Production state awareness R/W/E [133]
+  UINT8   SecBadBlkMgmnt;                         // Bad Block Management mode R/W [134]
+  UINT8   Reserved4;                              // Reserved [135]
+  UINT8   EnhStartAddr[4];                        // Enhanced User Data Start Address R/W [139:136]
+  UINT8   EnhSizeMult[3];                         // Enhanced User Data Area Size R/W [142:140]
+  UINT8   GpSizeMult[12];                         // General Purpose Partition Size R/W [154:143]
+  UINT8   PartitionSettingCompleted;              // Partitioning Setting R/W [155]
+  UINT8   PartitionsAttribute;                    // Partitions attribute R/W [156]
+  UINT8   MaxEnhSizeMult[3];                      // Max Enhanced Area Size R [159:157]
+  UINT8   PartitioningSupport;                    // Partitioning Support R [160]
+  UINT8   HpiMgmt;                                // HPI management R/W/EP [161]
+  UINT8   RstFunction;                            // H/W reset function R/W [162]
+  UINT8   BkopsEn;                                // Enable background operations handshake R/W [163]
+  UINT8   BkopsStart;                             // Manually start background operations W/EP [164]
+  UINT8   SanitizeStart;                          // Start Sanitize operation W/EP [165]
+  UINT8   WrRelParam;                             // Write reliability parameter register R [166]
+  UINT8   WrRelSet;                               // Write reliability setting register R/W [167]
+  UINT8   RpmbSizeMult;                           // RPMB Size R [168]
+  UINT8   FwConfig;                               // FW configuration R/W [169]
+  UINT8   Reserved5;                              // Reserved [170]
+  UINT8   UserWp;                                 // User area write protection register R/W,R/W/CP&R/W/EP [171]
+  UINT8   Reserved6;                              // Reserved [172]
+  UINT8   BootWp;                                 // Boot area write protection register R/W&R/W/CP[173]
+  UINT8   BootWpStatus;                           // Boot write protection status registers R [174]
+  UINT8   EraseGroupDef;                          // High-density erase group definition R/W/EP [175]
+  UINT8   Reserved7;                              // Reserved [176]
+  UINT8   BootBusConditions;                      // Boot bus Conditions R/W/E [177]
+  UINT8   BootConfigProt;                         // Boot config protection R/W&R/W/CP[178]
+  UINT8   PartitionConfig;                        // Partition configuration R/W/E&R/W/EP[179]
+  UINT8   Reserved8;                              // Reserved [180]
+  UINT8   ErasedMemCont;                          // Erased memory content R [181]
+  UINT8   Reserved9;                              // Reserved [182]
+  UINT8   BusWidth;                               // Bus width mode W/EP [183]
+  UINT8   Reserved10;                             // Reserved [184]
+  UINT8   HsTiming;                               // High-speed interface timing R/W/EP [185]
+  UINT8   Reserved11;                             // Reserved [186]
+  UINT8   PowerClass;                             // Power class R/W/EP [187]
+  UINT8   Reserved12;                             // Reserved [188]
+  UINT8   CmdSetRev;                              // Command set revision R [189]
+  UINT8   Reserved13;                             // Reserved [190]
+  UINT8   CmdSet;                                 // Command set R/W/EP [191]
+  //
+  // Properties Segment
+  //
+  UINT8   ExtCsdRev;                              // Extended CSD revision [192]
+  UINT8   Reserved14;                             // Reserved [193]
+  UINT8   CsdStructure;                           // CSD STRUCTURE [194]
+  UINT8   Reserved15;                             // Reserved [195]
+  UINT8   DeviceType;                             // Device type [196]
+  UINT8   DriverStrength;                         // I/O Driver Strength [197]
+  UINT8   OutOfInterruptTime;                     // Out-of-interrupt busy timing[198]
+  UINT8   PartitionSwitchTime;                    // Partition switching timing [199]
+  UINT8   PwrCl52M195V;                           // Power class for 52MHz at 1.95V [200]
+  UINT8   PwrCl26M195V;                           // Power class for 26MHz at 1.95V [201]
+  UINT8   PwrCl52M360V;                           // Power class for 52MHz at 3.6V [202]
+  UINT8   PwrCl26M360V;                           // Power class for 26MHz at 3.6V [203]
+  UINT8   Reserved16;                             // Reserved [204]
+  UINT8   MinPerfR4B26M;                          // Minimum Read Performance for 4bit at 26MHz [205]
+  UINT8   MinPerfW4B26M;                          // Minimum Write Performance for 4bit at 26MHz [206]
+  UINT8   MinPerfR8B26M4B52M;                     // Minimum Read Performance for 8bit at 26MHz, for 4bit at 52MHz [207]
+  UINT8   MinPerfW8B26M4B52M;                     // Minimum Write Performance for 8bit at 26MHz, for 4bit at 52MHz [208]
+  UINT8   MinPerfR8B52M;                          // Minimum Read Performance for 8bit at 52MHz [209]
+  UINT8   MinPerfW8B52M;                          // Minimum Write Performance for 8bit at 52MHz [210]
+  UINT8   Reserved17;                             // Reserved [211]
+  UINT8   SecCount[4];                            // Sector Count [215:212]
+  UINT8   SleepNotificationTime;                  // Sleep Notification Timout [216]
+  UINT8   SATimeout;                              // Sleep/awake timeout [217]
+  UINT8   ProductionStateAwarenessTimeout;        // Production state awareness timeout [218]
+  UINT8   SCVccq;                                 // Sleep current (VCCQ) [219]
+  UINT8   SCVcc;                                  // Sleep current (VCC) [220]
+  UINT8   HcWpGrpSize;                            // High-capacity write protect group size [221]
+  UINT8   RelWrSecC;                              // Reliable write sector count [222]
+  UINT8   EraseTimeoutMult;                       // High-capacity erase timeout [223]
+  UINT8   HcEraseGrpSize;                         // High-capacity erase unit size [224]
+  UINT8   AccSize;                                // Access size [225]
+  UINT8   BootSizeMult;                           // Boot partition size [226]
+  UINT8   Reserved18;                             // Reserved [227]
+  UINT8   BootInfo;                               // Boot information [228]
+  UINT8   SecTrimMult;                            // Secure TRIM Multiplier [229]
+  UINT8   SecEraseMult;                           // Secure Erase Multiplier [230]
+  UINT8   SecFeatureSupport;                      // Secure Feature support [231]
+  UINT8   TrimMult;                               // TRIM Multiplier [232]
+  UINT8   Reserved19;                             // Reserved [233]
+  UINT8   MinPerfDdrR8b52M;                       // Minimum Read Performance for 8bit at 52MHz in DDR mode [234]
+  UINT8   MinPerfDdrW8b52M;                       // Minimum Write Performance for 8bit at 52MHz in DDR mode [235]
+  UINT8   PwrCl200M130V;                          // Power class for 200MHz, at VCCQ=1.3V, VCC = 3.6V [236]
+  UINT8   PwrCl200M195V;                          // Power class for 200MHz at VCCQ=1.95V, VCC = 3.6V [237]
+  UINT8   PwrClDdr52M195V;                        // Power class for 52MHz, DDR at VCC= 1.95V [238]
+  UINT8   PwrClDdr52M360V;                        // Power class for 52MHz, DDR at VCC= 3.6V [239]
+  UINT8   Reserved20;                             // Reserved [240]
+  UINT8   IniTimeoutAp;                           // 1st initialization time after partitioning [241]
+  UINT8   CorrectlyPrgSectorsNum[4];              // Number of correctly programmed sectors [245:242]
+  UINT8   BkopsStatus;                            // Background operations status [246]
+  UINT8   PowerOffLongTime;                       // Power off notification(long) timeout [247]
+  UINT8   GenericCmd6Time;                        // Generic CMD6 timeout [248]
+  UINT8   CacheSize[4];                           // Cache size [252:249]
+  UINT8   PwrClDdr200M360V;                       // Power class for 200MHz, DDR at VCC= 3.6V [253]
+  UINT8   FirmwareVersion[8];                     // Firmware version [261:254]
+  UINT8   DeviceVersion[2];                       // Device version [263:262]
+  UINT8   OptimalTrimUnitSize;                    // Optimal trim unit size[264]
+  UINT8   OptimalWriteSize;                       // Optimal write size [265]
+  UINT8   OptimalReadSize;                        // Optimal read size [266]
+  UINT8   PreEolInfo;                             // Pre EOL information [267]
+  UINT8   DeviceLifeTimeEstTypA;                  // Device life time estimation type A [268]
+  UINT8   DeviceLifeTimeEstTypB;                  // Device life time estimation type B [269]
+  UINT8   VendorProprietaryHealthReport[32];      // Vendor proprietary health report [301:270]
+  UINT8   NumOfFwSectorsProgrammed[4];            // Number of FW sectors correctly programmed [305:302]
+  UINT8   Reserved21[181];                        // Reserved [486:306]
+  UINT8   FfuArg[4];                              // FFU Argument [490:487]
+  UINT8   OperationCodeTimeout;                   // Operation codes timeout [491]
+  UINT8   FfuFeatures;                            // FFU features [492]
+  UINT8   SupportedModes;                         // Supported modes [493]
+  UINT8   ExtSupport;                             // Extended partitions attribute support [494]
+  UINT8   LargeUnitSizeM1;                        // Large Unit size [495]
+  UINT8   ContextCapabilities;                    // Context management capabilities [496]
+  UINT8   TagResSize;                             // Tag Resources Size [497]
+  UINT8   TagUnitSize;                            // Tag Unit Size [498]
+  UINT8   DataTagSupport;                         // Data Tag Support [499]
+  UINT8   MaxPackedWrites;                        // Max packed write commands [500]
+  UINT8   MaxPackedReads;                         // Max packed read commands[501]
+  UINT8   BkOpsSupport;                           // Background operations support [502]
+  UINT8   HpiFeatures;                            // HPI features [503]
+  UINT8   SupportedCmdSet;                        // Supported Command Sets [504]
+  UINT8   ExtSecurityErr;                         // Extended Security Commands Error [505]
+  UINT8   Reserved22[6];                          // Reserved [511:506]
+} EMMC_EXT_CSD;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/HighPrecisionEventTimerTable.h b/MdePkg/Include/IndustryStandard/HighPrecisionEventTimerTable.h
new file mode 100644
index 000000000000..97b1c45edfc9
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/HighPrecisionEventTimerTable.h
@@ -0,0 +1,52 @@
+/** @file
+  ACPI high precision event timer table definition, at www.intel.com
+  Specification name is IA-PC HPET (High Precision Event Timers) Specification.
+    
+  Copyright (c) 2007 - 2008, 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 _HIGH_PRECISION_EVENT_TIMER_TABLE_H_
+#define _HIGH_PRECISION_EVENT_TIMER_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// High Precision Event Timer Table header definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  EventTimerBlockId;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  BaseAddressLower32Bit;
+  UINT8                                   HpetNumber;
+  UINT16                                  MainCounterMinimumClockTickInPeriodicMode;
+  UINT8                                   PageProtectionAndOemAttribute;
+} EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER;
+
+///
+/// HPET Revision (defined in spec)
+///
+#define EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_REVISION  0x01
+
+//
+// Page protection setting
+// Values 3 through 15 are reserved for use by the specification
+//
+#define EFI_ACPI_NO_PAGE_PROTECTION   0
+#define EFI_ACPI_4KB_PAGE_PROTECTION  1
+#define EFI_ACPI_64KB_PAGE_PROTECTION 2
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Hsti.h b/MdePkg/Include/IndustryStandard/Hsti.h
new file mode 100644
index 000000000000..2d9994ecb7fa
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Hsti.h
@@ -0,0 +1,82 @@
+/** @file
+  Support for HSTI 1.0 specification, defined at 
+  Microsoft Hardware Security Testability Specification.
+
+  Copyright (c) 2015, 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 __HSTI_H__
+#define __HSTI_H__
+
+#pragma pack(1)
+
+#define ADAPTER_INFO_PLATFORM_SECURITY_GUID \
+  {0x6be272c7, 0x1320, 0x4ccd, { 0x90, 0x17, 0xd4, 0x61, 0x2c, 0x01, 0x2b, 0x25 }}
+
+#define PLATFORM_SECURITY_VERSION_VNEXTCS         0x00000003
+
+#define PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE 0x00000001  // IHV
+#define PLATFORM_SECURITY_ROLE_PLATFORM_IBV       0x00000002
+#define PLATFORM_SECURITY_ROLE_IMPLEMENTOR_OEM    0x00000003 
+#define PLATFORM_SECURITY_ROLE_IMPLEMENTOR_ODM    0x00000004  
+
+typedef struct {
+  //
+  //  Return PLATFORM_SECURITY_VERSION_VNEXTCS
+  //
+  UINT32  Version;
+  //
+  // The role of the publisher of this interface.  Reference platform designers
+  // such as IHVs and IBVs are expected to return PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE
+  // and PLATFORM_SECURITY_ROLE_PLATFORM_IBV respectively.
+  // If the test modules from the designers are unable to fully verify all
+  // security features, then the platform implementers, OEMs and ODMs, will
+  // need to publish this interface with a role of Implementer.
+  //
+  UINT32  Role;
+  //
+  // Human readable vendor, model, & version of this implementation.
+  //
+  CHAR16  ImplementationID[256];
+  //
+  // The size in bytes of the SecurityFeaturesRequired and SecurityFeaturesEnabled arrays.
+  // The arrays must be the same size.
+  //
+  UINT32  SecurityFeaturesSize;
+  //
+  // IHV-defined bitfield corresponding to all security features which must be
+  // implemented to meet the security requirements defined by PLATFORM_SECURITY_VERSION Version.
+  //
+//UINT8   SecurityFeaturesRequired[];     //Ignored for non-IHV
+  //
+  // Publisher-defined bitfield corresponding to all security features which
+  // have implemented programmatic tests in this module.
+  //
+//UINT8   SecurityFeaturesImplemented[];
+  //
+  // Publisher-defined bitfield corresponding to all security features which
+  // have been verified implemented by this implementation.
+  //
+//UINT8   SecurityFeaturesVerified[];
+  //
+  // A Null-terminated string, one failure per line (CR/LF terminated), with a
+  // unique identifier that the OEM/ODM can use to locate the documentation
+  // which will describe the steps to remediate the failure - a URL to the
+  // documentation is recommended.
+  //
+//CHAR16	ErrorString[];
+} ADAPTER_INFO_PLATFORM_SECURITY;
+
+#pragma pack()
+
+extern EFI_GUID gAdapterInfoPlatformSecurityGuid;
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Http11.h b/MdePkg/Include/IndustryStandard/Http11.h
new file mode 100644
index 000000000000..797e74e4d4b9
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Http11.h
@@ -0,0 +1,254 @@
+/** @file
+  Hypertext Transfer Protocol -- HTTP/1.1 Standard definitions, from RFC 2616    
+
+  This file contains common HTTP 1.1 definitions from RFC 2616 
+   
+  (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<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 __HTTP_11_H__
+#define __HTTP_11_H__
+
+#pragma pack(1)
+
+///
+/// HTTP Version (currently HTTP 1.1)
+/// 
+/// The version of an HTTP message is indicated by an HTTP-Version field
+/// in the first line of the message.
+///
+#define HTTP_VERSION        "HTTP/1.1"
+
+///
+/// HTTP Request Method definitions
+/// 
+/// The Method  token indicates the method to be performed on the
+/// resource identified by the Request-URI. The method is case-sensitive.
+///
+#define HTTP_METHOD_OPTIONS "OPTIONS"
+#define HTTP_METHOD_GET     "GET"
+#define HTTP_METHOD_HEAD    "HEAD"
+#define HTTP_METHOD_POST    "POST"
+#define HTTP_METHOD_PUT     "PUT"
+#define HTTP_METHOD_DELETE  "DELETE"
+#define HTTP_METHOD_TRACE   "TRACE"
+#define HTTP_METHOD_CONNECT "CONNECT"
+#define HTTP_METHOD_PATCH   "PATCH"
+
+///
+/// Connect method has maximum length according to EFI_HTTP_METHOD defined in
+/// UEFI2.5 spec so use this.
+///
+#define HTTP_METHOD_MAXIMUM_LEN  sizeof (HTTP_METHOD_CONNECT)
+
+///
+/// Accept Request Header
+/// The Accept request-header field can be used to specify certain media types which are 
+/// acceptable for the response. Accept headers can be used to indicate that the request 
+/// is specifically limited to a small set of desired types, as in the case of a request 
+/// for an in-line image.
+///
+#define HTTP_HEADER_ACCEPT             "Accept"
+
+
+/// 
+/// Accept-Charset Request Header
+/// The Accept-Charset request-header field can be used to indicate what character sets 
+/// are acceptable for the response. This field allows clients capable of understanding 
+/// more comprehensive or special-purpose character sets to signal that capability to a 
+/// server which is capable of representing documents in those character sets.
+///
+#define HTTP_HEADER_ACCEPT_CHARSET     "Accept-Charset"
+
+/// 
+/// Accept-Language Request Header
+/// The Accept-Language request-header field is similar to Accept, 
+/// but restricts the set of natural languages that are preferred 
+/// as a response to the request.
+///
+#define HTTP_HEADER_ACCEPT_LANGUAGE    "Accept-Language"
+
+///
+/// Accept-Ranges Request Header
+/// The Accept-Ranges response-header field allows the server to
+/// indicate its acceptance of range requests for a resource:
+///
+#define HTTP_HEADER_ACCEPT_RANGES      "Accept-Ranges"
+
+
+/// 
+/// Accept-Encoding Request Header
+/// The Accept-Encoding request-header field is similar to Accept, 
+/// but restricts the content-codings that are acceptable in the response.
+///
+#define HTTP_HEADER_ACCEPT_ENCODING    "Accept-Encoding"
+
+///
+/// Content-Encoding Header
+/// The Content-Encoding entity-header field is used as a modifier to the media-type. 
+/// When present, its value indicates what additional content codings have been applied 
+/// to the entity-body, and thus what decoding mechanisms must be applied in order to 
+/// obtain the media-type referenced by the Content-Type header field. Content-Encoding 
+/// is primarily used to allow a document to be compressed without losing the identity 
+/// of its underlying media type.
+///
+#define HTTP_HEADER_CONTENT_ENCODING   "Content-Encoding"
+
+/// 
+/// HTTP Content-Encoding Compression types
+///
+
+#define HTTP_CONTENT_ENCODING_IDENTITY "identity"  /// No transformation is used. This is the default value for content coding.
+#define HTTP_CONTENT_ENCODING_GZIP     "gzip"      /// Content-Encoding: GNU zip format (described in RFC 1952).
+#define HTTP_CONTENT_ENCODING_COMPRESS "compress"  /// encoding format produced by the common UNIX file compression program "compress". 
+#define HTTP_CONTENT_ENCODING_DEFLATE  "deflate"   /// The "zlib" format defined in RFC 1950 in combination with the "deflate" 
+                                                   /// compression mechanism described in RFC 1951.
+
+
+///
+/// Content-Type Header
+/// The Content-Type entity-header field indicates the media type of the entity-body sent to 
+/// the recipient or, in the case of the HEAD method, the media type that would have been sent 
+/// had the request been a GET.
+///
+#define HTTP_HEADER_CONTENT_TYPE       "Content-Type"
+//
+// Common Media Types defined in http://www.iana.org/assignments/media-types/media-types.xhtml
+//
+#define HTTP_CONTENT_TYPE_APP_JSON          "application/json"
+#define HTTP_CONTENT_TYPE_APP_OCTET_STREAM  "application/octet-stream"
+                                           
+#define HTTP_CONTENT_TYPE_TEXT_HTML         "text/html"
+#define HTTP_CONTENT_TYPE_TEXT_PLAIN        "text/plain"
+#define HTTP_CONTENT_TYPE_TEXT_CSS          "text/css"
+#define HTTP_CONTENT_TYPE_TEXT_XML          "text/xml"
+                                           
+#define HTTP_CONTENT_TYPE_IMAGE_GIF         "image/gif"
+#define HTTP_CONTENT_TYPE_IMAGE_JPEG        "image/jpeg"
+#define HTTP_CONTENT_TYPE_IMAGE_PNG         "image/png"
+#define HTTP_CONTENT_TYPE_IMAGE_SVG_XML     "image/svg+xml"
+
+
+///
+/// Content-Length Header
+/// The Content-Length entity-header field indicates the size of the entity-body, 
+/// in decimal number of OCTETs, sent to the recipient or, in the case of the HEAD 
+/// method, the size of the entity-body that would have been sent had the request been a GET.
+///
+#define HTTP_HEADER_CONTENT_LENGTH     "Content-Length"
+                                                                                                              
+///
+/// Transfer-Encoding Header
+/// The Transfer-Encoding general-header field indicates what (if any) type of transformation 
+/// has been applied to the message body in order to safely transfer it between the sender 
+/// and the recipient. This differs from the content-coding in that the transfer-coding 
+/// is a property of the message, not of the entity.
+///
+#define HTTP_HEADER_TRANSFER_ENCODING  "Transfer-Encoding"
+
+
+///
+/// User Agent Request Header
+/// 
+/// The User-Agent request-header field contains information about the user agent originating 
+/// the request. This is for statistical purposes, the tracing of protocol violations, and 
+/// automated recognition of user agents for the sake of tailoring responses to avoid 
+/// particular user agent limitations. User agents SHOULD include this field with requests. 
+/// The field can contain multiple product tokens and comments identifying the agent and any 
+/// subproducts which form a significant part of the user agent. 
+/// By convention, the product tokens are listed in order of their significance for 
+/// identifying the application.
+///
+#define HTTP_HEADER_USER_AGENT         "User-Agent"
+
+///
+/// Host Request Header
+///
+/// The Host request-header field specifies the Internet host and port number of the resource 
+/// being requested, as obtained from the original URI given by the user or referring resource 
+///
+#define HTTP_HEADER_HOST              "Host"
+
+///
+/// Location Response Header
+/// 
+/// The Location response-header field is used to redirect the recipient to a location other than 
+/// the Request-URI for completion of the request or identification of a new resource. 
+/// For 201 (Created) responses, the Location is that of the new resource which was created by 
+/// the request. For 3xx responses, the location SHOULD indicate the server's preferred URI for 
+/// automatic redirection to the resource. The field value consists of a single absolute URI.
+///
+#define HTTP_HEADER_LOCATION           "Location"
+
+///
+/// The If-Match request-header field is used with a method to make it conditional.
+/// A client that has one or more entities previously obtained from the resource 
+/// can verify that one of those entities is current by including a list of their 
+/// associated entity tags in the If-Match header field. 
+/// The purpose of this feature is to allow efficient updates of cached information 
+/// with a minimum amount of transaction overhead. It is also used, on updating requests, 
+/// to prevent inadvertent modification of the wrong version of a resource. 
+/// As a special case, the value "*" matches any current entity of the resource.
+///
+#define HTTP_HEADER_IF_MATCH          "If-Match"
+
+
+///
+/// The If-None-Match request-header field is used with a method to make it conditional. 
+/// A client that has one or more entities previously obtained from the resource can verify 
+/// that none of those entities is current by including a list of their associated entity 
+/// tags in the If-None-Match header field. The purpose of this feature is to allow efficient 
+/// updates of cached information with a minimum amount of transaction overhead. It is also used 
+/// to prevent a method (e.g. PUT) from inadvertently modifying an existing resource when the 
+/// client believes that the resource does not exist.
+///
+#define HTTP_HEADER_IF_NONE_MATCH     "If-None-Match"
+
+
+
+/// 
+/// Authorization Request Header
+/// The Authorization field value consists of credentials
+/// containing the authentication information of the user agent for
+/// the realm of the resource being requested.
+///
+#define HTTP_HEADER_AUTHORIZATION     "Authorization"
+
+///
+/// ETAG Response Header
+/// The ETag response-header field provides the current value of the entity tag 
+/// for the requested variant. 
+///
+#define HTTP_HEADER_ETAG              "ETag"
+
+///
+/// Custom header field checked by the iLO web server to
+/// specify a client session key.
+/// Example:     X-Auth-Token: 24de6b1f8fa147ad59f6452def628798
+///
+#define  HTTP_HEADER_X_AUTH_TOKEN      "X-Auth-Token"
+
+///
+/// Expect Header
+/// The "Expect" header field in a request indicates a certain set of
+/// behaviors (expectations) that need to be supported by the server in
+/// order to properly handle this request. The only such expectation
+/// defined by this specification is 100-continue.
+///
+#define  HTTP_HEADER_EXPECT            "Expect"
+
+///
+/// Expect Header Value
+///
+#define  HTTP_EXPECT_100_CONTINUE       "100-continue"
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IScsiBootFirmwareTable.h b/MdePkg/Include/IndustryStandard/IScsiBootFirmwareTable.h
new file mode 100644
index 000000000000..d542b2c41291
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IScsiBootFirmwareTable.h
@@ -0,0 +1,167 @@
+/** @file
+  The definition for iSCSI Boot Firmware Table, it's defined in Microsoft's
+  iSCSI Boot Firmware Table(iBFT) as Defined in ACPI 3.0b Specification. 
+  
+  Copyright (c) 2006 - 2013, 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 _ISCSI_BOOT_FIRMWARE_TABLE_H_
+#define _ISCSI_BOOT_FIRMWARE_TABLE_H_
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_REVISION            0x01
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_ALIGNMENT 8
+
+///
+/// Structure Type/ID
+///
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_RESERVED_STRUCTURE_ID         0
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE_ID          1
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_ID        2
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_ID              3
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_ID           4
+#define  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_EXTERNSIONS_STRUCTURE_ID      5
+
+///
+/// from the definition of IP_PREFIX_ORIGIN Enumeration in MSDN,
+/// not defined in Microsoft iBFT document.
+///
+typedef enum {
+  IpPrefixOriginOther = 0,
+  IpPrefixOriginManual,
+  IpPrefixOriginWellKnown,
+  IpPrefixOriginDhcp,
+  IpPrefixOriginRouterAdvertisement,
+  IpPrefixOriginUnchanged = 16
+} IP_PREFIX_VALUE;
+
+#pragma pack(1)
+
+///
+/// iBF Table Header
+///
+typedef struct {
+  UINT32  Signature;
+  UINT32  Length;
+  UINT8   Revision;
+  UINT8   Checksum;
+  UINT8   OemId[6];
+  UINT64  OemTableId;
+  UINT8   Reserved[24];
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_HEADER;
+
+///
+/// Common Header of Boot Firmware Table Structure 
+///
+typedef struct {
+  UINT8   StructureId;
+  UINT8   Version;
+  UINT16  Length;
+  UINT8   Index;
+  UINT8   Flags;
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_HEADER;
+
+///
+/// Control Structure
+///
+typedef struct {
+  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_HEADER  Header;
+  UINT16                                               Extensions;
+  UINT16                                               InitiatorOffset;
+  UINT16                                               NIC0Offset;
+  UINT16                                               Target0Offset;
+  UINT16                                               NIC1Offset;
+  UINT16                                               Target1Offset;  
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE;
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE_VERSION              0x1
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_CONTROL_STRUCTURE_FLAG_BOOT_FAILOVER   BIT0
+
+///
+/// Initiator Structure
+///
+typedef struct {
+  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_HEADER  Header;
+  EFI_IPv6_ADDRESS                                     ISnsServer;
+  EFI_IPv6_ADDRESS                                     SlpServer;
+  EFI_IPv6_ADDRESS                                     PrimaryRadiusServer;
+  EFI_IPv6_ADDRESS                                     SecondaryRadiusServer;
+  UINT16                                               IScsiNameLength;
+  UINT16                                               IScsiNameOffset;
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE;
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_VERSION             0x1
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_FLAG_BLOCK_VALID    BIT0 
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_INITIATOR_STRUCTURE_FLAG_BOOT_SELECTED  BIT1 
+
+///
+/// NIC Structure
+///
+typedef struct {
+  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_HEADER  Header;
+  EFI_IPv6_ADDRESS                                     Ip;
+  UINT8                                                SubnetMaskPrefixLength;
+  UINT8                                                Origin;
+  EFI_IPv6_ADDRESS                                     Gateway;
+  EFI_IPv6_ADDRESS                                     PrimaryDns;
+  EFI_IPv6_ADDRESS                                     SecondaryDns;
+  EFI_IPv6_ADDRESS                                     DhcpServer;
+  UINT16                                               VLanTag;
+  UINT8                                                Mac[6];
+  UINT16                                               PciLocation;
+  UINT16                                               HostNameLength;
+  UINT16                                               HostNameOffset;
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE;
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_VERSION                 0x1
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_FLAG_BLOCK_VALID        BIT0
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_FLAG_BOOT_SELECTED      BIT1
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_NIC_STRUCTURE_FLAG_GLOBAL             BIT2
+
+///
+/// Target Structure
+///
+typedef struct {
+  EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_STRUCTURE_HEADER  Header;
+  EFI_IPv6_ADDRESS                                     Ip;
+  UINT16                                               Port;
+  UINT8                                                BootLun[8];
+  UINT8                                                CHAPType;
+  UINT8                                                NicIndex;
+  UINT16                                               IScsiNameLength;
+  UINT16                                               IScsiNameOffset;
+  UINT16                                               CHAPNameLength;
+  UINT16                                               CHAPNameOffset;
+  UINT16                                               CHAPSecretLength;
+  UINT16                                               CHAPSecretOffset;
+  UINT16                                               ReverseCHAPNameLength;
+  UINT16                                               ReverseCHAPNameOffset;
+  UINT16                                               ReverseCHAPSecretLength;
+  UINT16                                               ReverseCHAPSecretOffset;
+} EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE;
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_VERSION               0x1
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_BLOCK_VALID      BIT0
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_BOOT_SELECTED    BIT1
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_RADIUS_CHAP      BIT2
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_FLAG_RADIUS_RCHAP     BIT3
+
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_NO_CHAP        0
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_CHAP           1
+#define EFI_ACPI_ISCSI_BOOT_FIRMWARE_TABLE_TARGET_STRUCTURE_CHAP_TYPE_MUTUAL_CHAP    2
+
+#pragma pack()
+
+#endif
+
diff --git a/MdePkg/Include/IndustryStandard/Ipmi.h b/MdePkg/Include/IndustryStandard/Ipmi.h
new file mode 100644
index 000000000000..4cb7494d7bca
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Ipmi.h
@@ -0,0 +1,29 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_H_
+#define _IPMI_H_
+
+#include <IndustryStandard/IpmiNetFnChassis.h>
+#include <IndustryStandard/IpmiNetFnBridge.h>
+#include <IndustryStandard/IpmiNetFnSensorEvent.h>
+#include <IndustryStandard/IpmiNetFnApp.h>
+#include <IndustryStandard/IpmiNetFnFirmware.h>
+#include <IndustryStandard/IpmiNetFnStorage.h>
+#include <IndustryStandard/IpmiNetFnTransport.h>
+#include <IndustryStandard/IpmiNetFnGroupExtension.h>
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnApp.h b/MdePkg/Include/IndustryStandard/IpmiNetFnApp.h
new file mode 100644
index 000000000000..2d2d8e7c3681
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnApp.h
@@ -0,0 +1,623 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  This file contains all NetFn App commands, including:
+    IPM Device "Global" Commands (Chapter 20)
+    Firmware Firewall & Command Discovery Commands (Chapter 21)
+    BMC Watchdog Timer Commands (Chapter 27)
+    IPMI Messaging Support Commands (Chapter 22)
+    RMCP+ Support and Payload Commands (Chapter 24)
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_APP_H_
+#define _IPMI_NET_FN_APP_H_
+
+#pragma pack(1)
+//
+// Net function definition for App command
+//
+#define IPMI_NETFN_APP  0x06
+
+//
+//  Below is Definitions for IPM Device "Global" Commands  (Chapter 20)
+//
+
+//
+//  Definitions for Get Device ID command
+//
+#define IPMI_APP_GET_DEVICE_ID 0x1
+
+//
+//  Constants and Structure definitions for "Get Device ID" command to follow here
+//
+typedef struct {
+  UINT8   CompletionCode;
+  UINT8   DeviceId;
+  UINT8   DeviceRevision : 4;
+  UINT8   Reserved : 3;
+  UINT8   DeviceSdr : 1;
+  UINT8   MajorFirmwareRev : 7;
+  UINT8   UpdateMode : 1;
+  UINT8   MinorFirmwareRev;
+  UINT8   SpecificationVersion;
+  UINT8   SensorDeviceSupport : 1;
+  UINT8   SdrRepositorySupport : 1;
+  UINT8   SelDeviceSupport : 1;
+  UINT8   FruInventorySupport : 1;
+  UINT8   IpmbMessageReceiver : 1;
+  UINT8   IpmbMessageGenerator : 1;
+  UINT8   BridgeSupport : 1;
+  UINT8   ChassisSupport : 1;
+  UINT8   ManufacturerId[3];
+  UINT16  ProductId;
+  UINT32  AuxFirmwareRevInfo;
+} IPMI_GET_DEVICE_ID_RESPONSE;
+
+
+//
+//  Definitions for Cold Reset command
+//
+#define IPMI_APP_COLD_RESET  0x2
+
+//
+//  Constants and Structure definitions for "Cold Reset" command to follow here
+//
+
+//
+//  Definitions for Warm Reset command
+//
+#define IPMI_APP_WARM_RESET  0x3
+
+//
+//  Constants and Structure definitions for "Warm Reset" command to follow here
+//
+
+//
+//  Definitions for Get Self Results command
+//
+#define IPMI_APP_GET_SELFTEST_RESULTS  0x4
+
+//
+//  Constants and Structure definitions for "Get Self Test Results" command to follow here
+//
+typedef struct {
+  UINT8  CompletionCode;
+  UINT8  Result;
+  UINT8  Param;
+} IPMI_SELF_TEST_RESULT_RESPONSE;
+
+#define IPMI_APP_SELFTEST_NO_ERROR             0x55
+#define IPMI_APP_SELFTEST_NOT_IMPLEMENTED      0x56
+#define IPMI_APP_SELFTEST_ERROR                0x57
+#define IPMI_APP_SELFTEST_FATAL_HW_ERROR       0x58
+#define IPMI_APP_SELFTEST_INACCESSIBLE_SEL     0x80
+#define IPMI_APP_SELFTEST_INACCESSIBLE_SDR     0x40
+#define IPMI_APP_SELFTEST_INACCESSIBLE_FRU     0x20
+#define IPMI_APP_SELFTEST_IPMB_SIGNAL_FAIL     0x10
+#define IPMI_APP_SELFTEST_SDR_REPOSITORY_EMPTY 0x08
+#define IPMI_APP_SELFTEST_FRU_CORRUPT          0x04
+#define IPMI_APP_SELFTEST_FW_BOOTBLOCK_CORRUPT 0x02
+#define IPMI_APP_SELFTEST_FW_CORRUPT           0x01
+
+//
+//  Definitions for Manufacturing Test ON command
+//
+#define IPMI_APP_MANUFACTURING_TEST_ON 0x5
+
+//
+//  Constants and Structure definitions for "Manufacturing Test ON" command to follow here
+//
+
+//
+//  Definitions for Set ACPI Power State command
+//
+#define IPMI_APP_SET_ACPI_POWERSTATE 0x6
+
+//
+//  Constants and Structure definitions for "Set ACPI Power State" command to follow here
+//
+typedef struct {
+  UINT8  AcpiSystemPowerState  : 7;
+  UINT8  AcpiSystemStateChange : 1;
+  UINT8  AcpiDevicePowerState  : 7;
+  UINT8  AcpiDeviceStateChange : 1;
+} IPMI_SET_ACPI_POWER_STATE_REQUEST;
+
+//
+//  Definitions for Get ACPI Power State command
+//
+#define IPMI_APP_GET_ACPI_POWERSTATE 0x7
+
+//
+//  Constants and Structure definitions for "Get ACPI Power State" command to follow here
+//
+
+//
+//  Definitions for Get Device GUID command
+//
+#define IPMI_APP_GET_DEVICE_GUID 0x8
+
+//
+//  Constants and Structure definitions for "Get Device GUID" command to follow here
+//
+//
+//  Message structure definition for "Get Device Guid" IPMI command
+//
+typedef struct {
+  UINT8  CompletionCode;
+  UINT8  Guid[16];
+} IPMI_GET_DEVICE_GUID_RESPONSE;
+
+//
+//  Below is Definitions for BMC Watchdog Timer Commands (Chapter 27)
+//
+
+//
+//  Definitions for Reset WatchDog Timer command
+//
+#define IPMI_APP_RESET_WATCHDOG_TIMER  0x22
+
+//
+//  Constants and Structure definitions for "Reset WatchDog Timer" command to follow here
+//
+typedef struct {
+  UINT8 TimerUse : 3;
+  UINT8 Reserved : 3;
+  UINT8 TimerRunning : 1;
+  UINT8 TimerUseExpirationFlagLog : 1;
+} IPMI_WATCHDOG_TIMER_USE;
+
+//
+//  Definitions for Set WatchDog Timer command
+//
+#define IPMI_APP_SET_WATCHDOG_TIMER  0x24
+
+//
+//  Constants and Structure definitions for "Set WatchDog Timer" command to follow here
+//
+typedef struct {
+  IPMI_WATCHDOG_TIMER_USE         TimerUse;
+  UINT8                           TimerActions;
+  UINT8                           PretimeoutInterval;
+  UINT8                           TimerUseExpirationFlagsClear;
+  UINT16                          InitialCountdownValue;
+} IPMI_SET_WATCHDOG_TIMER_REQUEST;
+
+//
+//  Definitions for Get WatchDog Timer command
+//
+#define IPMI_APP_GET_WATCHDOG_TIMER  0x25
+
+//
+//  Constants and Structure definitions for "Get WatchDog Timer" command to follow here
+//
+typedef struct {
+  UINT8                           CompletionCode;
+  IPMI_WATCHDOG_TIMER_USE         TimerUse;
+  UINT8                           TimerActions;
+  UINT8                           PretimeoutInterval;
+  UINT8                           TimerUseExpirationFlagsClear;
+  UINT16                          InitialCountdownValue;
+  UINT16                          PresentCountdownValue;
+} IPMI_GET_WATCHDOG_TIMER_RESPONSE;
+
+//
+//  Below is Definitions for IPMI Messaging Support Commands (Chapter 22)
+//
+
+//
+//  Definitions for Set BMC Global Enables command
+//
+#define IPMI_APP_SET_BMC_GLOBAL_ENABLES  0x2E
+
+//
+//  Constants and Structure definitions for "Set BMC Global Enables " command to follow here
+//
+
+//
+//  Definitions for Get BMC Global Enables command
+//
+#define IPMI_APP_GET_BMC_GLOBAL_ENABLES  0x2F
+
+//
+//  Constants and Structure definitions for "Get BMC Global Enables " command to follow here
+//
+
+//
+//  Definitions for Clear Message Flags command
+//
+#define IPMI_APP_CLEAR_MESSAGE_FLAGS 0x30
+
+//
+//  Constants and Structure definitions for "Clear Message Flags" command to follow here
+//
+
+//
+//  Definitions for Get Message Flags command
+//
+#define IPMI_APP_GET_MESSAGE_FLAGS 0x31
+
+//
+//  Constants and Structure definitions for "Get Message Flags" command to follow here
+//
+
+//
+//  Definitions for Enable Message Channel Receive command
+//
+#define IPMI_APP_ENABLE_MESSAGE_CHANNEL_RECEIVE  0x32
+
+//
+//  Constants and Structure definitions for "Enable Message Channel Receive" command to follow here
+//
+
+//
+//  Definitions for Get Message command
+//
+#define IPMI_APP_GET_MESSAGE 0x33
+
+//
+//  Constants and Structure definitions for "Get Message" command to follow here
+//
+
+//
+//  Definitions for Send Message command
+//
+#define IPMI_APP_SEND_MESSAGE  0x34
+
+//
+//  Constants and Structure definitions for "Send Message" command to follow here
+//
+
+//
+//  Definitions for Read Event Message Buffer command
+//
+#define IPMI_APP_READ_EVENT_MSG_BUFFER 0x35
+
+//
+//  Constants and Structure definitions for "Read Event Message Buffer" command to follow here
+//
+
+//
+//  Definitions for Get BT Interface Capabilities command
+//
+#define IPMI_APP_GET_BT_INTERFACE_CAPABILITY 0x36
+
+//
+//  Constants and Structure definitions for "Get BT Interface Capabilities" command to follow here
+//
+
+//
+//  Definitions for Get System GUID command
+//
+#define IPMI_APP_GET_SYSTEM_GUID 0x37
+
+//
+//  Constants and Structure definitions for "Get System GUID" command to follow here
+//
+
+//
+//  Definitions for Get Channel Authentication Capabilities command
+//
+#define IPMI_APP_GET_CHANNEL_AUTHENTICATION_CAPABILITIES 0x38
+
+//
+//  Constants and Structure definitions for "Get Channel Authentication Capabilities" command to follow here
+//
+
+//
+//  Definitions for Get Session Challenge command
+//
+#define IPMI_APP_GET_SESSION_CHALLENGE 0x39
+
+//
+//  Constants and Structure definitions for "Get Session Challenge" command to follow here
+//
+
+//
+//  Definitions for Activate Session command
+//
+#define IPMI_APP_ACTIVATE_SESSION  0x3A
+
+//
+//  Constants and Structure definitions for "Activate Session" command to follow here
+//
+
+//
+//  Definitions for Set Session Privelege Level command
+//
+#define IPMI_APP_SET_SESSION_PRIVELEGE_LEVEL 0x3B
+
+//
+//  Constants and Structure definitions for "Set Session Privelege Level" command to follow here
+//
+
+//
+//  Definitions for Close Session command
+//
+#define IPMI_APP_CLOSE_SESSION 0x3C
+
+//
+//  Constants and Structure definitions for "Close Session" command to follow here
+//
+
+//
+//  Definitions for Get Session Info command
+//
+#define IPMI_APP_GET_SESSION_INFO  0x3D
+
+//
+//  Constants and Structure definitions for "Get Session Info" command to follow here
+//
+
+//
+//  Definitions for Get Auth Code command
+//
+#define IPMI_APP_GET_AUTHCODE  0x3F
+
+//
+//  Constants and Structure definitions for "Get AuthCode" command to follow here
+//
+
+//
+//  Definitions for Set Channel Access command
+//
+#define IPMI_APP_SET_CHANNEL_ACCESS  0x40
+
+//
+//  Constants and Structure definitions for "Set Channel Access" command to follow here
+//
+
+//
+//  Definitions for Get Channel Access command
+//
+#define IPMI_APP_GET_CHANNEL_ACCESS  0x41
+
+//
+//  Constants and Structure definitions for "Get Channel Access" command to follow here
+//
+typedef struct {
+  UINT8  ChannelNo : 4;
+  UINT8  Reserve1 : 4;
+  UINT8  Reserve2 : 6;
+  UINT8  MemoryType : 2;
+} IPMI_GET_CHANNEL_ACCESS_REQUEST;
+
+typedef struct {
+  UINT8  CompletionCode;
+  UINT8  AccessMode : 3;
+  UINT8  UserLevelAuthEnabled : 1;
+  UINT8  MessageAuthEnable : 1;
+  UINT8  Alert : 1;
+  UINT8  Reserve1 : 2;
+  UINT8  ChannelPriviledgeLimit : 4;
+  UINT8  Reserve2 : 4;
+} IPMI_GET_CHANNEL_ACCESS_RESPONSE;
+
+//
+//  Definitions for Get Channel Info command
+//
+#define IPMI_APP_GET_CHANNEL_INFO  0x42
+
+//
+//  Constants and Structure definitions for "Get Channel Info" command to follow here
+//
+typedef struct {
+  UINT8   CompletionCode;
+  UINT8   ChannelNo : 4;
+  UINT8   Reserve1 : 4;
+  UINT8   ChannelMediumType : 7;
+  UINT8   Reserve2 : 1;
+  UINT8   ChannelProtocolType : 5;
+  UINT8   Reserve3 : 3;
+  UINT8   ActiveSessionCount : 6;
+  UINT8   SessionSupport : 2;
+  UINT8   VendorId[3];
+  UINT16  AuxChannelInfo;
+} IPMI_GET_CHANNEL_INFO_RESPONSE;
+
+//
+//  Definitions for Get Channel Info command
+//
+#define IPMI_APP_GET_CHANNEL_INFO  0x42
+
+//
+//  Constants and Structure definitions for "Get Channel Info" command to follow here
+//
+
+//
+//  Definitions for Set User Access command
+//
+#define IPMI_APP_SET_USER_ACCESS 0x43
+
+//
+//  Constants and Structure definitions for "Set User Access" command to follow here
+//
+
+//
+//  Definitions for Get User Access command
+//
+#define IPMI_APP_GET_USER_ACCESS 0x44
+
+//
+//  Constants and Structure definitions for "Get User Access" command to follow here
+//
+
+//
+//  Definitions for Set User Name command
+//
+#define IPMI_APP_SET_USER_NAME 0x45
+
+//
+//  Constants and Structure definitions for "Set User Name" command to follow here
+//
+
+//
+//  Definitions for Get User Name command
+//
+#define IPMI_APP_GET_USER_NAME 0x46
+
+//
+//  Constants and Structure definitions for "Get User Name" command to follow here
+//
+
+//
+//  Definitions for Set User Password command
+//
+#define IPMI_APP_SET_USER_PASSWORD 0x47
+
+//
+//  Constants and Structure definitions for "Set User Password" command to follow here
+//
+
+//
+//  Below is Definitions for RMCP+ Support and Payload Commands (Chapter 24)
+//
+
+//
+//  Definitions for Activate Payload command
+//
+#define IPMI_APP_ACTIVATE_PAYLOAD  0x48
+
+//
+//  Constants and Structure definitions for "Activate Payload" command to follow here
+//
+
+//
+//  Definitions for De-Activate Payload command
+//
+#define IPMI_APP_DEACTIVATE_PAYLOAD  0x49
+
+//
+//  Constants and Structure definitions for "DeActivate Payload" command to follow here
+//
+
+//
+//  Definitions for Get Payload activation Status command
+//
+#define IPMI_APP_GET_PAYLOAD_ACTIVATION_STATUS 0x4a
+
+//
+//  Constants and Structure definitions for "Get Payload activation Status" command to follow here
+//
+
+//
+//  Definitions for Get Payload Instance Info command
+//
+#define IPMI_APP_GET_PAYLOAD_INSTANCE_INFO 0x4b
+
+//
+//  Constants and Structure definitions for "Get Payload Instance Info" command to follow here
+//
+
+//
+//  Definitions for Set User Payload Access command
+//
+#define IPMI_APP_SET_USER_PAYLOAD_ACCESS 0x4C
+
+//
+//  Constants and Structure definitions for "Set User Payload Access" command to follow here
+//
+
+//
+//  Definitions for Get User Payload Access command
+//
+#define IPMI_APP_GET_USER_PAYLOAD_ACCESS 0x4D
+
+//
+//  Constants and Structure definitions for "Get User Payload Access" command to follow here
+//
+
+//
+//  Definitions for Get Channel Payload Support command
+//
+#define IPMI_APP_GET_CHANNEL_PAYLOAD_SUPPORT 0x4E
+
+//
+//  Constants and Structure definitions for "Get Channel Payload Support" command to follow here
+//
+
+//
+//  Definitions for Get Channel Payload Version command
+//
+#define IPMI_APP_GET_CHANNEL_PAYLOAD_VERSION 0x4F
+
+//
+//  Constants and Structure definitions for "Get Channel Payload Version" command to follow here
+//
+
+//
+//  Definitions for Get Channel OEM Payload Info command
+//
+#define IPMI_APP_GET_CHANNEL_OEM_PAYLOAD_INFO  0x50
+
+//
+//  Constants and Structure definitions for "Get Channel OEM Payload Info" command to follow here
+//
+
+//
+//  Definitions for  Master Write-Read command
+//
+#define IPMI_APP_MASTER_WRITE_READ 0x52
+
+//
+//  Constants and Structure definitions for "Master Write Read" command to follow here
+//
+
+//
+//  Definitions for  Get Channel Cipher Suites command
+//
+#define IPMI_APP_GET_CHANNEL_CIPHER_SUITES 0x54
+
+//
+//  Constants and Structure definitions for "Get Channel Cipher Suites" command to follow here
+//
+
+//
+//  Below is Definitions for RMCP+ Support and Payload Commands (Chapter 24, Section 3)
+//
+
+//
+//  Definitions for  Suspend-Resume Payload Encryption command
+//
+#define IPMI_APP_SUSPEND_RESUME_PAYLOAD_ENCRYPTION 0x55
+
+//
+//  Constants and Structure definitions for "Suspend-Resume Payload Encryption" command to follow here
+//
+
+//
+//  Below is Definitions for IPMI Messaging Support Commands (Chapter 22, Section 25 and 9)
+//
+
+//
+//  Definitions for  Set Channel Security Keys command
+//
+#define IPMI_APP_SET_CHANNEL_SECURITY_KEYS 0x56
+
+//
+//  Constants and Structure definitions for "Set Channel Security Keys" command to follow here
+//
+
+//
+//  Definitions for  Get System Interface Capabilities command
+//
+#define IPMI_APP_GET_SYSTEM_INTERFACE_CAPABILITIES 0x57
+
+//
+//  Constants and Structure definitions for "Get System Interface Capabilities" command to follow here
+//
+
+#pragma pack()
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnBridge.h b/MdePkg/Include/IndustryStandard/IpmiNetFnBridge.h
new file mode 100644
index 000000000000..7f174fdc6975
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnBridge.h
@@ -0,0 +1,243 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+  IPMI Intelligent Chassis Management Bus Bridge Specification Version 1.0,
+  Revision 1.3.
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_BRIDGE_H_
+#define _IPMI_NET_FN_BRIDGE_H_
+
+//
+// Net function definition for Bridge command
+//
+#define IPMI_NETFN_BRIDGE 0x02
+
+//
+//  Definitions for Get Bridge State command
+//
+#define IPMI_BRIDGE_GET_STATE  0x00
+
+//
+//  Constants and Structure definitions for "Get Bridge State" command to follow here
+//
+
+//
+//  Definitions for Set Bridge State command
+//
+#define IPMI_BRIDGE_SET_STATE  0x01
+
+//
+//  Constants and Structure definitions for "Set Bridge State" command to follow here
+//
+
+//
+//  Definitions for Get ICMB Address command
+//
+#define IPMI_BRIDGE_GET_ICMB_ADDRESS 0x02
+
+//
+//  Constants and Structure definitions for "Get ICMB Address" command to follow here
+//
+
+//
+//  Definitions for Set ICMB Address command
+//
+#define IPMI_BRIDGE_SET_ICMB_ADDRESS 0x03
+
+//
+//  Constants and Structure definitions for "Set ICMB Address" command to follow here
+//
+
+//
+//  Definitions for Set Bridge Proxy Address command
+//
+#define IPMI_BRIDGE_SET_PROXY_ADDRESS  0x04
+
+//
+//  Constants and Structure definitions for "Set Bridge Proxy Address" command to follow here
+//
+
+//
+//  Definitions for Get Bridge Statistics command
+//
+#define IPMI_BRIDGE_GET_BRIDGE_STATISTICS  0x05
+
+//
+//  Constants and Structure definitions for "Get Bridge Statistics" command to follow here
+//
+
+//
+//  Definitions for Get ICMB Capabilities command
+//
+#define IPMI_BRIDGE_GET_ICMB_CAPABILITIES  0x06
+
+//
+//  Constants and Structure definitions for "Get ICMB Capabilities" command to follow here
+//
+
+//
+//  Definitions for Clear Bridge Statistics command
+//
+#define IPMI_BRIDGE_CLEAR_STATISTICS 0x08
+
+//
+//  Constants and Structure definitions for "Clear Bridge Statistics" command to follow here
+//
+
+//
+//  Definitions for Get Bridge Proxy Address command
+//
+#define IPMI_BRIDGE_GET_PROXY_ADDRESS  0x09
+
+//
+//  Constants and Structure definitions for "Get Bridge Proxy Address" command to follow here
+//
+
+//
+//  Definitions for Get ICMB Connector Info command
+//
+#define IPMI_BRIDGE_GET_ICMB_CONNECTOR_INFO  0x0A
+
+//
+//  Constants and Structure definitions for "Get ICMB Connector Info " command to follow here
+//
+
+//
+//  Definitions for Get ICMB Connection ID command
+//
+#define IPMI_BRIDGE_GET_ICMB_CONNECTION_ID 0x0B
+
+//
+//  Constants and Structure definitions for "Get ICMB Connection ID" command to follow here
+//
+
+//
+//  Definitions for Get ICMB Connection ID command
+//
+#define IPMI_BRIDGE_SEND_ICMB_CONNECTION_ID  0x0C
+
+//
+//  Constants and Structure definitions for "Send ICMB Connection ID" command to follow here
+//
+
+//
+//  Definitions for Prepare for Discoveery command
+//
+#define IPMI_BRIDGE_PREPARE_FOR_DISCOVERY  0x10
+
+//
+//  Constants and Structure definitions for "Prepare for Discoveery" command to follow here
+//
+
+//
+//  Definitions for Get Addresses command
+//
+#define IPMI_BRIDGE_GET_ADDRESSES  0x11
+
+//
+//  Constants and Structure definitions for "Get Addresses" command to follow here
+//
+
+//
+//  Definitions for Set Discovered command
+//
+#define IPMI_BRIDGE_SET_DISCOVERED 0x12
+
+//
+//  Constants and Structure definitions for "Set Discovered" command to follow here
+//
+
+//
+//  Definitions for Get Chassis Device ID command
+//
+#define IPMI_BRIDGE_GET_CHASSIS_DEVICEID 0x13
+
+//
+//  Constants and Structure definitions for "Get Chassis Device ID" command to follow here
+//
+
+//
+//  Definitions for Set Chassis Device ID command
+//
+#define IPMI_BRIDGE_SET_CHASSIS_DEVICEID 0x14
+
+//
+//  Constants and Structure definitions for "Set Chassis Device ID" command to follow here
+//
+
+//
+//  Definitions for Bridge Request command
+//
+#define IPMI_BRIDGE_REQUEST  0x20
+
+//
+//  Constants and Structure definitions for "Bridge Request" command to follow here
+//
+
+//
+//  Definitions for Bridge Message command
+//
+#define IPMI_BRIDGE_MESSAGE  0x21
+
+//
+//  Constants and Structure definitions for "Bridge Message" command to follow here
+//
+
+//
+//  Definitions for Get Event Count command
+//
+#define IPMI_BRIDGE_GET_EVENT_COUNT  0x30
+
+//
+//  Constants and Structure definitions for "Get Event Count" command to follow here
+//
+
+//
+//  Definitions for Set Event Destination command
+//
+#define IPMI_BRIDGE_SET_EVENT_DESTINATION  0x31
+
+//
+//  Constants and Structure definitions for "Set Event Destination" command to follow here
+//
+
+//
+//  Definitions for Set Event Reception State command
+//
+#define IPMI_BRIDGE_SET_EVENT_RECEPTION_STATE  0x32
+
+//
+//  Constants and Structure definitions for "Set Event Reception State" command to follow here
+//
+
+//
+//  Definitions for Set Event Reception State command
+//
+#define IPMI_BRIDGE_SET_EVENT_RECEPTION_STATE  0x32
+
+//
+//  Constants and Structure definitions for "Set Event Reception State" command to follow here
+//
+
+//
+//  Definitions for Send ICMB Event Message command
+//
+#define IPMI_BRIDGE_SEND_ICMB_EVENT_MESSAGE  0x33
+
+//
+//  Constants and Structure definitions for "Send ICMB Event Message" command to follow here
+//
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnChassis.h b/MdePkg/Include/IndustryStandard/IpmiNetFnChassis.h
new file mode 100644
index 000000000000..833feeb9dd87
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnChassis.h
@@ -0,0 +1,303 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  This file contains all NetFn Chassis commands, including:
+    Chassis Commands (Chapter 28)
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_CHASSIS_H_
+#define _IPMI_NET_FN_CHASSIS_H_
+
+#pragma pack (1)
+//
+// Net function definition for Chassis command
+//
+#define IPMI_NETFN_CHASSIS  0x00
+
+//
+//  Below is Definitions for Chassis commands (Chapter 28)
+//
+
+//
+//  Definitions for Get Chassis Capabilities command
+//
+#define IPMI_CHASSIS_GET_CAPABILITIES  0x00
+
+//
+//  Constants and Structure definitions for "Get Chassis Capabilities" command to follow here
+//
+
+//
+//  Definitions for Get Chassis Status command
+//
+#define IPMI_CHASSIS_GET_STATUS  0x01
+
+//
+//  Constants and Structure definitions for "Get Chassis Status" command to follow here
+//
+
+//
+//  Definitions for Chassis Control command
+//
+#define IPMI_CHASSIS_CONTROL 0x02
+
+//
+//  Constants and Structure definitions for "Chassis Control" command to follow here
+//
+
+//
+//  Definitions for Chassis Reset command
+//
+#define IPMI_CHASSIS_RESET 0x03
+
+//
+//  Constants and Structure definitions for "Chassis Reset" command to follow here
+//
+
+//
+//  Definitions for Chassis Identify command
+//
+#define IPMI_CHASSIS_IDENTIFY  0x04
+
+//
+//  Constants and Structure definitions for "Chassis Identify" command to follow here
+//
+
+//
+//  Definitions for Set Chassis Capabilities command
+//
+#define IPMI_CHASSIS_SET_CAPABILITIES  0x05
+
+//
+//  Constants and Structure definitions for "Set Chassis Capabilities" command to follow here
+//
+
+//
+//  Definitions for Set Power Restore Policy command
+//
+#define IPMI_CHASSIS_SET_POWER_RESTORE_POLICY  0x06
+
+//
+//  Constants and Structure definitions for "Set Power Restore Policy" command to follow here
+//
+
+//
+//  Definitions for Get System Restart Cause command
+//
+#define IPMI_CHASSIS_GET_SYSTEM_RESTART_CAUSE  0x07
+
+//
+//  Constants and Structure definitions for "Get System Restart Cause" command to follow here
+//
+typedef enum {
+  Unknown,
+  ChassisControlCommand,
+  ResetViaPushButton,
+  PowerupViaPowerButton,
+  WatchdogExpiration,
+  Oem,
+  AutoPowerOnAlwaysRestore,
+  AutoPowerOnRestorePrevious,
+  ResetViaPef,
+  PowerCycleViaPef,
+  SoftReset,
+  PowerUpViaRtc
+} IPMI_SYSTEM_RESTART_CAUSE;
+
+typedef struct {
+  UINT8  CompletionCode;
+  UINT8  Cause:4;
+  UINT8  Reserved:4;
+  UINT8  ChannelNumber;
+} IPMI_GET_SYSTEM_RESTART_CAUSE_RESPONSE;
+
+//
+//  Definitions for Set System BOOT options command
+//
+#define IPMI_CHASSIS_SET_SYSTEM_BOOT_OPTIONS 0x08
+
+//
+//  Constants and Structure definitions for "Set System boot options" command to follow here
+//
+typedef struct {
+  UINT8    ParameterSelector:7;
+  UINT8    MarkParameterInvalid:1;
+  UINT8    ParameterData[1];
+} IPMI_SET_BOOT_OPTIONS_REQUEST;
+
+//
+//  Definitions for Get System BOOT options command
+//
+#define IPMI_CHASSIS_GET_SYSTEM_BOOT_OPTIONS 0x09
+
+//
+//  Constants and Structure definitions for "Get System boot options" command to follow here
+//
+typedef struct {
+  UINT8    ParameterSelector:7;
+  UINT8    Reserved:1;
+  UINT8    SetSelector;
+  UINT8    BlockSelector;
+} IPMI_GET_BOOT_OPTIONS_REQUEST;
+
+typedef struct {
+  UINT8 Parameter;
+  UINT8 Valid;
+  UINT8 Data1;
+  UINT8 Data2;
+  UINT8 Data3;
+  UINT8 Data4;
+  UINT8 Data5;
+} IPMI_GET_THE_SYSTEM_BOOT_OPTIONS;
+
+typedef struct {
+  UINT8   ParameterVersion;
+  UINT8   ParameterValid;
+  UINT8   ChannelNumber;
+  UINT32  SessionId;
+  UINT32  TimeStamp;
+  UINT8   Reserved[3];
+} IPMI_BOOT_INITIATOR;
+
+//
+// Response Parameters for IPMI Get Boot Options
+//
+typedef struct {
+  UINT8   SetInProgress: 2;
+  UINT8   Reserved: 6;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_0;
+
+typedef struct {
+  UINT8   ServicePartitionSelector;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_1;
+
+typedef struct {
+  UINT8   ServicePartitionDiscovered:1;
+  UINT8   ServicePartitionScanRequest:1;
+  UINT8   Reserved: 5;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_2;
+
+typedef struct {
+  UINT8   BmcBootFlagValid: 5;
+  UINT8   Reserved: 3;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_3;
+
+typedef struct {
+  UINT8   WriteMask;
+  UINT8   BootInitiatorAcknowledgeData;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_4;
+
+#define BOOT_OPTION_HANDLED_BY_BIOS 0x01
+
+typedef struct {
+  //
+  // Data 1
+  //
+  UINT8   Reserved0:6;
+  UINT8   PersistentOptions:1;
+  UINT8   BootFlagValid:1;
+  //
+  // Data 2
+  //
+  UINT8   LockReset:1;
+  UINT8   ScreenBlank:1;
+  UINT8   BootDeviceSelector:4;
+  UINT8   LockKeyboard:1;
+  UINT8   CmosClear:1;
+  //
+  //
+  // Data 3
+  UINT8   ConsoleRedirection:2;
+  UINT8   LockSleep:1;
+  UINT8   UserPasswordBypass:1;
+  UINT8   ForceProgressEventTrap:1;
+  UINT8   BiosVerbosity:2;
+  UINT8   LockPower:1;
+  //
+  // Data 4
+  //
+  UINT8   BiosMuxControlOverride:2;
+  UINT8   BiosSharedModeOverride:1;
+  UINT8   Reserved1:4;
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_5;
+
+typedef struct {
+  UINT8   ChannelNumber:4;
+  UINT8   Reserved:4;
+  UINT8   SessionId[4];
+  UINT8   BootInfoTimeStamp[4];
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_6;
+
+typedef struct {
+  UINT8   SetSelector;
+  UINT8   BlockData[16];
+} IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_7;
+
+typedef union {
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_0   Parm0;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_1   Parm1;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_2   Parm2;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_3   Parm3;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_4   Parm4;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_5   Parm5;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_6   Parm6;
+  IPMI_BOOT_OPTIONS_RESPONSE_PARAMETER_7   Parm7;
+} IPMI_BOOT_OPTIONS_PARAMETERS;
+
+typedef struct {
+  UINT8    CompletionCode;
+  UINT8    ParameterVersion:4;
+  UINT8    Reserved:4;
+  UINT8    ParameterSelector:7;
+  UINT8    ParameterValid:1;
+  UINT8    ParameterData[1];
+} IPMI_GET_BOOT_OPTIONS_RESPONSE;
+
+//
+//  Definitions for Set front panel button enables command
+//
+#define IPMI_CHASSIS_SET_FRONT_PANEL_BUTTON_ENABLES 0x0A
+
+typedef struct {
+  UINT8    DisablePoweroffButton:1;
+  UINT8    DisableResetButton:1;
+  UINT8    DisableDiagnosticInterruptButton:1;
+  UINT8    DisableStandbyButton:1;
+  UINT8    Reserved:4;
+} IPMI_CHASSIS_SET_FRONT_PANEL_BUTTON_ENABLES_REQUEST;
+
+//
+//  Constants and Structure definitions for "Set front panel button enables" command to follow here
+//
+
+//
+//  Definitions for Set Power Cycle Interval command
+//
+#define IPMI_CHASSIS_SET_POWER_CYCLE_INTERVALS 0x0B
+
+//
+//  Constants and Structure definitions for "Set Power Cycle Interval" command to follow here
+//
+
+//
+//  Definitions for Get POH Counter command
+//
+#define IPMI_CHASSIS_GET_POH_COUNTER 0x0F
+
+//
+//  Constants and Structure definitions for "Get POH Counter" command to follow here
+//
+#pragma pack()
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnFirmware.h b/MdePkg/Include/IndustryStandard/IpmiNetFnFirmware.h
new file mode 100644
index 000000000000..aba3c41d06c3
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnFirmware.h
@@ -0,0 +1,26 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_FIRMWARE_H_
+#define _IPMI_NET_FN_FIRMWARE_H_
+
+//
+// Net function definition for Firmware command
+//
+#define IPMI_NETFN_FIRMWARE 0x08
+
+//
+// All Firmware commands and their structure definitions to follow here
+//
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnGroupExtension.h b/MdePkg/Include/IndustryStandard/IpmiNetFnGroupExtension.h
new file mode 100644
index 000000000000..2a8ec6956703
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnGroupExtension.h
@@ -0,0 +1,26 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_GROUP_EXTENSION_H_
+#define _IPMI_NET_FN_GROUP_EXTENSION_H_
+
+//
+// Net function definition for Group Extension command
+//
+#define IPMI_NETFN_GROUP_EXT  0x2C
+
+//
+// All Group Extension commands and their structure definitions to follow here
+//
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnSensorEvent.h b/MdePkg/Include/IndustryStandard/IpmiNetFnSensorEvent.h
new file mode 100644
index 000000000000..f9d851e6ca1c
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnSensorEvent.h
@@ -0,0 +1,52 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  This file contains all NetFn Sensor/Event commands, including:
+    Event Commands (Chapter 29)
+    PEF and Alerting Commands (Chapter 30)
+    Sensor Device Commands (Chapter 35)
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_SENSOR_EVENT_H_
+#define _IPMI_NET_FN_SENSOR_EVENT_H_
+
+#pragma pack(1)
+//
+// Net function definition for Sensor command
+//
+#define IPMI_NETFN_SENSOR_EVENT 0x04
+
+//
+// All Sensor commands and their structure definitions to follow here
+//
+
+//
+//  Definitions for Send Platform Event Message command
+//
+#define IPMI_SENSOR_PLATFORM_EVENT_MESSAGE   0x02
+
+typedef struct {
+  UINT8   GeneratorId;
+  UINT8   EvMRevision;
+  UINT8   SensorType;
+  UINT8   SensorNumber;
+  UINT8   EventDirType;
+  UINT8   OEMEvData1;
+  UINT8   OEMEvData2;
+  UINT8   OEMEvData3;
+} IPMI_PLATFORM_EVENT_MESSAGE_DATA_REQUEST;
+
+#pragma pack()
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnStorage.h b/MdePkg/Include/IndustryStandard/IpmiNetFnStorage.h
new file mode 100644
index 000000000000..210db1e7e933
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnStorage.h
@@ -0,0 +1,542 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  This file contains all NetFn Storage commands, including:
+    FRU Inventory Commands (Chapter 34)
+    SDR Repository (Chapter 33)
+    System Event Log(SEL) Commands (Chapter 31)
+    SEL Record Formats (Chapter 32)
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_STORAGE_H_
+#define _IPMI_NET_FN_STORAGE_H_
+
+#pragma pack(1)
+//
+// Net function definition for Storage command
+//
+#define IPMI_NETFN_STORAGE  0x0A
+
+//
+// All Storage commands and their structure definitions to follow here
+//
+
+//
+//  Below is Definitions for FRU Inventory Commands (Chapter 34)
+//
+
+//
+//  Definitions for Get Fru Inventory Area Info command
+//
+#define IPMI_STORAGE_GET_FRU_INVENTORY_AREAINFO  0x10
+
+//
+//  Constants and Structure definitions for "Get Fru Inventory Area Info" command to follow here
+//
+
+//
+//  Definitions for Get Fru Data command
+//
+#define IPMI_STORAGE_READ_FRU_DATA 0x11
+
+//
+//  Constants and Structure definitions for "Get Fru Data" command to follow here
+//
+typedef struct {
+  UINT8   FruDeviceId;
+  UINT16  FruOffset;
+} IPMI_FRU_COMMON_DATA;
+
+typedef struct {
+  IPMI_FRU_COMMON_DATA Data;
+  UINT8                Count;
+} IPMI_FRU_READ_COMMAND;
+
+//
+//  Definitions for Write Fru Data command
+//
+#define IPMI_STORAGE_WRITE_FRU_DATA  0x12
+
+//
+//  Constants and Structure definitions for "Write Fru Data" command to follow here
+//
+typedef struct {
+  IPMI_FRU_COMMON_DATA Data;
+  UINT8                FruData[16];
+} IPMI_FRU_WRITE_COMMAND;
+
+//
+//  Below is Definitions for SDR Repository (Chapter 33)
+//
+
+//
+//  Definitions for Get SDR Repository Info command
+//
+#define IPMI_STORAGE_GET_SDR_REPOSITORY_INFO 0x20
+
+//
+//  Constants and Structure definitions for "Get SDR Repository Info" command to follow here
+//
+typedef struct {
+  UINT8   CompletionCode;
+  UINT8   Version;
+  UINT16  RecordCount;
+  UINT16  FreeSpace;
+  UINT32  RecentAdditionTimeStamp;
+  UINT32  RecentEraseTimeStamp;
+  UINT8   SdrRepAllocInfoCmd : 1;
+  UINT8   SdrRepReserveCmd : 1;
+  UINT8   PartialAddSdrCmd : 1;
+  UINT8   DeleteSdrRepCmd : 1;
+  UINT8   Reserved : 1;
+  UINT8   SdrRepUpdateOp : 2;
+  UINT8   Overflow : 1;
+} IPMI_GET_SDR_REPOSITORY_INFO;
+
+//
+//  Definitions for Get SDR Repository Allocateion Info command
+//
+#define IPMI_STORAGE_GET_SDR_REPOSITORY_ALLOCATION_INFO  0x21
+
+//
+//  Constants and Structure definitions for "Get SDR Repository Allocateion Info" command to follow here
+//
+
+//
+//  Definitions for Reserve SDR Repository command
+//
+#define IPMI_STORAGE_RESERVE_SDR_REPOSITORY  0x22
+
+//
+//  Constants and Structure definitions for "Reserve SDR Repository" command to follow here
+//
+
+//
+//  Definitions for Get SDR command
+//
+#define IPMI_STORAGE_GET_SDR 0x23
+
+//
+//  Constants and Structure definitions for "Get SDR" command to follow here
+//
+
+typedef struct {
+  UINT16  RecordId;                     // 1
+  UINT8   Version;                      // 3
+  UINT8   RecordType;                   // 4
+  UINT8   RecordLength;                 // 5
+  UINT8   OwnerId;                      // 6
+  UINT8   OwnerLun;                     // 7
+  UINT8   SensorNumber;                 // 8
+  UINT8   EntityId;                     // 9
+  UINT8   EntityInstance;               // 10
+  UINT8   EventScanningEnabled : 1;     // 11
+  UINT8   EventScanningDisabled : 1;    // 11
+  UINT8   InitSensorType : 1;           // 11
+  UINT8   InitHysteresis : 1;           // 11
+  UINT8   InitThresholds : 1;           // 11
+  UINT8   InitEvent : 1;                // 11
+  UINT8   InitScanning : 1;             // 11
+  UINT8   Reserved : 1;                 // 11
+  UINT8   EventMessageControl : 2;      // 12
+  UINT8   ThresholdAccessSupport : 2;   // 12
+  UINT8   HysteresisSupport : 2;        // 12
+  UINT8   ReArmSupport : 1;             // 12
+  UINT8   IgnoreSensor : 1;             // 12
+  UINT8   SensorType;                   // 13
+  UINT8   EventType;                    // 14
+  UINT8   Reserved1[7];                 // 15
+  UINT8   UnitType;                     // 22
+  UINT8   Reserved2;                    // 23
+  UINT8   Linearization : 7;            // 24
+  UINT8   Reserved3 : 1;                // 24
+  UINT8   MLo;                          // 25
+  UINT8   Toleremce : 6;                // 26
+  UINT8   MHi : 2;                      // 26
+  UINT8   BLo;                          // 27
+  UINT8   AccuracyLow : 6;              // 28
+  UINT8   BHi : 2;                      // 28
+  UINT8   Reserved4 : 2;                // 29
+  UINT8   AccuracyExp : 2;              // 29
+  UINT8   AccuracyHi : 4;               // 29
+  UINT8   BExp : 4;                     // 30
+  UINT8   RExp : 4;                     // 30
+  UINT8   NominalReadingSpscified : 1;  // 31
+  UINT8   NominalMaxSpscified : 1;      // 31
+  UINT8   NominalMinSpscified : 1;      // 31
+  UINT8   Reserved5 : 5;                // 31
+  UINT8   NominalReading;               // 32
+  UINT8   Reserved6[4];                 // 33
+  UINT8   UpperNonRecoverThreshold;     // 37
+  UINT8   UpperCriticalThreshold;       // 38
+  UINT8   UpperNonCriticalThreshold;    // 39
+  UINT8   LowerNonRecoverThreshold;     // 40
+  UINT8   LowerCriticalThreshold;       // 41
+  UINT8   LowerNonCriticalThreshold;    // 42
+  UINT8   Reserved7[5];                 // 43
+  UINT8   IdStringLength;               // 48
+  UINT8   AsciiIdString[16];            // 49 - 64
+} IPMI_SDR_RECORD_STRUCT_1;
+
+typedef struct {
+  UINT16  RecordId;                     // 1
+  UINT8   Version;                      // 3
+  UINT8   RecordType;                   // 4
+  UINT8   RecordLength;                 // 5
+  UINT8   OwnerId;                      // 6
+  UINT8   OwnerLun;                     // 7
+  UINT8   SensorNumber;                 // 8
+  UINT8   EntityId;                     // 9
+  UINT8   EntityInstance;               // 10
+  UINT8   SensorScanning : 1;           // 11
+  UINT8   EventScanning : 1;            // 11
+  UINT8   InitSensorType : 1;           // 11
+  UINT8   InitHysteresis : 1;           // 11
+  UINT8   InitThresholds : 1;           // 11
+  UINT8   InitEvent : 1;                // 11
+  UINT8   InitScanning : 1;             // 11
+  UINT8   Reserved : 1;                 // 11
+  UINT8   EventMessageControl : 2;      // 12
+  UINT8   ThresholdAccessSupport : 2;   // 12
+  UINT8   HysteresisSupport : 2;        // 12
+  UINT8   ReArmSupport : 1;             // 12
+  UINT8   IgnoreSensor : 1;             // 12
+  UINT8   SensorType;                   // 13
+  UINT8   EventType;                    // 14
+  UINT8   Reserved1[7];                 // 15
+  UINT8   UnitType;                     // 22
+  UINT8   Reserved2[9];                 // 23
+  UINT8   IdStringLength;               // 32
+  UINT8   AsciiIdString[16];            // 33 - 48
+} IPMI_SDR_RECORD_STRUCT_2;
+
+typedef struct {
+  UINT8 Reserved1 : 1;
+  UINT8 ControllerSlaveAddress : 7;
+  UINT8 FruDeviceId;
+  UINT8 BusId : 3;
+  UINT8 Lun : 2;
+  UINT8 Reserved : 2;
+  UINT8 LogicalFruDevice : 1;
+  UINT8 Reserved3 : 4;
+  UINT8 ChannelNumber : 4;
+} IPMI_FRU_DATA_INFO;
+
+typedef struct {
+  UINT16            RecordId;           // 1
+  UINT8             Version;            // 3
+  UINT8             RecordType;         // 4
+  UINT8             RecordLength;       // 5
+  IPMI_FRU_DATA_INFO FruDeviceData;      // 6
+  UINT8             Reserved1;          // 10
+  UINT8             DeviceType;         // 11
+  UINT8             DeviceTypeModifier; // 12
+  UINT8             FruEntityId;        // 13
+  UINT8             FruEntityInstance;  // 14
+  UINT8             OemReserved;        // 15
+  UINT8             Length : 4;         // 16
+  UINT8             Reserved2 : 1;      // 16
+  UINT8             StringType : 3;     // 16
+  UINT8             String[16];         // 17
+} IPMI_SDR_RECORD_STRUCT_11;
+
+typedef struct {
+  UINT16              NextRecordId;       //1
+  UINT16              RecordId;           //3
+  UINT8               Version;            //5
+  UINT8               RecordType;         //6
+  UINT8               RecordLength;       //7
+  UINT8               ManufacturerId[3];  //8
+  UINT8               StringChars[20];
+} IPMI_SDR_RECORD_STRUCT_C0;
+
+typedef struct {
+  UINT16              NextRecordId;       //1
+  UINT16              RecordId;           //3
+  UINT8               Version;            //5
+  UINT8               RecordType;         //6
+  UINT8               RecordLength;       //7
+} IPMI_SDR_RECORD_STRUCT_HEADER;
+
+typedef union {
+  IPMI_SDR_RECORD_STRUCT_1  SensorType1;
+  IPMI_SDR_RECORD_STRUCT_2  SensorType2;
+  IPMI_SDR_RECORD_STRUCT_11 SensorType11;
+  IPMI_SDR_RECORD_STRUCT_C0       SensorTypeC0;
+  IPMI_SDR_RECORD_STRUCT_HEADER   SensorHeader;
+} IPMI_SENSOR_RECORD_STRUCT;
+
+typedef struct {
+  UINT16      ReservationId;
+  UINT16      RecordId;
+  UINT8       RecordOffset;
+  UINT8       BytesToRead;
+} IPMI_GET_SDR_REQUEST;
+
+//
+//  Definitions for Add SDR command
+//
+#define IPMI_STORAGE_ADD_SDR 0x24
+
+//
+//  Constants and Structure definitions for "Add SDR" command to follow here
+//
+
+//
+//  Definitions for Partial Add SDR command
+//
+#define IPMI_STORAGE_PARTIAL_ADD_SDR 0x25
+
+//
+//  Constants and Structure definitions for "Partial Add SDR" command to follow here
+//
+
+//
+//  Definitions for Delete SDR command
+//
+#define IPMI_STORAGE_DELETE_SDR  0x26
+
+//
+//  Constants and Structure definitions for "Delete SDR" command to follow here
+//
+
+//
+//  Definitions for Clear SDR Repository command
+//
+#define IPMI_STORAGE_CLEAR_SDR 0x27
+
+//
+//  Constants and Structure definitions for "Clear SDR Repository" command to follow here
+//
+
+//
+//  Definitions for Get SDR Repository Time command
+//
+#define IPMI_STORAGE_GET_SDR_REPOSITORY_TIME 0x28
+
+//
+//  Constants and Structure definitions for "Get SDR Repository Time" command to follow here
+//
+
+//
+//  Definitions for Set SDR Repository Time command
+//
+#define IPMI_STORAGE_SET_SDR_REPOSITORY_TIME 0x29
+
+//
+//  Constants and Structure definitions for "Set SDR Repository Time" command to follow here
+//
+
+//
+//  Definitions for Enter SDR Repository Update Mode command
+//
+#define IPMI_STORAGE_ENTER_SDR_UPDATE_MODE 0x2A
+
+//
+//  Constants and Structure definitions for "Enter SDR Repository Update Mode" command to follow here
+//
+
+//
+//  Definitions for Exit SDR Repository Update Mode command
+//
+#define IPMI_STORAGE_EXIT_SDR_UPDATE_MODE  0x2B
+
+//
+//  Constants and Structure definitions for "Exit SDR Repository Update Mode" command to follow here
+//
+
+//
+//  Definitions for Run Initialize Agent command
+//
+#define IPMI_STORAGE_RUN_INIT_AGENT  0x2C
+
+//
+//  Constants and Structure definitions for "Run Initialize Agent" command to follow here
+//
+
+//
+//  Below is Definitions for System Event Log(SEL) Commands (Chapter 31)
+//
+
+//
+//  Definitions for Get SEL Info command
+//
+#define IPMI_STORAGE_GET_SEL_INFO  0x40
+
+//
+//  Constants and Structure definitions for "Get SEL Info" command to follow here
+//
+typedef struct {
+  UINT8   CompletionCode;
+  UINT8   Version;              // Version of SEL
+  UINT16  NoOfEntries;          // No of Entries in the SEL
+  UINT16  FreeSpace;            // Free space in Bytes
+  UINT32  RecentAddTimeStamp;   // Most Recent Addition of Time Stamp
+  UINT32  RecentEraseTimeStamp; // Most Recent Erasure of Time Stamp
+  UINT8   OperationSupport;     // Operation Support
+} IPMI_GET_SEL_INFO_RESPONSE;
+
+//
+//  Definitions for Get SEL Allocation Info command
+//
+#define IPMI_STORAGE_GET_SEL_ALLOCATION_INFO 0x41
+
+//
+//  Constants and Structure definitions for "Get SEL Allocation Info" command to follow here
+//
+
+//
+//  Definitions for Reserve SEL command
+//
+#define IPMI_STORAGE_RESERVE_SEL 0x42
+
+//
+//  Constants and Structure definitions for "Reserve SEL" command to follow here
+//
+
+//
+//  Definitions for Get SEL Entry command
+//
+#define IPMI_STORAGE_GET_SEL_ENTRY 0x43
+
+//
+//  Constants and Structure definitions for "Get SEL Entry" command to follow here
+//
+typedef struct {
+  UINT8 ReserveId[2]; // Reservation ID, LS Byte First
+  UINT8 SelRecID[2];  // Sel Record ID, LS Byte First
+  UINT8 Offset;       // Offset Into Record
+  UINT8 BytesToRead;  // Bytes to be Read, 0xFF for entire record
+} IPMI_GET_SEL_ENTRY_REQUEST;
+
+//
+//  Definitions for Add SEL Entry command
+//
+#define IPMI_STORAGE_ADD_SEL_ENTRY 0x44
+
+//
+//  Constants and Structure definitions for "Add SEL Entry" command to follow here
+//
+
+//
+//  Definitions for Partial Add SEL Entry command
+//
+#define IPMI_STORAGE_PARTIAL_ADD_SEL_ENTRY 0x45
+
+//
+//  Constants and Structure definitions for "Partial Add SEL Entry" command to follow here
+//
+
+//
+//  Definitions for Delete SEL Entry command
+//
+#define IPMI_STORAGE_DELETE_SEL_ENTRY  0x46
+
+//
+//  Constants and Structure definitions for "Delete SEL Entry" command to follow here
+//
+typedef struct {
+  UINT8 ReserveId[2];       // Reservation ID, LS byte first
+  UINT8 RecordToDelete[2];  // Record to Delete, LS Byte First
+} IPMI_DELETE_SEL_REQUEST;
+
+//
+//  Definitions for Clear SEL command
+//
+#define IPMI_STORAGE_CLEAR_SEL 0x47
+
+//
+//  Constants and Structure definitions for "Clear SEL" command to follow here
+//
+typedef struct {
+  UINT8 Reserve[2]; // Reserve ID, LSB first
+  UINT8 AscC;       // Ascii for 'C' (0x43)
+  UINT8 AscL;       // Ascii for 'L' (0x4c)
+  UINT8 AscR;       // Ascii for 'R' (0x52)
+  UINT8 Erase;      // 0xAA, Initiate Erase, 0x00 Get Erase Status
+} IPMI_CLEAR_SEL_REQUEST;
+
+//
+//  Definitions for Get SEL Time command
+//
+#define IPMI_STORAGE_GET_SEL_TIME  0x48
+
+//
+//  Constants and Structure definitions for "Get SEL Time" command to follow here
+//
+
+//
+//  Definitions for Set SEL Time command
+//
+#define IPMI_STORAGE_SET_SEL_TIME  0x49
+
+//
+//  Constants and Structure definitions for "Set SEL Time" command to follow here
+//
+
+//
+//  Definitions for Get Auxillary Log Status command
+//
+#define IPMI_STORAGE_GET_AUXILLARY_LOG_STATUS  0x5A
+
+//
+//  Constants and Structure definitions for "Get Auxillary Log Status" command to follow here
+//
+
+//
+//  Definitions for Set Auxillary Log Status command
+//
+#define IPMI_STORAGE_SET_AUXILLARY_LOG_STATUS  0x5B
+
+//
+//  Constants and Structure definitions for "Set Auxillary Log Status" command to follow here
+//
+
+#define IPMI_COMPLETE_SEL_RECORD 0xFF
+
+//
+//  Below is Definitions for SEL Record Formats (Chapter 32)
+//
+typedef struct {
+  UINT16  RecordId;
+  UINT8   RecordType;
+  UINT32  TimeStamp;
+  UINT16  GeneratorId;
+  UINT8   EvMRevision;
+  UINT8   SensorType;
+  UINT8   SensorNumber;
+  UINT8   EventDirType;
+  UINT8   OEMEvData1;
+  UINT8   OEMEvData2;
+  UINT8   OEMEvData3;
+} IPMI_SEL_EVENT_RECORD_DATA;
+
+#define IPMI_SEL_SYSTEM_RECORD                     0x02
+
+#define IPMI_EVM_REVISION                          0x04
+#define IPMI_BIOS_ID                               0x18
+#define IPMI_FORMAT_REV                            0x00
+#define IPMI_FORMAT_REV1                           0x01
+#define IPMI_SOFTWARE_ID                           0x01
+#define IPMI_PLATFORM_VAL_ID                       0x01
+#define IPMI_GENERATOR_ID(i,f)                     ((i << 1) | (f << 1) | IPMI_SOFTWARE_ID)
+
+#define IPMI_SENSOR_TYPE_EVENT_CODE_DISCRETE       0x6F
+
+#define IPMI_OEM_SPECIFIC_DATA                     0x02
+#define IPMI_SENSOR_SPECIFIC_DATA                  0x03
+
+#pragma pack()
+#endif
diff --git a/MdePkg/Include/IndustryStandard/IpmiNetFnTransport.h b/MdePkg/Include/IndustryStandard/IpmiNetFnTransport.h
new file mode 100644
index 000000000000..ad1a9aad707a
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/IpmiNetFnTransport.h
@@ -0,0 +1,566 @@
+/** @file
+  IPMI 2.0 definitions from the IPMI Specification Version 2.0, Revision 1.1.
+
+  This file contains all NetFn Transport commands, including:
+    IPM LAN Commands (Chapter 23)
+    IPMI Serial/Modem Commands (Chapter 25)
+    SOL Commands (Chapter 26)
+    Command Forwarding Commands (Chapter 35b)
+
+  See IPMI specification, Appendix G, Command Assignments
+  and Appendix H, Sub-function Assignments.
+
+  Copyright (c) 1999 - 2015, 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 _IPMI_NET_FN_TRANSPORT_H_
+#define _IPMI_NET_FN_TRANSPORT_H_
+
+#pragma pack(1)
+//
+// Net function definition for Transport command
+//
+#define IPMI_NETFN_TRANSPORT  0x0C
+
+//
+//  Below is Definitions for IPM LAN Commands (Chapter 23)
+//
+
+//
+//  Definitions for Set Lan Configuration Parameters command
+//
+#define IPMI_TRANSPORT_SET_LAN_CONFIG_PARAMETERS 0x01
+
+//
+//  Constants and Structure definitions for "Set Lan Configuration Parameters" command to follow here
+//
+
+//
+// LAN Management Structure
+//
+typedef enum {
+  IpmiLanReserved1,
+  IpmiLanReserved2,
+  IpmiLanAuthType,
+  IpmiLanIpAddress,
+  IpmiLanIpAddressSource,
+  IpmiLanMacAddress,
+  IpmiLanSubnetMask,
+  IpmiLanIpv4HeaderParam,
+  IpmiLanPrimaryRcmpPort,
+  IpmiLanSecondaryRcmpPort,
+  IpmiLanBmcGeneratedArpCtrl,
+  IpmiLanArpInterval,
+  IpmiLanDefaultGateway,
+  IpmiLanDefaultGatewayMac,
+  IpmiLanBackupGateway,
+  IpmiLanBackupGatewayMac,
+  IpmiLanCommunityString,
+  IpmiLanReserved3,
+  IpmiLanDestinationType,
+  IpmiLanDestinationAddress
+} IPMI_LAN_OPTION_TYPE;
+
+//
+// IP Address Source
+//
+typedef enum {
+  IpmiUnspecified,
+  IpmiStaticAddrsss,
+  IpmiDynamicAddressBmcDhcp,
+  IpmiDynamicAddressBiosDhcp,
+  IpmiDynamicAddressBmcNonDhcp
+} IPMI_IP_ADDRESS_SRC;
+
+//
+// Destination Type
+//
+typedef enum {
+  IpmiPetTrapDestination,
+  IpmiDirectedEventDestination,
+  IpmiReserved1,
+  IpmiReserved2,
+  IpmiReserved3,
+  IpmiReserved4,
+  IpmiReserved5,
+  IpmiOem1,
+  IpmiOem2
+} IPMI_LAN_DEST_TYPE_DEST_TYPE;
+
+typedef struct {
+  UINT8 NoAuth : 1;
+  UINT8 MD2Auth : 1;
+  UINT8 MD5Auth : 1;
+  UINT8 Reserved1 : 1;
+  UINT8 StraightPswd : 1;
+  UINT8 OemType : 1;
+  UINT8 Reserved2 : 2;
+} IPMI_LAN_AUTH_TYPE;
+
+typedef struct {
+  UINT8 IpAddress[4];
+} IPMI_LAN_IP_ADDRESS;
+
+typedef struct {
+  UINT8 AddressSrc : 4;
+  UINT8 Reserved : 4;
+} IPMI_LAN_IP_ADDRESS_SRC;
+
+typedef struct {
+  UINT8 MacAddress[6];
+} IPMI_LAN_MAC_ADDRESS;
+
+typedef struct {
+  UINT8 IpAddress[4];
+} IPMI_LAN_SUBNET_MASK;
+
+typedef struct {
+  UINT8 TimeToLive;
+  UINT8 IpFlag : 3;
+  UINT8 Reserved1 : 5;
+  UINT8 Precedence : 3;
+  UINT8 Reserved2 : 1;
+  UINT8 ServiceType : 4;
+} IPMI_LAN_IPV4_HDR_PARAM;
+
+typedef struct {
+  UINT8 RcmpPortMsb;
+  UINT8 RcmpPortLsb;
+} IPMI_LAN_RCMP_PORT;
+
+typedef struct {
+  UINT8 EnableBmcArpResponse : 1;
+  UINT8 EnableBmcGratuitousArp : 1;
+  UINT8 Reserved : 6;
+} IPMI_LAN_BMC_GENERATED_ARP_CONTROL;
+
+typedef struct {
+  UINT8 ArpInterval;
+} IPMI_LAN_ARP_INTERVAL;
+
+typedef struct {
+  UINT8 Data[18];
+} IPMI_LAN_COMMUNITY_STRING;
+
+typedef struct {
+  UINT8 DestinationSelector : 4;
+  UINT8 Reserved2 : 4;
+  UINT8 DestinationType : 3;
+  UINT8 Reserved1 : 4;
+  UINT8 AlertAcknowledged : 1;
+} IPMI_LAN_DEST_TYPE;
+
+typedef struct {
+  UINT8               DestinationSelector : 4;
+  UINT8               Reserved1 : 4;
+  UINT8               AlertingIpAddressSelector : 4;
+  UINT8               AddressFormat : 4;
+  UINT8               UseDefaultGateway : 1;
+  UINT8               Reserved2 : 7;
+  IPMI_LAN_IP_ADDRESS  AlertingIpAddress;
+  IPMI_LAN_MAC_ADDRESS AlertingMacAddress;
+} IPMI_LAN_DEST_ADDRESS;
+
+typedef union {
+  IPMI_LAN_AUTH_TYPE                 IpmiLanAuthType;
+  IPMI_LAN_IP_ADDRESS                IpmiLanIpAddress;
+  IPMI_LAN_IP_ADDRESS_SRC            IpmiLanIpAddressSrc;
+  IPMI_LAN_MAC_ADDRESS               IpmiLanMacAddress;
+  IPMI_LAN_SUBNET_MASK               IpmiLanSubnetMask;
+  IPMI_LAN_IPV4_HDR_PARAM            IpmiLanIpv4HdrParam;
+  IPMI_LAN_RCMP_PORT                 IpmiLanPrimaryRcmpPort;
+  IPMI_LAN_BMC_GENERATED_ARP_CONTROL IpmiLanArpControl;
+  IPMI_LAN_ARP_INTERVAL              IpmiLanArpInterval;
+  IPMI_LAN_COMMUNITY_STRING          IpmiLanCommunityString;
+  IPMI_LAN_DEST_TYPE                 IpmiLanDestType;
+  IPMI_LAN_DEST_ADDRESS              IpmiLanDestAddress;
+} IPMI_LAN_OPTIONS;
+
+//
+//  Definitions for Get Lan Configuration Parameters command
+//
+#define IPMI_TRANSPORT_GET_LAN_CONFIG_PARAMETERS 0x02
+
+//
+//  Constants and Structure definitions for "Get Lan Configuration Parameters" command to follow here
+//
+
+//
+//  Definitions for Suspend BMC ARPs command
+//
+#define IPMI_TRANSPORT_SUSPEND_BMC_ARPS  0x03
+
+//
+//  Constants and Structure definitions for "Suspend BMC ARPs" command to follow here
+//
+
+//
+//  Definitions for Get IP-UDP-RMCP Statistics command
+//
+#define IPMI_TRANSPORT_GET_PACKET_STATISTICS 0x04
+
+//
+//  Constants and Structure definitions for "Get IP-UDP-RMCP Statistics" command to follow here
+//
+
+//
+//  Below is Definitions for IPMI Serial/Modem Commands (Chapter 25)
+//
+
+//
+//  Definitions for Set Serial/Modem Configuration command
+//
+#define IPMI_TRANSPORT_SET_SERIAL_CONFIGURATION  0x10
+
+//
+//  Constants and Structure definitions for "Set Serial/Modem Configuration" command to follow here
+//
+
+//
+// EMP OPTION DATA
+//
+typedef struct {
+  UINT8 NoAuthentication : 1;
+  UINT8 MD2Authentication : 1;
+  UINT8 MD5Authentication : 1;
+  UINT8 Reserved1 : 1;
+  UINT8 StraightPassword : 1;
+  UINT8 OemProprietary : 1;
+  UINT8 Reservd2 : 2;
+} IPMI_EMP_AUTH_TYPE;
+
+typedef struct {
+  UINT8 EnableBasicMode : 1;
+  UINT8 EnablePPPMode : 1;
+  UINT8 EnableTerminalMode : 1;
+  UINT8 Reserved1 : 2;
+  UINT8 SnoopOsPPPNegotiation : 1;
+  UINT8 Reserved2 : 1;
+  UINT8 DirectConnect : 1;
+} IPMI_EMP_CONNECTION_TYPE;
+
+typedef struct {
+  UINT8 InactivityTimeout : 4;
+  UINT8 Reserved : 4;
+} IPMI_EMP_INACTIVITY_TIMEOUT;
+
+typedef struct {
+  UINT8 IpmiCallback : 1;
+  UINT8 CBCPCallback : 1;
+  UINT8 Reserved1 : 6;
+  UINT8 CbcpEnableNoCallback : 1;
+  UINT8 CbcpEnablePreSpecifiedNumber : 1;
+  UINT8 CbcpEnableUserSpecifiedNumber : 1;
+  UINT8 CbcpEnableCallbackFromList : 1;
+  UINT8 Reserved : 4;
+  UINT8 CallbackDestination1;
+  UINT8 CallbackDestination2;
+  UINT8 CallbackDestination3;
+} IPMI_EMP_CHANNEL_CALLBACK_CONTROL;
+
+typedef struct {
+  UINT8 CloseSessionOnDCDLoss : 1;
+  UINT8 EnableSessionInactivityTimeout : 1;
+  UINT8 Reserved : 6;
+} IPMI_EMP_SESSION_TERMINATION;
+
+typedef struct {
+  UINT8 Reserved1 : 5;
+  UINT8 EnableDtrHangup : 1;
+  UINT8 FlowControl : 2;
+  UINT8 BitRate : 4;
+  UINT8 Reserved2 : 4;
+  UINT8 SaveSetting : 1;
+  UINT8 SetComPort : 1;
+  UINT8 Reserved3 : 6;
+} IPMI_EMP_MESSAGING_COM_SETTING;
+
+typedef struct {
+  UINT8 RingDurationInterval : 6;
+  UINT8 Reserved1 : 2;
+  UINT8 RingDeadTime : 4;
+  UINT8 Reserved : 4;
+} IPMI_EMP_MODEM_RING_TIME;
+
+typedef struct {
+  UINT8 Reserved;
+  UINT8 InitString[48];
+} IPMI_EMP_MODEM_INIT_STRING;
+
+typedef struct {
+  UINT8 EscapeSequence[5];
+} IPMI_EMP_MODEM_ESC_SEQUENCE;
+
+typedef struct {
+  UINT8 HangupSequence[8];
+} IPMI_EMP_MODEM_HANGUP_SEQUENCE;
+
+typedef struct {
+  UINT8 ModelDialCommend[8];
+} IPMI_MODEM_DIALUP_COMMAND;
+
+typedef struct {
+  UINT8 PageBlackoutInterval;
+} IPMI_PAGE_BLACKOUT_INTERVAL;
+
+typedef struct {
+  UINT8 CommunityString[18];
+} IPMI_EMP_COMMUNITY_STRING;
+
+typedef struct {
+  UINT8 Reserved5 : 4;
+  UINT8 DialStringSelector : 4;
+} IPMI_DIAL_PAGE_DESTINATION;
+
+typedef struct {
+  UINT8 TapAccountSelector : 4;
+  UINT8 Reserved : 4;
+} IPMI_TAP_PAGE_DESTINATION;
+
+typedef struct {
+  UINT8 PPPAccountSetSelector;
+  UINT8 DialStringSelector;
+} IPMI_PPP_ALERT_DESTINATION;
+
+typedef union {
+  IPMI_DIAL_PAGE_DESTINATION    DialPageDestination;
+  IPMI_TAP_PAGE_DESTINATION     TapPageDestination;
+  IPMI_PPP_ALERT_DESTINATION    PppAlertDestination;
+} IPMI_DEST_TYPE_SPECIFIC;
+
+typedef struct {
+  UINT8 DestinationSelector : 4;
+  UINT8 Reserved1 : 4;
+  UINT8 DestinationType : 4;
+  UINT8 Reserved2 : 3;
+  UINT8 AlertAckRequired : 1;
+  UINT8 AlertAckTimeoutSeconds;
+  UINT8 NumRetriesCall : 3;
+  UINT8 Reserved3 : 1;
+  UINT8 NumRetryAlert : 3;
+  UINT8 Reserved4 : 1;
+  IPMI_DEST_TYPE_SPECIFIC DestinationTypeSpecific;
+} IPMI_EMP_DESTINATION_INFO;
+
+typedef struct {
+  UINT8 DestinationSelector : 4;
+  UINT8 Reserved1 : 4;
+  UINT8 Parity : 3;
+  UINT8 CharacterSize : 1;
+  UINT8 StopBit : 1;
+  UINT8 DtrHangup : 1;
+  UINT8 FlowControl : 2;
+  UINT8 BitRate : 4;
+  UINT8 Reserved2 : 4;
+  UINT8 SaveSetting : 1;
+  UINT8 SetComPort : 1;
+  UINT8 Reserved3 : 6;
+} IPMI_EMP_DESTINATION_COM_SETTING;
+
+typedef struct {
+  UINT8 DialStringSelector : 4;
+  UINT8 Reserved1 : 4;
+  UINT8 Reserved2;
+  UINT8 DialString[48];
+} IPMI_DESTINATION_DIAL_STRING;
+
+typedef union {
+  UINT32  IpAddressLong;
+  UINT8   IpAddress[4];
+} IPMI_PPP_IP_ADDRESS;
+
+typedef struct {
+  UINT8 IpAddressSelector : 4;
+  UINT8 Reserved1 : 4;
+  IPMI_PPP_IP_ADDRESS PppIpAddress;
+} IPMI_DESTINATION_IP_ADDRESS;
+
+typedef struct {
+  UINT8 TapSelector;
+  UINT8 TapServiceSelector : 4;
+  UINT8 TapDialStringSelector : 4;
+} IPMI_DESTINATION_TAP_ACCOUNT;
+
+typedef struct {
+  UINT8 TapSelector;
+  UINT8 PagerIdString[16];
+} IPMI_TAP_PAGER_ID_STRING;
+
+typedef union {
+  UINT8                              OptionData;
+  IPMI_EMP_AUTH_TYPE                 EmpAuthType;
+  IPMI_EMP_CONNECTION_TYPE           EmpConnectionType;
+  IPMI_EMP_INACTIVITY_TIMEOUT        EmpInactivityTimeout;
+  IPMI_EMP_CHANNEL_CALLBACK_CONTROL  EmpCallbackControl;
+  IPMI_EMP_SESSION_TERMINATION       EmpSessionTermination;
+  IPMI_EMP_MESSAGING_COM_SETTING     EmpMessagingComSetting;
+  IPMI_EMP_MODEM_RING_TIME           EmpModemRingTime;
+  IPMI_EMP_MODEM_INIT_STRING         EmpModemInitString;
+  IPMI_EMP_MODEM_ESC_SEQUENCE        EmpModemEscSequence;
+  IPMI_EMP_MODEM_HANGUP_SEQUENCE     EmpModemHangupSequence;
+  IPMI_MODEM_DIALUP_COMMAND          EmpModemDialupCommand;
+  IPMI_PAGE_BLACKOUT_INTERVAL        EmpPageBlackoutInterval;
+  IPMI_EMP_COMMUNITY_STRING          EmpCommunityString;
+  IPMI_EMP_DESTINATION_INFO          EmpDestinationInfo;
+  IPMI_EMP_DESTINATION_COM_SETTING   EmpDestinationComSetting;
+  UINT8                              CallRetryBusySignalInterval;
+  IPMI_DESTINATION_DIAL_STRING       DestinationDialString;
+  IPMI_DESTINATION_IP_ADDRESS        DestinationIpAddress;
+  IPMI_DESTINATION_TAP_ACCOUNT       DestinationTapAccount;
+  IPMI_TAP_PAGER_ID_STRING           TapPagerIdString;
+} IPMI_EMP_OPTIONS;
+
+//
+//  Definitions for Get Serial/Modem Configuration command
+//
+#define IPMI_TRANSPORT_GET_SERIAL_CONFIGURATION  0x11
+
+//
+//  Constants and Structure definitions for "Get Serial/Modem Configuration" command to follow here
+//
+
+//
+//  Definitions for Set Serial/Modem Mux command
+//
+#define IPMI_TRANSPORT_SET_SERIAL_MUX  0x12
+
+//
+//  Constants and Structure definitions for "Set Serial/Modem Mux" command to follow here
+//
+typedef struct {
+  UINT8 ChannelNo : 4;
+  UINT8 Reserved1 : 4;
+  UINT8 MuxSetting : 4;
+  UINT8 Reserved2 : 4;
+} IPMI_SET_SERIAL_MODEM_MUX_COMMAND_REQUEST;
+
+typedef struct {
+  UINT8 MuxSetToBmc : 1;
+  UINT8 CommandStatus : 1;
+  UINT8 MessagingSessionActive : 1;
+  UINT8 AlertInProgress : 1;
+  UINT8 Reserved2 : 2;
+  UINT8 MuxToBmcAllowed : 1;
+  UINT8 MuxToSystemBlocked : 1;
+} IPMI_SET_SERIAL_MODEM_MUX_COMMAND_RESPONSE;
+
+//
+//  Definitions for Get TAP Response Code command
+//
+#define IPMI_TRANSPORT_GET_TAP_RESPONSE_CODE 0x13
+
+//
+//  Constants and Structure definitions for "Get TAP Response Code" command to follow here
+//
+
+//
+//  Definitions for Set PPP UDP Proxy Transmit Data command
+//
+#define IPMI_TRANSPORT_SET_PPP_UDP_PROXY_TXDATA  0x14
+
+//
+//  Constants and Structure definitions for "Set PPP UDP Proxy Transmit Data" command to follow here
+//
+
+//
+//  Definitions for Get PPP UDP Proxy Transmit Data command
+//
+#define IPMI_TRANSPORT_GET_PPP_UDP_PROXY_TXDATA  0x15
+
+//
+//  Constants and Structure definitions for "Get PPP UDP Proxy Transmit Data" command to follow here
+//
+
+//
+//  Definitions for Send PPP UDP Proxy Packet command
+//
+#define IPMI_TRANSPORT_SEND_PPP_UDP_PROXY_PACKET 0x16
+
+//
+//  Constants and Structure definitions for "Send PPP UDP Proxy Packet" command to follow here
+//
+
+//
+//  Definitions for Get PPP UDP Proxy Receive Data command
+//
+#define IPMI_TRANSPORT_GET_PPP_UDP_PROXY_RX  0x17
+
+//
+//  Constants and Structure definitions for "Get PPP UDP Proxy Receive Data" command to follow here
+//
+
+//
+//  Definitions for Serial/Modem connection active command
+//
+#define IPMI_TRANSPORT_SERIAL_CONNECTION_ACTIVE  0x18
+
+//
+//  Constants and Structure definitions for "Serial/Modem connection active" command to follow here
+//
+
+//
+//  Definitions for Callback command
+//
+#define IPMI_TRANSPORT_CALLBACK  0x19
+
+//
+//  Constants and Structure definitions for "Callback" command to follow here
+//
+
+//
+//  Definitions for Set user Callback Options command
+//
+#define IPMI_TRANSPORT_SET_USER_CALLBACK_OPTIONS 0x1A
+
+//
+//  Constants and Structure definitions for "Set user Callback Options" command to follow here
+//
+
+//
+//  Definitions for Get user Callback Options command
+//
+#define IPMI_TRANSPORT_GET_USER_CALLBACK_OPTIONS 0x1B
+
+//
+//  Constants and Structure definitions for "Get user Callback Options" command to follow here
+//
+
+//
+//  Below is Definitions for SOL Commands (Chapter 26)
+//
+
+//
+//  Definitions for SOL activating command
+//
+#define IPMI_TRANSPORT_SOL_ACTIVATING  0x20
+
+//
+//  Constants and Structure definitions for "SOL activating" command to follow here
+//
+
+//
+//  Definitions for Set SOL Configuration Parameters command
+//
+#define IPMI_TRANSPORT_SET_SOL_CONFIG_PARAM  0x21
+
+//
+//  Constants and Structure definitions for "Set SOL Configuration Parameters" command to follow here
+//
+
+//
+//  Definitions for Get SOL Configuration Parameters command
+//
+#define IPMI_TRANSPORT_GET_SOL_CONFIG_PARAM  0x22
+
+//
+//  Constants and Structure definitions for "Get SOL Configuration Parameters" command to follow here
+//
+#pragma pack()
+#endif
diff --git a/MdePkg/Include/IndustryStandard/LegacyBiosMpTable.h b/MdePkg/Include/IndustryStandard/LegacyBiosMpTable.h
new file mode 100644
index 000000000000..41045bd9765e
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/LegacyBiosMpTable.h
@@ -0,0 +1,294 @@
+/** @file
+  Defives data structures per MultiProcessor Specification Ver 1.4.
+  
+  The MultiProcessor Specification defines an enhancement to the standard 
+  to which PC manufacturers design DOS-compatible systems.
+
+Copyright (c) 2007 - 2011, 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 _LEGACY_BIOS_MPTABLE_H_
+#define _LEGACY_BIOS_MPTABLE_H_
+
+#define EFI_LEGACY_MP_TABLE_REV_1_4 0x04
+
+//
+// Define MP table structures. All are packed.
+//
+#pragma pack(1)
+
+#define EFI_LEGACY_MP_TABLE_FLOATING_POINTER_SIGNATURE  SIGNATURE_32 ('_', 'M', 'P', '_')
+typedef struct {
+  UINT32  Reserved1 : 6;
+  UINT32  MutipleClk : 1;
+  UINT32  Imcr : 1;
+  UINT32  Reserved2 : 24;
+} FEATUREBYTE2_5;
+
+typedef struct {
+  UINT32  Signature;
+  UINT32  PhysicalAddress;
+  UINT8   Length;
+  UINT8   SpecRev;
+  UINT8   Checksum;
+  UINT8   FeatureByte1;
+  FEATUREBYTE2_5 FeatureByte2_5;
+} EFI_LEGACY_MP_TABLE_FLOATING_POINTER;
+
+#define EFI_LEGACY_MP_TABLE_HEADER_SIGNATURE  SIGNATURE_32 ('P', 'C', 'M', 'P')
+typedef struct {
+  UINT32  Signature;
+  UINT16  BaseTableLength;
+  UINT8   SpecRev;
+  UINT8   Checksum;
+  CHAR8   OemId[8];
+  CHAR8   OemProductId[12];
+  UINT32  OemTablePointer;
+  UINT16  OemTableSize;
+  UINT16  EntryCount;
+  UINT32  LocalApicAddress;
+  UINT16  ExtendedTableLength;
+  UINT8   ExtendedChecksum;
+  UINT8   Reserved;
+} EFI_LEGACY_MP_TABLE_HEADER;
+
+typedef struct {
+  UINT8 EntryType;
+} EFI_LEGACY_MP_TABLE_ENTRY_TYPE;
+
+//
+// Entry Type 0: Processor.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_TYPE_PROCESSOR  0x00
+typedef struct {
+  UINT8 Enabled : 1;
+  UINT8 Bsp : 1;
+  UINT8 Reserved : 6;
+} EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_FLAGS;
+
+typedef struct {
+  UINT32  Stepping : 4;
+  UINT32  Model : 4;
+  UINT32  Family : 4;
+  UINT32  Reserved : 20;
+} EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_SIGNATURE;
+
+typedef struct {
+  UINT32  Fpu : 1;
+  UINT32  Reserved1 : 6;
+  UINT32  Mce : 1;
+  UINT32  Cx8 : 1;
+  UINT32  Apic : 1;
+  UINT32  Reserved2 : 22;
+} EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_FEATURES;
+
+typedef struct {
+  UINT8 EntryType;
+  UINT8 Id;
+  UINT8 Ver;
+  EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_FLAGS     Flags;
+  EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_SIGNATURE Signature;
+  EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR_FEATURES  Features;
+  UINT32  Reserved1;
+  UINT32  Reserved2;
+} EFI_LEGACY_MP_TABLE_ENTRY_PROCESSOR;
+
+//
+// Entry Type 1: Bus.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_TYPE_BUS  0x01
+typedef struct {
+  UINT8 EntryType;
+  UINT8 Id;
+  CHAR8 TypeString[6];
+} EFI_LEGACY_MP_TABLE_ENTRY_BUS;
+
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_CBUS   "CBUS  "  // Corollary CBus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_CBUSII "CBUSII"  // Corollary CBUS II
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_EISA   "EISA  "  // Extended ISA
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_FUTURE "FUTURE"  // IEEE FutureBus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_INTERN "INTERN"  // Internal bus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_ISA    "ISA   "  // Industry Standard Architecture
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_MBI    "MBI   "  // Multibus I
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_MBII   "MBII  "  // Multibus II
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_MCA    "MCA   "  // Micro Channel Architecture
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_MPI    "MPI   "  // MPI
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_MPSA   "MPSA  "  // MPSA
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_NUBUS  "NUBUS "  // Apple Macintosh NuBus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_PCI    "PCI   "  // Peripheral Component Interconnect
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_PCMCIA "PCMCIA"  // PC Memory Card International Assoc.
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_TC     "TC    "  // DEC TurboChannel
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_VL     "VL    "  // VESA Local Bus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_VME    "VME   "  // VMEbus
+#define EFI_LEGACY_MP_TABLE_ENTRY_BUS_STRING_XPRESS "XPRESS"  // Express System Bus
+//
+// Entry Type 2: I/O APIC.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_TYPE_IOAPIC 0x02
+typedef struct {
+  UINT8 Enabled : 1;
+  UINT8 Reserved : 7;
+} EFI_LEGACY_MP_TABLE_ENTRY_IOAPIC_FLAGS;
+
+typedef struct {
+  UINT8 EntryType;
+  UINT8 Id;
+  UINT8 Ver;
+  EFI_LEGACY_MP_TABLE_ENTRY_IOAPIC_FLAGS Flags;
+  UINT32  Address;
+} EFI_LEGACY_MP_TABLE_ENTRY_IOAPIC;
+
+//
+// Entry Type 3: I/O Interrupt Assignment.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_TYPE_IO_INT 0x03
+typedef struct {
+  UINT16  Polarity : 2;
+  UINT16  Trigger : 2;
+  UINT16  Reserved : 12;
+} EFI_LEGACY_MP_TABLE_ENTRY_INT_FLAGS;
+
+typedef struct {
+  UINT8 IntNo : 2;
+  UINT8 Dev : 5;
+  UINT8 Reserved : 1;
+} EFI_LEGACY_MP_TABLE_ENTRY_INT_FIELDS;
+
+typedef union {
+  EFI_LEGACY_MP_TABLE_ENTRY_INT_FIELDS fields;
+  UINT8 byte;
+} EFI_LEGACY_MP_TABLE_ENTRY_INT_SOURCE_BUS_IRQ;
+
+typedef struct {
+  UINT8 EntryType;
+  UINT8 IntType;
+  EFI_LEGACY_MP_TABLE_ENTRY_INT_FLAGS Flags;
+  UINT8 SourceBusId;
+  EFI_LEGACY_MP_TABLE_ENTRY_INT_SOURCE_BUS_IRQ SourceBusIrq;
+  UINT8 DestApicId;
+  UINT8 DestApicIntIn;
+} EFI_LEGACY_MP_TABLE_ENTRY_IO_INT;
+
+typedef enum {
+  EfiLegacyMpTableEntryIoIntTypeInt   = 0,
+  EfiLegacyMpTableEntryIoIntTypeNmi   = 1,
+  EfiLegacyMpTableEntryIoIntTypeSmi   = 2,
+  EfiLegacyMpTableEntryIoIntTypeExtInt= 3,
+} EFI_LEGACY_MP_TABLE_ENTRY_IO_INT_TYPE;
+
+typedef enum {
+  EfiLegacyMpTableEntryIoIntFlagsPolaritySpec       = 0x0,
+  EfiLegacyMpTableEntryIoIntFlagsPolarityActiveHigh = 0x1,
+  EfiLegacyMpTableEntryIoIntFlagsPolarityReserved   = 0x2,
+  EfiLegacyMpTableEntryIoIntFlagsPolarityActiveLow  = 0x3,
+} EFI_LEGACY_MP_TABLE_ENTRY_IO_INT_FLAGS_POLARITY;
+
+typedef enum {
+  EfiLegacyMpTableEntryIoIntFlagsTriggerSpec        = 0x0,
+  EfiLegacyMpTableEntryIoIntFlagsTriggerEdge        = 0x1,
+  EfiLegacyMpTableEntryIoIntFlagsTriggerReserved    = 0x2,
+  EfiLegacyMpTableEntryIoIntFlagsTriggerLevel       = 0x3,
+} EFI_LEGACY_MP_TABLE_ENTRY_IO_INT_FLAGS_TRIGGER;
+
+//
+// Entry Type 4: Local Interrupt Assignment.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_TYPE_LOCAL_INT  0x04
+typedef struct {
+  UINT8 EntryType;
+  UINT8 IntType;
+  EFI_LEGACY_MP_TABLE_ENTRY_INT_FLAGS Flags;
+  UINT8 SourceBusId;
+  EFI_LEGACY_MP_TABLE_ENTRY_INT_SOURCE_BUS_IRQ SourceBusIrq;
+  UINT8 DestApicId;
+  UINT8 DestApicIntIn;
+} EFI_LEGACY_MP_TABLE_ENTRY_LOCAL_INT;
+
+typedef enum {
+  EfiLegacyMpTableEntryLocalIntTypeInt              = 0,
+  EfiLegacyMpTableEntryLocalIntTypeNmi              = 1,
+  EfiLegacyMpTableEntryLocalIntTypeSmi              = 2,
+  EfiLegacyMpTableEntryLocalIntTypeExtInt           = 3,
+} EFI_LEGACY_MP_TABLE_ENTRY_LOCAL_INT_TYPE;
+
+typedef enum {
+  EfiLegacyMpTableEntryLocalIntFlagsPolaritySpec      = 0x0,
+  EfiLegacyMpTableEntryLocalIntFlagsPolarityActiveHigh= 0x1,
+  EfiLegacyMpTableEntryLocalIntFlagsPolarityReserved  = 0x2,
+  EfiLegacyMpTableEntryLocalIntFlagsPolarityActiveLow = 0x3,
+} EFI_LEGACY_MP_TABLE_ENTRY_LOCAL_INT_FLAGS_POLARITY;
+
+typedef enum {
+  EfiLegacyMpTableEntryLocalIntFlagsTriggerSpec       = 0x0,
+  EfiLegacyMpTableEntryLocalIntFlagsTriggerEdge       = 0x1,
+  EfiLegacyMpTableEntryLocalIntFlagsTriggerReserved   = 0x2,
+  EfiLegacyMpTableEntryLocalIntFlagsTriggerLevel      = 0x3,
+} EFI_LEGACY_MP_TABLE_ENTRY_LOCAL_INT_FLAGS_TRIGGER;
+
+//
+// Entry Type 128: System Address Space Mapping.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_EXT_TYPE_SYS_ADDR_SPACE_MAPPING 0x80
+typedef struct {
+  UINT8   EntryType;
+  UINT8   Length;
+  UINT8   BusId;
+  UINT8   AddressType;
+  UINT64  AddressBase;
+  UINT64  AddressLength;
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_SYS_ADDR_SPACE_MAPPING;
+
+typedef enum {
+  EfiLegacyMpTableEntryExtSysAddrSpaceMappingIo       = 0,
+  EfiLegacyMpTableEntryExtSysAddrSpaceMappingMemory   = 1,
+  EfiLegacyMpTableEntryExtSysAddrSpaceMappingPrefetch = 2,
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_SYS_ADDR_SPACE_MAPPING_TYPE;
+
+//
+// Entry Type 129: Bus Hierarchy.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_EXT_TYPE_BUS_HIERARCHY  0x81
+typedef struct {
+  UINT8 SubtractiveDecode : 1;
+  UINT8 Reserved : 7;
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_BUS_HIERARCHY_BUSINFO;
+
+typedef struct {
+  UINT8 EntryType;
+  UINT8 Length;
+  UINT8 BusId;
+  EFI_LEGACY_MP_TABLE_ENTRY_EXT_BUS_HIERARCHY_BUSINFO BusInfo;
+  UINT8 ParentBus;
+  UINT8 Reserved1;
+  UINT8 Reserved2;
+  UINT8 Reserved3;
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_BUS_HIERARCHY;
+
+//
+// Entry Type 130: Compatibility Bus Address Space Modifier.
+//
+#define EFI_LEGACY_MP_TABLE_ENTRY_EXT_TYPE_COMPAT_BUS_ADDR_SPACE_MODIFIER 0x82
+typedef struct {
+  UINT8 RangeMode : 1;
+  UINT8 Reserved : 7;
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_COMPAT_BUS_ADDR_SPACE_MODIFIER_ADDR_MODE;
+
+typedef struct {
+  UINT8 EntryType;
+  UINT8 Length;
+  UINT8 BusId;
+  EFI_LEGACY_MP_TABLE_ENTRY_EXT_COMPAT_BUS_ADDR_SPACE_MODIFIER_ADDR_MODE AddrMode;
+  UINT32  PredefinedRangeList;
+} EFI_LEGACY_MP_TABLE_ENTRY_EXT_COMPAT_BUS_ADDR_SPACE_MODIFIER;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/LowPowerIdleTable.h b/MdePkg/Include/IndustryStandard/LowPowerIdleTable.h
new file mode 100644
index 000000000000..2b361ed390a5
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/LowPowerIdleTable.h
@@ -0,0 +1,82 @@
+/** @file
+  ACPI Low Power Idle Table (LPIT) definitions
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+    - ACPI Low Power Idle Table (LPIT) Revision 001, dated July 2014
+      http://www.uefi.org/sites/default/files/resources/ACPI_Low_Power_Idle_Table.pdf
+
+  @par Glossary:
+    - GAS - Generic Address Structure
+    - LPI - Low Power Idle
+**/
+#ifndef _LOW_POWER_IDLE_TABLE_H_
+#define _LOW_POWER_IDLE_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+#pragma pack(1)
+
+///
+/// LPI Structure Types
+///
+#define ACPI_LPI_STRUCTURE_TYPE_NATIVE_CSTATE     0x00
+
+///
+/// Low Power Idle (LPI) State Flags
+///
+typedef union {
+  struct {
+    UINT32 Disabled           : 1;  ///< If set, LPI state is not used
+    /**
+      If set, Residency counter is not available for this LPI state and
+      Residency Counter Frequency is invalid
+    **/
+    UINT32 CounterUnavailable : 1;
+    UINT32 Reserved           : 30; ///< Reserved for future use. Must be zero
+  } Bits;
+  UINT32 Data32;
+} ACPI_LPI_STATE_FLAGS;
+
+///
+/// Low Power Idle (LPI) structure with Native C-state instruction entry trigger descriptor
+///
+typedef struct {
+  UINT32                                  Type;   ///< LPI State descriptor Type 0
+  UINT32                                  Length; ///< Length of LPI state Descriptor Structure
+  ///
+  /// Unique LPI state identifier: zero based, monotonically increasing identifier
+  ///
+  UINT16                                  UniqueId;
+  UINT8                                   Reserved[2];  ///< Must be Zero
+  ACPI_LPI_STATE_FLAGS                    Flags;        ///< LPI state flags
+  /**
+    The LPI entry trigger, matching an existing _CST.Register object, represented as a
+    Generic Address Structure. All processors must request this state or deeper to trigger.
+  **/
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  EntryTrigger;
+  UINT32                                  Residency;  ///< Minimum residency or break-even in uSec
+  UINT32                                  Latency;    ///< Worst case exit latency in uSec
+  /**
+    [optional] Residency counter, represented as a Generic Address Structure.
+    If not present, Flags[1] bit should be set.
+  **/
+  EFI_ACPI_6_1_GENERIC_ADDRESS_STRUCTURE  ResidencyCounter;
+  /**
+    [optional] Residency counter frequency in cycles per second. Value 0 indicates that
+    counter runs at TSC frequency. Valid only if Residency Counter is present.
+  **/
+  UINT64                                  ResidencyCounterFrequency;
+} ACPI_LPI_NATIVE_CSTATE_DESCRIPTOR;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Mbr.h b/MdePkg/Include/IndustryStandard/Mbr.h
new file mode 100644
index 000000000000..302e44d77301
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Mbr.h
@@ -0,0 +1,60 @@
+/** @file
+  Legacy Master Boot Record Format Definition.
+
+Copyright (c) 2006 - 2008, 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 _MBR_H_
+#define _MBR_H_
+
+#define MBR_SIGNATURE               0xaa55
+
+#define EXTENDED_DOS_PARTITION      0x05
+#define EXTENDED_WINDOWS_PARTITION  0x0F
+
+#define MAX_MBR_PARTITIONS          4
+
+#define PMBR_GPT_PARTITION          0xEE
+#define EFI_PARTITION               0xEF
+
+#define MBR_SIZE                    512
+
+#pragma pack(1)
+///
+/// MBR Partition Entry
+///
+typedef struct {
+  UINT8 BootIndicator;
+  UINT8 StartHead;
+  UINT8 StartSector;
+  UINT8 StartTrack;
+  UINT8 OSIndicator;
+  UINT8 EndHead;
+  UINT8 EndSector;
+  UINT8 EndTrack;
+  UINT8 StartingLBA[4];
+  UINT8 SizeInLBA[4];
+} MBR_PARTITION_RECORD;
+
+///
+/// MBR Partition Table
+///
+typedef struct {
+  UINT8                 BootStrapCode[440];
+  UINT8                 UniqueMbrSignature[4];
+  UINT8                 Unknown[2];
+  MBR_PARTITION_RECORD  Partition[MAX_MBR_PARTITIONS];
+  UINT16                Signature;
+} MASTER_BOOT_RECORD;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/MemoryMappedConfigurationSpaceAccessTable.h b/MdePkg/Include/IndustryStandard/MemoryMappedConfigurationSpaceAccessTable.h
new file mode 100644
index 000000000000..d855d9b271d7
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/MemoryMappedConfigurationSpaceAccessTable.h
@@ -0,0 +1,53 @@
+/** @file
+  ACPI memory mapped configuration space access table definition, defined at 
+  in the PCI Firmware Specification, version 3.0.
+  Specification is available at http://www.pcisig.com.
+    
+  Copyright (c) 2007 - 2008, 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 _MEMORY_MAPPED_CONFIGURATION_SPACE_ACCESS_TABLE_H_
+#define _MEMORY_MAPPED_CONFIGURATION_SPACE_ACCESS_TABLE_H_
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// Memory Mapped Configuration Space Access Table (MCFG)
+/// This table is a basic description table header followed by
+/// a number of base address allocation structures.
+///
+typedef struct {
+  UINT64  BaseAddress;
+  UINT16  PciSegmentGroupNumber;
+  UINT8   StartBusNumber;
+  UINT8   EndBusNumber;
+  UINT32  Reserved;
+} EFI_ACPI_MEMORY_MAPPED_ENHANCED_CONFIGURATION_SPACE_BASE_ADDRESS_ALLOCATION_STRUCTURE;
+
+///
+/// MCFG Table header definition.  The rest of the table 
+/// must be defined in a platform specific manner.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER                       Header;
+  UINT64                                            Reserved;
+} EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE_HEADER;
+
+///
+/// MCFG Revision (defined in spec)
+///
+#define EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_SPACE_ACCESS_TABLE_REVISION  0x01
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/MemoryOverwriteRequestControlLock.h b/MdePkg/Include/IndustryStandard/MemoryOverwriteRequestControlLock.h
new file mode 100644
index 000000000000..415c134779ae
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/MemoryOverwriteRequestControlLock.h
@@ -0,0 +1,43 @@
+/** @file
+  Support for Microsoft Secure MOR implementation, defined at 
+  Microsoft Secure MOR implementation.
+  https://msdn.microsoft.com/en-us/library/windows/hardware/mt270973(v=vs.85).aspx
+
+  Copyright (c) 2015 - 2016, 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 __MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_H__
+#define __MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_H__
+
+#define MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_GUID \
+  { \
+    0xBB983CCF, 0x151D, 0x40E1, {0xA0, 0x7B, 0x4A, 0x17, 0xBE, 0x16, 0x82, 0x92} \
+  }
+
+#define MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME L"MemoryOverwriteRequestControlLock"
+
+//
+// VendorGuid: {BB983CCF-151D-40E1-A07B-4A17BE168292}
+// Name:       MemoryOverwriteRequestControlLock
+// Attributes: NV+BS+RT
+// GetVariable value in Data parameter: 0x0 (unlocked); 0x1 (locked without key); 0x2 (locked with key)
+// SetVariable value in Data parameter: 0x0 (unlocked); 0x1 (locked);
+//                                      Revision 2 additionally accepts an 8-byte value that represents a shared secret key.
+//
+
+//
+// Note: Setting MemoryOverwriteRequestControlLock does not commit to flash (just changes the internal lock state).
+// Getting the variable returns the internal state and never exposes the key.
+//
+
+extern EFI_GUID gEfiMemoryOverwriteRequestControlLockGuid;
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Nvme.h b/MdePkg/Include/IndustryStandard/Nvme.h
new file mode 100644
index 000000000000..5914b58cfdd4
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Nvme.h
@@ -0,0 +1,935 @@
+/** @file
+  Definitions based on NVMe spec. version 1.1.
+
+  (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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.
+
+  @par Specification Reference:
+  NVMe Specification 1.1
+
+**/
+
+#ifndef __NVM_E_H__
+#define __NVM_E_H__
+
+#pragma pack(1)
+
+//
+// controller register offsets
+//
+#define NVME_CAP_OFFSET          0x0000  // Controller Capabilities
+#define NVME_VER_OFFSET          0x0008  // Version
+#define NVME_INTMS_OFFSET        0x000c  // Interrupt Mask Set
+#define NVME_INTMC_OFFSET        0x0010  // Interrupt Mask Clear
+#define NVME_CC_OFFSET           0x0014  // Controller Configuration
+#define NVME_CSTS_OFFSET         0x001c  // Controller Status
+#define NVME_NSSR_OFFSET         0x0020  // NVM Subsystem Reset
+#define NVME_AQA_OFFSET          0x0024  // Admin Queue Attributes
+#define NVME_ASQ_OFFSET          0x0028  // Admin Submission Queue Base Address
+#define NVME_ACQ_OFFSET          0x0030  // Admin Completion Queue Base Address
+#define NVME_SQ0_OFFSET          0x1000  // Submission Queue 0 (admin) Tail Doorbell
+#define NVME_CQ0_OFFSET          0x1004  // Completion Queue 0 (admin) Head Doorbell
+
+//
+// These register offsets are defined as 0x1000 + (N * (4 << CAP.DSTRD))
+// Get the doorbell stride bit shift value from the controller capabilities.
+//
+#define NVME_SQTDBL_OFFSET(QID, DSTRD)    0x1000 + ((2 * (QID)) * (4 << (DSTRD)))       // Submission Queue y (NVM) Tail Doorbell
+#define NVME_CQHDBL_OFFSET(QID, DSTRD)    0x1000 + (((2 * (QID)) + 1) * (4 << (DSTRD))) // Completion Queue y (NVM) Head Doorbell
+
+
+#pragma pack(1)
+
+//
+// 3.1.1 Offset 00h: CAP - Controller Capabilities
+//
+typedef struct {
+  UINT16 Mqes;      // Maximum Queue Entries Supported
+  UINT8  Cqr:1;     // Contiguous Queues Required
+  UINT8  Ams:2;     // Arbitration Mechanism Supported
+  UINT8  Rsvd1:5;
+  UINT8  To;        // Timeout
+  UINT16 Dstrd:4;
+  UINT16 Nssrs:1;   // NVM Subsystem Reset Supported NSSRS
+  UINT16 Css:4;     // Command Sets Supported - Bit 37
+  UINT16 Rsvd3:7;
+  UINT8  Mpsmin:4;
+  UINT8  Mpsmax:4;
+  UINT8  Rsvd4;
+} NVME_CAP;
+
+//
+// 3.1.2 Offset 08h: VS - Version
+//
+typedef struct {
+  UINT16 Mnr;       // Minor version number
+  UINT16 Mjr;       // Major version number
+} NVME_VER;
+
+//
+// 3.1.5 Offset 14h: CC - Controller Configuration
+//
+typedef struct {
+  UINT16 En:1;       // Enable
+  UINT16 Rsvd1:3;
+  UINT16 Css:3;      // I/O Command Set Selected
+  UINT16 Mps:4;      // Memory Page Size
+  UINT16 Ams:3;      // Arbitration Mechanism Selected
+  UINT16 Shn:2;      // Shutdown Notification
+  UINT8  Iosqes:4;   // I/O Submission Queue Entry Size
+  UINT8  Iocqes:4;   // I/O Completion Queue Entry Size
+  UINT8  Rsvd2;
+} NVME_CC;
+
+//
+// 3.1.6 Offset 1Ch: CSTS - Controller Status
+//
+typedef struct {
+  UINT32 Rdy:1;      // Ready
+  UINT32 Cfs:1;      // Controller Fatal Status
+  UINT32 Shst:2;     // Shutdown Status
+  UINT32 Nssro:1;    // NVM Subsystem Reset Occurred
+  UINT32 Rsvd1:27;
+} NVME_CSTS;
+
+//
+// 3.1.8 Offset 24h: AQA - Admin Queue Attributes
+//
+typedef struct {
+  UINT16 Asqs:12;    // Submission Queue Size
+  UINT16 Rsvd1:4;
+  UINT16 Acqs:12;    // Completion Queue Size
+  UINT16 Rsvd2:4;
+} NVME_AQA;
+
+//
+// 3.1.9 Offset 28h: ASQ - Admin Submission Queue Base Address
+//
+#define NVME_ASQ      UINT64
+//
+// 3.1.10 Offset 30h: ACQ - Admin Completion Queue Base Address
+//
+#define NVME_ACQ      UINT64
+
+//
+// 3.1.11 Offset (1000h + ((2y) * (4 << CAP.DSTRD))): SQyTDBL - Submission Queue y Tail Doorbell
+//
+typedef struct {
+  UINT16 Sqt;
+  UINT16 Rsvd1;
+} NVME_SQTDBL;
+
+//
+// 3.1.12 Offset (1000h + ((2y + 1) * (4 << CAP.DSTRD))): CQyHDBL - Completion Queue y Head Doorbell
+//
+typedef struct {
+  UINT16 Cqh;
+  UINT16 Rsvd1;
+} NVME_CQHDBL;
+
+//
+// NVM command set structures
+//
+// Read Command
+//
+typedef struct {
+  //
+  // CDW 10, 11
+  //
+  UINT64 Slba;                /* Starting Sector Address */
+  //
+  // CDW 12
+  //
+  UINT16 Nlb;                 /* Number of Sectors */
+  UINT16 Rsvd1:10;
+  UINT16 Prinfo:4;            /* Protection Info Check */
+  UINT16 Fua:1;               /* Force Unit Access */
+  UINT16 Lr:1;                /* Limited Retry */
+  //
+  // CDW 13
+  //
+  UINT32 Af:4;                /* Access Frequency */
+  UINT32 Al:2;                /* Access Latency */
+  UINT32 Sr:1;                /* Sequential Request */
+  UINT32 In:1;                /* Incompressible */
+  UINT32 Rsvd2:24;
+  //
+  // CDW 14
+  //
+  UINT32 Eilbrt;              /* Expected Initial Logical Block Reference Tag */
+  //
+  // CDW 15
+  //
+  UINT16 Elbat;               /* Expected Logical Block Application Tag */
+  UINT16 Elbatm;              /* Expected Logical Block Application Tag Mask */
+} NVME_READ;
+
+//
+// Write Command
+//
+typedef struct {
+  //
+  // CDW 10, 11
+  //
+  UINT64 Slba;                /* Starting Sector Address */
+  //
+  // CDW 12
+  //
+  UINT16 Nlb;                 /* Number of Sectors */
+  UINT16 Rsvd1:10;
+  UINT16 Prinfo:4;            /* Protection Info Check */
+  UINT16 Fua:1;               /* Force Unit Access */
+  UINT16 Lr:1;                /* Limited Retry */
+  //
+  // CDW 13
+  //
+  UINT32 Af:4;                /* Access Frequency */
+  UINT32 Al:2;                /* Access Latency */
+  UINT32 Sr:1;                /* Sequential Request */
+  UINT32 In:1;                /* Incompressible */
+  UINT32 Rsvd2:24;
+  //
+  // CDW 14
+  //
+  UINT32 Ilbrt;               /* Initial Logical Block Reference Tag */
+  //
+  // CDW 15
+  //
+  UINT16 Lbat;                /* Logical Block Application Tag */
+  UINT16 Lbatm;               /* Logical Block Application Tag Mask */
+} NVME_WRITE;
+
+//
+// Flush
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Flush;               /* Flush */
+} NVME_FLUSH;
+
+//
+// Write Uncorrectable command
+//
+typedef struct {
+  //
+  // CDW 10, 11
+  //
+  UINT64 Slba;                /* Starting LBA */
+  //
+  // CDW 12
+  //
+  UINT32 Nlb:16;              /* Number of  Logical Blocks */
+  UINT32 Rsvd1:16;
+} NVME_WRITE_UNCORRECTABLE;
+
+//
+// Write Zeroes command
+//
+typedef struct {
+  //
+  // CDW 10, 11
+  //
+  UINT64 Slba;                /* Starting LBA */
+  //
+  // CDW 12
+  //
+  UINT16 Nlb;                 /* Number of Logical Blocks */
+  UINT16 Rsvd1:10;
+  UINT16 Prinfo:4;            /* Protection Info Check */
+  UINT16 Fua:1;               /* Force Unit Access */
+  UINT16 Lr:1;                /* Limited Retry */
+  //
+  // CDW 13
+  //
+  UINT32 Rsvd2;
+  //
+  // CDW 14
+  //
+  UINT32 Ilbrt;               /* Initial Logical Block Reference Tag */
+  //
+  // CDW 15
+  //
+  UINT16 Lbat;                /* Logical Block Application Tag */
+  UINT16 Lbatm;               /* Logical Block Application Tag Mask */
+} NVME_WRITE_ZEROES;
+
+//
+// Compare command
+//
+typedef struct {
+  //
+  // CDW 10, 11
+  //
+  UINT64 Slba;                /* Starting LBA */
+  //
+  // CDW 12
+  //
+  UINT16 Nlb;                 /* Number of Logical Blocks */
+  UINT16 Rsvd1:10;
+  UINT16 Prinfo:4;            /* Protection Info Check */
+  UINT16 Fua:1;               /* Force Unit Access */
+  UINT16 Lr:1;                /* Limited Retry */
+  //
+  // CDW 13
+  //
+  UINT32 Rsvd2;
+  //
+  // CDW 14
+  //
+  UINT32 Eilbrt;              /* Expected Initial Logical Block Reference Tag */
+  //
+  // CDW 15
+  //
+  UINT16 Elbat;               /* Expected Logical Block Application Tag */
+  UINT16 Elbatm;              /* Expected Logical Block Application Tag Mask */
+} NVME_COMPARE;
+
+typedef union {
+  NVME_READ                   Read;
+  NVME_WRITE                  Write;
+  NVME_FLUSH                  Flush;
+  NVME_WRITE_UNCORRECTABLE    WriteUncorrectable;
+  NVME_WRITE_ZEROES           WriteZeros;
+  NVME_COMPARE                Compare;
+} NVME_CMD;
+
+typedef struct {
+  UINT16 Mp;                /* Maximum Power */
+  UINT8  Rsvd1;             /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8  Mps:1;             /* Max Power Scale */
+  UINT8  Nops:1;            /* Non-Operational State */
+  UINT8  Rsvd2:6;           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT32 Enlat;             /* Entry Latency */
+  UINT32 Exlat;             /* Exit Latency */
+  UINT8  Rrt:5;             /* Relative Read Throughput */
+  UINT8  Rsvd3:3;           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8  Rrl:5;             /* Relative Read Leatency */
+  UINT8  Rsvd4:3;           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8  Rwt:5;             /* Relative Write Throughput */
+  UINT8  Rsvd5:3;           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8  Rwl:5;             /* Relative Write Leatency */
+  UINT8  Rsvd6:3;           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8  Rsvd7[16];         /* Reserved as of Nvm Express 1.1 Spec */
+} NVME_PSDESCRIPTOR;
+
+//
+//  Identify Controller Data
+//
+typedef struct {
+  //
+  // Controller Capabilities and Features 0-255
+  //
+  UINT16 Vid;                 /* PCI Vendor ID */
+  UINT16 Ssvid;               /* PCI sub-system vendor ID */
+  UINT8  Sn[20];              /* Product serial number */
+
+  UINT8  Mn[40];              /* Proeduct model number */
+  UINT8  Fr[8];               /* Firmware Revision */
+  UINT8  Rab;                 /* Recommended Arbitration Burst */
+  UINT8  Ieee_oui[3];         /* Organization Unique Identifier */
+  UINT8  Cmic;                /* Multi-interface Capabilities */
+  UINT8  Mdts;                /* Maximum Data Transfer Size */
+  UINT8  Cntlid[2];           /* Controller ID */
+  UINT8  Rsvd1[176];          /* Reserved as of Nvm Express 1.1 Spec */
+  //
+  // Admin Command Set Attributes
+  //
+  UINT16 Oacs;                /* Optional Admin Command Support */
+    #define NAMESPACE_MANAGEMENT_SUPPORTED  BIT3
+    #define FW_DOWNLOAD_ACTIVATE_SUPPORTED  BIT2
+    #define FORMAT_NVM_SUPPORTED            BIT1
+    #define SECURITY_SEND_RECEIVE_SUPPORTED BIT0
+  UINT8  Acl;                 /* Abort Command Limit */
+  UINT8  Aerl;                /* Async Event Request Limit */
+  UINT8  Frmw;                /* Firmware updates */
+  UINT8  Lpa;                 /* Log Page Attributes */
+  UINT8  Elpe;                /* Error Log Page Entries */
+  UINT8  Npss;                /* Number of Power States Support */
+  UINT8  Avscc;               /* Admin Vendor Specific Command Configuration */
+  UINT8  Apsta;               /* Autonomous Power State Transition Attributes */
+  UINT8  Rsvd2[246];          /* Reserved as of Nvm Express 1.1 Spec */
+  //
+  // NVM Command Set Attributes
+  //
+  UINT8  Sqes;                /* Submission Queue Entry Size */
+  UINT8  Cqes;                /* Completion Queue Entry Size */
+  UINT16 Rsvd3;               /* Reserved as of Nvm Express 1.1 Spec */
+  UINT32 Nn;                  /* Number of Namespaces */
+  UINT16 Oncs;                /* Optional NVM Command Support */
+  UINT16 Fuses;               /* Fused Operation Support */
+  UINT8  Fna;                 /* Format NVM Attributes */
+  UINT8  Vwc;                 /* Volatile Write Cache */
+  UINT16 Awun;                /* Atomic Write Unit Normal */
+  UINT16 Awupf;               /* Atomic Write Unit Power Fail */
+  UINT8  Nvscc;               /* NVM Vendor Specific Command Configuration */
+  UINT8  Rsvd4;               /* Reserved as of Nvm Express 1.1 Spec */
+  UINT16 Acwu;                /* Atomic Compare & Write Unit */
+  UINT16 Rsvd5;               /* Reserved as of Nvm Express 1.1 Spec */
+  UINT32 Sgls;                /* SGL Support  */
+  UINT8  Rsvd6[164];          /* Reserved as of Nvm Express 1.1 Spec */
+  //
+  // I/O Command set Attributes
+  //
+  UINT8 Rsvd7[1344];          /* Reserved as of Nvm Express 1.1 Spec */
+  //
+  // Power State Descriptors
+  //
+  NVME_PSDESCRIPTOR PsDescriptor[32];
+
+  UINT8  VendorData[1024];    /* Vendor specific data */
+} NVME_ADMIN_CONTROLLER_DATA;
+
+typedef struct {
+  UINT16 Ms;                /* Metadata Size */
+  UINT8  Lbads;             /* LBA Data Size */
+  UINT8  Rp:2;              /* Relative Performance */
+    #define LBAF_RP_BEST      00b
+    #define LBAF_RP_BETTER    01b
+    #define LBAF_RP_GOOD      10b
+    #define LBAF_RP_DEGRADED  11b
+  UINT8  Rsvd1:6;           /* Reserved as of Nvm Express 1.1 Spec */
+} NVME_LBAFORMAT;
+
+//
+// Identify Namespace Data
+//
+typedef struct {
+  //
+  // NVM Command Set Specific
+  //
+  UINT64 Nsze;                /* Namespace Size (total number of blocks in formatted namespace) */
+  UINT64 Ncap;                /* Namespace Capacity (max number of logical blocks) */
+  UINT64 Nuse;                /* Namespace Utilization */
+  UINT8  Nsfeat;              /* Namespace Features */
+  UINT8  Nlbaf;               /* Number of LBA Formats */
+  UINT8  Flbas;               /* Formatted LBA size */
+  UINT8  Mc;                  /* Metadata Capabilities */
+  UINT8  Dpc;                 /* End-to-end Data Protection capabilities */
+  UINT8  Dps;                 /* End-to-end Data Protection Type Settings */
+  UINT8  Nmic;                /* Namespace Multi-path I/O and Namespace Sharing Capabilities */
+  UINT8  Rescap;              /* Reservation Capabilities */
+  UINT8  Rsvd1[88];           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT64 Eui64;               /* IEEE Extended Unique Identifier */
+  //
+  // LBA Format
+  //
+  NVME_LBAFORMAT LbaFormat[16];
+
+  UINT8 Rsvd2[192];           /* Reserved as of Nvm Express 1.1 Spec */
+  UINT8 VendorData[3712];     /* Vendor specific data */
+} NVME_ADMIN_NAMESPACE_DATA;
+
+//
+// NvmExpress Admin Identify Cmd
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Cns:2;
+  UINT32 Rsvd1:30;
+} NVME_ADMIN_IDENTIFY;
+
+//
+// NvmExpress Admin Create I/O Completion Queue
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Qid:16;              /* Queue Identifier */
+  UINT32 Qsize:16;            /* Queue Size */
+
+  //
+  // CDW 11
+  //
+  UINT32 Pc:1;                /* Physically Contiguous */
+  UINT32 Ien:1;               /* Interrupts Enabled */
+  UINT32 Rsvd1:14;            /* reserved as of Nvm Express 1.1 Spec */
+  UINT32 Iv:16;               /* Interrupt Vector for MSI-X or MSI*/
+} NVME_ADMIN_CRIOCQ;
+
+//
+// NvmExpress Admin Create I/O Submission Queue
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Qid:16;              /* Queue Identifier */
+  UINT32 Qsize:16;            /* Queue Size */
+
+  //
+  // CDW 11
+  //
+  UINT32 Pc:1;                /* Physically Contiguous */
+  UINT32 Qprio:2;             /* Queue Priority */
+  UINT32 Rsvd1:13;            /* Reserved as of Nvm Express 1.1 Spec */
+  UINT32 Cqid:16;             /* Completion Queue ID */
+} NVME_ADMIN_CRIOSQ;
+
+//
+// NvmExpress Admin Delete I/O Completion Queue
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT16 Qid;
+  UINT16 Rsvd1;
+} NVME_ADMIN_DEIOCQ;
+
+//
+// NvmExpress Admin Delete I/O Submission Queue
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT16 Qid;
+  UINT16 Rsvd1;
+} NVME_ADMIN_DEIOSQ;
+
+//
+// NvmExpress Admin Abort Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Sqid:16;             /* Submission Queue identifier */
+  UINT32 Cid:16;              /* Command Identifier */
+} NVME_ADMIN_ABORT;
+
+//
+// NvmExpress Admin Firmware Activate Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Fs:3;                /* Submission Queue identifier */
+  UINT32 Aa:2;                /* Command Identifier */
+  UINT32 Rsvd1:27;
+} NVME_ADMIN_FIRMWARE_ACTIVATE;
+
+//
+// NvmExpress Admin Firmware Image Download Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Numd;                /* Number of Dwords */
+  //
+  // CDW 11
+  //
+  UINT32 Ofst;                /* Offset */
+} NVME_ADMIN_FIRMWARE_IMAGE_DOWNLOAD;
+
+//
+// NvmExpress Admin Get Features Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Fid:8;                /* Feature Identifier */
+  UINT32 Sel:3;                /* Select */
+  UINT32 Rsvd1:21;
+} NVME_ADMIN_GET_FEATURES;
+
+//
+// NvmExpress Admin Get Log Page Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Lid:8;               /* Log Page Identifier */
+    #define LID_ERROR_INFO   0x1
+    #define LID_SMART_INFO   0x2
+    #define LID_FW_SLOT_INFO 0x3
+  UINT32 Rsvd1:8;
+  UINT32 Numd:12;             /* Number of Dwords */
+  UINT32 Rsvd2:4;             /* Reserved as of Nvm Express 1.1 Spec */
+} NVME_ADMIN_GET_LOG_PAGE;
+
+//
+// NvmExpress Admin Set Features Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Fid:8;               /* Feature Identifier */
+  UINT32 Rsvd1:23;
+  UINT32 Sv:1;                /* Save */
+} NVME_ADMIN_SET_FEATURES;
+
+//
+// NvmExpress Admin Format NVM Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Lbaf:4;              /* LBA Format */
+  UINT32 Ms:1;                /* Metadata Settings */
+  UINT32 Pi:3;                /* Protection Information */
+  UINT32 Pil:1;               /* Protection Information Location */
+  UINT32 Ses:3;               /* Secure Erase Settings */
+  UINT32 Rsvd1:20;
+} NVME_ADMIN_FORMAT_NVM;
+
+//
+// NvmExpress Admin Security Receive Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Rsvd1:8;
+  UINT32 Spsp:16;             /* SP Specific */
+  UINT32 Secp:8;              /* Security Protocol */
+  //
+  // CDW 11
+  //
+  UINT32 Al;                  /* Allocation Length */
+} NVME_ADMIN_SECURITY_RECEIVE;
+
+//
+// NvmExpress Admin Security Send Command
+//
+typedef struct {
+  //
+  // CDW 10
+  //
+  UINT32 Rsvd1:8;
+  UINT32 Spsp:16;             /* SP Specific */
+  UINT32 Secp:8;              /* Security Protocol */
+  //
+  // CDW 11
+  //
+  UINT32 Tl;                  /* Transfer Length */
+} NVME_ADMIN_SECURITY_SEND;
+
+typedef union {
+  NVME_ADMIN_IDENTIFY                   Identify;
+  NVME_ADMIN_CRIOCQ                     CrIoCq;
+  NVME_ADMIN_CRIOSQ                     CrIoSq;
+  NVME_ADMIN_DEIOCQ                     DeIoCq;
+  NVME_ADMIN_DEIOSQ                     DeIoSq;
+  NVME_ADMIN_ABORT                      Abort;
+  NVME_ADMIN_FIRMWARE_ACTIVATE          Activate;
+  NVME_ADMIN_FIRMWARE_IMAGE_DOWNLOAD    FirmwareImageDownload;
+  NVME_ADMIN_GET_FEATURES               GetFeatures;
+  NVME_ADMIN_GET_LOG_PAGE               GetLogPage;
+  NVME_ADMIN_SET_FEATURES               SetFeatures;
+  NVME_ADMIN_FORMAT_NVM                 FormatNvm;
+  NVME_ADMIN_SECURITY_RECEIVE           SecurityReceive;
+  NVME_ADMIN_SECURITY_SEND              SecuritySend;
+} NVME_ADMIN_CMD;
+
+typedef struct {
+  UINT32 Cdw10;
+  UINT32 Cdw11;
+  UINT32 Cdw12;
+  UINT32 Cdw13;
+  UINT32 Cdw14;
+  UINT32 Cdw15;
+} NVME_RAW;
+
+typedef union {
+  NVME_ADMIN_CMD Admin;   // Union of Admin commands
+  NVME_CMD       Nvm;     // Union of Nvm commands
+  NVME_RAW       Raw;
+} NVME_PAYLOAD;
+
+//
+// Submission Queue
+//
+typedef struct {
+  //
+  // CDW 0, Common to all comnmands
+  //
+  UINT8  Opc;               // Opcode
+  UINT8  Fuse:2;            // Fused Operation
+  UINT8  Rsvd1:5;
+  UINT8  Psdt:1;            // PRP or SGL for Data Transfer
+  UINT16 Cid;               // Command Identifier
+
+  //
+  // CDW 1
+  //
+  UINT32 Nsid;              // Namespace Identifier
+
+  //
+  // CDW 2,3
+  //
+  UINT64 Rsvd2;
+
+  //
+  // CDW 4,5
+  //
+  UINT64 Mptr;              // Metadata Pointer
+
+  //
+  // CDW 6-9
+  //
+  UINT64 Prp[2];            // First and second PRP entries
+
+  NVME_PAYLOAD Payload;
+
+} NVME_SQ;
+
+//
+// Completion Queue
+//
+typedef struct {
+  //
+  // CDW 0
+  //
+  UINT32 Dword0;
+  //
+  // CDW 1
+  //
+  UINT32 Rsvd1;
+  //
+  // CDW 2
+  //
+  UINT16 Sqhd;              // Submission Queue Head Pointer
+  UINT16 Sqid;              // Submission Queue Identifier
+  //
+  // CDW 3
+  //
+  UINT16 Cid;               // Command Identifier
+  UINT16 Pt:1;              // Phase Tag
+  UINT16 Sc:8;              // Status Code
+  UINT16 Sct:3;             // Status Code Type
+  UINT16 Rsvd2:2;
+  UINT16 Mo:1;              // More
+  UINT16 Dnr:1;             // Do Not Retry
+} NVME_CQ;
+
+//
+// Nvm Express Admin cmd opcodes
+//
+#define NVME_ADMIN_DEIOSQ_CMD                0x00
+#define NVME_ADMIN_CRIOSQ_CMD                0x01
+#define NVME_ADMIN_GET_LOG_PAGE_CMD          0x02
+#define NVME_ADMIN_DEIOCQ_CMD                0x04
+#define NVME_ADMIN_CRIOCQ_CMD                0x05
+#define NVME_ADMIN_IDENTIFY_CMD              0x06
+#define NVME_ADMIN_ABORT_CMD                 0x08
+#define NVME_ADMIN_SET_FEATURES_CMD          0x09
+#define NVME_ADMIN_GET_FEATURES_CMD          0x0A
+#define NVME_ADMIN_ASYNC_EVENT_REQUEST_CMD   0x0C
+#define NVME_ADMIN_NAMESACE_MANAGEMENT_CMD   0x0D
+#define NVME_ADMIN_FW_COMMIT_CMD             0x10
+#define NVME_ADMIN_FW_IAMGE_DOWNLOAD_CMD     0x11
+#define NVME_ADMIN_NAMESACE_ATTACHMENT_CMD   0x15
+#define NVME_ADMIN_FORMAT_NVM_CMD            0x80
+#define NVME_ADMIN_SECURITY_SEND_CMD         0x81
+#define NVME_ADMIN_SECURITY_RECEIVE_CMD      0x82
+
+#define NVME_IO_FLUSH_OPC                    0
+#define NVME_IO_WRITE_OPC                    1
+#define NVME_IO_READ_OPC                     2
+
+typedef enum {
+  DeleteIOSubmissionQueueOpcode = NVME_ADMIN_DEIOSQ_CMD,
+  CreateIOSubmissionQueueOpcode = NVME_ADMIN_CRIOSQ_CMD,
+  GetLogPageOpcode = NVME_ADMIN_GET_LOG_PAGE_CMD,
+  DeleteIOCompletionQueueOpcode = NVME_ADMIN_DEIOCQ_CMD,
+  CreateIOCompletionQueueOpcode = NVME_ADMIN_CRIOCQ_CMD,
+  IdentifyOpcode = NVME_ADMIN_IDENTIFY_CMD,
+  AbortOpcode = NVME_ADMIN_ABORT_CMD,
+  SetFeaturesOpcode = NVME_ADMIN_SET_FEATURES_CMD,
+  GetFeaturesOpcode = NVME_ADMIN_GET_FEATURES_CMD,
+  AsyncEventRequestOpcode = NVME_ADMIN_ASYNC_EVENT_REQUEST_CMD,
+  NamespaceManagementOpcode = NVME_ADMIN_NAMESACE_MANAGEMENT_CMD,
+  FirmwareCommitOpcode = NVME_ADMIN_FW_COMMIT_CMD,
+  FirmwareImageDownloadOpcode = NVME_ADMIN_FW_IAMGE_DOWNLOAD_CMD,
+  NamespaceAttachmentOpcode = NVME_ADMIN_NAMESACE_ATTACHMENT_CMD,
+  FormatNvmOpcode = NVME_ADMIN_FORMAT_NVM_CMD,
+  SecuritySendOpcode = NVME_ADMIN_SECURITY_SEND_CMD,
+  SecurityReceiveOpcode = NVME_ADMIN_SECURITY_RECEIVE_CMD
+} NVME_ADMIN_COMMAND_OPCODE;
+
+//
+// Controller or Namespace Structure (CNS) field
+// (ref. spec. v1.1 figure 82).
+//
+typedef enum {
+IdentifyNamespaceCns = 0x0,
+IdentifyControllerCns = 0x1,
+IdentifyActiveNsListCns = 0x2
+} NVME_ADMIN_IDENTIFY_CNS;
+
+//
+// Commit Action
+// (ref. spec. 1.1 figure 60).
+//
+typedef enum {
+  ActivateActionReplace = 0x0,
+  ActivateActionReplaceActivate = 0x1,
+  ActivateActionActivate = 0x2
+} NVME_FW_ACTIVATE_ACTION;
+
+//
+// Firmware Slot
+// (ref. spec. 1.1 Figure 60).
+//
+typedef enum {
+  FirmwareSlotCtrlChooses = 0x0,
+  FirmwareSlot1 = 0x1,
+  FirmwareSlot2 = 0x2,
+  FirmwareSlot3 = 0x3,
+  FirmwareSlot4 = 0x4,
+  FirmwareSlot5 = 0x5,
+  FirmwareSlot6 = 0x6,
+  FirmwareSlot7 = 0x7
+} NVME_FW_ACTIVATE_SLOT;
+
+//
+// Get Log Page ? Log Page Identifiers
+// (ref. spec. v1.1 Figure 73).
+//
+typedef enum {
+  ErrorInfoLogID = LID_ERROR_INFO,
+  SmartHealthInfoLogID = LID_SMART_INFO,
+  FirmwareSlotInfoLogID = LID_FW_SLOT_INFO
+} NVME_LOG_ID;
+
+//
+// Get Log Page ? Firmware Slot Information Log
+// (ref. spec. v1.1 Figure 77).
+//
+typedef struct {
+  //
+  // Indicates the firmware slot from which the actively running firmware revision was loaded.
+  //
+  UINT8 ActivelyRunningFwSlot:3;
+  UINT8 :1;
+  //
+  // Indicates the firmware slot that is going to be activated at the next controller reset. If this field is 0h, then the controller does not indicate the firmware slot that is going to be activated at the next controller reset.
+  //
+  UINT8 NextActiveFwSlot:3;
+  UINT8 :1;
+} NVME_ACTIVE_FW_INFO;
+
+//
+// Get Log Page ? Firmware Slot Information Log
+// (ref. spec. v1.1 Figure 77).
+//
+typedef struct {
+  //
+  // Specifies information about the active firmware revision.
+  //s
+  NVME_ACTIVE_FW_INFO  ActiveFwInfo;
+  UINT8                Reserved1[7];
+  //
+  // Contains the revision of the firmware downloaded to firmware slot 1/7. If no valid firmware revision is present or if this slot is unsupported, all zeros shall be returned.
+  //
+  CHAR8                FwRevisionSlot[7][8];
+  UINT8                Reserved2[448];
+} NVME_FW_SLOT_INFO_LOG;
+
+//
+// SMART / Health Information (Log Identifier 02h)
+// (ref. spec. v1.1 5.10.1.2)
+//
+typedef struct {
+  //
+  // This field indicates critical warnings for the state of the controller.
+  //
+  UINT8  CriticalWarningAvailableSpare:1;
+  UINT8  CriticalWarningTemperature:1;
+  UINT8  CriticalWarningReliability:1;
+  UINT8  CriticalWarningMediaReadOnly:1;
+  UINT8  CriticalWarningVolatileBackup:1;
+  UINT8  CriticalWarningReserved:3;
+  //
+  // Contains a value corresponding to a temperature in degrees Kelvin that represents the current composite temperature of the controller and namespace(s) associated with that controller. The manner in which this value is computed is implementation specific and may not represent the actual temperature of any physical point in the NVM subsystem.
+  //
+  UINT16 CompositeTemp;
+  //
+  // Contains a normalized percentage (0 to 100%) of the remaining spare capacity available.
+  //
+  UINT8  AvailableSpare;
+  //
+  // When the Available Spare falls below the threshold indicated in this field, an asynchronous event completion may occur. The value is indicated as a normalized percentage (0 to 100%).
+  //
+  UINT8  AvailableSpareThreshold;
+  //
+  // Contains a vendor specific estimate of the percentage of NVM subsystem life used based on the actual usage and the manufacturer?s prediction of NVM life. A value of 100 indicates that the estimated endurance of the NVM in the NVM subsystem has been consumed, but may not indicate an NVM subsystem failure. The value is allowed to exceed 100. Percentages greater than 254 shall be represented as 255. This value shall be updated once per power-on hour (when the controller is not in a sleep state).
+  //
+  UINT8  PercentageUsed;
+  UINT8  Reserved1[26];
+  //
+  // Contains the number of 512 byte data units the host has read from the controller; this value does not include metadata.
+  //
+  UINT8  DataUnitsRead[16];
+  //
+  // Contains the number of 512 byte data units the host has written to the controller; this value does not include metadata.
+  //
+  UINT8  DataUnitsWritten[16];
+  //
+  // Contains the number of read commands completed by the controller.
+  //
+  UINT8  HostReadCommands[16];
+  //
+  // Contains the number of write commands completed by the controller.
+  //
+  UINT8  HostWriteCommands[16];
+  //
+  // Contains the amount of time the controller is busy with I/O commands. This value is reported in minutes.
+  //
+  UINT8  ControllerBusyTime[16];
+  //
+  // Contains the number of power cycles.
+  //
+  UINT8  PowerCycles[16];
+  //
+  // Contains the number of power-on hours.
+  //
+  UINT8  PowerOnHours[16];
+  //
+  // Contains the number of unsafe shutdowns.
+  //
+  UINT8  UnsafeShutdowns[16];
+  //
+  // Contains the number of occurrences where the controller detected an unrecovered data integrity error.
+  //
+  UINT8  MediaAndDataIntegrityErrors[16];
+  //
+  // Contains the number of Error Information log entries over the life of the controller.
+  //
+  UINT8  NumberErrorInformationLogEntries[16];
+  //
+  // Contains the amount of time in minutes that the controller is operational and the Composite Temperature is greater than or equal to the Warning Composite Temperature Threshold (WCTEMP) field and less than the Critical Composite Temperature Threshold (CCTEMP) field in the Identify Controller data structure in Figure 90.
+  //
+  UINT32 WarningCompositeTemperatureTime;
+  //
+  // Contains the amount of time in minutes that the controller is operational and the Composite Temperature is greater the Critical Composite Temperature Threshold (CCTEMP) field in the Identify Controller data structure in Figure 90.
+  //
+  UINT32 CriticalCompositeTemperatureTime;
+  //
+  // Contains the current temperature in degrees Kelvin reported by the temperature sensor.  An implementation that does not implement the temperature sensor reports a temperature of zero degrees Kelvin.
+  //
+  UINT16 TemperatureSensor[8];
+  UINT8  Reserved2[296];
+} NVME_SMART_HEALTH_INFO_LOG;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Pal.h b/MdePkg/Include/IndustryStandard/Pal.h
new file mode 100644
index 000000000000..5dc26a2f7b10
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Pal.h
@@ -0,0 +1,3302 @@
+/** @file
+  Main PAL API's defined in Intel Itanium Architecture Software Developer's Manual.
+
+  Copyright (c) 2006 - 2012, 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 __PAL_API_H__
+#define __PAL_API_H__
+
+#define PAL_SUCCESS             0x0
+
+///
+/// CacheType of PAL_CACHE_FLUSH.
+///
+#define PAL_CACHE_FLUSH_INSTRUCTION_ALL   1
+#define PAL_CACHE_FLUSH_DATA_ALL          2
+#define PAL_CACHE_FLUSH_ALL               3
+#define PAL_CACHE_FLUSH_SYNC_TO_DATA      4
+
+
+///
+/// Bitmask of Opearation of PAL_CACHE_FLUSH.
+///
+#define PAL_CACHE_FLUSH_INVALIDATE_LINES     BIT0
+#define PAL_CACHE_FLUSH_NO_INVALIDATE_LINES  0
+#define PAL_CACHE_FLUSH_POLL_INTERRUPT       BIT1
+#define PAL_CACHE_FLUSH_NO_INTERRUPT         0
+
+/**
+  PAL Procedure - PAL_CACHE_FLUSH.
+
+  Flush the instruction or data caches. It is required by Itanium processors.
+  The PAL procedure supports the Static Registers calling
+  convention. It could be called at virtual mode and physical
+  mode.
+
+  @param Index              Index of PAL_CACHE_FLUSH within the
+                            list of PAL procedures.
+  @param CacheType          Unsigned 64-bit integer indicating
+                            which cache to flush.
+  @param Operation          Formatted bit vector indicating the
+                            operation of this call.
+  @param ProgressIndicator  Unsigned 64-bit integer specifying
+                            the starting position of the flush
+                            operation.
+
+  @retval 2                 Call completed without error, but a PMI
+                            was taken during the execution of this
+                            procedure.
+  @retval 1                 Call has not completed flushing due to
+                            a pending interrupt.
+  @retval 0                 Call completed without error
+  @retval -2                Invalid argument
+  @retval -3                Call completed with error
+
+  @return R9                Unsigned 64-bit integer specifying the vector
+                            number of the pending interrupt.
+  @return R10               Unsigned 64-bit integer specifying the
+                            starting position of the flush operation.
+  @return R11               Unsigned 64-bit integer specifying the vector
+                            number of the pending interrupt.
+
+**/
+#define PAL_CACHE_FLUSH   1
+
+
+///
+/// Attributes of PAL_CACHE_CONFIG_INFO1
+///
+#define PAL_CACHE_ATTR_WT   0
+#define PAL_CACHE_ATTR_WB   1
+
+///
+/// PAL_CACHE_CONFIG_INFO1.StoreHint
+///
+#define PAL_CACHE_STORE_TEMPORAL      0
+#define PAL_CACHE_STORE_NONE_TEMPORAL 3
+
+///
+/// PAL_CACHE_CONFIG_INFO1.StoreHint
+///
+#define PAL_CACHE_STORE_TEMPORAL_LVL_1        0
+#define PAL_CACHE_STORE_NONE_TEMPORAL_LVL_ALL 3
+
+///
+/// PAL_CACHE_CONFIG_INFO1.StoreHint
+///
+#define PAL_CACHE_LOAD_TEMPORAL_LVL_1         0
+#define PAL_CACHE_LOAD_NONE_TEMPORAL_LVL_1    1
+#define PAL_CACHE_LOAD_NONE_TEMPORAL_LVL_ALL  3
+
+///
+/// Detail the characteristics of a given processor controlled
+/// cache in the cache hierarchy.
+///
+typedef struct {
+  UINT64  IsUnified   : 1;
+  UINT64  Attributes  : 2;
+  UINT64  Associativity:8;
+  UINT64  LineSize:8;
+  UINT64  Stride:8;
+  UINT64  StoreLatency:8;
+  UINT64  StoreHint:8;
+  UINT64  LoadHint:8;
+} PAL_CACHE_INFO_RETURN1;
+
+///
+/// Detail the characteristics of a given processor controlled
+/// cache in the cache hierarchy.
+///
+typedef struct {
+  UINT64  CacheSize:32;
+  UINT64  AliasBoundary:8;
+  UINT64  TagLsBits:8;
+  UINT64  TagMsBits:8;
+} PAL_CACHE_INFO_RETURN2;
+
+/**
+  PAL Procedure - PAL_CACHE_INFO.
+
+  Return detailed instruction or data cache information. It is
+  required by Itanium processors. The PAL procedure supports the Static
+  Registers calling convention. It could be called at virtual
+  mode and physical mode.
+
+  @param Index        Index of PAL_CACHE_INFO within the list of
+                      PAL procedures.
+  @param CacheLevel   Unsigned 64-bit integer specifying the
+                      level in the cache hierarchy for which
+                      information is requested. This value must
+                      be between 0 and one less than the value
+                      returned in the cache_levels return value
+                      from PAL_CACHE_SUMMARY.
+  @param CacheType    Unsigned 64-bit integer with a value of 1
+                      for instruction cache and 2 for data or
+                      unified cache. All other values are
+                      reserved.
+  @param Reserved     Should be 0.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error
+
+  @return R9          Detail the characteristics of a given
+                      processor controlled cache in the cache
+                      hierarchy. See PAL_CACHE_INFO_RETURN1.
+  @return R10         Detail the characteristics of a given
+                      processor controlled cache in the cache
+                      hierarchy. See PAL_CACHE_INFO_RETURN2.
+  @return R11         Reserved with 0.
+
+**/
+#define PAL_CACHE_INFO    2
+
+
+
+///
+/// Level of PAL_CACHE_INIT.
+///
+#define PAL_CACHE_INIT_ALL  0xffffffffffffffffULL
+
+///
+/// CacheType
+///
+#define PAL_CACHE_INIT_TYPE_INSTRUCTION                 0x1
+#define PAL_CACHE_INIT_TYPE_DATA                        0x2
+#define PAL_CACHE_INIT_TYPE_INSTRUCTION_AND_DATA        0x3
+
+///
+/// Restrict of PAL_CACHE_INIT.
+///
+#define PAL_CACHE_INIT_NO_RESTRICT  0
+#define PAL_CACHE_INIT_RESTRICTED   1
+
+/**
+  PAL Procedure - PAL_CACHE_INIT.
+
+  Initialize the instruction or data caches. It is required by
+  Itanium processors. The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode.
+
+  @param Index      Index of PAL_CACHE_INIT within the list of PAL
+                    procedures.
+  @param Level      Unsigned 64-bit integer containing the level of
+                    cache to initialize. If the cache level can be
+                    initialized independently, only that level will
+                    be initialized. Otherwise
+                    implementation-dependent side-effects will
+                    occur.
+  @param CacheType  Unsigned 64-bit integer with a value of 1 to
+                    initialize the instruction cache, 2 to
+                    initialize the data cache, or 3 to
+                    initialize both. All other values are
+                    reserved.
+  @param Restrict   Unsigned 64-bit integer with a value of 0 or
+                    1. All other values are reserved. If
+                    restrict is 1 and initializing the specified
+                    level and cache_type of the cache would
+                    cause side-effects, PAL_CACHE_INIT will
+                    return -4 instead of initializing the cache.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+  @retval -4        Call could not initialize the specified
+                    level and cache_type of the cache without
+                    side-effects and restrict was 1.
+
+**/
+#define PAL_CACHE_INIT    3
+
+
+///
+/// PAL_CACHE_PROTECTION.Method.
+///
+#define PAL_CACHE_PROTECTION_NONE_PROTECT   0
+#define PAL_CACHE_PROTECTION_ODD_PROTECT    1
+#define PAL_CACHE_PROTECTION_EVEN_PROTECT   2
+#define PAL_CACHE_PROTECTION_ECC_PROTECT    3
+
+
+
+///
+/// PAL_CACHE_PROTECTION.TagOrData.
+///
+#define PAL_CACHE_PROTECTION_PROTECT_DATA   0
+#define PAL_CACHE_PROTECTION_PROTECT_TAG    1
+#define PAL_CACHE_PROTECTION_PROTECT_TAG_ANDTHEN_DATA   2
+#define PAL_CACHE_PROTECTION_PROTECT_DATA_ANDTHEN_TAG   3
+
+///
+/// 32-bit protection information structures.
+///
+typedef struct {
+  UINT32  DataBits:8;
+  UINT32  TagProtLsb:6;
+  UINT32  TagProtMsb:6;
+  UINT32  ProtBits:6;
+  UINT32  Method:4;
+  UINT32  TagOrData:2;
+} PAL_CACHE_PROTECTION;
+
+/**
+  PAL Procedure - PAL_CACHE_PROT_INFO.
+
+  Return instruction or data cache protection information. It is
+  required by Itanium processors. The PAL procedure supports the Static
+  Registers calling convention. It could be called at physical
+  mode and Virtual mode.
+
+  @param Index      Index of PAL_CACHE_PROT_INFO within the list of
+                    PAL procedures.
+  @param CacheLevel Unsigned 64-bit integer specifying the level
+                    in the cache hierarchy for which information
+                    is requested. This value must be between 0
+                    and one less than the value returned in the
+                    cache_levels return value from
+                    PAL_CACHE_SUMMARY.
+  @param CacheType  Unsigned 64-bit integer with a value of 1
+                    for instruction cache and 2 for data or
+                    unified cache. All other values are
+                    reserved.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+
+  @return R9        Detail the characteristics of a given
+                    processor controlled cache in the cache
+                    hierarchy. See PAL_CACHE_PROTECTION[0..1].
+  @return R10       Detail the characteristics of a given
+                    processor controlled cache in the cache
+                    hierarchy. See PAL_CACHE_PROTECTION[2..3].
+  @return R11       Detail the characteristics of a given
+                    processor controlled cache in the cache
+                    hierarchy. See PAL_CACHE_PROTECTION[4..5].
+
+**/
+#define PAL_CACHE_PROT_INFO     38
+
+typedef struct {
+  UINT64  ThreadId : 16;    ///< The thread identifier of the logical
+                            ///< processor for which information is being
+                            ///< returned. This value will be unique on a per core basis.
+  UINT64  Reserved1: 16;
+  UINT64  CoreId: 16;       ///< The core identifier of the logical processor
+                            ///< for which information is being returned.
+                            ///< This value will be unique on a per physical
+                            ///< processor package basis.
+  UINT64  Reserved2: 16;
+} PAL_PCOC_N_CACHE_INFO1;
+
+
+typedef struct {
+  UINT64  LogicalAddress : 16;  ///< Logical address: geographical address
+                                ///< of the logical processor for which
+                                ///< information is being returned. This is
+                                ///< the same value that is returned by the
+                                ///< PAL_FIXED_ADDR procedure when it is
+                                ///< called on the logical processor.
+  UINT64  Reserved1: 16;
+  UINT64  Reserved2: 32;
+} PAL_PCOC_N_CACHE_INFO2;
+
+/**
+  PAL Procedure - PAL_CACHE_SHARED_INFO.
+
+  Returns information on which logical processors share caches.
+  It is optional. The PAL procedure supports the Static
+  Registers calling convention. It could be called at physical
+  mode and Virtual mode.
+
+  @param Index       Index of PAL_CACHE_SHARED_INFO within the list
+                     of PAL procedures.
+  @param CacheLevel  Unsigned 64-bit integer specifying the
+                     level in the cache hierarchy for which
+                     information is requested. This value must
+                     be between 0 and one less than the value
+                     returned in the cache_levels return value
+                     from PAL_CACHE_SUMMARY.
+  @param CacheType   Unsigned 64-bit integer with a value of 1
+                     for instruction cache and 2 for data or
+                     unified cache. All other values are
+                     reserved.
+  @param ProcNumber  Unsigned 64-bit integer that specifies for
+                     which logical processor information is
+                     being requested. This input argument must
+                     be zero for the first call to this
+                     procedure and can be a maximum value of
+                     one less than the number of logical
+                     processors sharing this cache, which is
+                     returned by the num_shared return value.
+
+  @retval 0          Call completed without error
+  @retval -1         Unimplemented procedure
+  @retval -2         Invalid argument
+  @retval -3         Call completed with error.
+
+  @return R9         Unsigned integer that returns the number of
+                     logical processors that share the processor
+                     cache level and type, for which information was
+                     requested.
+  @return R10        The format of PAL_PCOC_N_CACHE_INFO1.
+  @return R11        The format of PAL_PCOC_N_CACHE_INFO2.
+
+**/
+#define PAL_CACHE_SHARED_INFO   43
+
+
+/**
+  PAL Procedure - PAL_CACHE_SUMMARY.
+
+  Return a summary of the cache hierarchy. It is required by
+  Itanium processors. The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode and Virtual
+  mode.
+
+  @param Index  Index of PAL_CACHE_SUMMARY within the list of
+                PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    CacheLevels   Unsigned 64-bit integer denoting the
+                              number of levels of cache
+                              implemented by the processor.
+                              Strictly, this is the number of
+                              levels for which the cache
+                              controller is integrated into the
+                              processor (the cache SRAMs may be
+                              external to the processor).
+  @return R10   UniqueCaches  Unsigned 64-bit integer denoting the
+                              number of unique caches implemented
+                              by the processor. This has a maximum
+                              of 2*cache_levels, but may be less
+                              if any of the levels in the cache
+                              hierarchy are unified caches or do
+                              not have both instruction and data
+                              caches.
+
+**/
+#define PAL_CACHE_SUMMARY   4
+
+
+//
+// Virtual Memory Attributes implemented by processor.
+//
+#define PAL_MEMORY_ATTR_WB      0
+#define PAL_MEMORY_ATTR_WC      6
+#define PAL_MEMORY_ATTR_UC      4
+#define PAL_MEMORY_ATTR_UCE     5
+#define PAL_MEMORY_ATTR_NATPAGE 7
+
+/**
+  PAL Procedure - PAL_MEM_ATTRIB.
+
+  Return a list of supported memory attributes.. It is required
+  by Itanium processors. The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode and Virtual
+  mode.
+
+  @param Index  Index of PAL_MEM_ATTRIB within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Attributes  8-bit vector of memory attributes
+                            implemented by processor. See Virtual
+                            Memory Attributes above.
+
+**/
+
+#define PAL_MEM_ATTRIB      5
+
+/**
+  PAL Procedure - PAL_PREFETCH_VISIBILITY.
+
+  Used in architected sequence to transition pages from a
+  cacheable, speculative attribute to an uncacheable attribute.
+  It is required by Itanium processors. The PAL procedure supports the Static
+  Registers calling convention. It could be called at physical
+  mode and Virtual mode.
+
+  @param Index          Index of PAL_PREFETCH_VISIBILITY within the list
+                        of PAL procedures.
+  @param TransitionType Unsigned integer specifying the type
+                        of memory attribute transition that is
+                        being performed.
+
+  @retval 1             Call completed without error; this
+                        call is not necessary on remote
+                        processors.
+  @retval 0             Call completed without error
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+
+**/
+#define PAL_PREFETCH_VISIBILITY   41
+
+/**
+  PAL Procedure - PAL_PTCE_INFO.
+
+  Return information needed for ptc.e instruction to purge
+  entire TC. It is required by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called at
+  physical mode and Virtual mode.
+
+  @param Index  Index of PAL_PTCE_INFO within the list
+                of PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Unsigned 64-bit integer denoting the beginning
+                address to be used by the first PTCE instruction
+                in the purge loop.
+  @return R10   Two unsigned 32-bit integers denoting the loop
+                counts of the outer (loop 1) and inner (loop 2)
+                purge loops. count1 (loop 1) is contained in bits
+                63:32 of the parameter, and count2 (loop 2) is
+                contained in bits 31:0 of the parameter.
+  @return R11   Two unsigned 32-bit integers denoting the loop
+                strides of the outer (loop 1) and inner (loop 2)
+                purge loops. stride1 (loop 1) is contained in bits
+                63:32 of the parameter, and stride2 (loop 2) is
+                contained in bits 31:0 of the parameter.
+
+**/
+#define PAL_PTCE_INFO     6
+
+typedef struct {
+  UINT64  NumberSets:8;             ///< Unsigned 8-bit integer denoting the number
+                                    ///< of hash sets for the specified level
+                                    ///< (1=fully associative)
+  UINT64  NumberWays:8;             ///< Unsigned 8-bit integer denoting the
+                                    ///< associativity of the specified level
+                                    ///< (1=direct).
+  UINT64  NumberEntries:16;         ///< Unsigned 16-bit integer denoting the
+                                    ///< number of entries in the specified TC.
+  UINT64  PageSizeIsOptimized:1;    ///< Flag denoting whether the
+                                    ///< specified level is optimized for
+                                    ///< the region's preferred page size
+                                    ///< (1=optimized) tc_pages indicates
+                                    ///< which page sizes are usable by
+                                    ///< this translation cache.
+  UINT64  TcIsUnified:1;            ///< Flag denoting whether the specified TC is
+                                    ///< unified (1=unified).
+  UINT64  EntriesReduction:1;       ///< Flag denoting whether installed
+                                    ///< translation registers will reduce
+                                    ///< the number of entries within the
+                                    ///< specified TC.
+} PAL_TC_INFO;
+
+/**
+  PAL Procedure - PAL_VM_INFO.
+
+  Return detailed information about virtual memory features
+  supported in the processor. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and Virtual mode.
+
+  @param Index    Index of PAL_VM_INFO within the list
+                  of PAL procedures.
+  @param TcLevel  Unsigned 64-bit integer specifying the level
+                  in the TLB hierarchy for which information is
+                  required. This value must be between 0 and one
+                  less than the value returned in the
+                  vm_info_1.num_tc_levels return value from
+                  PAL_VM_SUMMARY.
+  @param TcType   Unsigned 64-bit integer with a value of 1 for
+                  instruction translation cache and 2 for data
+                  or unified translation cache. All other values
+                  are reserved.
+
+  @retval 0       Call completed without error
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+
+  @return R9      8-byte formatted value returning information
+                  about the specified TC. See PAL_TC_INFO above.
+  @return R10     64-bit vector containing a bit for each page
+                  size supported in the specified TC, where bit
+                  position n indicates a page size of 2**n.
+
+**/
+#define PAL_VM_INFO       7
+
+
+/**
+  PAL Procedure - PAL_VM_PAGE_SIZE.
+
+  Return virtual memory TC and hardware walker page sizes
+  supported in the processor. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and Virtual mode.
+
+  @param Index  Index of PAL_VM_PAGE_SIZE within the list
+                of PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    64-bit vector containing a bit for each
+                architected page size that is supported for
+                TLB insertions and region registers.
+  @return R10   64-bit vector containing a bit for each
+                architected page size supported for TLB purge
+                operations.
+
+**/
+#define PAL_VM_PAGE_SIZE 34
+
+typedef struct {
+  UINT64  WalkerPresent:1;              ///< 1-bit flag indicating whether a hardware
+                                        ///< TLB walker is implemented (1 = walker
+                                        ///< present).
+  UINT64  WidthOfPhysicalAddress: 7;    ///< Unsigned 7-bit integer
+                                        ///< denoting the number of bits of
+                                        ///< physical address implemented.
+  UINT64  WidthOfKey:8;                 ///< Unsigned 8-bit integer denoting the number
+                                        ///< of bits mplemented in the PKR.key field.
+  UINT64  MaxPkrIndex:8;                ///< Unsigned 8-bit integer denoting the
+                                        ///< maximum PKR index (number of PKRs-1).
+  UINT64  HashTagId:8;                  ///< Unsigned 8-bit integer which uniquely
+                                        ///< identifies the processor hash and tag
+                                        ///< algorithm.
+  UINT64  MaxDtrIndex:8;                ///< Unsigned 8 bit integer denoting the
+                                        ///< maximum data translation register index
+                                        ///< (number of dtr entries - 1).
+  UINT64  MaxItrIndex:8;                ///< Unsigned 8 bit integer denoting the
+                                        ///< maximum instruction translation register
+                                        ///< index (number of itr entries - 1).
+  UINT64  NumberOfUniqueTc:8;           ///< Unsigned 8-bit integer denoting the
+                                        ///< number of unique TCs implemented.
+                                        ///< This is a maximum of
+                                        ///< 2*num_tc_levels.
+  UINT64  NumberOfTcLevels:8;           ///< Unsigned 8-bit integer denoting the
+                                        ///< number of TC levels.
+} PAL_VM_INFO1;
+
+typedef struct {
+  UINT64  WidthOfVirtualAddress:8;  ///< Unsigned 8-bit integer denoting
+                                    ///< is the total number of virtual
+                                    ///< address bits - 1.
+  UINT64  WidthOfRid:8;             ///< Unsigned 8-bit integer denoting the number
+                                    ///< of bits implemented in the RR.rid field.
+  UINT64  MaxPurgedTlbs:16;         ///< Unsigned 16 bit integer denoting the
+                                    ///< maximum number of concurrent outstanding
+                                    ///< TLB purges allowed by the processor. A
+                                    ///< value of 0 indicates one outstanding
+                                    ///< purge allowed. A value of 216-1
+                                    ///< indicates no limit on outstanding
+                                    ///< purges. All other values indicate the
+                                    ///< actual number of concurrent outstanding
+                                    ///< purges allowed.
+  UINT64  Reserved:32;
+} PAL_VM_INFO2;
+
+/**
+  PAL Procedure - PAL_VM_SUMMARY.
+
+  Return summary information about virtual memory features
+  supported in the processor. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and Virtual mode.
+
+  @param Index  Index of PAL_VM_SUMMARY within the list
+                of PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    8-byte formatted value returning global virtual
+                memory information. See PAL_VM_INFO1 above.
+  @return R10   8-byte formatted value returning global virtual
+                memory information. See PAL_VM_INFO2 above.
+
+**/
+#define PAL_VM_SUMMARY  8
+
+
+//
+// Bit mask of TR_valid flag.
+//
+#define PAL_TR_ACCESS_RIGHT_IS_VALID      BIT0
+#define PAL_TR_PRIVILEGE_LEVEL_IS_VALID   BIT1
+#define PAL_TR_DIRTY_IS_VALID             BIT2
+#define PAL_TR_MEMORY_ATTR_IS_VALID       BIT3
+
+
+/**
+  PAL Procedure - PAL_VM_TR_READ.
+
+  Read contents of a translation register. It is required by
+  Itanium processors. The PAL procedure supports the Stacked Register calling
+  convention. It could be called at physical mode.
+
+  @param Index      Index of PAL_VM_TR_READ within the list
+                    of PAL procedures.
+  @param RegNumber  Unsigned 64-bit number denoting which TR to
+                    read.
+  @param TrType     Unsigned 64-bit number denoting whether to
+                    read an ITR (0) or DTR (1). All other values
+                    are reserved.
+  @param TrBuffer   64-bit pointer to the 32-byte memory buffer in
+                    which translation data is returned.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+
+  @return R9        Formatted bit vector denoting which fields are
+                    valid. See TR_valid above.
+
+**/
+#define PAL_VM_TR_READ  261
+
+
+
+
+//
+// Bit Mask of Processor Bus Fesatures .
+//
+
+/**
+
+  When 0, bus data errors are detected and single bit errors are
+  corrected. When 1, no error detection or correction is done.
+
+**/
+#define PAL_BUS_DISABLE_DATA_ERROR_SIGNALLING   BIT63
+
+
+/**
+
+  When 0, bus address errors are signalled on the bus. When 1,
+  no bus errors are signalled on the bus. If Disable Bus Address
+  Error Checking is 1, this bit is ignored.
+
+**/
+#define PAL_BUS_DISABLE_ADDRESS_ERROR_SIGNALLING   BIT62
+
+
+
+
+/**
+
+  When 0, bus errors are detected, single bit errors are
+  corrected., and a CMCI or MCA is generated internally to the
+  processor. When 1, no bus address errors are detected or
+  corrected.
+
+**/
+#define PAL_BUS_DISABLE_ADDRESS_ERROR_CHECK   BIT61
+
+
+/**
+
+  When 0, bus protocol errors (BINIT#) are signaled by the
+  processor on the bus. When 1, bus protocol errors (BINIT#) are
+  not signaled on the bus. If Disable Bus Initialization Event
+  Checking is 1, this bit is ignored.
+
+**/
+#define PAL_BUS_DISABLE_INITIALIZATION_EVENT_SIGNALLING   BIT60
+
+
+/**
+
+  When 0, bus protocol errors (BINIT#) are detected and sampled
+  and an MCA is generated internally to the processor. When 1,
+  the processor will ignore bus protocol error conditions
+  (BINIT#).
+
+**/
+#define PAL_BUS_DISABLE_INITIALIZATION_EVENT_CHECK   BIT59
+
+
+
+/**
+
+  When 0, BERR# is signalled if a bus error is detected. When 1,
+  bus errors are not signalled on the bus.
+
+**/
+#define PAL_BUS_DISABLE_ERROR_SIGNALLING   BIT58
+
+
+
+
+/**
+
+  When 0, BERR# is signalled when internal processor requestor
+  initiated bus errors are detected. When 1, internal requester
+  bus errors are not signalled on the bus.
+
+**/
+#define PAL_BUS_DISABLE__INTERNAL_ERROR_SIGNALLING   BIT57
+
+
+/**
+
+  When 0, the processor takes an MCA if BERR# is asserted. When
+  1, the processor ignores the BERR# signal.
+
+**/
+#define PAL_BUS_DISABLE_ERROR_CHECK   BIT56
+
+
+/**
+
+  When 0, the processor asserts BINIT# if it detects a parity
+  error on the signals which identify the transactions to which
+  this is a response. When 1, the processor ignores parity on
+  these signals.
+
+**/
+#define PAL_BUS_DISABLE_RSP_ERROR_CHECK   BIT55
+
+
+/**
+
+  When 0, the in-order transaction queue is limited only by the
+  number of hardware entries. When 1, the processor's in-order
+  transactions queue is limited to one entry.
+
+**/
+#define PAL_BUS_DISABLE_TRANSACTION_QUEUE   BIT54
+
+/**
+
+  Enable a bus cache line replacement transaction when a cache
+  line in the exclusive state is replaced from the highest level
+  processor cache and is not present in the lower level processor
+  caches. When 0, no bus cache line replacement transaction will
+  be seen on the bus. When 1, bus cache line replacement
+  transactions will be seen on the bus when the above condition is
+  detected.
+
+**/
+#define PAL_BUS_ENABLE_EXCLUSIVE_CACHE_LINE_REPLACEMENT   BIT53
+
+
+/**
+
+  Enable a bus cache line replacement transaction when a cache
+  line in the shared or exclusive state is replaced from the
+  highest level processor cache and is not present in the lower
+  level processor caches.
+  When 0, no bus cache line replacement transaction will be seen
+  on the bus. When 1, bus cache line replacement transactions
+  will be seen on the bus when the above condition is detected.
+
+**/
+#define PAL_BUS_ENABLE_SHARED_CACHE_LINE_REPLACEMENT   BIT52
+
+
+
+/**
+
+  When 0, the data bus is configured at the 2x data transfer
+  rate.When 1, the data bus is configured at the 1x data
+  transfer rate, 30 Opt. Req. Disable Bus Lock Mask. When 0, the
+  processor executes locked transactions atomically. When 1, the
+  processor masks the bus lock signal and executes locked
+  transactions as a non-atomic series of transactions.
+
+**/
+#define PAL_BUS_ENABLE_HALF_TRANSFER   BIT30
+
+/**
+
+  When 0, the processor will deassert bus request when finished
+  with each transaction. When 1, the processor will continue to
+  assert bus request after it has finished, if it was the last
+  agent to own the bus and if there are no other pending
+  requests.
+
+**/
+#define PAL_BUS_REQUEST_BUS_PARKING   BIT29
+
+
+/**
+  PAL Procedure - PAL_BUS_GET_FEATURES.
+
+  Return configurable processor bus interface features and their
+  current settings. It is required by Itanium processors. The PAL procedure
+  supports the Stacked Register calling convention. It could be
+  called at physical mode.
+
+  @param Index  Index of PAL_BUS_GET_FEATURES within the list
+                of PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    64-bit vector of features implemented.
+                (1=implemented, 0=not implemented)
+  @return R10   64-bit vector of current feature settings.
+  @return R11   64-bit vector of features controllable by
+                software. (1=controllable, 0= not controllable)
+
+**/
+#define PAL_BUS_GET_FEATURES 9
+
+/**
+  PAL Procedure - PAL_BUS_SET_FEATURES.
+
+  Enable or disable configurable features in processor bus
+  interface. It is required by Itanium processors. The PAL procedure
+  supports the Static Registers calling convention. It could be
+  called at physical mode.
+
+  @param Index          Index of PAL_BUS_SET_FEATURES within the list
+                        of PAL procedures.
+  @param FeatureSelect  64-bit vector denoting desired state of
+                        each feature (1=select, 0=non-select).
+
+  @retval 0             Call completed without error
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+
+**/
+#define PAL_BUS_SET_FEATURES 10
+
+
+/**
+  PAL Procedure - PAL_DEBUG_INFO.
+
+  Return the number of instruction and data breakpoint
+  registers. It is required by Itanium processors. The
+  PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode and virtual
+  mode.
+
+  @param Index  Index of PAL_DEBUG_INFO within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Unsigned 64-bit integer denoting the number of
+                pairs of instruction debug registers implemented
+                by the processor.
+  @return R10   Unsigned 64-bit integer denoting the number of
+                pairs of data debug registers implemented by the
+                processor.
+
+**/
+#define PAL_DEBUG_INFO  11
+
+/**
+  PAL Procedure - PAL_FIXED_ADDR.
+
+  Return the fixed component of a processor's directed address.
+  It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and virtual mode.
+
+  @param Index  Index of PAL_FIXED_ADDR within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Fixed geographical address of this processor.
+
+**/
+#define PAL_FIXED_ADDR 12
+
+/**
+  PAL Procedure - PAL_FREQ_BASE.
+
+  Return the frequency of the output clock for use by the
+  platform, if generated by the processor. It is optinal. The
+  PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode and virtual
+  mode.
+
+  @param Index  Index of PAL_FREQ_BASE within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -1    Unimplemented procedure
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Base frequency of the platform if generated by the
+                processor chip.
+
+**/
+#define PAL_FREQ_BASE 13
+
+
+/**
+  PAL Procedure - PAL_FREQ_RATIOS.
+
+  Return ratio of processor, bus, and interval time counter to
+  processor input clock or output clock for platform use, if
+  generated by the processor. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and virtual mode.
+
+  @param Index  Index of PAL_FREQ_RATIOS within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Ratio of the processor frequency to the input
+                clock of the processor, if the platform clock is
+                generated externally or to the output clock to the
+                platform, if the platform clock is generated by
+                the processor.
+  @return R10   Ratio of the bus frequency to the input clock of
+                the processor, if the platform clock is generated
+                externally or to the output clock to the platform,
+                if the platform clock is generated by the
+                processor.
+  @return R11   Ratio of the interval timer counter rate to input
+                clock of the processor, if the platform clock is
+                generated externally or to the output clock to the
+                platform, if the platform clock is generated by
+                the processor.
+
+**/
+#define PAL_FREQ_RATIOS 14
+
+typedef struct {
+  UINT64  NumberOfLogicalProcessors:16;     ///< Total number of logical
+                                            ///< processors on this physical
+                                            ///< processor package that are
+                                            ///< enabled.
+  UINT64  ThreadsPerCore:8;                 ///< Number of threads per core.
+  UINT64  Reserved1:8;
+  UINT64  CoresPerProcessor:8;              ///< Total number of cores on this
+                                            ///< physical processor package.
+  UINT64  Reserved2:8;
+  UINT64  PhysicalProcessorPackageId:8;     ///< Physical processor package
+                                            ///< identifier which was
+                                            ///< assigned at reset by the
+                                            ///< platform or bus
+                                            ///< controller. This value may
+                                            ///< or may not be unique
+                                            ///< across the entire platform
+                                            ///< since it depends on the
+                                            ///< platform vendor's policy.
+  UINT64  Reserved3:8;
+} PAL_LOGICAL_PROCESSPR_OVERVIEW;
+
+typedef struct {
+   UINT64 ThreadId:16;      ///< The thread identifier of the logical
+                            ///< processor for which information is being
+                            ///< returned. This value will be unique on a per
+                            ///< core basis.
+   UINT64 Reserved1:16;
+   UINT64 CoreId:16;        ///< The core identifier of the logical processor
+                            ///< for which information is being returned.
+                            ///< This value will be unique on a per physical
+                            ///< processor package basis.
+   UINT64 Reserved2:16;
+} PAL_LOGICAL_PROCESSORN_INFO1;
+
+typedef struct {
+   UINT64 LogicalAddress:16;    ///< Geographical address of the logical
+                                ///< processor for which information is being
+                                ///< returned. This is the same value that is
+                                ///< returned by the PAL_FIXED_ADDR procedure
+                                ///< when it is called on the logical processor.
+   UINT64 Reserved:48;
+} PAL_LOGICAL_PROCESSORN_INFO2;
+
+/**
+  PAL Procedure - PAL_LOGICAL_TO_PHYSICAL.
+
+  Return information on which logical processors map to a
+  physical processor die. It is optinal. The PAL procedure
+  supports the Static Registers calling convention. It could be
+  called at physical mode and virtual mode.
+
+  @param Index            Index of PAL_LOGICAL_TO_PHYSICAL within the list of PAL
+                          procedures.
+  @param ProcessorNumber  Signed 64-bit integer that specifies
+                          for which logical processor
+                          information is being requested. When
+                          this input argument is -1, information
+                          is returned about the logical
+                          processor on which the procedure call
+                          is made. This input argument must be
+                          in the range of 1 up to one less than
+                          the number of logical processors
+                          returned by num_log in the
+                          log_overview return value.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+
+  @return R9              The format of PAL_LOGICAL_PROCESSPR_OVERVIEW.
+  @return R10             The format of PAL_LOGICAL_PROCESSORN_INFO1.
+  @return R11             The format of PAL_LOGICAL_PROCESSORN_INFO2.
+
+**/
+#define PAL_LOGICAL_TO_PHYSICAL 42
+
+typedef struct {
+  UINT64  NumberOfPmcPairs:8;               ///< Unsigned 8-bit number defining the
+                                            ///< number of generic PMC/PMD pairs.
+  UINT64  WidthOfCounter:8;                 ///< Unsigned 8-bit number in the range
+                                            ///< 0:60 defining the number of
+                                            ///< implemented counter bits.
+  UINT64  TypeOfCycleCounting:8;            ///< Unsigned 8-bit number defining the
+                                            ///< event type for counting processor cycles.
+  UINT64  TypeOfRetiredInstructionBundle:8; ///< Retired Unsigned 8-bit
+                                            ///< number defining the
+                                            ///< event type for retired
+                                            ///< instruction bundles.
+  UINT64  Reserved:32;
+} PAL_PERFORMANCE_INFO;
+
+/**
+  PAL Procedure - PAL_PERF_MON_INFO.
+
+  Return the number and type of performance monitors. It is
+  required by Itanium processors. The PAL procedure supports the Static
+  Registers calling convention. It could be called at physical
+  mode and virtual mode.
+
+  @param Index              Index of PAL_PERF_MON_INFO within the list of
+                            PAL procedures.
+  @param PerformanceBuffer  An address to an 8-byte aligned
+                            128-byte memory buffer.
+
+  @retval 0                 Call completed without error
+  @retval -2                Invalid argument
+  @retval -3                Call completed with error.
+
+  @return R9                Information about the performance monitors
+                            implemented. See PAL_PERFORMANCE_INFO;
+
+**/
+#define PAL_PERF_MON_INFO 15
+
+#define PAL_PLATFORM_ADDR_INTERRUPT_BLOCK_TOKEN                       0x0
+#define PAL_PLATFORM_ADDR_IO_BLOCK_TOKEN                              0x1
+
+/**
+  PAL Procedure - PAL_PLATFORM_ADDR.
+
+  Specify processor interrupt block address and I/O port space
+  address. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode and virtual mode.
+
+  @param Index    Index of PAL_PLATFORM_ADDR within the list of
+                  PAL procedures.
+  @param Type     Unsigned 64-bit integer specifying the type of
+                  block. 0 indicates that the processor interrupt
+                  block pointer should be initialized. 1 indicates
+                  that the processor I/O block pointer should be
+                  initialized.
+  @param Address  Unsigned 64-bit integer specifying the address
+                  to which the processor I/O block or interrupt
+                  block shall be set. The address must specify
+                  an implemented physical address on the
+                  processor model, bit 63 is ignored.
+
+  @retval 0       Call completed without error
+  @retval -1      Unimplemented procedure.
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+
+**/
+#define PAL_PLATFORM_ADDR 16
+
+typedef struct {
+  UINT64  Reserved1:36;
+  UINT64  FaultInUndefinedIns:1;                ///< Bit36, No Unimplemented
+                                                ///< instruction address reported as
+                                                ///< fault. Denotes how the processor
+                                                ///< reports the detection of
+                                                ///< unimplemented instruction
+                                                ///< addresses. When 1, the processor
+                                                ///< reports an Unimplemented
+                                                ///< Instruction Address fault on the
+                                                ///< unimplemented address; when 0, it
+                                                ///< reports an Unimplemented
+                                                ///< Instruction Address trap on the
+                                                ///< previous instruction in program
+                                                ///< order. This feature may only be
+                                                ///< interrogated by
+                                                ///< PAL_PROC_GET_FEATURES. It may not
+                                                ///< be enabled or disabled by
+                                                ///< PAL_PROC_SET_FEATURES. The
+                                                ///< corresponding argument is ignored.
+                                                
+  UINT64  NoPresentPmi:1;                       ///< Bit37, No INIT, PMI, and LINT pins
+                                                ///< present. Denotes the absence of INIT,
+                                                ///< PMI, LINT0 and LINT1 pins on the
+                                                ///< processor. When 1, the pins are absent.
+                                                ///< When 0, the pins are present. This
+                                                ///< feature may only be interrogated by
+                                                ///< PAL_PROC_GET_FEATURES. It may not be
+                                                ///< enabled or disabled by
+                                                ///< PAL_PROC_SET_FEATURES. The corresponding
+                                                ///< argument is ignored.
+                                                
+  UINT64  NoSimpleImpInUndefinedIns:1;          ///< Bit38, No Simple
+                                                ///< implementation of
+                                                ///< unimplemented instruction
+                                                ///< addresses. Denotes how an
+                                                ///< unimplemented instruction
+                                                ///< address is recorded in IIP
+                                                ///< on an Unimplemented
+                                                ///< Instruction Address trap or
+                                                ///< fault. When 1, the full
+                                                ///< unimplemented address is
+                                                ///< recorded in IIP; when 0, the
+                                                ///< address is sign extended
+                                                ///< (virtual addresses) or zero
+                                                ///< extended (physical
+                                                ///< addresses). This feature may
+                                                ///< only be interrogated by
+                                                ///< PAL_PROC_GET_FEATURES. It
+                                                ///< may not be enabled or
+                                                ///< disabled by
+                                                ///< PAL_PROC_SET_FEATURES. The
+                                                ///< corresponding argument is
+                                                ///< ignored.
+
+  UINT64  NoVariablePState:1;                   ///< Bit39, No Variable P-state
+                                                ///< performance: A value of 1, indicates
+                                                ///< that a processor implements
+                                                ///< techniques to optimize performance
+                                                ///< for the given P-state power budget
+                                                ///< by dynamically varying the
+                                                ///< frequency, such that maximum
+                                                ///< performance is achieved for the
+                                                ///< power budget. A value of 0,
+                                                ///< indicates that P-states have no
+                                                ///< frequency variation or very small
+                                                ///< frequency variations for their given
+                                                ///< power budget. This feature may only
+                                                ///< be interrogated by
+                                                ///< PAL_PROC_GET_FEATURES. it may not be
+                                                ///< enabled or disabled by
+                                                ///< PAL_PROC_SET_FEATURES. The
+                                                ///< corresponding argument is ignored.
+
+  UINT64  NoVM:1;                               ///< Bit40, No Virtual Machine features implemented.
+                                                ///< Denotes whether PSR.vm is implemented. This
+                                                ///< feature may only be interrogated by
+                                                ///< PAL_PROC_GET_FEATURES. It may not be enabled or
+                                                ///< disabled by PAL_PROC_SET_FEATURES. The
+                                                ///< corresponding argument is ignored.
+
+  UINT64  NoXipXpsrXfs:1;                       ///< Bit41, No XIP, XPSR, and XFS
+                                                ///< implemented. Denotes whether XIP, XPSR,
+                                                ///< and XFS are implemented for machine
+                                                ///< check recovery. This feature may only be
+                                                ///< interrogated by PAL_PROC_GET_FEATURES.
+                                                ///< It may not be enabled or disabled by
+                                                ///< PAL_PROC_SET_FEATURES. The corresponding
+                                                ///< argument is ignored.
+
+  UINT64  NoXr1ThroughXr3:1;                    ///< Bit42, No XR1 through XR3 implemented.
+                                                ///<   Denotes whether XR1 XR3 are
+                                                ///<   implemented for machine check
+                                                ///<   recovery. This feature may only be
+                                                ///<   interrogated by PAL_PROC_GET_FEATURES.
+                                                ///<   It may not be enabled or disabled by
+                                                ///<   PAL_PROC_SET_FEATURES. The
+                                                ///<   corresponding argument is ignored.
+
+  UINT64  DisableDynamicPrediction:1;           ///< Bit43, Disable Dynamic
+                                                ///< Predicate Prediction. When
+                                                ///< 0, the processor may predict
+                                                ///< predicate results and
+                                                ///< execute speculatively, but
+                                                ///< may not commit results until
+                                                ///< the actual predicates are
+                                                ///< known. When 1, the processor
+                                                ///< shall not execute predicated
+                                                ///< instructions until the
+                                                ///< actual predicates are known.
+
+  UINT64  DisableSpontaneousDeferral:1;         ///< Bit44, Disable Spontaneous
+                                                ///<   Deferral. When 1, the
+                                                ///<   processor may optionally
+                                                ///<   defer speculative loads
+                                                ///<   that do not encounter any
+                                                ///<   exception conditions, but
+                                                ///<   that trigger other
+                                                ///<   implementation-dependent
+                                                ///<   conditions (e.g., cache
+                                                ///<   miss). When 0, spontaneous
+                                                ///<   deferral is disabled.
+
+  UINT64  DisableDynamicDataCachePrefetch:1;    ///< Bit45, Disable Dynamic
+                                                ///<   Data Cache Prefetch.
+                                                ///<   When 0, the processor
+                                                ///<   may prefetch into the
+                                                ///<   caches any data which
+                                                ///<   has not been accessed
+                                                ///<   by instruction
+                                                ///<   execution, but which
+                                                ///<   is likely to be
+                                                ///<   accessed. When 1, no
+                                                ///<   data may be fetched
+                                                ///<   until it is needed for
+                                                ///<   instruction execution
+                                                ///<   or is fetched by an
+                                                ///<   lfetch instruction.
+
+  UINT64  DisableDynamicInsCachePrefetch:1;     ///< Bit46, Disable
+                                                ///< DynamicInstruction Cache
+                                                ///< Prefetch. When 0, the
+                                                ///< processor may prefetch
+                                                ///< into the caches any
+                                                ///< instruction which has
+                                                ///< not been executed, but
+                                                ///< whose execution is
+                                                ///< likely. When 1,
+                                                ///< instructions may not be
+                                                ///< fetched until needed or
+                                                ///< hinted for execution.
+                                                ///< (Prefetch for a hinted
+                                                ///< branch is allowed even
+                                                ///< when dynamic instruction
+                                                ///< cache prefetch is
+                                                ///< disabled.)
+
+  UINT64  DisableBranchPrediction:1;            ///< Bit47, Disable Dynamic branch
+                                                ///<   prediction. When 0, the
+                                                ///<   processor may predict branch
+                                                ///<   targets and speculatively
+                                                ///<   execute, but may not commit
+                                                ///<   results. When 1, the processor
+                                                ///<   must wait until branch targets
+                                                ///<   are known to execute.
+  UINT64  Reserved2:4;
+  UINT64  DisablePState:1;                      ///< Bit52, Disable P-states. When 1, the PAL
+                                                ///< P-state procedures (PAL_PSTATE_INFO,
+                                                ///< PAL_SET_PSTATE, PAL_GET_PSTATE) will
+                                                ///< return with a status of -1
+                                                ///< (Unimplemented procedure).
+
+  UINT64  EnableMcaOnDataPoisoning:1;           ///< Bit53, Enable MCA signaling
+                                                ///< on data-poisoning event
+                                                ///< detection. When 0, a CMCI
+                                                ///< will be signaled on error
+                                                ///< detection. When 1, an MCA
+                                                ///< will be signaled on error
+                                                ///< detection. If this feature
+                                                ///< is not supported, then the
+                                                ///< corresponding argument is
+                                                ///< ignored when calling
+                                                ///< PAL_PROC_SET_FEATURES. Note
+                                                ///< that the functionality of
+                                                ///< this bit is independent of
+                                                ///< the setting in bit 60
+                                                ///< (Enable CMCI promotion), and
+                                                ///< that the bit 60 setting does
+                                                ///< not affect CMCI signaling
+                                                ///< for data-poisoning related
+                                                ///< events. Volume 2: Processor
+                                                ///< Abstraction Layer 2:431
+                                                ///< PAL_PROC_GET_FEATURES
+
+  UINT64  EnableVmsw:1;                         ///< Bit54, Enable the use of the vmsw
+                                                ///<   instruction. When 0, the vmsw instruction
+                                                ///<   causes a Virtualization fault when
+                                                ///<   executed at the most privileged level.
+                                                ///<   When 1, this bit will enable normal
+                                                ///<   operation of the vmsw instruction.
+
+  UINT64  EnableEnvNotification:1;              ///< Bit55, Enable external
+                                                ///< notification when the processor
+                                                ///< detects hardware errors caused
+                                                ///< by environmental factors that
+                                                ///< could cause loss of
+                                                ///< deterministic behavior of the
+                                                ///< processor. When 1, this bit will
+                                                ///< enable external notification,
+                                                ///< when 0 external notification is
+                                                ///< not provided. The type of
+                                                ///< external notification of these
+                                                ///< errors is processor-dependent. A
+                                                ///< loss of processor deterministic
+                                                ///< behavior is considered to have
+                                                ///< occurred if these
+                                                ///< environmentally induced errors
+                                                ///< cause the processor to deviate
+                                                ///< from its normal execution and
+                                                ///< eventually causes different
+                                                ///< behavior which can be observed
+                                                ///<  at the processor bus pins.
+                                                ///< Processor errors that do not
+                                                ///< have this effects (i.e.,
+                                                ///< software induced machine checks)
+                                                ///< may or may not be promoted
+                                                ///< depending on the processor
+                                                ///< implementation.
+
+  UINT64  DisableBinitWithTimeout:1;            ///< Bit56, Disable a BINIT on
+                                                ///<   internal processor time-out.
+                                                ///<   When 0, the processor may
+                                                ///<   generate a BINIT on an
+                                                ///<   internal processor time-out.
+                                                ///<   When 1, the processor will not
+                                                ///<   generate a BINIT on an
+                                                ///<   internal processor time-out.
+                                                ///<   The event is silently ignored.
+
+  UINT64  DisableDPM:1;                         ///< Bit57, Disable Dynamic Power Management
+                                                ///<   (DPM). When 0, the hardware may reduce
+                                                ///<   power consumption by removing the clock
+                                                ///<   input from idle functional units. When 1,
+                                                ///<   all functional units will receive clock
+                                                ///<   input, even when idle.
+
+  UINT64  DisableCoherency:1;                   ///< Bit58, Disable Coherency. When 0,
+                                                ///< the processor uses normal coherency
+                                                ///< requests and responses. When 1, the
+                                                ///< processor answers all requests as if
+                                                ///< the line were not present.
+
+  UINT64  DisableCache:1;                       ///< Bit59, Disable Cache. When 0, the
+                                                ///< processor performs cast outs on
+                                                ///< cacheable pages and issues and responds
+                                                ///< to coherency requests normally. When 1,
+                                                ///< the processor performs a memory access
+                                                ///< for each reference regardless of cache
+                                                ///< contents and issues no coherence
+                                                ///< requests and responds as if the line
+                                                ///< were not present. Cache contents cannot
+                                                ///< be relied upon when the cache is
+                                                ///< disabled. WARNING: Semaphore
+                                                ///< instructions may not be atomic or may
+                                                ///< cause Unsupported Data Reference faults
+                                                ///< if caches are disabled.
+
+  UINT64  EnableCmciPromotion:1;                ///< Bit60, Enable CMCI promotion When
+                                                ///<   1, Corrected Machine Check
+                                                ///<   Interrupts (CMCI) are promoted to
+                                                ///<   MCAs. They are also further
+                                                ///<   promoted to BERR if bit 39, Enable
+                                                ///<   MCA promotion, is also set and
+                                                ///<   they are promoted to BINIT if bit
+                                                ///<   38, Enable MCA to BINIT promotion,
+                                                ///<   is also set. This bit has no
+                                                ///<   effect if MCA signalling is
+                                                ///<   disabled (see
+                                                ///<   PAL_BUS_GET/SET_FEATURES)
+
+  UINT64  EnableMcaToBinitPromotion:1;          ///< Bit61, Enable MCA to BINIT
+                                                ///< promotion. When 1, machine
+                                                ///< check aborts (MCAs) are
+                                                ///< promoted to the Bus
+                                                ///< Initialization signal, and
+                                                ///< the BINIT pin is assert on
+                                                ///< each occurrence of an MCA.
+                                                ///< Setting this bit has no
+                                                ///< effect if BINIT signalling
+                                                ///< is disabled. (See
+                                                ///< PAL_BUS_GET/SET_FEATURES)
+
+  UINT64  EnableMcaPromotion:1;                 ///< Bit62, Enable MCA promotion. When
+                                                ///<   1, machine check aborts (MCAs) are
+                                                ///<   promoted to the Bus Error signal,
+                                                ///<   and the BERR pin is assert on each
+                                                ///<   occurrence of an MCA. Setting this
+                                                ///<   bit has no effect if BERR
+                                                ///<   signalling is disabled. (See
+                                                ///<   PAL_BUS_GET/SET_FEATURES)
+                                                
+  UINT64  EnableBerrPromotion:1;                ///< Bit63. Enable BERR promotion. When
+                                                ///<   1, the Bus Error (BERR) signal is
+                                                ///<   promoted to the Bus Initialization
+                                                ///<   (BINIT) signal, and the BINIT pin
+                                                ///<   is asserted on the occurrence of
+                                                ///<   each Bus Error. Setting this bit
+                                                ///<   has no effect if BINIT signalling
+                                                ///<   is disabled. (See
+                                                ///<   PAL_BUS_GET/SET_FEATURES)
+} PAL_PROCESSOR_FEATURES;
+
+/**
+  PAL Procedure - PAL_PROC_GET_FEATURES.
+
+  Return configurable processor features and their current
+  setting. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode and virtual mode.
+
+  @param Index      Index of PAL_PROC_GET_FEATURES within the list of
+                    PAL procedures.
+  @param Reserved   Reserved parameter.
+  @param FeatureSet Feature set information is being requested
+                    for.
+
+  @retval 1         Call completed without error; The
+                    feature_set passed is not supported but a
+                    feature_set of a larger value is supported.
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+  @retval -8        feature_set passed is beyond the maximum
+                    feature_set supported
+
+  @return R9        64-bit vector of features implemented. See
+                    PAL_PROCESSOR_FEATURES.
+  @return R10       64-bit vector of current feature settings. See
+                    PAL_PROCESSOR_FEATURES.
+  @return R11       64-bit vector of features controllable by
+                    software.
+
+**/
+#define PAL_PROC_GET_FEATURES 17
+
+
+/**
+  PAL Procedure - PAL_PROC_SET_FEATURES.
+
+  Enable or disable configurable processor features. It is
+  required by Itanium processors. The PAL procedure supports the Static
+  Registers calling convention. It could be called at physical
+  mode.
+
+  @param Index          Index of PAL_PROC_SET_FEATURES within the list of
+                        PAL procedures.
+  @param FeatureSelect  64-bit vector denoting desired state of
+                        each feature (1=select, 0=non-select).
+  @param FeatureSet     Feature set to apply changes to. See
+                        PAL_PROC_GET_FEATURES for more information
+                        on feature sets.
+
+  @retval 1             Call completed without error; The
+                        feature_set passed is not supported but a
+                        feature_set of a larger value is supported
+  @retval 0             Call completed without error
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+  @retval -8            feature_set passed is beyond the maximum
+                        feature_set supported
+
+**/
+#define PAL_PROC_SET_FEATURES 18
+
+
+//
+// Value of PAL_REGISTER_INFO.InfoRequest.
+//
+#define PAL_APPLICATION_REGISTER_IMPLEMENTED  0
+#define PAL_APPLICATION_REGISTER_READABLE     1
+#define PAL_CONTROL_REGISTER_IMPLEMENTED      2
+#define PAL_CONTROL_REGISTER_READABLE         3
+
+
+/**
+  PAL Procedure - PAL_REGISTER_INFO.
+
+  Return AR and CR register information. It is required by Itanium processors.
+  The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode and virtual
+  mode.
+
+  @param Index        Index of PAL_REGISTER_INFO within the list of
+                      PAL procedures.
+  @param InfoRequest  Unsigned 64-bit integer denoting what
+                      register information is requested. See
+                      PAL_REGISTER_INFO.InfoRequest above.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+  @return R9          64-bit vector denoting information for registers
+                      0-63. Bit 0 is register 0, bit 63 is register 63.
+  @return R10         64-bit vector denoting information for registers
+                      64-127. Bit 0 is register 64, bit 63 is register
+                      127.
+
+**/
+#define PAL_REGISTER_INFO 39
+
+/**
+  PAL Procedure - PAL_RSE_INFO.
+
+  Return RSE information. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and virtual mode.
+
+  @param Index        Index of PAL_RSE_INFO within the list of
+                      PAL procedures.
+  @param InfoRequest  Unsigned 64-bit integer denoting what
+                      register information is requested. See
+                      PAL_REGISTER_INFO.InfoRequest above.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+  @return R9          Number of physical stacked general registers.
+  @return R10         RSE hints supported by processor.
+
+**/
+#define PAL_RSE_INFO 19
+
+typedef struct {
+  UINT64  VersionOfPalB:16;     ///< Is a 16-bit binary coded decimal (BCD)
+                                ///< number that provides identification
+                                ///< information about the PAL_B firmware.
+  UINT64  Reserved1:8;
+  UINT64  PalVendor:8;          ///< Is an unsigned 8-bit integer indicating the
+                                ///< vendor of the PAL code.
+  UINT64  VersionOfPalA:16;     ///< Is a 16-bit binary coded decimal (BCD)
+                                ///< number that provides identification
+                                ///< information about the PAL_A firmware. In
+                                ///< the split PAL_A model, this return value
+                                ///< is the version number of the
+                                ///< processor-specific PAL_A. The generic
+                                ///< PAL_A version is not returned by this
+                                ///< procedure in the split PAL_A model.
+  UINT64  Reserved2:16;
+} PAL_VERSION_INFO;
+
+/**
+  PAL Procedure - PAL_VERSION.
+
+  Return version of PAL code. It is required by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode and virtual mode.
+
+  @param Index        Index of PAL_VERSION within the list of
+                      PAL procedures.
+  @param InfoRequest  Unsigned 64-bit integer denoting what
+                      register information is requested. See
+                      PAL_REGISTER_INFO.InfoRequest above.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+  @return R9          8-byte formatted value returning the minimum PAL
+                      version needed for proper operation of the
+                      processor. See PAL_VERSION_INFO above.
+  @return R10         8-byte formatted value returning the current PAL
+                      version running on the processor. See
+                      PAL_VERSION_INFO above.
+
+**/
+#define PAL_VERSION 20
+
+
+
+//
+// Vectors of PAL_MC_CLEAR_LOG.pending
+//
+#define PAL_MC_PENDING    BIT0
+#define PAL_INIT_PENDING  BIT1
+
+/**
+  PAL Procedure - PAL_MC_CLEAR_LOG.
+
+  Clear all error information from processor error logging
+  registers. It is required by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called at
+  physical mode and virtual mode.
+
+  @param Index  Index of PAL_MC_CLEAR_LOG within the list of
+                PAL procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    64-bit vector denoting whether an event is
+                pending. See PAL_MC_CLEAR_LOG.pending above.
+
+**/
+#define PAL_MC_CLEAR_LOG 21
+
+/**
+  PAL Procedure - PAL_MC_DRAIN.
+
+  Ensure that all operations that could cause an MCA have
+  completed. It is required by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called at
+  physical mode and virtual mode.
+
+  @param Index  Index of PAL_MC_DRAIN within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+**/
+#define PAL_MC_DRAIN 22
+
+
+/**
+  PAL Procedure - PAL_MC_DYNAMIC_STATE.
+
+  Return Processor Dynamic State for logging by SAL. It is
+  optional. The PAL procedure supports the Static Registers
+  calling convention. It could be called at physical mode.
+
+  @param Index  Index of PAL_MC_DYNAMIC_STATE within the list of PAL
+                procedures.
+  @param Offset Offset of the next 8 bytes of Dynamic Processor
+                State to return. (multiple of 8).
+
+  @retval 0     Call completed without error
+  @retval -1    Unimplemented procedure.
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+  @return R9    Unsigned 64-bit integer denoting bytes of Dynamic
+                Processor State returned.
+  @return R10   Next 8 bytes of Dynamic Processor State.
+
+**/
+#define PAL_MC_DYNAMIC_STATE 24
+
+
+
+//
+// Values of PAL_MC_ERROR_INFO.InfoIndex.
+//
+#define PAL_PROCESSOR_ERROR_MAP       0
+#define PAL_PROCESSOR_STATE_PARAM     1
+#define PAL_STRUCTURE_SPECIFIC_ERROR  2
+
+typedef struct {
+ UINT64 CoreId:4;                   ///< Bit3:0,  Processor core ID (default is 0 for
+                                    ///< processors with a single core)
+
+ UINT64 ThreadId:4;                 ///< Bit7:4, Logical thread ID (default is 0 for
+                                    ///< processors that execute a single thread)
+
+ UINT64 InfoOfInsCache:4;           ///< Bit11:8, Error information is
+                                    ///< available for 1st, 2nd, 3rd, and 4th
+                                    ///< level instruction caches.
+
+ UINT64 InfoOfDataCache:4;          ///< Bit15:12, Error information is
+                                    ///<   available for 1st, 2nd, 3rd, and 4th
+                                    ///<   level data/unified caches.
+
+ UINT64 InfoOfInsTlb:4;             ///< Bit19:16 Error information is available
+                                    ///< for 1st, 2nd, 3rd, and 4th level
+                                    ///< instruction TLB.
+
+ UINT64 InfoOfDataTlb:4;            ///< Bit23:20, Error information is available
+                                    ///< for 1st, 2nd, 3rd, and 4th level
+                                    ///< data/unified TLB
+
+ UINT64 InfoOfProcessorBus:4;       ///< Bit27:24 Error information is
+                                    ///<   available for the 1st, 2nd, 3rd,
+                                    ///<   and 4th level processor bus
+                                    ///<   hierarchy.
+ UINT64 InfoOfRegisterFile:4;       ///< Bit31:28 Error information is
+                                    ///<   available on register file
+                                    ///<   structures.
+ UINT64 InfoOfMicroArch:4;          ///< Bit47:32, Error information is
+                                    ///<   available on micro-architectural
+                                    ///<   structures.
+ UINT64 Reserved:16;
+} PAL_MC_ERROR_INFO_LEVEL_INDEX;
+
+//
+// Value of PAL_MC_ERROR_INFO.ErrorTypeIndex
+//
+#define PAL_ERR_INFO_BY_LEVEL_INDEX               0
+#define PAL_ERR_INFO_TARGET_ADDRESS               1
+#define PAL_ERR_INFO_REQUESTER_IDENTIFIER         2
+#define PAL_ERR_INFO_REPONSER_INDENTIFIER         3
+#define PAL_ERR_INFO_PRECISE_INSTRUCTION_POINTER  4
+
+typedef struct {
+  UINT64  Operation:4;                  ///< Bit3:0, Type of cache operation that caused
+                                        ///< the machine check: 0 - unknown or internal
+                                        ///< error 1 - load 2 - store 3 - instruction
+                                        ///< fetch or instruction prefetch 4 - data
+                                        ///< prefetch (both hardware and software) 5 -
+                                        ///< snoop (coherency check) 6 - cast out
+                                        ///< (explicit or implicit write-back of a cache
+                                        ///< line) 7 - move in (cache line fill)
+
+  UINT64  FailedCacheLevel:2;           ///< Bit5:4 Level of cache where the
+                                        ///< error occurred. A value of 0
+                                        ///< indicates the first level of cache.
+  UINT64  Reserved1:2;
+  UINT64  FailedInDataPart:1;           ///< Bit8, Failure located in the data part of the cache line.
+  UINT64  FailedInTagPart:1;            ///< Bit9, Failure located in the tag part of the cache line.
+  UINT64  FailedInDataCache:1;          ///< Bit10, Failure located in the data cache
+
+  UINT64  FailedInInsCache:1;           ///< Bit11, Failure located in the
+                                        ///< instruction cache.
+                                        
+  UINT64  Mesi:3;                       ///< Bit14:12,  0 - cache line is invalid. 1 - cache
+                                        ///< line is held shared. 2 - cache line is held
+                                        ///< exclusive. 3 - cache line is modified. All other
+                                        ///< values are reserved.
+                                        
+  UINT64  MesiIsValid:1;                ///< Bit15, The mesi field in the cache_check
+                                        ///< parameter is valid.
+                                        
+  UINT64  FailedWay:5;                  ///< Bit20:16, Failure located in the way of
+                                        ///< the cache indicated by this value.
+
+  UINT64  WayIndexIsValid:1;            ///< Bit21, The way and index field in the
+                                        ///< cache_check parameter is valid.
+
+  UINT64  Reserved2:1;
+  UINT64  MultipleBitsError:1;          ///< Bit23, A multiple-bit error was
+                                        ///< detected, and data was poisoned for
+                                        ///< the corresponding cache line during
+                                        ///< castout.
+  UINT64  Reserved3:8;
+  UINT64  IndexOfCacheLineError:20;     ///< Bit51:32, Index of the cache
+                                        ///< line where the error occurred.
+  UINT64  Reserved4:2;
+
+  UINT64  InstructionSet:1;             ///< Bit54, Instruction set. If this value
+                                        ///<   is set to zero, the instruction that
+                                        ///<   generated the machine check was an
+                                        ///<   Intel Itanium instruction. If this bit
+                                        ///<   is set to one, the instruction that
+                                        ///<   generated the machine check was IA-32
+                                        ///<   instruction.
+
+  UINT64  InstructionSetIsValid:1;      ///< Bit55, The is field in the
+                                        ///< cache_check parameter is valid.
+
+  UINT64  PrivilegeLevel:2;             ///< Bit57:56, Privilege level. The
+                                        ///<   privilege level of the instruction
+                                        ///<   bundle responsible for generating the
+                                        ///<   machine check.
+
+  UINT64  PrivilegeLevelIsValide:1;     ///< Bit58, The pl field of the
+                                        ///<   cache_check parameter is
+                                        ///<   valid.
+
+  UINT64  McCorrected:1;                ///< Bit59, Machine check corrected: This bit
+                                        ///<   is set to one to indicate that the machine
+                                        ///<   check has been corrected.
+
+  UINT64  TargetAddressIsValid:1;       ///< Bit60, Target address is valid:
+                                        ///< This bit is set to one to
+                                        ///< indicate that a valid target
+                                        ///< address has been logged.
+
+  UINT64  RequesterIdentifier:1;        ///< Bit61, Requester identifier: This
+                                        ///<   bit is set to one to indicate that
+                                        ///<   a valid requester identifier has
+                                        ///<   been logged.
+
+  UINT64  ResponserIdentifier:1;        ///< Bit62, Responder identifier: This
+                                        ///<   bit is set to one to indicate that
+                                        ///<   a valid responder identifier has
+                                        ///<   been logged.
+
+  UINT64  PreciseInsPointer:1;          ///< Bit63,  Precise instruction pointer.
+                                        ///< This bit is set to one to indicate
+                                        ///< that a valid precise instruction
+                                        ///< pointer has been logged.
+
+} PAL_CACHE_CHECK_INFO;
+
+
+typedef struct {
+  UINT64  FailedSlot:8;                 ///< Bit7:0, Slot number of the translation
+                                        ///< register where the failure occurred.
+  UINT64  FailedSlotIsValid:1;          ///< Bit8, The tr_slot field in the
+                                        ///< TLB_check parameter is valid.
+  UINT64  Reserved1 :1;
+  UINT64  TlbLevel:2;                   ///< Bit11:10,  The level of the TLB where the
+                                        ///< error occurred. A value of 0 indicates the
+                                        ///< first level of TLB
+  UINT64  Reserved2 :4;
+
+  UINT64  FailedInDataTr:1;             ///< Bit16, Error occurred in the data
+                                        ///< translation registers.
+
+  UINT64  FailedInInsTr:1;              ///< Bit17, Error occurred in the instruction
+                                        ///< translation registers
+
+  UINT64  FailedInDataTc:1;             ///< Bit18, Error occurred in data
+                                        ///< translation cache.
+
+  UINT64  FailedInInsTc:1;              ///< Bit19, Error occurred in the instruction
+                                        ///< translation cache.
+
+  UINT64  FailedOperation:4;            ///< Bit23:20, Type of cache operation that
+                                        ///<   caused the machine check: 0 - unknown
+                                        ///<   1 - TLB access due to load instruction
+                                        ///<   2 - TLB access due to store
+                                        ///<   instruction 3 - TLB access due to
+                                        ///<   instruction fetch or instruction
+                                        ///<   prefetch 4 - TLB access due to data
+                                        ///<   prefetch (both hardware and software)
+                                        ///<   5 - TLB shoot down access 6 - TLB
+                                        ///<   probe instruction (probe, tpa) 7 -
+                                        ///<   move in (VHPT fill) 8 - purge (insert
+                                        ///<   operation that purges entries or a TLB
+                                        ///<   purge instruction) All other values
+                                        ///<   are reserved.
+
+  UINT64  Reserved3:30;
+  UINT64  InstructionSet:1;             ///< Bit54, Instruction set. If this value
+                                        ///<   is set to zero, the instruction that
+                                        ///<   generated the machine check was an
+                                        ///<   Intel Itanium instruction. If this bit
+                                        ///<   is set to one, the instruction that
+                                        ///<   generated the machine check was IA-32
+                                        ///<   instruction.
+
+  UINT64  InstructionSetIsValid:1;      ///< Bit55, The is field in the
+                                        ///< TLB_check parameter is valid.
+
+  UINT64  PrivelegeLevel:2;             ///< Bit57:56, Privilege level. The
+                                        ///<   privilege level of the instruction
+                                        ///<   bundle responsible for generating the
+                                        ///<   machine check.
+
+  UINT64  PrivelegeLevelIsValid:1;      ///< Bit58,  The pl field of the
+                                        ///< TLB_check parameter is valid.
+
+  UINT64  McCorrected:1;                ///< Bit59, Machine check corrected: This bit
+                                        ///<   is set to one to indicate that the machine
+                                        ///<   check has been corrected.
+
+  UINT64  TargetAddressIsValid:1;       ///< Bit60, Target address is valid:
+                                        ///< This bit is set to one to
+                                        ///< indicate that a valid target
+                                        ///< address has been logged.
+
+  UINT64  RequesterIdentifier:1;        ///< Bit61 Requester identifier: This
+                                        ///<   bit is set to one to indicate that
+                                        ///<   a valid requester identifier has
+                                        ///<   been logged.
+
+  UINT64  ResponserIdentifier:1;        ///< Bit62, Responder identifier:  This
+                                        ///<   bit is set to one to indicate that
+                                        ///<   a valid responder identifier has
+                                        ///<   been logged.
+
+  UINT64  PreciseInsPointer:1;          ///< Bit63 Precise instruction pointer.
+                                        ///<   This bit is set to one to indicate
+                                        ///<   that a valid precise instruction
+                                        ///<   pointer has been logged.
+} PAL_TLB_CHECK_INFO;
+
+/**
+  PAL Procedure - PAL_MC_ERROR_INFO.
+
+  Return Processor Machine Check Information and Processor
+  Static State for logging by SAL. It is required by Itanium processors. The
+  PAL procedure supports the Static Registers calling
+  convention. It could be called at physical and virtual mode.
+
+  @param Index            Index of PAL_MC_ERROR_INFO within the list of PAL
+                          procedures.
+  @param InfoIndex        Unsigned 64-bit integer identifying the
+                          error information that is being requested.
+                          See PAL_MC_ERROR_INFO.InfoIndex.
+  @param LevelIndex       8-byte formatted value identifying the
+                          structure to return error information
+                          on. See PAL_MC_ERROR_INFO_LEVEL_INDEX.
+  @param ErrorTypeIndex   Unsigned 64-bit integer denoting the
+                          type of error information that is
+                          being requested for the structure
+                          identified in LevelIndex.
+
+  @retval 0               Call completed without error
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -6              Argument was valid, but no error
+                          information was available
+
+  @return R9              Error information returned. The format of this
+                          value is dependant on the input values passed.
+  @return R10             If this value is zero, all the error information
+                          specified by err_type_index has been returned. If
+                          this value is one, more structure-specific error
+                          information is available and the caller needs to
+                          make this procedure call again with level_index
+                          unchanged and err_type_index, incremented.
+
+**/
+#define PAL_MC_ERROR_INFO 25
+
+/**
+  PAL Procedure - PAL_MC_EXPECTED.
+
+  Set/Reset Expected Machine Check Indicator. It is required by
+  Itanium processors. The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode.
+
+  @param Index      Index of PAL_MC_EXPECTED within the list of PAL
+                    procedures.
+  @param Expected   Unsigned integer with a value of 0 or 1 to
+                    set or reset the hardware resource
+                    PALE_CHECK examines for expected machine
+                    checks.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+
+  @return R9        Unsigned integer denoting whether a machine check
+                    was previously expected.
+
+**/
+#define PAL_MC_EXPECTED 23
+
+/**
+  PAL Procedure - PAL_MC_REGISTER_MEM.
+
+  Register min-state save area with PAL for machine checks and
+  inits. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index    Index of PAL_MC_REGISTER_MEM within the list of PAL
+                  procedures.
+  @param Address  Physical address of the buffer to be
+                  registered with PAL.
+
+  @retval 0       Call completed without error
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+
+**/
+#define PAL_MC_REGISTER_MEM 27
+
+/**
+  PAL Procedure - PAL_MC_RESUME.
+
+  Restore minimal architected state and return to interrupted
+  process. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index        Index of PAL_MC_RESUME within the list of PAL
+                      procedures.
+  @param SetCmci      Unsigned 64 bit integer denoting whether to
+                      set the CMC interrupt. A value of 0 indicates
+                      not to set the interrupt, a value of 1
+                      indicated to set the interrupt, and all other
+                      values are reserved.
+  @param SavePtr      Physical address of min-state save area used
+                      to used to restore processor state.
+  @param NewContext   Unsigned 64-bit integer denoting whether
+                      the caller is returning to a new context.
+                      A value of 0 indicates the caller is
+                      returning to the interrupted context, a
+                      value of 1 indicates that the caller is
+                      returning to a new context.
+
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+**/
+#define PAL_MC_RESUME 26
+
+/**
+  PAL Procedure - PAL_HALT.
+
+  Enter the low-power HALT state or an implementation-dependent
+  low-power state. It is optinal. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index        Index of PAL_HALT within the list of PAL
+                      procedures.
+  @param HaltState    Unsigned 64-bit integer denoting low power
+                      state requested.
+  @param IoDetailPtr  8-byte aligned physical address pointer to
+                      information on the type of I/O
+                      (load/store) requested.
+
+  @retval 0           Call completed without error
+  @retval -1          Unimplemented procedure
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+  @return R9          Value returned if a load instruction is requested
+                      in the io_detail_ptr
+
+**/
+#define PAL_HALT 28
+
+
+/**
+  PAL Procedure - PAL_HALT_INFO.
+
+  Return the low power capabilities of the processor. It is
+  required by Itanium processors. The PAL procedure supports the
+  Stacked Registers calling convention. It could be called at
+  physical and virtual mode.
+
+  @param Index        Index of PAL_HALT_INFO within the list of PAL
+                      procedures.
+  @param PowerBuffer  64-bit pointer to a 64-byte buffer aligned
+                      on an 8-byte boundary.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+**/
+#define PAL_HALT_INFO 257
+
+
+/**
+  PAL Procedure - PAL_HALT_LIGHT.
+
+  Enter the low power LIGHT HALT state. It is required by
+  Itanium processors. The PAL procedure supports the Static Registers calling
+  convention. It could be called at physical and virtual mode.
+
+  @param Index  Index of PAL_HALT_LIGHT within the list of PAL
+                procedures.
+
+  @retval 0     Call completed without error
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+
+**/
+#define PAL_HALT_LIGHT 29
+
+/**
+  PAL Procedure - PAL_CACHE_LINE_INIT.
+
+  Initialize tags and data of a cache line for processor
+  testing. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical and virtual mode.
+
+  @param Index      Index of PAL_CACHE_LINE_INIT within the list of PAL
+                    procedures.
+  @param Address    Unsigned 64-bit integer value denoting the
+                    physical address from which the physical page
+                    number is to be generated. The address must be
+                    an implemented physical address, bit 63 must
+                    be zero.
+  @param DataValue  64-bit data value which is used to
+                    initialize the cache line.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+
+**/
+#define PAL_CACHE_LINE_INIT 31
+
+/**
+  PAL Procedure - PAL_CACHE_READ.
+
+  Read tag and data of a cache line for diagnostic testing. It
+  is optional. The PAL procedure supports the
+  Satcked Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index    Index of PAL_CACHE_READ within the list of PAL
+                  procedures.
+  @param LineId   8-byte formatted value describing where in the
+                  cache to read the data.
+  @param Address  64-bit 8-byte aligned physical address from
+                  which to read the data. The address must be an
+                  implemented physical address on the processor
+                  model with bit 63 set to zero.
+
+  @retval 1       The word at address was found in the
+                  cache, but the line was invalid.
+  @retval 0       Call completed without error
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+  @retval -5      The word at address was not found in the
+                  cache.
+  @retval -7      The operation requested is not supported
+                  for this cache_type and level.
+
+  @return R9      Right-justified value returned from the cache
+                  line.
+  @return R10     The number of bits returned in data.
+  @return R11     The status of the cache line.
+
+**/
+#define PAL_CACHE_READ 259
+
+
+/**
+  PAL Procedure - PAL_CACHE_WRITE.
+
+  Write tag and data of a cache for diagnostic testing. It is
+  optional. The PAL procedure supports the Satcked Registers
+  calling convention. It could be called at physical mode.
+
+  @param Index    Index of PAL_CACHE_WRITE within the list of PAL
+                  procedures.
+  @param LineId   8-byte formatted value describing where in the
+                  cache to write the data.
+  @param Address  64-bit 8-byte aligned physical address at
+                  which the data should be written. The address
+                  must be an implemented physical address on the
+                  processor model with bit 63 set to 0.
+  @param Data     Unsigned 64-bit integer value to write into
+                  the specified part of the cache.
+
+  @retval 0       Call completed without error
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+  @retval -7      The operation requested is not supported
+                  for this cache_type and level.
+
+**/
+#define PAL_CACHE_WRITE 260
+
+/**
+  PAL Procedure - PAL_TEST_INFO.
+
+  Returns alignment and size requirements needed for the memory
+  buffer passed to the PAL_TEST_PROC procedure as well as
+  information on self-test control words for the processor self
+  tests. It is required by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index      Index of PAL_TEST_INFO within the list of PAL
+                    procedures.
+  @param TestPhase  Unsigned integer that specifies which phase
+                    of the processor self-test information is
+                    being requested on. A value of 0 indicates
+                    the phase two of the processor self-test and
+                    a value of 1 indicates phase one of the
+                    processor self-test. All other values are
+                    reserved.
+
+  @retval 0         Call completed without error
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+
+  @return R9        Unsigned 64-bit integer denoting the number of
+                    bytes of main memory needed to perform the second
+                    phase of processor self-test.
+  @return R10       Unsigned 64-bit integer denoting the alignment
+                    required for the memory buffer.
+  @return R11       48-bit wide bit-field indicating if control of
+                    the processor self-tests is supported and which
+                    bits of the test_control field are defined for
+                    use.
+
+**/
+#define PAL_TEST_INFO 37
+
+typedef struct {
+  UINT64  BufferSize:56;    ///< Indicates the size in bytes of the memory
+                            ///< buffer that is passed to this procedure.
+                            ///< BufferSize must be greater than or equal in
+                            ///< size to the bytes_needed return value from
+                            ///< PAL_TEST_INFO, otherwise this procedure will
+                            ///< return with an invalid argument return
+                            ///< value.
+
+  UINT64  TestPhase:8;      ///< Defines which phase of the processor
+                            ///< self-tests are requested to be run. A value
+                            ///< of zero indicates to run phase two of the
+                            ///< processor self-tests. Phase two of the
+                            ///< processor self-tests are ones that require
+                            ///< external memory to execute correctly. A
+                            ///< value of one indicates to run phase one of
+                            ///< the processor self-tests. Phase one of the
+                            ///< processor self-tests are tests run during
+                            ///< PALE_RESET and do not depend on external
+                            ///< memory to run correctly. When the caller
+                            ///< requests to have phase one of the processor
+                            ///< self-test run via this procedure call, a
+                            ///< memory buffer may be needed to save and
+                            ///< restore state as required by the PAL calling
+                            ///< conventions. The procedure PAL_TEST_INFO
+                            ///< informs the caller about the requirements of
+                            ///< the memory buffer.
+} PAL_TEST_INFO_INFO;
+
+typedef struct {
+  UINT64  TestControl:47;       ///< This is an ordered implementation-specific
+                                ///<   control word that allows the user control
+                                ///<   over the length and runtime of the
+                                ///<   processor self-tests. This control word is
+                                ///<   ordered from the longest running tests up
+                                ///<   to the shortest running tests with bit 0
+                                ///<   controlling the longest running test. PAL
+                                ///<   may not implement all 47-bits of the
+                                ///<   test_control word. PAL communicates if a
+                                ///<   bit provides control by placing a zero in
+                                ///<   that bit. If a bit provides no control,
+                                ///<   PAL will place a one in it. PAL will have
+                                ///<   two sets of test_control bits for the two
+                                ///<   phases of the processor self-test. PAL
+                                ///<   provides information about implemented
+                                ///<   test_control bits at the hand-off from PAL
+                                ///<   to SAL for the firmware recovery check.
+                                ///<   These test_control bits provide control
+                                ///<   for phase one of processor self-test. It
+                                ///<   also provides this information via the PAL
+                                ///<   procedure call PAL_TEST_INFO for both the
+                                ///<   phase one and phase two processor tests
+                                ///<   depending on which information the caller
+                                ///<   is requesting. PAL interprets these bits
+                                ///<   as input parameters on two occasions. The
+                                ///<   first time is when SAL passes control back
+                                ///<   to PAL after the firmware recovery check.
+                                ///<   The second time is when a call to
+                                ///<   PAL_TEST_PROC is made. When PAL interprets
+                                ///<   these bits it will only interpret
+                                ///<   implemented test_control bits and will
+                                ///<   ignore the values located in the
+                                ///<   unimplemented test_control bits. PAL
+                                ///<   interprets the implemented bits such that
+                                ///<   if a bit contains a zero, this indicates
+                                ///<   to run the test. If a bit contains a one,
+                                ///<   this indicates to PAL to skip the test. If
+                                ///<   the cs bit indicates that control is not
+                                ///<    available, the test_control bits will be
+                                ///<   ignored or generate an illegal argument in
+                                ///<   procedure calls if the caller sets these
+                                ///<   bits.
+                                
+  UINT64  ControlSupport:1;     ///< This bit defines if an implementation
+                                ///<  supports control of the PAL self-tests
+                                ///<  via the self-test control word. If
+                                ///<  this bit is 0, the implementation does
+                                ///<  not support control of the processor
+                                ///<  self-tests via the self-test control
+                                ///<  word. If this bit is 1, the
+                                ///<  implementation does support control of
+                                ///<  the processor self-tests via the
+                                ///<  self-test control word. If control is
+                                ///<  not supported, GR37 will be ignored at
+                                ///<  the hand-off between SAL and PAL after
+                                ///<  the firmware recovery check and the
+                                ///<  PAL procedures related to the
+                                ///<  processor self-tests may return
+                                ///<  illegal arguments if a user tries to
+                                ///<  use the self-test control features.
+  UINT64  Reserved:16;
+} PAL_SELF_TEST_CONTROL;
+
+typedef struct {
+  UINT64  Attributes:8;         ///< Specifies the memory attributes that are
+                                ///<  allowed to be used with the memory buffer
+                                ///<  passed to this procedure. The attributes
+                                ///<  parameter is a vector where each bit
+                                ///<  represents one of the virtual memory
+                                ///<  attributes defined by the architecture.See
+                                ///<  MEMORY_AATRIBUTES. The caller is required
+                                ///<  to support the cacheable attribute for the
+                                ///<  memory buffer, otherwise an invalid
+                                ///<  argument will be returned.
+  UINT64  Reserved:8;
+  UINT64  TestControl:48;       ///< Is the self-test control word
+                                ///<  corresponding to the test_phase passed.
+                                ///<  This test_control directs the coverage and
+                                ///<  runtime of the processor self-tests
+                                ///<  specified by the test_phase input
+                                ///<  argument. Information on if this
+                                ///<  feature is implemented and the number of
+                                ///<  bits supported can be obtained by the
+                                ///<  PAL_TEST_INFO procedure call. If this
+                                ///<  feature is implemented by the processor,
+                                ///<  the caller can selectively skip parts of
+                                ///<  the processor self-test by setting
+                                ///<  test_control bits to a one. If a bit has a
+                                ///<  zero, this test will be run. The values in
+                                ///<  the unimplemented bits are ignored. If
+                                ///<  PAL_TEST_INFO indicated that the self-test
+                                ///<  control word is not implemented, this
+                                ///<  procedure will return with an invalid
+                                ///<  argument status if the caller sets any of
+                                ///<  the test_control bits. See
+                                ///<  PAL_SELF_TEST_CONTROL.
+} PAL_TEST_CONTROL;
+
+/**
+  PAL Procedure - PAL_TEST_PROC.
+
+  Perform late processor self test. It is required by Itanium processors. The
+  PAL procedure supports the Static Registers calling
+  convention. It could be called at physical mode.
+
+  @param Index        Index of PAL_TEST_PROC within the list of PAL
+                      procedures.
+  @param TestAddress  64-bit physical address of main memory
+                      area to be used by processor self-test.
+                      The memory region passed must be
+                      cacheable, bit 63 must be zero.
+  @param TestInfo     Input argument specifying the size of the
+                      memory buffer passed and the phase of the
+                      processor self-test that should be run. See
+                      PAL_TEST_INFO.
+  @param TestParam    Input argument specifying the self-test
+                      control word and the allowable memory
+                      attributes that can be used with the memory
+                      buffer. See PAL_TEST_CONTROL.
+
+  @retval 1           Call completed without error, but hardware
+                      failures occurred during self-test.
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+  @return R9          Formatted 8-byte value denoting the state of the
+                      processor after self-test
+
+**/
+#define PAL_TEST_PROC 258
+
+typedef struct {
+  UINT32  NumberOfInterruptControllers;     ///< Number of interrupt
+                                            ///< controllers currently
+                                            ///< enabled on the system.
+
+  UINT32  NumberOfProcessors;               ///< Number of processors currently
+                                            ///< enabled on the system.
+} PAL_PLATFORM_INFO;
+
+/**
+  PAL Procedure - PAL_COPY_INFO.
+
+  Return information needed to relocate PAL procedures and PAL
+  PMI code to memory. It is required by Itanium processors. The PAL procedure
+  supports the Static Registers calling convention. It could be
+  called at physical mode.
+
+  @param Index              Index of PAL_COPY_INFO within the list of PAL
+                            procedures.
+  @param CopyType           Unsigned integer denoting type of procedures
+                            for which copy information is requested.
+  @param PlatformInfo       8-byte formatted value describing the
+                            number of processors and the number of
+                            interrupt controllers currently enabled
+                            on the system. See PAL_PLATFORM_INFO.
+  @param McaProcStateInfo   Unsigned integer denoting the number
+                            of bytes that SAL needs for the
+                            min-state save area for each
+                            processor.
+
+  @retval 0                 Call completed without error
+  @retval -2                Invalid argument
+  @retval -3                Call completed with error.
+
+  @return R9                Unsigned integer denoting the number of bytes of
+                            PAL information that must be copied to main
+                            memory.
+  @return R10               Unsigned integer denoting the starting alignment
+                            of the data to be copied.
+
+**/
+#define PAL_COPY_INFO 30
+
+/**
+  PAL Procedure - PAL_COPY_PAL.
+
+  Relocate PAL procedures and PAL PMI code to memory. It is
+  required by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at physical
+  mode.
+
+  @param Index          Index of PAL_COPY_PAL within the list of PAL
+                        procedures.
+  @param TargetAddress  Physical address of a memory buffer to
+                        copy relocatable PAL procedures and PAL
+                        PMI code.
+  @param AllocSize      Unsigned integer denoting the size of the
+                        buffer passed by SAL for the copy operation.
+  @param CopyOption     Unsigned integer indicating whether
+                        relocatable PAL code and PAL PMI code
+                        should be copied from firmware address
+                        space to main memory.
+
+  @retval 0             Call completed without error
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+
+  @return R9            Unsigned integer denoting the offset of PAL_PROC
+                        in the relocatable segment copied.
+
+**/
+#define PAL_COPY_PAL 256
+
+/**
+  PAL Procedure - PAL_ENTER_IA_32_ENV.
+
+  Enter IA-32 System environment. It is optional. The PAL
+  procedure supports the Static Registers calling convention.
+  It could be called at physical mode.
+
+  Note: Since this is a special call, it does not follow the PAL
+  static register calling convention. GR28 contains the index of
+  PAL_ENTER_IA_32_ENV within the list of PAL procedures. All other
+  input arguments including GR29-GR31 are setup by SAL to values
+  as required by the IA-32 operating system defined in Table
+  11-67. The registers that are designated as preserved, scratch,
+  input arguments and procedure return values by the static
+  procedure calling convention are not followed by this call. For
+  instance, GR5 and GR6 need not be preserved since these are
+  regarded as scratch by the IA-32 operating system. Note: In an
+  MP system, this call must be COMPLETED on the first CPU to enter
+  the IA-32 System Environment (may or may not be the BSP) prior
+  to being called on the remaining processors in the MP system.
+
+  @param Index  GR28 contains the index of the
+                PAL_ENTER_IA_32_ENV call within the list of PAL
+                procedures.
+
+
+  @retval  The status is returned in GR4.
+                  -1 - Un-implemented procedure 0 JMPE detected
+                  at privilege level
+
+                  0 - 1 SAL allocated buffer for IA-32 System
+                  Environment operation is too small
+
+                  2 - IA-32 Firmware Checksum Error
+
+                  3 -  SAL allocated buffer for IA-32 System
+                  Environment operation is not properly aligned
+
+                  4 - Error in SAL MP Info Table
+
+                  5 - Error in SAL Memory Descriptor Table
+
+                  6 - Error in SAL System Table
+
+                  7 - Inconsistent IA-32 state
+
+                  8 - IA-32 Firmware Internal Error
+
+                  9 - IA-32 Soft Reset (Note: remaining register
+                  state is undefined for this termination
+                  reason)
+
+                  10 - Machine Check Error
+
+                  11 - Error in SAL I/O Intercept Table
+
+                  12 - Processor exit due to other processor in
+                  MP system terminating the IA32 system
+                  environment. (Note: remaining register state
+                  is undefined for this termination reason.)
+
+                  13 - Itanium architecture-based state
+                  corruption by either SAL PMI handler or I/O
+                  Intercept callback function.
+
+
+**/
+#define PAL_ENTER_IA_32_ENV 33
+
+/**
+  PAL Procedure - PAL_PMI_ENTRYPOINT.
+
+  Register PMI memory entrypoints with processor. It is required
+  by Itanium processors. The PAL procedure supports the Stacked Registers
+  calling convention. It could be called at physical mode.
+
+  @param Index        Index of PAL_PMI_ENTRYPOINT within the list of
+                      PAL procedures.
+  @param SalPmiEntry  256-byte aligned physical address of SAL
+                      PMI entrypoint in memory.
+
+  @retval 0           Call completed without error
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+
+**/
+#define PAL_PMI_ENTRYPOINT 32
+
+
+/**
+
+  The ASCII brand identification string will be copied to the
+  address specified in the address input argument. The processor
+  brand identification string is defined to be a maximum of 128
+  characters long; 127 bytes will contain characters and the 128th
+  byte is defined to be NULL (0). A processor may return less than
+  the 127 ASCII characters as long as the string is null
+  terminated. The string length will be placed in the brand_info
+  return argument.
+
+**/
+#define PAL_BRAND_INFO_ID_REQUEST  0
+
+/**
+  PAL Procedure - PAL_BRAND_INFO.
+
+  Provides processor branding information. It is optional by
+  Itanium processors. The PAL procedure supports the Stacked Registers calling
+  convention. It could be called at physical and Virtual mode.
+
+  @param Index        Index of PAL_BRAND_INFO within the list of PAL
+                      procedures.
+  @param InfoRequest  Unsigned 64-bit integer specifying the
+                      information that is being requested. (See
+                      PAL_BRAND_INFO_ID_REQUEST)
+  @param Address      Unsigned 64-bit integer specifying the
+                      address of the 128-byte block to which the
+                      processor brand string shall be written.
+
+  @retval 0           Call completed without error
+  @retval -1          Unimplemented procedure
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+  @retval -6          Input argument is not implemented.
+
+  @return R9          Brand information returned. The format of this
+                      value is dependent on the input values passed.
+
+**/
+#define PAL_BRAND_INFO  274
+
+/**
+  PAL Procedure - PAL_GET_HW_POLICY.
+
+  Returns the current hardware resource sharing policy of the
+  processor. It is optional by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called at
+  physical and Virtual mode.
+
+
+  @param Index            Index of PAL_GET_HW_POLICY within the list of PAL
+                          procedures.
+  @param ProcessorNumber  Unsigned 64-bit integer that specifies
+                          for which logical processor
+                          information is being requested. This
+                          input argument must be zero for the
+                          first call to this procedure and can
+                          be a maximum value of one less than
+                          the number of logical processors
+                          impacted by the hardware resource
+                          sharing policy, which is returned by
+                          the R10 return value.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -9              Call requires PAL memory buffer.
+
+  @return R9              Unsigned 64-bit integer representing the current
+                          hardware resource sharing policy.
+  @return R10             Unsigned 64-bit integer that returns the number
+                          of logical processors impacted by the policy
+                          input argument.
+  @return R11             Unsigned 64-bit integer containing the logical
+                          address of one of the logical processors
+                          impacted by policy modification.
+
+**/
+#define PAL_GET_HW_POLICY   48
+
+
+//
+// Value of PAL_SET_HW_POLICY.Policy
+//
+#define PAL_SET_HW_POLICY_PERFORMANCE               0
+#define PAL_SET_HW_POLICY_FAIRNESS                  1
+#define PAL_SET_HW_POLICY_HIGH_PRIORITY             2
+#define PAL_SET_HW_POLICY_EXCLUSIVE_HIGH_PRIORITY   3
+
+/**
+  PAL Procedure - PAL_SET_HW_POLICY.
+
+  Sets the current hardware resource sharing policy of the
+  processor. It is optional by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called at
+  physical and Virtual mode.
+
+  @param Index    Index of PAL_SET_HW_POLICY within the list of PAL
+                  procedures.
+  @param Policy   Unsigned 64-bit integer specifying the hardware
+                  resource sharing policy the caller is setting.
+                  See Value of PAL_SET_HW_POLICY.Policy above.
+
+  @retval 1       Call completed successfully but could not
+                  change the hardware policy since a
+                  competing logical processor is set in
+                  exclusive high priority.
+  @retval 0       Call completed without error
+  @retval -1      Unimplemented procedure
+  @retval -2      Invalid argument
+  @retval -3      Call completed with error.
+  @retval -9      Call requires PAL memory buffer.
+
+**/
+#define PAL_SET_HW_POLICY   49
+
+typedef struct {
+  UINT64  Mode:3;                   ///< Bit2:0, Indicates the mode of operation for this
+                                    ///<    procedure: 0 - Query mode 1 - Error inject mode
+                                    ///<    (err_inj should also be specified) 2 - Cancel
+                                    ///<    outstanding trigger. All other fields in
+                                    ///<    PAL_MC_ERROR_TYPE_INFO,
+                                    ///<    PAL_MC_ERROR_STRUCTURE_INFO and
+                                    ///<    PAL_MC_ERROR_DATA_BUFFER are ignored. All other
+                                    ///<    values are reserved.
+
+  UINT64  ErrorInjection:3;         ///< Bit5:3, indicates the mode of error
+                                    ///<  injection: 0 - Error inject only (no
+                                    ///<  error consumption) 1 - Error inject
+                                    ///<  and consume All other values are
+                                    ///<  reserved.
+
+  UINT64  ErrorSeverity:2;          ///< Bit7:6, indicates the severity desired
+                                    ///<  for error injection/query. Definitions
+                                    ///<  of the different error severity types
+                                    ///<  0 - Corrected error 1 - Recoverable
+                                    ///<  error 2 - Fatal error 3 - Reserved
+
+  UINT64  ErrorStructure:5;         ///< Bit12:8, Indicates the structure
+                                    ///<  identification for error
+                                    ///<  injection/query: 0 - Any structure
+                                    ///<  (cannot be used during query mode).
+                                    ///<  When selected, the structure type used
+                                    ///<  for error injection is determined by
+                                    ///<  PAL. 1 - Cache 2 - TLB 3 - Register
+                                    ///<  file 4 - Bus/System interconnect 5-15
+                                    ///<  - Reserved 16-31 - Processor
+                                    ///<  specific error injection
+                                    ///<  capabilities.ErrorDataBuffer is used
+                                    ///<  to specify error types. Please refer
+                                    ///<  to the processor specific
+                                    ///<  documentation for additional details.
+
+  UINT64  StructureHierarchy:3;     ///< Bit15:13, Indicates the structure
+                                    ///<  hierarchy for error
+                                    ///<  injection/query: 0 - Any level of
+                                    ///<  hierarchy (cannot be used during
+                                    ///<  query mode). When selected, the
+                                    ///<  structure hierarchy used for error
+                                    ///<  injection is determined by PAL. 1
+                                    ///<  - Error structure hierarchy
+                                    ///<  level-1 2 - Error structure
+                                    ///<  hierarchy level-2 3 - Error
+                                    ///<  structure hierarchy level-3 4 -
+                                    ///<  Error structure hierarchy level-4
+                                    ///<  All other values are reserved.
+
+  UINT64  Reserved:32;              ///< Reserved 47:16 Reserved
+
+  UINT64  ImplSpec:16;              ///< Bit63:48, Processor specific error injection capabilities.
+} PAL_MC_ERROR_TYPE_INFO;
+
+typedef struct {
+  UINT64  StructInfoIsValid:1;              ///< Bit0 When 1, indicates that the
+                                            ///< structure information fields
+                                            ///< (c_t,cl_p,cl_id) are valid and
+                                            ///< should be used for error injection.
+                                            ///< When 0, the structure information
+                                            ///< fields are ignored, and the values
+                                            ///< of these fields used for error
+                                            ///< injection are
+                                            ///< implementation-specific.
+
+  UINT64  CacheType:2;                      ///< Bit2:1  Indicates which cache should be used
+                                            ///< for error injection: 0 - Reserved 1 -
+                                            ///< Instruction cache 2 - Data or unified cache
+                                            ///< 3 - Reserved
+
+  UINT64  PortionOfCacheLine:3;             ///< Bit5:3 Indicates the portion of the
+                                            ///<   cache line where the error should
+                                            ///<   be injected: 0 - Reserved 1 - Tag
+                                            ///<   2 - Data 3 - mesi All other
+                                            ///<   values are reserved.
+
+  UINT64  Mechanism:3;                      ///< Bit8:6 Indicates which mechanism is used to
+                                            ///< identify the cache line to be used for error
+                                            ///< injection: 0 - Reserved 1 - Virtual address
+                                            ///< provided in the inj_addr field of the buffer
+                                            ///< pointed to by err_data_buffer should be used
+                                            ///< to identify the cache line for error
+                                            ///< injection. 2 - Physical address provided in
+                                            ///< the inj_addr field of the buffer pointed to
+                                            ///< by err_data_buffershould be used to identify
+                                            ///< the cache line for error injection. 3 - way
+                                            ///< and index fields provided in err_data_buffer
+                                            ///< should be used to identify the cache line
+                                            ///< for error injection. All other values are
+                                            ///< reserved.
+
+  UINT64  DataPoisonOfCacheLine:1;          ///< Bit9 When 1, indicates that a
+                                            ///< multiple bit, non-correctable
+                                            ///< error should be injected in the
+                                            ///< cache line specified by cl_id.
+                                            ///< If this injected error is not
+                                            ///< consumed, it may eventually
+                                            ///< cause a data-poisoning event
+                                            ///< resulting in a corrected error
+                                            ///< signal, when the associated
+                                            ///< cache line is cast out (implicit
+                                            ///< or explicit write-back of the
+                                            ///< cache line). The error severity
+                                            ///< specified by err_sev in
+                                            ///< err_type_info must be set to 0
+                                            ///< (corrected error) when this bit
+                                            ///< is set.
+
+  UINT64  Reserved1:22;
+
+  UINT64  TrigerInfoIsValid:1;              ///< Bit32 When 1, indicates that the
+                                            ///< trigger information fields (trigger,
+                                            ///< trigger_pl) are valid and should be
+                                            ///< used for error injection. When 0,
+                                            ///< the trigger information fields are
+                                            ///< ignored and error injection is
+                                            ///< performed immediately.
+
+  UINT64  Triger:4;                         ///< Bit36:33 Indicates the operation type to be
+                                            ///<   used as the error trigger condition. The
+                                            ///<   address corresponding to the trigger is
+                                            ///<   specified in the trigger_addr field of the
+                                            ///<   buffer pointed to by err_data_buffer: 0 -
+                                            ///<   Instruction memory access. The trigger match
+                                            ///<   conditions for this operation type are similar
+                                            ///<   to the IBR address breakpoint match conditions
+                                            ///<   1 - Data memory access. The trigger match
+                                            ///<   conditions for this operation type are similar
+                                            ///<   to the DBR address breakpoint match conditions
+                                            ///<   All other values are reserved.
+
+  UINT64  PrivilegeOfTriger:3;              ///< Bit39:37  Indicates the privilege
+                                            ///< level of the context during which
+                                            ///< the error should be injected: 0 -
+                                            ///< privilege level 0 1 - privilege
+                                            ///< level 1 2 - privilege level 2 3 -
+                                            ///< privilege level 3 All other values
+                                            ///< are reserved. If the implementation
+                                            ///< does not support privilege level
+                                            ///< qualifier for triggers (i.e. if
+                                            ///< trigger_pl is 0 in the capabilities
+                                            ///< vector), this field is ignored and
+                                            ///< triggers can be taken at any
+                                            ///< privilege level.
+
+  UINT64  Reserved2:24;
+} PAL_MC_ERROR_STRUCT_INFO;
+
+/**
+
+   Buffer Pointed to by err_data_buffer - TLB
+
+**/
+typedef struct {
+  UINT64  TrigerAddress;
+  UINT64  VirtualPageNumber:52;
+  UINT64  Reserved1:8;
+  UINT64  RegionId:24;
+  UINT64  Reserved2:40;
+} PAL_MC_ERROR_DATA_BUFFER_TLB;
+
+/**
+  PAL Procedure - PAL_MC_ERROR_INJECT.
+
+  Injects the requested processor error or returns information
+  on the supported injection capabilities for this particular
+  processor implementation. It is optional by Itanium processors. The PAL
+  procedure supports the Stacked Registers calling convention.
+  It could be called at physical and Virtual mode.
+
+  @param Index            Index of PAL_MC_ERROR_INJECT within the list of PAL
+                          procedures.
+  @param ErrorTypeInfo    Unsigned 64-bit integer specifying the
+                          first level error information which
+                          identifies the error structure and
+                          corresponding structure hierarchy, and
+                          the error severity.
+  @param ErrorStructInfo  Unsigned 64-bit integer identifying
+                          the optional structure specific
+                          information that provides the  second
+                          level details for the requested error.
+  @param ErrorDataBuffer  64-bit physical address of a buffer
+                          providing additional parameters for
+                          the requested error. The address of
+                          this buffer must be 8-byte aligned.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -4              Call completed with error; the requested
+                          error could not be injected due to failure in
+                          locating the target location in the specified
+                          structure.
+  @retval -5              Argument was valid, but requested error
+                          injection capability is not supported.
+  @retval -9              Call requires PAL memory buffer.
+
+  @return R9              64-bit vector specifying the supported error
+                          injection capabilities for the input argument
+                          combination of struct_hier, err_struct and
+                          err_sev fields in ErrorTypeInfo.
+  @return R10             64-bit vector specifying the architectural
+                          resources that are used by the procedure.
+
+**/
+#define PAL_MC_ERROR_INJECT 276
+
+
+//
+// Types of PAL_GET_PSTATE.Type
+//
+#define PAL_GET_PSTATE_RECENT                 0
+#define PAL_GET_PSTATE_AVERAGE_NEW_START      1
+#define PAL_GET_PSTATE_AVERAGE                2
+#define PAL_GET_PSTATE_NOW                    3
+
+/**
+  PAL Procedure - PAL_GET_PSTATE.
+
+  Returns the performance index of the processor. It is optional
+  by Itanium processors. The PAL procedure supports the Stacked Registers
+  calling convention. It could be called at physical and Virtual
+  mode.
+
+  @param Index  Index of PAL_GET_PSTATE within the list of PAL
+                procedures.
+  @param Type   Type of performance_index value to be returned
+                by this procedure.See PAL_GET_PSTATE.Type above.
+
+  @retval 1     Call completed without error, but accuracy
+                of performance index has been impacted by a
+                thermal throttling event, or a
+                hardware-initiated event.
+  @retval 0     Call completed without error
+  @retval -1    Unimplemented procedure
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+  @retval -9    Call requires PAL memory buffer.
+
+  @return R9    Unsigned integer denoting the processor
+                performance for the time duration since the last
+                PAL_GET_PSTATE procedure call was made. The
+                value returned is between 0 and 100, and is
+                relative to the performance index of the highest
+                available P-state.
+
+**/
+#define PAL_GET_PSTATE      262
+
+/**
+
+  Layout of PAL_PSTATE_INFO.PStateBuffer
+
+**/
+typedef struct {
+  UINT32  PerformanceIndex:7;
+  UINT32  Reserved1:5;
+  UINT32  TypicalPowerDissipation:20;
+  UINT32  TransitionLatency1;
+  UINT32  TransitionLatency2;
+  UINT32  Reserved2;
+} PAL_PSTATE_INFO_BUFFER;
+
+
+/**
+  PAL Procedure - PAL_PSTATE_INFO.
+
+  Returns information about the P-states supported by the
+  processor. It is optional by Itanium processors. The PAL procedure supports
+  the Static Registers calling convention. It could be called
+  at physical and Virtual mode.
+
+  @param Index          Index of PAL_PSTATE_INFO within the list of PAL
+                        procedures.
+  @param PStateBuffer   64-bit pointer to a 256-byte buffer
+                        aligned on an 8-byte boundary. See
+                        PAL_PSTATE_INFO_BUFFER above.
+
+  @retval 0             Call completed without error
+  @retval -1            Unimplemented procedure
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+
+  @return R9            Unsigned integer denoting the number of P-states
+                        supported. The maximum value of this field is 16.
+  @return R10           Dependency domain information
+
+**/
+#define PAL_PSTATE_INFO     44
+
+
+/**
+  PAL Procedure - PAL_SET_PSTATE.
+
+  To request a processor transition to a given P-state. It is
+  optional by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at physical
+  and Virtual mode.
+
+  @param Index        Index of PAL_SET_PSTATE within the list of PAL
+                      procedures.
+  @param PState       Unsigned integer denoting the processor
+                      P-state being requested.
+  @param ForcePState  Unsigned integer denoting whether the
+                      P-state change should be forced for the
+                      logical processor.
+
+  @retval 1           Call completed without error, but
+                      transition request was not accepted
+  @retval 0           Call completed without error
+  @retval -1          Unimplemented procedure
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+  @retval -9          Call requires PAL memory buffer.
+
+**/
+#define PAL_SET_PSTATE      263
+
+/**
+  PAL Procedure - PAL_SHUTDOWN.
+
+  Put the logical processor into a low power state which can be
+  exited only by a reset event. It is optional by Itanium processors. The PAL
+  procedure supports the Static Registers calling convention. It
+  could be called at physical mode.
+
+  @param Index            Index of PAL_SHUTDOWN within the list of PAL
+                          procedures.
+  @param NotifyPlatform   8-byte aligned physical address
+                          pointer providing details on how to
+                          optionally notify the platform that
+                          the processor is entering a shutdown
+                          state.
+
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -9              Call requires PAL memory buffer.
+
+**/
+#define PAL_SHUTDOWN        45
+
+/**
+
+  Layout of PAL_MEMORY_BUFFER.ControlWord
+
+**/
+typedef struct {
+  UINT64  Registration:1;
+  UINT64  ProbeInterrupt:1;
+  UINT64  Reserved:62;
+} PAL_MEMORY_CONTROL_WORD;
+
+/**
+  PAL Procedure - PAL_MEMORY_BUFFER.
+
+  Provides cacheable memory to PAL for exclusive use during
+  runtime. It is optional by Itanium processors. The PAL procedure supports the
+  Static Registers calling convention. It could be called at
+  physical mode.
+
+  @param Index        Index of PAL_MEMORY_BUFFER within the list of PAL
+                      procedures.
+  @param BaseAddress  Physical address of the memory buffer
+                      allocated for PAL use.
+  @param AllocSize    Unsigned integer denoting the size of the
+                      memory buffer.
+  @param ControlWord  Formatted bit vector that provides control
+                      options for this procedure. See
+                      PAL_MEMORY_CONTROL_WORD above.
+
+  @retval 1           Call has not completed a buffer relocation
+                      due to a pending interrupt
+  @retval 0           Call completed without error
+  @retval -1          Unimplemented procedure
+  @retval -2          Invalid argument
+  @retval -3          Call completed with error.
+  @retval -9          Call requires PAL memory buffer.
+
+  @return R9          Returns the minimum size of the memory buffer
+                      required if the alloc_size input argument was
+                      not large enough.
+
+**/
+#define PAL_MEMORY_BUFFER   277
+
+
+/**
+  PAL Procedure - PAL_VP_CREATE.
+
+  Initializes a new vpd for the operation of a new virtual
+  processor in the virtual environment. It is optional by Itanium processors.
+  The PAL procedure supports the Stacked Registers calling
+  convention. It could be called at Virtual mode.
+
+  @param Index            Index of PAL_VP_CREATE within the list of PAL
+                          procedures.
+  @param Vpd              64-bit host virtual pointer to the Virtual
+                          Processor Descriptor (VPD).
+  @param HostIva          64-bit host virtual pointer to the host IVT
+                          for the virtual processor
+  @param OptionalHandler  64-bit non-zero host-virtual pointer
+                          to an optional handler for
+                          virtualization intercepts.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -9              Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_CREATE       265
+
+/**
+
+  Virtual Environment Information Parameter
+
+**/
+typedef struct {
+  UINT64    Reserved1:8;
+  UINT64    Opcode:1;
+  UINT64    Reserved:53;
+} PAL_VP_ENV_INFO_RETURN;
+
+/**
+  PAL Procedure - PAL_VP_ENV_INFO.
+
+  Returns the parameters needed to enter a virtual environment.
+  It is optional by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at Virtual
+  mode.
+
+  @param Index            Index of PAL_VP_ENV_INFO within the list of PAL
+                          procedures.
+  @param Vpd              64-bit host virtual pointer to the Virtual
+                          Processor Descriptor (VPD).
+  @param HostIva          64-bit host virtual pointer to the host IVT
+                          for the virtual processor
+  @param OptionalHandler  64-bit non-zero host-virtual pointer
+                          to an optional handler for
+                          virtualization intercepts.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -9              Call requires PAL memory buffer.
+
+  @return R9              Unsigned integer denoting the number of bytes
+                          required by the PAL virtual environment buffer
+                          during PAL_VP_INIT_ENV
+  @return R10             64-bit vector of virtual environment
+                          information. See PAL_VP_ENV_INFO_RETURN.
+
+
+**/
+#define PAL_VP_ENV_INFO       266
+
+/**
+  PAL Procedure - PAL_VP_EXIT_ENV.
+
+  Allows a logical processor to exit a virtual environment.
+  It is optional by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at Virtual
+  mode.
+
+  @param Index  Index of PAL_VP_EXIT_ENV within the list of PAL
+                procedures.
+  @param Iva    Optional 64-bit host virtual pointer to the IVT
+                when this procedure is done
+
+  @retval 0     Call completed without error
+  @retval -1    Unimplemented procedure
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+  @retval -9    Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_EXIT_ENV       267
+
+
+
+/**
+  PAL Procedure - PAL_VP_INIT_ENV.
+
+  Allows a logical processor to enter a virtual environment. It
+  is optional by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at Virtual
+  mode.
+
+  @param Index          Index of PAL_VP_INIT_ENV within the list of PAL
+                        procedures.
+  @param ConfigOptions  64-bit vector of global configuration
+                        settings.
+  @param PhysicalBase   Host physical base address of a block of
+                        contiguous physical memory for the PAL
+                        virtual environment buffer 1) This
+                        memory area must be allocated by the VMM
+                        and be 4K aligned. The first logical
+                        processor to enter the environment will
+                        initialize the physical block for
+                        virtualization operations.
+  @param VirtualBase    Host virtual base address of the
+                        corresponding physical memory block for
+                        the PAL virtual environment buffer : The
+                        VMM must maintain the host virtual to host
+                        physical data and instruction translations
+                        in TRs for addresses within the allocated
+                        address space. Logical processors in this
+                        virtual environment will use this address
+                        when transitioning to virtual mode
+                        operations.
+
+  @retval 0             Call completed without error
+  @retval -1            Unimplemented procedure
+  @retval -2            Invalid argument
+  @retval -3            Call completed with error.
+  @retval -9            Call requires PAL memory buffer.
+
+  @return R9            Virtualization Service Address - VSA specifies
+                        the virtual base address of the PAL
+                        virtualization services in this virtual
+                        environment.
+
+
+**/
+#define PAL_VP_INIT_ENV       268
+
+
+/**
+  PAL Procedure - PAL_VP_REGISTER.
+
+  Register a different host IVT and/or a different optional
+  virtualization intercept handler for the virtual processor
+  specified by vpd. It is optional by Itanium processors. The PAL procedure
+  supports the Stacked Registers calling convention. It could be
+  called at Virtual mode.
+
+  @param Index            Index of PAL_VP_REGISTER within the list of PAL
+                          procedures.
+  @param Vpd              64-bit host virtual pointer to the Virtual
+                          Processor Descriptor (VPD) host_iva 64-bit host
+                          virtual pointer to the host IVT for the virtual
+                          processor
+  @param OptionalHandler  64-bit non-zero host-virtual pointer
+                          to an optional handler for
+                          virtualization intercepts.
+
+  @retval 0               Call completed without error
+  @retval -1              Unimplemented procedure
+  @retval -2              Invalid argument
+  @retval -3              Call completed with error.
+  @retval -9              Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_REGISTER       269
+
+
+/**
+  PAL Procedure - PAL_VP_RESTORE.
+
+  Restores virtual processor state for the specified vpd on the
+  logical processor. It is optional by Itanium processors. The PAL procedure
+  supports the Stacked Registers calling convention. It could be
+  called at Virtual mode.
+
+  @param Index      Index of PAL_VP_RESTORE within the list of PAL
+                    procedures.
+  @param Vpd        64-bit host virtual pointer to the Virtual
+                    Processor Descriptor (VPD) host_iva 64-bit host
+                    virtual pointer to the host IVT for the virtual
+                    processor
+  @param PalVector  Vector specifies PAL procedure
+                    implementation-specific state to be
+                    restored.
+
+  @retval 0         Call completed without error
+  @retval -1        Unimplemented procedure
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+  @retval -9        Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_RESTORE       270
+
+/**
+  PAL Procedure - PAL_VP_SAVE.
+
+  Saves virtual processor state for the specified vpd on the
+  logical processor. It is optional by Itanium processors. The PAL procedure
+  supports the Stacked Registers calling convention. It could be
+  called at Virtual mode.
+
+  @param Index      Index of PAL_VP_SAVE within the list of PAL
+                    procedures.
+  @param Vpd        64-bit host virtual pointer to the Virtual
+                    Processor Descriptor (VPD) host_iva 64-bit host
+                    virtual pointer to the host IVT for the virtual
+                    processor
+  @param PalVector  Vector specifies PAL procedure
+                    implementation-specific state to be
+                    restored.
+
+  @retval 0         Call completed without error
+  @retval -1        Unimplemented procedure
+  @retval -2        Invalid argument
+  @retval -3        Call completed with error.
+  @retval -9        Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_SAVE       271
+
+
+/**
+  PAL Procedure - PAL_VP_TERMINATE.
+
+  Terminates operation for the specified virtual processor. It
+  is optional by Itanium processors. The PAL procedure supports the Stacked
+  Registers calling convention. It could be called at Virtual
+  mode.
+
+  @param Index  Index of PAL_VP_TERMINATE within the list of PAL
+                procedures.
+  @param Vpd    64-bit host virtual pointer to the Virtual
+                Processor Descriptor (VPD)
+  @param Iva    Optional 64-bit host virtual pointer to the IVT
+                when this procedure is done.
+
+  @retval 0     Call completed without error
+  @retval -1    Unimplemented procedure
+  @retval -2    Invalid argument
+  @retval -3    Call completed with error.
+  @retval -9    Call requires PAL memory buffer.
+
+**/
+#define PAL_VP_TERMINATE       272
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Pci.h b/MdePkg/Include/IndustryStandard/Pci.h
new file mode 100644
index 000000000000..e5954dbce7a5
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Pci.h
@@ -0,0 +1,23 @@
+/** @file
+  Support for the latest PCI standard.
+
+Copyright (c) 2006 - 2014, 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 _PCI_H_
+#define _PCI_H_
+
+#include <IndustryStandard/Pci30.h>
+#include <IndustryStandard/PciExpress21.h>
+#include <IndustryStandard/PciExpress30.h>
+#include <IndustryStandard/PciCodeId.h>
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Pci22.h b/MdePkg/Include/IndustryStandard/Pci22.h
new file mode 100644
index 000000000000..97f70e1d324f
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Pci22.h
@@ -0,0 +1,886 @@
+/** @file
+  Support for PCI 2.2 standard.
+
+  This file includes the definitions in the following specifications,
+    PCI Local Bus Specification, 2.2
+    PCI-to-PCI Bridge Architecture Specification, Revision 1.2
+    PC Card Standard, 8.0
+    PCI Power Management Interface Specifiction, Revision 1.2
+
+  Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014 - 2015, Hewlett-Packard Development Company, L.P.<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 _PCI22_H_
+#define _PCI22_H_
+
+#define PCI_MAX_BUS     255
+#define PCI_MAX_DEVICE  31
+#define PCI_MAX_FUNC    7
+
+#pragma pack(1)
+
+///
+/// Common header region in PCI Configuration Space
+/// Section 6.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  UINT16  VendorId;
+  UINT16  DeviceId;
+  UINT16  Command;
+  UINT16  Status;
+  UINT8   RevisionID;
+  UINT8   ClassCode[3];
+  UINT8   CacheLineSize;
+  UINT8   LatencyTimer;
+  UINT8   HeaderType;
+  UINT8   BIST;
+} PCI_DEVICE_INDEPENDENT_REGION;
+
+///
+/// PCI Device header region in PCI Configuration Space
+/// Section 6.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  UINT32  Bar[6];
+  UINT32  CISPtr;
+  UINT16  SubsystemVendorID;
+  UINT16  SubsystemID;
+  UINT32  ExpansionRomBar;
+  UINT8   CapabilityPtr;
+  UINT8   Reserved1[3];
+  UINT32  Reserved2;
+  UINT8   InterruptLine;
+  UINT8   InterruptPin;
+  UINT8   MinGnt;
+  UINT8   MaxLat;
+} PCI_DEVICE_HEADER_TYPE_REGION;
+
+///
+/// PCI Device Configuration Space
+/// Section 6.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  PCI_DEVICE_INDEPENDENT_REGION Hdr;
+  PCI_DEVICE_HEADER_TYPE_REGION Device;
+} PCI_TYPE00;
+
+///
+/// PCI-PCI Bridge header region in PCI Configuration Space
+/// Section 3.2, PCI-PCI Bridge Architecture, Version 1.2
+///
+typedef struct {
+  UINT32  Bar[2];
+  UINT8   PrimaryBus;
+  UINT8   SecondaryBus;
+  UINT8   SubordinateBus;
+  UINT8   SecondaryLatencyTimer;
+  UINT8   IoBase;
+  UINT8   IoLimit;
+  UINT16  SecondaryStatus;
+  UINT16  MemoryBase;
+  UINT16  MemoryLimit;
+  UINT16  PrefetchableMemoryBase;
+  UINT16  PrefetchableMemoryLimit;
+  UINT32  PrefetchableBaseUpper32;
+  UINT32  PrefetchableLimitUpper32;
+  UINT16  IoBaseUpper16;
+  UINT16  IoLimitUpper16;
+  UINT8   CapabilityPtr;
+  UINT8   Reserved[3];
+  UINT32  ExpansionRomBAR;
+  UINT8   InterruptLine;
+  UINT8   InterruptPin;
+  UINT16  BridgeControl;
+} PCI_BRIDGE_CONTROL_REGISTER;
+
+///
+/// PCI-to-PCI Bridge Configuration Space
+/// Section 3.2, PCI-PCI Bridge Architecture, Version 1.2
+///
+typedef struct {
+  PCI_DEVICE_INDEPENDENT_REGION Hdr;
+  PCI_BRIDGE_CONTROL_REGISTER   Bridge;
+} PCI_TYPE01;
+
+typedef union {
+  PCI_TYPE00  Device;
+  PCI_TYPE01  Bridge;
+} PCI_TYPE_GENERIC;
+
+/// 
+/// CardBus Conroller Configuration Space, 
+/// Section 4.5.1, PC Card Standard. 8.0
+///
+typedef struct {
+  UINT32  CardBusSocketReg;     ///< Cardus Socket/ExCA Base
+  UINT8   Cap_Ptr;
+  UINT8   Reserved;
+  UINT16  SecondaryStatus;      ///< Secondary Status
+  UINT8   PciBusNumber;         ///< PCI Bus Number
+  UINT8   CardBusBusNumber;     ///< CardBus Bus Number
+  UINT8   SubordinateBusNumber; ///< Subordinate Bus Number
+  UINT8   CardBusLatencyTimer;  ///< CardBus Latency Timer
+  UINT32  MemoryBase0;          ///< Memory Base Register 0
+  UINT32  MemoryLimit0;         ///< Memory Limit Register 0
+  UINT32  MemoryBase1;
+  UINT32  MemoryLimit1;
+  UINT32  IoBase0;
+  UINT32  IoLimit0;             ///< I/O Base Register 0
+  UINT32  IoBase1;              ///< I/O Limit Register 0
+  UINT32  IoLimit1;
+  UINT8   InterruptLine;        ///< Interrupt Line
+  UINT8   InterruptPin;         ///< Interrupt Pin
+  UINT16  BridgeControl;        ///< Bridge Control
+} PCI_CARDBUS_CONTROL_REGISTER;
+
+//
+// Definitions of PCI class bytes and manipulation macros.
+//
+#define PCI_CLASS_OLD                 0x00
+#define   PCI_CLASS_OLD_OTHER           0x00
+#define   PCI_CLASS_OLD_VGA             0x01
+
+#define PCI_CLASS_MASS_STORAGE        0x01
+#define   PCI_CLASS_MASS_STORAGE_SCSI   0x00
+#define   PCI_CLASS_MASS_STORAGE_IDE    0x01
+#define   PCI_CLASS_MASS_STORAGE_FLOPPY 0x02
+#define   PCI_CLASS_MASS_STORAGE_IPI    0x03
+#define   PCI_CLASS_MASS_STORAGE_RAID   0x04
+#define   PCI_CLASS_MASS_STORAGE_OTHER  0x80
+
+#define PCI_CLASS_NETWORK             0x02
+#define   PCI_CLASS_NETWORK_ETHERNET    0x00  
+#define   PCI_CLASS_NETWORK_TOKENRING   0x01
+#define   PCI_CLASS_NETWORK_FDDI        0x02
+#define   PCI_CLASS_NETWORK_ATM         0x03
+#define   PCI_CLASS_NETWORK_ISDN        0x04
+#define   PCI_CLASS_NETWORK_OTHER       0x80
+
+#define PCI_CLASS_DISPLAY             0x03
+#define   PCI_CLASS_DISPLAY_VGA         0x00
+#define     PCI_IF_VGA_VGA                0x00
+#define     PCI_IF_VGA_8514               0x01
+#define   PCI_CLASS_DISPLAY_XGA         0x01
+#define   PCI_CLASS_DISPLAY_3D          0x02
+#define   PCI_CLASS_DISPLAY_OTHER       0x80  
+
+#define PCI_CLASS_MEDIA               0x04
+#define   PCI_CLASS_MEDIA_VIDEO         0x00
+#define   PCI_CLASS_MEDIA_AUDIO         0x01
+#define   PCI_CLASS_MEDIA_TELEPHONE     0x02
+#define   PCI_CLASS_MEDIA_OTHER         0x80
+
+#define PCI_CLASS_MEMORY_CONTROLLER   0x05
+#define   PCI_CLASS_MEMORY_RAM          0x00
+#define   PCI_CLASS_MEMORY_FLASH        0x01
+#define   PCI_CLASS_MEMORY_OTHER        0x80
+
+#define PCI_CLASS_BRIDGE              0x06
+#define   PCI_CLASS_BRIDGE_HOST         0x00
+#define   PCI_CLASS_BRIDGE_ISA          0x01
+#define   PCI_CLASS_BRIDGE_EISA         0x02
+#define   PCI_CLASS_BRIDGE_MCA          0x03
+#define   PCI_CLASS_BRIDGE_P2P          0x04
+#define     PCI_IF_BRIDGE_P2P             0x00
+#define     PCI_IF_BRIDGE_P2P_SUBTRACTIVE 0x01
+#define   PCI_CLASS_BRIDGE_PCMCIA       0x05
+#define   PCI_CLASS_BRIDGE_NUBUS        0x06
+#define   PCI_CLASS_BRIDGE_CARDBUS      0x07
+#define   PCI_CLASS_BRIDGE_RACEWAY      0x08
+#define   PCI_CLASS_BRIDGE_OTHER        0x80
+#define   PCI_CLASS_BRIDGE_ISA_PDECODE  0x80
+
+#define PCI_CLASS_SCC                 0x07  ///< Simple communications controllers 
+#define   PCI_SUBCLASS_SERIAL           0x00
+#define     PCI_IF_GENERIC_XT             0x00
+#define     PCI_IF_16450                  0x01
+#define     PCI_IF_16550                  0x02
+#define     PCI_IF_16650                  0x03
+#define     PCI_IF_16750                  0x04
+#define     PCI_IF_16850                  0x05
+#define     PCI_IF_16950                  0x06
+#define   PCI_SUBCLASS_PARALLEL         0x01
+#define     PCI_IF_PARALLEL_PORT          0x00
+#define     PCI_IF_BI_DIR_PARALLEL_PORT   0x01
+#define     PCI_IF_ECP_PARALLEL_PORT      0x02
+#define     PCI_IF_1284_CONTROLLER        0x03
+#define     PCI_IF_1284_DEVICE            0xFE
+#define   PCI_SUBCLASS_MULTIPORT_SERIAL 0x02
+#define   PCI_SUBCLASS_MODEM            0x03
+#define     PCI_IF_GENERIC_MODEM          0x00
+#define     PCI_IF_16450_MODEM            0x01
+#define     PCI_IF_16550_MODEM            0x02
+#define     PCI_IF_16650_MODEM            0x03
+#define     PCI_IF_16750_MODEM            0x04
+#define   PCI_SUBCLASS_SCC_OTHER        0x80
+
+#define PCI_CLASS_SYSTEM_PERIPHERAL   0x08
+#define   PCI_SUBCLASS_PIC              0x00
+#define     PCI_IF_8259_PIC               0x00
+#define     PCI_IF_ISA_PIC                0x01
+#define     PCI_IF_EISA_PIC               0x02
+#define     PCI_IF_APIC_CONTROLLER        0x10  ///< I/O APIC interrupt controller , 32 bye none-prefectable memory.  
+#define     PCI_IF_APIC_CONTROLLER2       0x20 
+#define   PCI_SUBCLASS_DMA              0x01
+#define     PCI_IF_8237_DMA               0x00
+#define     PCI_IF_ISA_DMA                0x01
+#define     PCI_IF_EISA_DMA               0x02
+#define   PCI_SUBCLASS_TIMER            0x02
+#define     PCI_IF_8254_TIMER             0x00
+#define     PCI_IF_ISA_TIMER              0x01
+#define     PCI_IF_EISA_TIMER             0x02
+#define   PCI_SUBCLASS_RTC              0x03
+#define     PCI_IF_GENERIC_RTC            0x00
+#define     PCI_IF_ISA_RTC                0x01
+#define   PCI_SUBCLASS_PNP_CONTROLLER   0x04    ///< HotPlug Controller
+#define   PCI_SUBCLASS_PERIPHERAL_OTHER 0x80
+
+#define PCI_CLASS_INPUT_DEVICE        0x09
+#define   PCI_SUBCLASS_KEYBOARD         0x00
+#define   PCI_SUBCLASS_PEN              0x01
+#define   PCI_SUBCLASS_MOUSE_CONTROLLER 0x02
+#define   PCI_SUBCLASS_SCAN_CONTROLLER  0x03
+#define   PCI_SUBCLASS_GAMEPORT         0x04
+#define     PCI_IF_GAMEPORT               0x00
+#define     PCI_IF_GAMEPORT1              0x10
+#define   PCI_SUBCLASS_INPUT_OTHER      0x80
+
+#define PCI_CLASS_DOCKING_STATION     0x0A
+#define   PCI_SUBCLASS_DOCKING_GENERIC  0x00
+#define   PCI_SUBCLASS_DOCKING_OTHER    0x80
+
+#define PCI_CLASS_PROCESSOR           0x0B
+#define   PCI_SUBCLASS_PROC_386         0x00
+#define   PCI_SUBCLASS_PROC_486         0x01
+#define   PCI_SUBCLASS_PROC_PENTIUM     0x02
+#define   PCI_SUBCLASS_PROC_ALPHA       0x10
+#define   PCI_SUBCLASS_PROC_POWERPC     0x20
+#define   PCI_SUBCLASS_PROC_MIPS        0x30
+#define   PCI_SUBCLASS_PROC_CO_PORC     0x40 ///< Co-Processor
+
+#define PCI_CLASS_SERIAL              0x0C
+#define   PCI_CLASS_SERIAL_FIREWIRE     0x00
+#define     PCI_IF_1394                   0x00
+#define     PCI_IF_1394_OPEN_HCI          0x10
+#define   PCI_CLASS_SERIAL_ACCESS_BUS   0x01
+#define   PCI_CLASS_SERIAL_SSA          0x02
+#define   PCI_CLASS_SERIAL_USB          0x03
+#define     PCI_IF_UHCI                   0x00
+#define     PCI_IF_OHCI                   0x10
+#define     PCI_IF_USB_OTHER              0x80
+#define     PCI_IF_USB_DEVICE             0xFE
+#define   PCI_CLASS_SERIAL_FIBRECHANNEL 0x04
+#define   PCI_CLASS_SERIAL_SMB          0x05
+
+#define PCI_CLASS_WIRELESS            0x0D
+#define   PCI_SUBCLASS_IRDA             0x00
+#define   PCI_SUBCLASS_IR               0x01
+#define   PCI_SUBCLASS_RF               0x10
+#define   PCI_SUBCLASS_WIRELESS_OTHER   0x80
+
+#define PCI_CLASS_INTELLIGENT_IO      0x0E
+
+#define PCI_CLASS_SATELLITE           0x0F
+#define   PCI_SUBCLASS_TV               0x01
+#define   PCI_SUBCLASS_AUDIO            0x02
+#define   PCI_SUBCLASS_VOICE            0x03
+#define   PCI_SUBCLASS_DATA             0x04
+
+#define PCI_SECURITY_CONTROLLER       0x10   ///< Encryption and decryption controller
+#define   PCI_SUBCLASS_NET_COMPUT       0x00
+#define   PCI_SUBCLASS_ENTERTAINMENT    0x10 
+#define   PCI_SUBCLASS_SECURITY_OTHER   0x80
+
+#define PCI_CLASS_DPIO                0x11
+#define   PCI_SUBCLASS_DPIO             0x00
+#define   PCI_SUBCLASS_DPIO_OTHER       0x80
+
+/**  
+  Macro that checks whether the Base Class code of device matched.
+
+  @param  _p      Specified device.
+  @param  c       Base Class code needs matching.
+
+  @retval TRUE    Base Class code matches the specified device.
+  @retval FALSE   Base Class code doesn't match the specified device.         
+
+**/
+#define IS_CLASS1(_p, c)              ((_p)->Hdr.ClassCode[2] == (c))
+/**  
+  Macro that checks whether the Base Class code and Sub-Class code of device matched.
+
+  @param  _p      Specified device.
+  @param  c       Base Class code needs matching.
+  @param  s       Sub-Class code needs matching.
+
+  @retval TRUE    Base Class code and Sub-Class code match the specified device.
+  @retval FALSE   Base Class code and Sub-Class code don't match the specified device.         
+
+**/
+#define IS_CLASS2(_p, c, s)           (IS_CLASS1 (_p, c) && ((_p)->Hdr.ClassCode[1] == (s)))
+/**  
+  Macro that checks whether the Base Class code, Sub-Class code and Interface code of device matched.
+
+  @param  _p      Specified device.
+  @param  c       Base Class code needs matching.
+  @param  s       Sub-Class code needs matching.
+  @param  p       Interface code needs matching.
+
+  @retval TRUE    Base Class code, Sub-Class code and Interface code match the specified device.
+  @retval FALSE   Base Class code, Sub-Class code and Interface code don't match the specified device.         
+
+**/
+#define IS_CLASS3(_p, c, s, p)        (IS_CLASS2 (_p, c, s) && ((_p)->Hdr.ClassCode[0] == (p)))
+
+/**  
+  Macro that checks whether device is a display controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a display controller.
+  @retval FALSE   Device is not a display controller.
+
+**/
+#define IS_PCI_DISPLAY(_p)            IS_CLASS1 (_p, PCI_CLASS_DISPLAY)
+/**  
+  Macro that checks whether device is a VGA-compatible controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a VGA-compatible controller.
+  @retval FALSE   Device is not a VGA-compatible controller.
+
+**/
+#define IS_PCI_VGA(_p)                IS_CLASS3 (_p, PCI_CLASS_DISPLAY, PCI_CLASS_DISPLAY_VGA, PCI_IF_VGA_VGA)
+/**  
+  Macro that checks whether device is an 8514-compatible controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is an 8514-compatible controller.
+  @retval FALSE   Device is not an 8514-compatible controller.
+
+**/
+#define IS_PCI_8514(_p)               IS_CLASS3 (_p, PCI_CLASS_DISPLAY, PCI_CLASS_DISPLAY_VGA, PCI_IF_VGA_8514)
+/**  
+  Macro that checks whether device is built before the Class Code field was defined.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is an old device.
+  @retval FALSE   Device is not an old device.
+
+**/
+#define IS_PCI_OLD(_p)                IS_CLASS1 (_p, PCI_CLASS_OLD)
+/**  
+  Macro that checks whether device is a VGA-compatible device built before the Class Code field was defined.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is an old VGA-compatible device.
+  @retval FALSE   Device is not an old VGA-compatible device.
+
+**/
+#define IS_PCI_OLD_VGA(_p)            IS_CLASS2 (_p, PCI_CLASS_OLD, PCI_CLASS_OLD_VGA)
+/**  
+  Macro that checks whether device is an IDE controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is an IDE controller.
+  @retval FALSE   Device is not an IDE controller.
+
+**/
+#define IS_PCI_IDE(_p)                IS_CLASS2 (_p, PCI_CLASS_MASS_STORAGE, PCI_CLASS_MASS_STORAGE_IDE)
+/**  
+  Macro that checks whether device is a SCSI bus controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a SCSI bus controller.
+  @retval FALSE   Device is not a SCSI bus controller.
+
+**/
+#define IS_PCI_SCSI(_p)               IS_CLASS2 (_p, PCI_CLASS_MASS_STORAGE, PCI_CLASS_MASS_STORAGE_SCSI)
+/**  
+  Macro that checks whether device is a RAID controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a RAID controller.
+  @retval FALSE   Device is not a RAID controller.
+
+**/
+#define IS_PCI_RAID(_p)               IS_CLASS2 (_p, PCI_CLASS_MASS_STORAGE, PCI_CLASS_MASS_STORAGE_RAID)
+/**  
+  Macro that checks whether device is an ISA bridge.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is an ISA bridge.
+  @retval FALSE   Device is not an ISA bridge.
+
+**/
+#define IS_PCI_LPC(_p)                IS_CLASS2 (_p, PCI_CLASS_BRIDGE, PCI_CLASS_BRIDGE_ISA)
+/**  
+  Macro that checks whether device is a PCI-to-PCI bridge.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a PCI-to-PCI bridge.
+  @retval FALSE   Device is not a PCI-to-PCI bridge.
+
+**/
+#define IS_PCI_P2P(_p)                IS_CLASS3 (_p, PCI_CLASS_BRIDGE, PCI_CLASS_BRIDGE_P2P, PCI_IF_BRIDGE_P2P)
+/**  
+  Macro that checks whether device is a Subtractive Decode PCI-to-PCI bridge.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a Subtractive Decode PCI-to-PCI bridge.
+  @retval FALSE   Device is not a Subtractive Decode PCI-to-PCI bridge.
+
+**/
+#define IS_PCI_P2P_SUB(_p)            IS_CLASS3 (_p, PCI_CLASS_BRIDGE, PCI_CLASS_BRIDGE_P2P, PCI_IF_BRIDGE_P2P_SUBTRACTIVE)
+/**  
+  Macro that checks whether device is a 16550-compatible serial controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a 16550-compatible serial controller.
+  @retval FALSE   Device is not a 16550-compatible serial controller.
+
+**/
+#define IS_PCI_16550_SERIAL(_p)       IS_CLASS3 (_p, PCI_CLASS_SCC, PCI_SUBCLASS_SERIAL, PCI_IF_16550)
+/**  
+  Macro that checks whether device is a Universal Serial Bus controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a Universal Serial Bus controller.
+  @retval FALSE   Device is not a Universal Serial Bus controller.
+
+**/
+#define IS_PCI_USB(_p)                IS_CLASS2 (_p, PCI_CLASS_SERIAL, PCI_CLASS_SERIAL_USB)
+
+//
+// the definition of Header Type 
+//
+#define HEADER_TYPE_DEVICE            0x00
+#define HEADER_TYPE_PCI_TO_PCI_BRIDGE 0x01
+#define HEADER_TYPE_CARDBUS_BRIDGE    0x02
+#define HEADER_TYPE_MULTI_FUNCTION    0x80
+//
+// Mask of Header type
+//
+#define HEADER_LAYOUT_CODE            0x7f
+/**  
+  Macro that checks whether device is a PCI-PCI bridge.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a PCI-PCI bridge.
+  @retval FALSE   Device is not a PCI-PCI bridge.
+
+**/
+#define IS_PCI_BRIDGE(_p)             (((_p)->Hdr.HeaderType & HEADER_LAYOUT_CODE) == (HEADER_TYPE_PCI_TO_PCI_BRIDGE))
+/**  
+  Macro that checks whether device is a CardBus bridge.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a CardBus bridge.
+  @retval FALSE   Device is not a CardBus bridge.
+
+**/
+#define IS_CARDBUS_BRIDGE(_p)         (((_p)->Hdr.HeaderType & HEADER_LAYOUT_CODE) == (HEADER_TYPE_CARDBUS_BRIDGE))
+/**  
+  Macro that checks whether device is a multiple functions device.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a multiple functions device.
+  @retval FALSE   Device is not a multiple functions device.
+
+**/
+#define IS_PCI_MULTI_FUNC(_p)         ((_p)->Hdr.HeaderType & HEADER_TYPE_MULTI_FUNCTION)
+
+///
+/// Rom Base Address in Bridge, defined in PCI-to-PCI Bridge Architecure Specification,
+///
+#define PCI_BRIDGE_ROMBAR             0x38
+
+#define PCI_MAX_BAR                   0x0006
+#define PCI_MAX_CONFIG_OFFSET         0x0100
+
+#define PCI_VENDOR_ID_OFFSET                        0x00
+#define PCI_DEVICE_ID_OFFSET                        0x02
+#define PCI_COMMAND_OFFSET                          0x04
+#define PCI_PRIMARY_STATUS_OFFSET                   0x06
+#define PCI_REVISION_ID_OFFSET                      0x08
+#define PCI_CLASSCODE_OFFSET                        0x09
+#define PCI_CACHELINE_SIZE_OFFSET                   0x0C
+#define PCI_LATENCY_TIMER_OFFSET                    0x0D
+#define PCI_HEADER_TYPE_OFFSET                      0x0E
+#define PCI_BIST_OFFSET                             0x0F
+#define PCI_BASE_ADDRESSREG_OFFSET                  0x10
+#define PCI_CARDBUS_CIS_OFFSET                      0x28
+#define PCI_SVID_OFFSET                             0x2C ///< SubSystem Vendor id
+#define PCI_SUBSYSTEM_VENDOR_ID_OFFSET              0x2C
+#define PCI_SID_OFFSET                              0x2E ///< SubSystem ID
+#define PCI_SUBSYSTEM_ID_OFFSET                     0x2E
+#define PCI_EXPANSION_ROM_BASE                      0x30
+#define PCI_CAPBILITY_POINTER_OFFSET                0x34
+#define PCI_INT_LINE_OFFSET                         0x3C ///< Interrupt Line Register
+#define PCI_INT_PIN_OFFSET                          0x3D ///< Interrupt Pin Register
+#define PCI_MAXGNT_OFFSET                           0x3E ///< Max Grant Register
+#define PCI_MAXLAT_OFFSET                           0x3F ///< Max Latency Register
+
+//
+// defined in PCI-to-PCI Bridge Architecture Specification
+//
+#define PCI_BRIDGE_PRIMARY_BUS_REGISTER_OFFSET      0x18   
+#define PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET    0x19   
+#define PCI_BRIDGE_SUBORDINATE_BUS_REGISTER_OFFSET  0x1a   
+#define PCI_BRIDGE_SECONDARY_LATENCY_TIMER_OFFSET   0x1b
+#define PCI_BRIDGE_STATUS_REGISTER_OFFSET           0x1E   
+#define PCI_BRIDGE_CONTROL_REGISTER_OFFSET          0x3E   
+
+///
+/// Interrupt Line "Unknown" or "No connection" value defined for x86 based system
+///
+#define PCI_INT_LINE_UNKNOWN                        0xFF               
+
+///
+/// PCI Access Data Format
+///
+typedef union {
+  struct {
+    UINT32  Reg : 8;
+    UINT32  Func : 3;
+    UINT32  Dev : 5;
+    UINT32  Bus : 8;
+    UINT32  Reserved : 7;
+    UINT32  Enable : 1;
+  } Bits;
+  UINT32  Uint32;
+} PCI_CONFIG_ACCESS_CF8;
+
+#pragma pack()
+
+#define EFI_PCI_COMMAND_IO_SPACE                        BIT0   ///< 0x0001
+#define EFI_PCI_COMMAND_MEMORY_SPACE                    BIT1   ///< 0x0002
+#define EFI_PCI_COMMAND_BUS_MASTER                      BIT2   ///< 0x0004
+#define EFI_PCI_COMMAND_SPECIAL_CYCLE                   BIT3   ///< 0x0008
+#define EFI_PCI_COMMAND_MEMORY_WRITE_AND_INVALIDATE     BIT4   ///< 0x0010
+#define EFI_PCI_COMMAND_VGA_PALETTE_SNOOP               BIT5   ///< 0x0020
+#define EFI_PCI_COMMAND_PARITY_ERROR_RESPOND            BIT6   ///< 0x0040
+#define EFI_PCI_COMMAND_STEPPING_CONTROL                BIT7   ///< 0x0080
+#define EFI_PCI_COMMAND_SERR                            BIT8   ///< 0x0100
+#define EFI_PCI_COMMAND_FAST_BACK_TO_BACK               BIT9   ///< 0x0200
+
+//
+// defined in PCI-to-PCI Bridge Architecture Specification
+//
+#define EFI_PCI_BRIDGE_CONTROL_PARITY_ERROR_RESPONSE    BIT0   ///< 0x0001
+#define EFI_PCI_BRIDGE_CONTROL_SERR                     BIT1   ///< 0x0002
+#define EFI_PCI_BRIDGE_CONTROL_ISA                      BIT2   ///< 0x0004
+#define EFI_PCI_BRIDGE_CONTROL_VGA                      BIT3   ///< 0x0008
+#define EFI_PCI_BRIDGE_CONTROL_VGA_16                   BIT4   ///< 0x0010
+#define EFI_PCI_BRIDGE_CONTROL_MASTER_ABORT             BIT5   ///< 0x0020
+#define EFI_PCI_BRIDGE_CONTROL_RESET_SECONDARY_BUS      BIT6   ///< 0x0040
+#define EFI_PCI_BRIDGE_CONTROL_FAST_BACK_TO_BACK        BIT7   ///< 0x0080
+#define EFI_PCI_BRIDGE_CONTROL_PRIMARY_DISCARD_TIMER    BIT8   ///< 0x0100
+#define EFI_PCI_BRIDGE_CONTROL_SECONDARY_DISCARD_TIMER  BIT9   ///< 0x0200
+#define EFI_PCI_BRIDGE_CONTROL_TIMER_STATUS             BIT10  ///< 0x0400
+#define EFI_PCI_BRIDGE_CONTROL_DISCARD_TIMER_SERR       BIT11  ///< 0x0800
+
+//
+// Following are the PCI-CARDBUS bridge control bit, defined in PC Card Standard
+//
+#define EFI_PCI_BRIDGE_CONTROL_IREQINT_ENABLE           BIT7   ///< 0x0080
+#define EFI_PCI_BRIDGE_CONTROL_RANGE0_MEMORY_TYPE       BIT8   ///< 0x0100
+#define EFI_PCI_BRIDGE_CONTROL_RANGE1_MEMORY_TYPE       BIT9   ///< 0x0200
+#define EFI_PCI_BRIDGE_CONTROL_WRITE_POSTING_ENABLE     BIT10  ///< 0x0400
+
+//
+// Following are the PCI status control bit
+//
+#define EFI_PCI_STATUS_CAPABILITY                       BIT4   ///< 0x0010
+#define EFI_PCI_STATUS_66MZ_CAPABLE                     BIT5   ///< 0x0020
+#define EFI_PCI_FAST_BACK_TO_BACK_CAPABLE               BIT7   ///< 0x0080
+#define EFI_PCI_MASTER_DATA_PARITY_ERROR                BIT8   ///< 0x0100
+
+///
+/// defined in PC Card Standard
+///
+#define EFI_PCI_CARDBUS_BRIDGE_CAPABILITY_PTR 0x14
+
+#pragma pack(1)
+//
+// PCI Capability List IDs and records
+//
+#define EFI_PCI_CAPABILITY_ID_PMI     0x01
+#define EFI_PCI_CAPABILITY_ID_AGP     0x02
+#define EFI_PCI_CAPABILITY_ID_VPD     0x03
+#define EFI_PCI_CAPABILITY_ID_SLOTID  0x04
+#define EFI_PCI_CAPABILITY_ID_MSI     0x05
+#define EFI_PCI_CAPABILITY_ID_HOTPLUG 0x06
+#define EFI_PCI_CAPABILITY_ID_SHPC    0x0C
+
+///
+/// Capabilities List Header
+/// Section 6.7, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  UINT8 CapabilityID;
+  UINT8 NextItemPtr;
+} EFI_PCI_CAPABILITY_HDR;
+
+///
+/// PMC - Power Management Capabilities
+/// Section 3.2.3, PCI Power Management Interface Specifiction, Revision 1.2
+///
+typedef union {
+  struct {
+    UINT16 Version : 3;
+    UINT16 PmeClock : 1;
+    UINT16 Reserved : 1;
+    UINT16 DeviceSpecificInitialization : 1;
+    UINT16 AuxCurrent : 3;
+    UINT16 D1Support : 1;
+    UINT16 D2Support : 1;
+    UINT16 PmeSupport : 5;
+  } Bits;
+  UINT16 Data;
+} EFI_PCI_PMC;
+
+#define EFI_PCI_PMC_D3_COLD_MASK    (BIT15)
+
+///
+/// PMCSR - Power Management Control/Status
+/// Section 3.2.4, PCI Power Management Interface Specifiction, Revision 1.2
+///
+typedef union {
+  struct {
+    UINT16 PowerState : 2;
+    UINT16 ReservedForPciExpress : 1;
+    UINT16 NoSoftReset : 1;
+    UINT16 Reserved : 4;
+    UINT16 PmeEnable : 1;
+    UINT16 DataSelect : 4;
+    UINT16 DataScale : 2;
+    UINT16 PmeStatus : 1;
+  } Bits;
+  UINT16 Data;
+} EFI_PCI_PMCSR;
+
+#define PCI_POWER_STATE_D0     0
+#define PCI_POWER_STATE_D1     1
+#define PCI_POWER_STATE_D2     2
+#define PCI_POWER_STATE_D3_HOT 3
+
+///
+/// PMCSR_BSE - PMCSR PCI-to-PCI Bridge Support Extensions
+/// Section 3.2.5, PCI Power Management Interface Specifiction, Revision 1.2
+///
+typedef union {
+  struct {
+    UINT8 Reserved : 6;
+    UINT8 B2B3 : 1;
+    UINT8 BusPowerClockControl : 1;
+  } Bits;
+  UINT8   Uint8;
+} EFI_PCI_PMCSR_BSE;
+
+///
+/// Power Management Register Block Definition
+/// Section 3.2, PCI Power Management Interface Specifiction, Revision 1.2
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  EFI_PCI_PMC             PMC;
+  EFI_PCI_PMCSR           PMCSR;
+  EFI_PCI_PMCSR_BSE       BridgeExtention;
+  UINT8                   Data;
+} EFI_PCI_CAPABILITY_PMI;
+
+///
+/// A.G.P Capability
+/// Section 6.1.4, Accelerated Graphics Port Interface Specification, Revision 1.0
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT8                   Rev;
+  UINT8                   Reserved;
+  UINT32                  Status;
+  UINT32                  Command;
+} EFI_PCI_CAPABILITY_AGP;
+
+///
+/// VPD Capability Structure
+/// Appendix I, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT16                  AddrReg;
+  UINT32                  DataReg;
+} EFI_PCI_CAPABILITY_VPD;
+
+///
+/// Slot Numbering Capabilities Register
+/// Section 3.2.6, PCI-to-PCI Bridge Architeture Specification, Revision 1.2
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT8                   ExpnsSlotReg;
+  UINT8                   ChassisNo;
+} EFI_PCI_CAPABILITY_SLOTID;
+
+///
+/// Message Capability Structure for 32-bit Message Address
+/// Section 6.8.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT16                  MsgCtrlReg;
+  UINT32                  MsgAddrReg;
+  UINT16                  MsgDataReg;
+} EFI_PCI_CAPABILITY_MSI32;
+
+///
+/// Message Capability Structure for 64-bit Message Address
+/// Section 6.8.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT16                  MsgCtrlReg;
+  UINT32                  MsgAddrRegLsdw;
+  UINT32                  MsgAddrRegMsdw;
+  UINT16                  MsgDataReg;
+} EFI_PCI_CAPABILITY_MSI64;
+
+///
+/// Capability EFI_PCI_CAPABILITY_ID_HOTPLUG, 
+/// CompactPCI Hot Swap Specification PICMG 2.1, R1.0
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  ///
+  /// not finished - fields need to go here
+  ///
+} EFI_PCI_CAPABILITY_HOTPLUG;
+
+///
+/// Below macros (till PCI_BAR_NOCHANGE) were used by EfiIncompatiblePciDeviceSupport Protocol.
+///
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+///
+/// [ATTENTION] These macros are deprecated because they don't match Spec or not defined in Spec.
+///
+#define DEVICE_ID_NOCARE    0xFFFF                 ///< Deprecated. Value doesn't match Spec.
+#define PCI_BAR_OLD_ALIGN   0xFFFFFFFFFFFFFFFFULL  ///< Deprecated. Value isn't defined in Spec.
+#define PCI_BAR_EVEN_ALIGN  0xFFFFFFFFFFFFFFFEULL  ///< Deprecated. Value isn't defined in Spec.
+#define PCI_BAR_SQUAD_ALIGN 0xFFFFFFFFFFFFFFFDULL  ///< Deprecated. Value isn't defined in Spec.
+#define PCI_BAR_DQUAD_ALIGN 0xFFFFFFFFFFFFFFFCULL  ///< Deprecated. Value isn't defined in Spec.
+#define PCI_BAR_ALL         0xFF                   ///< Deprecated. Value doesn't match Spec.
+#define PCI_ACPI_UNUSED     0                      ///< Deprecated. Macro name is too general.
+#define PCI_BAR_NOCHANGE    0                      ///< Deprecated. Macro name is too general.
+
+#endif
+
+#define PCI_BAR_IDX0        0x00
+#define PCI_BAR_IDX1        0x01
+#define PCI_BAR_IDX2        0x02
+#define PCI_BAR_IDX3        0x03
+#define PCI_BAR_IDX4        0x04
+#define PCI_BAR_IDX5        0x05
+
+///
+/// EFI PCI Option ROM definitions
+/// 
+#define EFI_ROOT_BRIDGE_LIST                            'eprb'  
+#define EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE       0x0EF1  ///< defined in UEFI Spec.
+
+#define PCI_EXPANSION_ROM_HEADER_SIGNATURE              0xaa55
+#define PCI_DATA_STRUCTURE_SIGNATURE                    SIGNATURE_32 ('P', 'C', 'I', 'R')
+#define PCI_CODE_TYPE_PCAT_IMAGE                        0x00
+#define EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED         0x0001  ///< defined in UEFI spec.
+
+///
+/// Standard PCI Expansion ROM Header
+/// Section 13.4.2, Unified Extensible Firmware Interface Specification, Version 2.1
+///
+typedef struct {
+  UINT16  Signature;    ///< 0xaa55
+  UINT8   Reserved[0x16];
+  UINT16  PcirOffset;
+} PCI_EXPANSION_ROM_HEADER;
+
+///
+/// Legacy ROM Header Extensions
+/// Section 6.3.3.1, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  UINT16  Signature;    ///< 0xaa55
+  UINT8   Size512;
+  UINT8   InitEntryPoint[3];
+  UINT8   Reserved[0x12];
+  UINT16  PcirOffset;
+} EFI_LEGACY_EXPANSION_ROM_HEADER;
+
+///
+/// PCI Data Structure Format
+/// Section 6.3.1.2, PCI Local Bus Specification, 2.2
+///
+typedef struct {
+  UINT32  Signature;    ///< "PCIR"
+  UINT16  VendorId;
+  UINT16  DeviceId;
+  UINT16  Reserved0;
+  UINT16  Length;
+  UINT8   Revision;
+  UINT8   ClassCode[3];
+  UINT16  ImageLength;
+  UINT16  CodeRevision;
+  UINT8   CodeType;
+  UINT8   Indicator;
+  UINT16  Reserved1;
+} PCI_DATA_STRUCTURE;
+
+///
+/// EFI PCI Expansion ROM Header
+/// Section 13.4.2, Unified Extensible Firmware Interface Specification, Version 2.1
+///
+typedef struct {
+  UINT16  Signature;    ///< 0xaa55
+  UINT16  InitializationSize;
+  UINT32  EfiSignature; ///< 0x0EF1
+  UINT16  EfiSubsystem;
+  UINT16  EfiMachineType;
+  UINT16  CompressionType;
+  UINT8   Reserved[8];
+  UINT16  EfiImageHeaderOffset;
+  UINT16  PcirOffset;
+} EFI_PCI_EXPANSION_ROM_HEADER;
+
+typedef union {
+  UINT8                           *Raw;
+  PCI_EXPANSION_ROM_HEADER        *Generic;
+  EFI_PCI_EXPANSION_ROM_HEADER    *Efi;
+  EFI_LEGACY_EXPANSION_ROM_HEADER *PcAt;
+} EFI_PCI_ROM_HEADER;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Pci23.h b/MdePkg/Include/IndustryStandard/Pci23.h
new file mode 100644
index 000000000000..b4698ac2fbfa
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Pci23.h
@@ -0,0 +1,123 @@
+/** @file
+  Support for PCI 2.3 standard.
+
+  Copyright (c) 2006 - 2012, 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 _PCI23_H_
+#define _PCI23_H_
+
+#include <IndustryStandard/Pci22.h>
+
+///
+/// PCI_CLASS_MASS_STORAGE, Base Class 01h.
+///
+///@{
+#define PCI_CLASS_MASS_STORAGE_ATA       0x05
+#define   PCI_IF_MASS_STORAGE_SINGLE_DMA   0x20
+#define   PCI_IF_MASS_STORAGE_CHAINED_DMA  0x30
+///@}
+
+///
+/// PCI_CLASS_NETWORK, Base Class 02h.
+///
+///@{
+#define PCI_CLASS_NETWORK_WORLDFIP              0x05
+#define PCI_CLASS_NETWORK_PICMG_MULTI_COMPUTING 0x06
+///@}
+
+///
+/// PCI_CLASS_BRIDGE, Base Class 06h.
+///
+///@{
+#define PCI_CLASS_BRIDGE_SEMI_TRANSPARENT_P2P        0x09
+#define   PCI_IF_BRIDGE_SEMI_TRANSPARENT_P2P_PRIMARY   0x40
+#define   PCI_IF_BRIDGE_SEMI_TRANSPARENT_P2P_SECONDARY 0x80
+#define PCI_CLASS_BRIDGE_INFINIBAND_TO_PCI           0x0A
+///@}
+
+///
+/// PCI_CLASS_SCC, Base Class 07h.
+///
+///@{
+#define PCI_SUBCLASS_GPIB          0x04
+#define PCI_SUBCLASS_SMART_CARD    0x05
+///@}
+
+///
+/// PCI_CLASS_SERIAL, Base Class 0Ch.
+///
+///@{
+#define   PCI_IF_EHCI                      0x20
+#define PCI_CLASS_SERIAL_IB              0x06
+#define PCI_CLASS_SERIAL_IPMI            0x07
+#define   PCI_IF_IPMI_SMIC                 0x00
+#define   PCI_IF_IPMI_KCS                  0x01 ///< Keyboard Controller Style
+#define   PCI_IF_IPMI_BT                   0x02 ///< Block Transfer
+#define PCI_CLASS_SERIAL_SERCOS          0x08
+#define PCI_CLASS_SERIAL_CANBUS          0x09
+///@}
+
+///
+/// PCI_CLASS_WIRELESS, Base Class 0Dh.
+///
+///@{
+#define PCI_SUBCLASS_BLUETOOTH    0x11
+#define PCI_SUBCLASS_BROADBAND    0x12
+///@}
+
+///
+/// PCI_CLASS_DPIO, Base Class 11h.
+///
+///@{
+#define PCI_SUBCLASS_PERFORMANCE_COUNTERS          0x01
+#define PCI_SUBCLASS_COMMUNICATION_SYNCHRONIZATION 0x10
+#define PCI_SUBCLASS_MANAGEMENT_CARD               0x20
+///@}
+
+///
+/// defined in PCI Express Spec.
+///
+#define PCI_EXP_MAX_CONFIG_OFFSET     0x1000
+
+///
+/// PCI Capability List IDs and records.
+///
+#define EFI_PCI_CAPABILITY_ID_PCIX    0x07
+
+#pragma pack(1)
+///
+/// PCI-X Capabilities List, 
+/// Section 7.2, PCI-X Addendum to the PCI Local Bus Specification, Revision 1.0b.
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT16                  CommandReg;
+  UINT32                  StatusReg;
+} EFI_PCI_CAPABILITY_PCIX;
+
+///
+/// PCI-X Bridge Capabilities List, 
+/// Section 8.6.2, PCI-X Addendum to the PCI Local Bus Specification, Revision 1.0b.
+///
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR  Hdr;
+  UINT16                  SecStatusReg;
+  UINT32                  StatusReg;
+  UINT32                  SplitTransCtrlRegUp;
+  UINT32                  SplitTransCtrlRegDn;
+} EFI_PCI_CAPABILITY_PCIX_BRDG;
+
+#pragma pack()
+
+#define PCI_CODE_TYPE_EFI_IMAGE       0x03
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Pci30.h b/MdePkg/Include/IndustryStandard/Pci30.h
new file mode 100644
index 000000000000..57bd5a4179d2
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Pci30.h
@@ -0,0 +1,79 @@
+/** @file
+  Support for PCI 3.0 standard.
+
+  Copyright (c) 2006 - 2012, 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 __PCI30_H__
+#define __PCI30_H__
+
+
+#include <IndustryStandard/Pci23.h>
+
+///
+/// PCI_CLASS_MASS_STORAGE, Base Class 01h.
+///
+///@{
+#define PCI_CLASS_MASS_STORAGE_SATADPA   0x06
+#define   PCI_IF_MASS_STORAGE_SATA         0x00
+#define   PCI_IF_MASS_STORAGE_AHCI         0x01
+///@}
+
+///
+/// PCI_CLASS_WIRELESS, Base Class 0Dh.
+///
+///@{
+#define PCI_SUBCLASS_ETHERNET_80211A    0x20
+#define PCI_SUBCLASS_ETHERNET_80211B    0x21
+///@}
+
+/**
+  Macro that checks whether device is a SATA controller.
+
+  @param  _p      Specified device.
+
+  @retval TRUE    Device is a SATA controller.
+  @retval FALSE   Device is not a SATA controller.
+
+**/
+#define IS_PCI_SATADPA(_p) IS_CLASS2 (_p, PCI_CLASS_MASS_STORAGE, PCI_CLASS_MASS_STORAGE_SATADPA)
+
+///
+/// PCI Capability List IDs and records
+///
+#define EFI_PCI_CAPABILITY_ID_PCIEXP  0x10
+
+#pragma pack(1)
+
+///
+/// PCI Data Structure Format
+/// Section 5.1.2, PCI Firmware Specification, Revision 3.0
+///
+typedef struct {
+  UINT32  Signature;    ///< "PCIR"
+  UINT16  VendorId;
+  UINT16  DeviceId;
+  UINT16  DeviceListOffset;
+  UINT16  Length;
+  UINT8   Revision;
+  UINT8   ClassCode[3];
+  UINT16  ImageLength;
+  UINT16  CodeRevision;
+  UINT8   CodeType;
+  UINT8   Indicator;
+  UINT16  MaxRuntimeImageLength;
+  UINT16  ConfigUtilityCodeHeaderOffset;
+  UINT16  DMTFCLPEntryPointOffset;
+} PCI_3_0_DATA_STRUCTURE;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/PciCodeId.h b/MdePkg/Include/IndustryStandard/PciCodeId.h
new file mode 100644
index 000000000000..31b6b8ec5d3a
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/PciCodeId.h
@@ -0,0 +1,100 @@
+/** @file
+  The file lists the PCI class codes only defined in PCI code and ID assignment specification
+  revision 1.3.
+
+  Copyright (c) 2012, 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 __PCI_CODE_ID_H__
+#define __PCI_CODE_ID_H__
+
+
+///
+/// PCI_CLASS_MASS_STORAGE, Base Class 01h.
+///
+///@{
+#define   PCI_IF_MASS_STORAGE_SCSI_VENDOR_SPECIFIC          0x00
+#define   PCI_IF_MASS_STORAGE_SCSI_DEVICE_PQI               0x11
+#define   PCI_IF_MASS_STORAGE_SCSI_CONTROLLER_PQI           0x12
+#define   PCI_IF_MASS_STORAGE_SCSI_DEVICE_CONTROLLER_PQI    0x13
+#define   PCI_IF_MASS_STORAGE_SCSI_DEVICE_NVM_EXPRESS       0x21
+#define   PCI_IF_MASS_STORAGE_SATA_SERIAL_BUS               0x02
+#define PCI_CLASS_MASS_STORAGE_SAS                        0x07
+#define   PCI_IF_MASS_STORAGE_SAS                           0x00
+#define   PCI_IF_MASS_STORAGE_SAS_SERIAL_BUS                0x01
+#define PCI_CLASS_MASS_STORAGE_SOLID_STATE                0x08
+#define   PCI_IF_MASS_STORAGE_SOLID_STATE                   0x00
+#define   PCI_IF_MASS_STORAGE_SOLID_STATE_NVMHCI            0x01
+#define   PCI_IF_MASS_STORAGE_SOLID_STATE_ENTERPRISE_NVMHCI 0x02
+///@}
+
+///
+/// PCI_CLASS_NETWORK, Base Class 02h.
+///
+///@{
+#define PCI_CLASS_NETWORK_INFINIBAND   0x07
+///@}
+
+///
+/// PCI_CLASS_MEDIA, Base Class 04h.
+///
+///@{
+#define PCI_CLASS_MEDIA_MIXED_MODE   0x03
+///@}
+
+///
+/// PCI_CLASS_BRIDGE, Base Class 06h.
+///
+///@{
+#define PCI_CLASS_BRIDGE_ADVANCED_SWITCHING_TO_PCI      0x0B
+#define   PCI_IF_BRIDGE_ADVANCED_SWITCHING_TO_PCI_CUSTOM  0x00
+#define   PCI_IF_BRIDGE_ADVANCED_SWITCHING_TO_PCI_ASI_SIG 0x01
+///@}
+
+///
+/// PCI_CLASS_SYSTEM_PERIPHERAL, Base Class 08h.
+///
+///@{
+#define   PCI_IF_HPET                 0x03
+#define PCI_SUBCLASS_SD_HOST_CONTROLLER 0x05
+#define PCI_SUBCLASS_IOMMU              0x06
+///@}
+
+///
+/// PCI_CLASS_PROCESSOR, Base Class 0Bh.
+///
+///@{
+#define PCI_SUBCLASS_PROC_OTHER 0x80
+///@}
+
+///
+/// PCI_CLASS_SERIAL, Base Class 0Ch.
+///
+///@{
+#define   PCI_IF_XHCI             0x30
+#define PCI_CLASS_SERIAL_OTHER  0x80
+///@}
+
+///
+/// PCI_CLASS_SATELLITE, Base Class 0Fh.
+///
+///@{
+#define PCI_SUBCLASS_SATELLITE_OTHER 0x80
+///@}
+
+///
+/// PCI_CLASS_PROCESSING_ACCELERATOR, Base Class 12h.
+///
+///@{
+#define PCI_CLASS_PROCESSING_ACCELERATOR  0x12
+///@}
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/PciExpress21.h b/MdePkg/Include/IndustryStandard/PciExpress21.h
new file mode 100644
index 000000000000..61ec5542072f
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/PciExpress21.h
@@ -0,0 +1,651 @@
+/** @file
+  Support for the latest PCI standard.
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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 _PCIEXPRESS21_H_
+#define _PCIEXPRESS21_H_
+
+#include <IndustryStandard/Pci30.h>
+
+#pragma pack(1)
+///
+/// PCI Express Capability Structure
+///
+typedef union {
+  struct {
+    UINT16 Version : 4;
+    UINT16 DevicePortType : 4;
+    UINT16 SlotImplemented : 1;
+    UINT16 InterruptMessageNumber : 5;
+    UINT16 Undefined : 1;
+    UINT16 Reserved : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_CAPABILITY;
+
+#define PCIE_DEVICE_PORT_TYPE_PCIE_ENDPOINT                    0
+#define PCIE_DEVICE_PORT_TYPE_LEGACY_PCIE_ENDPOINT             1
+#define PCIE_DEVICE_PORT_TYPE_ROOT_PORT                        4
+#define PCIE_DEVICE_PORT_TYPE_UPSTREAM_PORT                    5
+#define PCIE_DEVICE_PORT_TYPE_DOWNSTREAM_PORT                  6
+#define PCIE_DEVICE_PORT_TYPE_PCIE_TO_PCI_BRIDGE               7
+#define PCIE_DEVICE_PORT_TYPE_PCI_TO_PCIE_BRIDGE               8
+#define PCIE_DEVICE_PORT_TYPE_ROOT_COMPLEX_INTEGRATED_ENDPOINT 9
+#define PCIE_DEVICE_PORT_TYPE_ROOT_COMPLEX_EVENT_COLLECTOR     10
+
+typedef union {
+  struct {
+    UINT32 MaxPayloadSize : 3;
+    UINT32 PhantomFunctions : 2;
+    UINT32 ExtendedTagField : 1;
+    UINT32 EndpointL0sAcceptableLatency : 3;
+    UINT32 EndpointL1AcceptableLatency : 3;
+    UINT32 Undefined : 3;
+    UINT32 RoleBasedErrorReporting : 1;
+    UINT32 Reserved : 2;
+    UINT32 CapturedSlotPowerLimitValue : 8;
+    UINT32 CapturedSlotPowerLimitScale : 2;
+    UINT32 FunctionLevelReset : 1;
+    UINT32 Reserved2 : 3;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_DEVICE_CAPABILITY;
+
+typedef union {
+  struct {
+    UINT16 CorrectableError : 1;
+    UINT16 NonFatalError : 1;
+    UINT16 FatalError : 1;
+    UINT16 UnsupportedRequest : 1;
+    UINT16 RelaxedOrdering : 1;
+    UINT16 MaxPayloadSize : 3;
+    UINT16 ExtendedTagField : 1;
+    UINT16 PhantomFunctions : 1;
+    UINT16 AuxPower : 1;
+    UINT16 NoSnoop : 1;
+    UINT16 MaxReadRequestSize : 3;
+    UINT16 BridgeConfigurationRetryOrFunctionLevelReset : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_DEVICE_CONTROL;
+
+typedef union {
+  struct {
+    UINT16 CorrectableError : 1;
+    UINT16 NonFatalError : 1;
+    UINT16 FatalError : 1;
+    UINT16 UnsupportedRequest : 1;
+    UINT16 AuxPower : 1;
+    UINT16 TransactionsPending : 1;
+    UINT16 Reserved : 10;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_DEVICE_STATUS;
+
+typedef union {
+  struct {
+    UINT32 MaxLinkSpeed : 4;
+    UINT32 MaxLinkWidth : 6;
+    UINT32 Aspm : 2;
+    UINT32 L0sExitLatency : 3;
+    UINT32 L1ExitLatency : 3;
+    UINT32 ClockPowerManagement : 1;
+    UINT32 SurpriseDownError : 1;
+    UINT32 DataLinkLayerLinkActive : 1;
+    UINT32 LinkBandwidthNotification : 1;
+    UINT32 AspmOptionalityCompliance : 1;
+    UINT32 Reserved : 1;
+    UINT32 PortNumber : 8;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_LINK_CAPABILITY;
+
+#define PCIE_LINK_ASPM_L0S BIT0
+#define PCIE_LINK_ASPM_L1  BIT1
+
+typedef union {
+  struct {
+    UINT16 AspmControl : 2;
+    UINT16 Reserved : 1;
+    UINT16 ReadCompletionBoundary : 1;
+    UINT16 LinkDisable : 1;
+    UINT16 RetrainLink : 1;
+    UINT16 CommonClockConfiguration : 1;
+    UINT16 ExtendedSynch : 1;
+    UINT16 ClockPowerManagement : 1;
+    UINT16 HardwareAutonomousWidthDisable : 1;
+    UINT16 LinkBandwidthManagementInterrupt : 1;
+    UINT16 LinkAutonomousBandwidthInterrupt : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_LINK_CONTROL;
+
+typedef union {
+  struct {
+    UINT16 CurrentLinkSpeed : 4;
+    UINT16 NegotiatedLinkWidth : 6;
+    UINT16 Undefined : 1;
+    UINT16 LinkTraining : 1;
+    UINT16 SlotClockConfiguration : 1;
+    UINT16 DataLinkLayerLinkActive : 1;
+    UINT16 LinkBandwidthManagement : 1;
+    UINT16 LinkAutonomousBandwidth : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_LINK_STATUS;
+
+typedef union {
+  struct {
+    UINT32 AttentionButton : 1;
+    UINT32 PowerController : 1;
+    UINT32 MrlSensor : 1;
+    UINT32 AttentionIndicator : 1;
+    UINT32 PowerIndicator : 1;
+    UINT32 HotPlugSurprise : 1;
+    UINT32 HotPlugCapable : 1;
+    UINT32 SlotPowerLimitValue : 8;
+    UINT32 SlotPowerLimitScale : 2;
+    UINT32 ElectromechanicalInterlock : 1;
+    UINT32 NoCommandCompleted : 1;
+    UINT32 PhysicalSlotNumber : 13;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_SLOT_CAPABILITY;
+
+typedef union {
+  struct {
+    UINT32 AttentionButtonPressed : 1;
+    UINT32 PowerFaultDetected : 1;
+    UINT32 MrlSensorChanged : 1;
+    UINT32 PresenceDetectChanged : 1;
+    UINT32 CommandCompletedInterrupt : 1;
+    UINT32 HotPlugInterrupt : 1;
+    UINT32 AttentionIndicator : 2;
+    UINT32 PowerIndicator : 2;
+    UINT32 PowerController : 1;
+    UINT32 ElectromechanicalInterlock : 1;
+    UINT32 DataLinkLayerStateChanged : 1;
+    UINT32 Reserved : 3;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_SLOT_CONTROL;
+
+typedef union {
+  struct {
+    UINT16 AttentionButtonPressed : 1;
+    UINT16 PowerFaultDetected : 1;
+    UINT16 MrlSensorChanged : 1;
+    UINT16 PresenceDetectChanged : 1;
+    UINT16 CommandCompleted : 1;
+    UINT16 MrlSensor : 1;
+    UINT16 PresenceDetect : 1;
+    UINT16 ElectromechanicalInterlock : 1;
+    UINT16 DataLinkLayerStateChanged : 1;
+    UINT16 Reserved : 7;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_SLOT_STATUS;
+
+typedef union {
+  struct {
+    UINT16 SystemErrorOnCorrectableError : 1;
+    UINT16 SystemErrorOnNonFatalError : 1;
+    UINT16 SystemErrorOnFatalError : 1;
+    UINT16 PmeInterrupt : 1;
+    UINT16 CrsSoftwareVisibility : 1;
+    UINT16 Reserved : 11;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_ROOT_CONTROL;
+
+typedef union {
+  struct {
+    UINT16 CrsSoftwareVisibility : 1;
+    UINT16 Reserved : 15;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_ROOT_CAPABILITY;
+
+typedef union {
+  struct {
+    UINT32 PmeRequesterId : 16;
+    UINT32 PmeStatus : 1;
+    UINT32 PmePending : 1;
+    UINT32 Reserved : 14;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_ROOT_STATUS;
+
+typedef union {
+  struct {
+    UINT32 CompletionTimeoutRanges : 4;
+    UINT32 CompletionTimeoutDisable : 1;
+    UINT32 AriForwarding : 1;
+    UINT32 AtomicOpRouting : 1;
+    UINT32 AtomicOp32Completer : 1;
+    UINT32 AtomicOp64Completer : 1;
+    UINT32 Cas128Completer : 1;
+    UINT32 NoRoEnabledPrPrPassing : 1;
+    UINT32 LtrMechanism : 1;
+    UINT32 TphCompleter : 2;
+    UINT32 Reserved : 4;
+    UINT32 Obff : 2;
+    UINT32 ExtendedFmtField : 1;
+    UINT32 EndEndTlpPrefix : 1;
+    UINT32 MaxEndEndTlpPrefixes : 2;
+    UINT32 Reserved2 : 8;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_DEVICE_CAPABILITY2;
+
+#define PCIE_DEVICE_CAPABILITY_OBFF_MESSAGE BIT0
+#define PCIE_DEVICE_CAPABILITY_OBFF_WAKE    BIT1
+
+typedef union {
+  struct {
+    UINT16 CompletionTimeoutValue : 4;
+    UINT16 CompletionTimeoutDisable : 1;
+    UINT16 AriForwarding : 1;
+    UINT16 AtomicOpRequester : 1;
+    UINT16 AtomicOpEgressBlocking : 1;
+    UINT16 IdoRequest : 1;
+    UINT16 IdoCompletion : 1;
+    UINT16 LtrMechanism : 2;
+    UINT16 Reserved : 2;
+    UINT16 Obff : 2;
+    UINT16 EndEndTlpPrefixBlocking : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_DEVICE_CONTROL2;
+
+#define PCIE_COMPLETION_TIMEOUT_50US_50MS   0
+#define PCIE_COMPLETION_TIMEOUT_50US_100US  1
+#define PCIE_COMPLETION_TIMEOUT_1MS_10MS    2
+#define PCIE_COMPLETION_TIMEOUT_16MS_55MS   5
+#define PCIE_COMPLETION_TIMEOUT_65MS_210MS  6
+#define PCIE_COMPLETION_TIMEOUT_260MS_900MS 9
+#define PCIE_COMPLETION_TIMEOUT_1S_3_5S     10
+#define PCIE_COMPLETION_TIMEOUT_4S_13S      13
+#define PCIE_COMPLETION_TIMEOUT_17S_64S     14
+
+#define PCIE_DEVICE_CONTROL_OBFF_DISABLED  0
+#define PCIE_DEVICE_CONTROL_OBFF_MESSAGE_A 1
+#define PCIE_DEVICE_CONTROL_OBFF_MESSAGE_B 2
+#define PCIE_DEVICE_CONTROL_OBFF_WAKE      3
+
+typedef union {
+  struct {
+    UINT32 Reserved : 1;
+    UINT32 LinkSpeedsVector : 7;
+    UINT32 Crosslink : 1;
+    UINT32 Reserved2 : 23;
+  } Bits;
+  UINT32   Uint32;
+} PCI_REG_PCIE_LINK_CAPABILITY2;
+
+typedef union {
+  struct {
+    UINT16 TargetLinkSpeed : 4;
+    UINT16 EnterCompliance : 1;
+    UINT16 HardwareAutonomousSpeedDisable : 1;
+    UINT16 SelectableDeemphasis : 1;
+    UINT16 TransmitMargin : 3;
+    UINT16 EnterModifiedCompliance : 1;
+    UINT16 ComplianceSos : 1;
+    UINT16 CompliancePresetDeemphasis : 4;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_LINK_CONTROL2;
+
+typedef union {
+  struct {
+    UINT16 CurrentDeemphasisLevel : 1;
+    UINT16 EqualizationComplete : 1;
+    UINT16 EqualizationPhase1Successful : 1;
+    UINT16 EqualizationPhase2Successful : 1;
+    UINT16 EqualizationPhase3Successful : 1;
+    UINT16 LinkEqualizationRequest : 1;
+    UINT16 Reserved : 10;
+  } Bits;
+  UINT16   Uint16;
+} PCI_REG_PCIE_LINK_STATUS2;
+
+typedef struct {
+  EFI_PCI_CAPABILITY_HDR          Hdr;
+  PCI_REG_PCIE_CAPABILITY         Capability;
+  PCI_REG_PCIE_DEVICE_CAPABILITY  DeviceCapability;
+  PCI_REG_PCIE_DEVICE_CONTROL     DeviceControl;
+  PCI_REG_PCIE_DEVICE_STATUS      DeviceStatus;
+  PCI_REG_PCIE_LINK_CAPABILITY    LinkCapability;
+  PCI_REG_PCIE_LINK_CONTROL       LinkControl;
+  PCI_REG_PCIE_LINK_STATUS        LinkStatus;
+  PCI_REG_PCIE_SLOT_CAPABILITY    SlotCapability;
+  PCI_REG_PCIE_SLOT_CONTROL       SlotControl;
+  PCI_REG_PCIE_SLOT_STATUS        SlotStatus;
+  PCI_REG_PCIE_ROOT_CONTROL       RootControl;
+  PCI_REG_PCIE_ROOT_CAPABILITY    RootCapability;
+  PCI_REG_PCIE_ROOT_STATUS        RootStatus;
+  PCI_REG_PCIE_DEVICE_CAPABILITY2 DeviceCapability2;
+  PCI_REG_PCIE_DEVICE_CONTROL2    DeviceControl2;
+  UINT16                          DeviceStatus2;
+  PCI_REG_PCIE_LINK_CAPABILITY2   LinkCapability2;
+  PCI_REG_PCIE_LINK_CONTROL2      LinkControl2;
+  PCI_REG_PCIE_LINK_STATUS2       LinkStatus2;
+  UINT32                          SlotCapability2;
+  UINT16                          SlotControl2;
+  UINT16                          SlotStatus2;
+} PCI_CAPABILITY_PCIEXP;
+
+#define EFI_PCIE_CAPABILITY_BASE_OFFSET                             0x100
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_CONTROL_ARI_HIERARCHY          0x10
+#define EFI_PCIE_CAPABILITY_DEVICE_CAPABILITIES_2_OFFSET            0x24
+#define EFI_PCIE_CAPABILITY_DEVICE_CAPABILITIES_2_ARI_FORWARDING    0x20
+#define EFI_PCIE_CAPABILITY_DEVICE_CONTROL_2_OFFSET                 0x28
+#define EFI_PCIE_CAPABILITY_DEVICE_CONTROL_2_ARI_FORWARDING         0x20
+
+//
+// for SR-IOV
+//
+#define EFI_PCIE_CAPABILITY_ID_ARI        0x0E
+#define EFI_PCIE_CAPABILITY_ID_ATS        0x0F
+#define EFI_PCIE_CAPABILITY_ID_SRIOV      0x10
+#define EFI_PCIE_CAPABILITY_ID_MRIOV      0x11
+
+typedef struct {
+  UINT32  CapabilityHeader;
+  UINT32  Capability;
+  UINT16  Control;
+  UINT16  Status;
+  UINT16  InitialVFs;
+  UINT16  TotalVFs;
+  UINT16  NumVFs;
+  UINT8   FunctionDependencyLink;
+  UINT8   Reserved0;
+  UINT16  FirstVFOffset;
+  UINT16  VFStride;
+  UINT16  Reserved1;
+  UINT16  VFDeviceID;
+  UINT32  SupportedPageSize;
+  UINT32  SystemPageSize;
+  UINT32  VFBar[6];
+  UINT32  VFMigrationStateArrayOffset;
+} SR_IOV_CAPABILITY_REGISTER;
+
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_CAPABILITIES               0x04
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_CONTROL                    0x08
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_STATUS                     0x0A
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_INITIALVFS                 0x0C
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_TOTALVFS                   0x0E
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_NUMVFS                     0x10
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_FUNCTION_DEPENDENCY_LINK   0x12
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_FIRSTVF                    0x14
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_VFSTRIDE                   0x16
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_VFDEVICEID                 0x1A
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_SUPPORTED_PAGE_SIZE        0x1C
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_SYSTEM_PAGE_SIZE           0x20
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR0                       0x24
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR1                       0x28
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR2                       0x2C
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR3                       0x30
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR4                       0x34
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_BAR5                       0x38
+#define EFI_PCIE_CAPABILITY_ID_SRIOV_VF_MIGRATION_STATE         0x3C
+
+typedef struct {
+  UINT32 CapabilityId:16;
+  UINT32 CapabilityVersion:4;
+  UINT32 NextCapabilityOffset:12;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER;
+
+#define PCI_EXP_EXT_HDR PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ADVANCED_ERROR_REPORTING_ID   0x0001
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ADVANCED_ERROR_REPORTING_VER1 0x1
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ADVANCED_ERROR_REPORTING_VER2 0x2
+
+typedef union {
+  struct {
+    UINT32 Undefined : 1;
+    UINT32 Reserved : 3;
+    UINT32 DataLinkProtocolError : 1;
+    UINT32 SurpriseDownError : 1;
+    UINT32 Reserved2 : 6;
+    UINT32 PoisonedTlp : 1;
+    UINT32 FlowControlProtocolError : 1;
+    UINT32 CompletionTimeout : 1;
+    UINT32 CompleterAbort : 1;
+    UINT32 UnexpectedCompletion : 1;
+    UINT32 ReceiverOverflow : 1;
+    UINT32 MalformedTlp : 1;
+    UINT32 EcrcError : 1;
+    UINT32 UnsupportedRequestError : 1;
+    UINT32 AcsVoilation : 1;
+    UINT32 UncorrectableInternalError : 1;
+    UINT32 McBlockedTlp : 1;
+    UINT32 AtomicOpEgressBlocked : 1;
+    UINT32 TlpPrefixBlockedError : 1;
+    UINT32 Reserved3 : 6;
+  } Bits;
+  UINT32   Uint32;
+} PCI_EXPRESS_REG_UNCORRECTABLE_ERROR;
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  PCI_EXPRESS_REG_UNCORRECTABLE_ERROR       UncorrectableErrorStatus;
+  PCI_EXPRESS_REG_UNCORRECTABLE_ERROR       UncorrectableErrorMask;
+  PCI_EXPRESS_REG_UNCORRECTABLE_ERROR       UncorrectableErrorSeverity;
+  UINT32                                    CorrectableErrorStatus;
+  UINT32                                    CorrectableErrorMask;
+  UINT32                                    AdvancedErrorCapabilitiesAndControl;
+  UINT32                                    HeaderLog[4];
+  UINT32                                    RootErrorCommand;
+  UINT32                                    RootErrorStatus;
+  UINT16                                    ErrorSourceIdentification;
+  UINT16                                    CorrectableErrorSourceIdentification;
+  UINT32                                    TlpPrefixLog[4];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_ADVANCED_ERROR_REPORTING;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VIRTUAL_CHANNEL_ID    0x0002
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VIRTUAL_CHANNEL_MFVC  0x0009
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VIRTUAL_CHANNEL_VER1  0x1
+
+typedef struct {
+  UINT32                                    VcResourceCapability:24;
+  UINT32                                    PortArbTableOffset:8;
+  UINT32                                    VcResourceControl;
+  UINT16                                    Reserved1;
+  UINT16                                    VcResourceStatus;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_VC;
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER              Header;
+  UINT32                                                ExtendedVcCount:3;
+  UINT32                                                PortVcCapability1:29;
+  UINT32                                                PortVcCapability2:24;
+  UINT32                                                VcArbTableOffset:8;
+  UINT16                                                PortVcControl;
+  UINT16                                                PortVcStatus;
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_VC  Capability[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_CAPABILITY;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_SERIAL_NUMBER_ID    0x0003
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_SERIAL_NUMBER_VER1  0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT64                                    SerialNumber;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_SERIAL_NUMBER;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_ID   0x0005
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT32                                    ElementSelfDescription;
+  UINT32                                    Reserved;
+  UINT32                                    LinkEntry[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_LINK_DECLARATION;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_GET_LINK_COUNT(LINK_DECLARATION) (UINT8)(((LINK_DECLARATION->ElementSelfDescription)&0x0000ff00)>>8)
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_CONTROL_ID   0x0006
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_CONTROL_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT32                                    RootComplexLinkCapabilities;
+  UINT16                                    RootComplexLinkControl;
+  UINT16                                    RootComplexLinkStatus;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_INTERNAL_LINK_CONTROL;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_POWER_BUDGETING_ID   0x0004
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_POWER_BUDGETING_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT32                                    DataSelect:8;
+  UINT32                                    Reserved:24;
+  UINT32                                    Data;
+  UINT32                                    PowerBudgetCapability:1;
+  UINT32                                    Reserved2:7;
+  UINT32                                    Reserved3:24;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_POWER_BUDGETING;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_ID   0x000D
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT16                                    AcsCapability;
+  UINT16                                    AcsControl;
+  UINT8                                     EgressControlVectorArray[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_ACS_EXTENDED;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_GET_EGRES_CONTROL(ACS_EXTENDED) (UINT8)(((ACS_EXTENDED->AcsCapability)&0x00000020))
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_GET_EGRES_VECTOR_SIZE(ACS_EXTENDED) (UINT8)(((ACS_EXTENDED->AcsCapability)&0x0000FF00))
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION_ID   0x0007
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT32                                    AssociationBitmap;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_MULTI_FUNCTION_VIRTUAL_CHANNEL_ID    0x0008
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_MULTI_FUNCTION_VIRTUAL_CHANNEL_VER1  0x1
+
+typedef PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_CAPABILITY PCI_EXPRESS_EXTENDED_CAPABILITIES_MULTI_FUNCTION_VIRTUAL_CHANNEL_CAPABILITY;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VENDOR_SPECIFIC_ID   0x000B
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VENDOR_SPECIFIC_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT32                                    VendorSpecificHeader;
+  UINT8                                     VendorSpecific[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_VENDOR_SPECIFIC;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_VENDOR_SPECIFIC_GET_SIZE(VENDOR) (UINT16)(((VENDOR->VendorSpecificHeader)&0xFFF00000)>>20)
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_RCRB_HEADER_ID   0x000A
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_RCRB_HEADER_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT16                                    VendorId;
+  UINT16                                    DeviceId;
+  UINT32                                    RcrbCapabilities;
+  UINT32                                    RcrbControl;
+  UINT32                                    Reserved;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_RCRB_HEADER;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_MULTICAST_ID   0x0012
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_MULTICAST_VER1 0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER  Header;
+  UINT16                                    MultiCastCapability;
+  UINT16                                    MulticastControl;
+  UINT64                                    McBaseAddress;
+  UINT64                                    McReceiveAddress;
+  UINT64                                    McBlockAll;
+  UINT64                                    McBlockUntranslated;
+  UINT64                                    McOverlayBar;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_MULTICAST;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_RESIZABLE_BAR_ID    0x0015
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_RESIZABLE_BAR_VER1  0x1
+
+typedef struct {
+  UINT32                                                 ResizableBarCapability;
+  UINT16                                                 ResizableBarControl;
+  UINT16                                                 Reserved;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR_ENTRY;
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER               Header;
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR_ENTRY  Capability[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR;
+
+#define GET_NUMBER_RESIZABLE_BARS(x) (((x->Capability[0].ResizableBarControl) & 0xE0) >> 5)
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ARI_CAPABILITY_ID    0x000E
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_ARI_CAPABILITY_VER1  0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER                Header;
+  UINT16                                                  AriCapability;
+  UINT16                                                  AriControl;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_ARI_CAPABILITY;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_ID    0x0016
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_VER1  0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER                Header;
+  UINT32                                                  DpaCapability;
+  UINT32                                                  DpaLatencyIndicator;
+  UINT16                                                  DpaStatus;
+  UINT16                                                  DpaControl;
+  UINT8                                                   DpaPowerAllocationArray[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_DYNAMIC_POWER_ALLOCATION;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_GET_SUBSTATE_MAX(POWER) (UINT16)(((POWER->DpaCapability)&0x0000000F))
+
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LATENCE_TOLERANCE_REPORTING_ID    0x0018
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_LATENCE_TOLERANCE_REPORTING_VER1  0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER                Header;
+  UINT16                                                  MaxSnoopLatency;
+  UINT16                                                  MaxNoSnoopLatency;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_LATENCE_TOLERANCE_REPORTING;
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_TPH_ID    0x0017
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_TPH_VER1  0x1
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER                Header;
+  UINT32                                                  TphRequesterCapability;
+  UINT32                                                  TphRequesterControl;
+  UINT16                                                  TphStTable[1];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_TPH;
+
+#define GET_TPH_TABLE_SIZE(x) ((x->TphRequesterCapability & 0x7FF0000)>>16) * sizeof(UINT16)
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/PciExpress30.h b/MdePkg/Include/IndustryStandard/PciExpress30.h
new file mode 100644
index 000000000000..5ab7feb8d64f
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/PciExpress30.h
@@ -0,0 +1,57 @@
+/** @file
+  Support for the PCI Express 3.0 standard.
+
+  This header file may not define all structures.  Please extend as required.
+
+  Copyright (c) 2014 - 2016, 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 _PCIEXPRESS30_H_
+#define _PCIEXPRESS30_H_
+
+#include <IndustryStandard/PciExpress21.h>
+
+#pragma pack(1)
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_SECONDARY_PCIE_ID    0x0019
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_SECONDARY_PCIE_VER1  0x1
+
+typedef union {
+  struct {
+    UINT32 PerformEqualization : 1;
+    UINT32 LinkEqualizationRequestInterruptEnable : 1;
+    UINT32 Reserved : 30;
+  } Bits;
+  UINT32   Uint32;
+} PCI_EXPRESS_REG_LINK_CONTROL3;
+
+typedef union {
+  struct {
+    UINT16 DownstreamPortTransmitterPreset : 4;
+    UINT16 DownstreamPortReceiverPresetHint : 3;
+    UINT16 Reserved : 1;
+    UINT16 UpstreamPortTransmitterPreset : 4;
+    UINT16 UpstreamPortReceiverPresetHint : 3;
+    UINT16 Reserved2 : 1;
+  } Bits;
+  UINT16   Uint16;
+} PCI_EXPRESS_REG_LANE_EQUALIZATION_CONTROL;
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER                Header;
+  PCI_EXPRESS_REG_LINK_CONTROL3                           LinkControl3;
+  UINT32                                                  LaneErrorStatus;
+  PCI_EXPRESS_REG_LANE_EQUALIZATION_CONTROL               EqualizationControl[2];
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_SECONDARY_PCIE;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/PciExpress31.h b/MdePkg/Include/IndustryStandard/PciExpress31.h
new file mode 100644
index 000000000000..72a3ccda81ee
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/PciExpress31.h
@@ -0,0 +1,78 @@
+/** @file
+Support for the PCI Express 3.1 standard.
+
+This header file may not define all structures.  Please extend as required.
+
+Copyright (c) 2016, 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 _PCIEXPRESS31_H_
+#define _PCIEXPRESS31_H_
+
+#include <IndustryStandard/PciExpress30.h>
+
+#pragma pack(1)
+
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_L1_PM_SUBSTATES_ID    0x001E
+#define PCI_EXPRESS_EXTENDED_CAPABILITY_L1_PM_SUBSTATES_VER1  0x1
+
+typedef union {
+  struct {
+    UINT32 PciPmL12 : 1;
+    UINT32 PciPmL11 : 1;
+    UINT32 AspmL12 : 1;
+    UINT32 AspmL11 : 1;
+    UINT32 L1PmSubstates : 1;
+    UINT32 Reserved : 3;
+    UINT32 CommonModeRestoreTime : 8;
+    UINT32 TPowerOnScale : 2;
+    UINT32 Reserved2 : 1;
+    UINT32 TPowerOnValue : 5;
+    UINT32 Reserved3 : 8;
+  } Bits;
+  UINT32   Uint32;
+} PCI_EXPRESS_REG_L1_PM_SUBSTATES_CAPABILITY;
+
+typedef union {
+  struct {
+    UINT32 PciPmL12 : 1;
+    UINT32 PciPmL11 : 1;
+    UINT32 AspmL12 : 1;
+    UINT32 AspmL11 : 1;
+    UINT32 Reserved : 4;
+    UINT32 CommonModeRestoreTime : 8;
+    UINT32 LtrL12ThresholdValue : 10;
+    UINT32 Reserved2 : 3;
+    UINT32 LtrL12ThresholdScale : 3;
+  } Bits;
+  UINT32   Uint32;
+} PCI_EXPRESS_REG_L1_PM_SUBSTATES_CONTROL1;
+
+typedef union {
+  struct {
+    UINT32 TPowerOnScale : 2;
+    UINT32 Reserved : 1;
+    UINT32 TPowerOnValue : 5;
+    UINT32 Reserved2 : 24;
+  } Bits;
+  UINT32   Uint32;
+} PCI_EXPRESS_REG_L1_PM_SUBSTATES_CONTROL2;
+
+typedef struct {
+  PCI_EXPRESS_EXTENDED_CAPABILITIES_HEADER   Header;
+  PCI_EXPRESS_REG_L1_PM_SUBSTATES_CAPABILITY Capability;
+  PCI_EXPRESS_REG_L1_PM_SUBSTATES_CONTROL1   Control1;
+  PCI_EXPRESS_REG_L1_PM_SUBSTATES_CONTROL2   Control2;
+} PCI_EXPRESS_EXTENDED_CAPABILITIES_L1_PM_SUBSTATES;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/PeImage.h b/MdePkg/Include/IndustryStandard/PeImage.h
new file mode 100644
index 000000000000..3af3edbd8ec2
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/PeImage.h
@@ -0,0 +1,756 @@
+/** @file
+  EFI image format for PE32, PE32+ and TE. Please note some data structures are 
+  different for PE32 and PE32+. EFI_IMAGE_NT_HEADERS32 is for PE32 and 
+  EFI_IMAGE_NT_HEADERS64 is for PE32+. 
+
+  This file is coded to the Visual Studio, Microsoft Portable Executable and 
+  Common Object File Format Specification, Revision 8.3 - February 6, 2013.
+  This file also includes some definitions in PI Specification, Revision 1.0.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2009, Apple Inc. 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 __PE_IMAGE_H__
+#define __PE_IMAGE_H__
+
+//
+// PE32+ Subsystem type for EFI images
+//
+#define EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION         10
+#define EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER 11
+#define EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER      12
+#define EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER      13 ///< defined PI Specification, 1.0
+
+
+//
+// PE32+ Machine type for EFI images
+//
+#define IMAGE_FILE_MACHINE_I386            0x014c
+#define IMAGE_FILE_MACHINE_IA64            0x0200
+#define IMAGE_FILE_MACHINE_EBC             0x0EBC
+#define IMAGE_FILE_MACHINE_X64             0x8664
+#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED  0x01c2
+#define IMAGE_FILE_MACHINE_ARM64           0xAA64
+
+//
+// EXE file formats
+//
+#define EFI_IMAGE_DOS_SIGNATURE     SIGNATURE_16('M', 'Z')
+#define EFI_IMAGE_OS2_SIGNATURE     SIGNATURE_16('N', 'E')
+#define EFI_IMAGE_OS2_SIGNATURE_LE  SIGNATURE_16('L', 'E')
+#define EFI_IMAGE_NT_SIGNATURE      SIGNATURE_32('P', 'E', '\0', '\0')
+
+///
+/// PE images can start with an optional DOS header, so if an image is run
+/// under DOS it can print an error message.
+///
+typedef struct {
+  UINT16  e_magic;    ///< Magic number.
+  UINT16  e_cblp;     ///< Bytes on last page of file.
+  UINT16  e_cp;       ///< Pages in file.
+  UINT16  e_crlc;     ///< Relocations.
+  UINT16  e_cparhdr;  ///< Size of header in paragraphs.
+  UINT16  e_minalloc; ///< Minimum extra paragraphs needed.
+  UINT16  e_maxalloc; ///< Maximum extra paragraphs needed.
+  UINT16  e_ss;       ///< Initial (relative) SS value.
+  UINT16  e_sp;       ///< Initial SP value.
+  UINT16  e_csum;     ///< Checksum.
+  UINT16  e_ip;       ///< Initial IP value.
+  UINT16  e_cs;       ///< Initial (relative) CS value.
+  UINT16  e_lfarlc;   ///< File address of relocation table.
+  UINT16  e_ovno;     ///< Overlay number.
+  UINT16  e_res[4];   ///< Reserved words.
+  UINT16  e_oemid;    ///< OEM identifier (for e_oeminfo).
+  UINT16  e_oeminfo;  ///< OEM information; e_oemid specific.
+  UINT16  e_res2[10]; ///< Reserved words.
+  UINT32  e_lfanew;   ///< File address of new exe header.
+} EFI_IMAGE_DOS_HEADER;
+
+///
+/// COFF File Header (Object and Image).
+///
+typedef struct {
+  UINT16  Machine;
+  UINT16  NumberOfSections;
+  UINT32  TimeDateStamp;
+  UINT32  PointerToSymbolTable;
+  UINT32  NumberOfSymbols;
+  UINT16  SizeOfOptionalHeader;
+  UINT16  Characteristics;
+} EFI_IMAGE_FILE_HEADER;
+
+///
+/// Size of EFI_IMAGE_FILE_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_FILE_HEADER        20
+
+//
+// Characteristics
+//
+#define EFI_IMAGE_FILE_RELOCS_STRIPPED      BIT0     ///< 0x0001  Relocation info stripped from file.
+#define EFI_IMAGE_FILE_EXECUTABLE_IMAGE     BIT1     ///< 0x0002  File is executable  (i.e. no unresolved externel references).
+#define EFI_IMAGE_FILE_LINE_NUMS_STRIPPED   BIT2     ///< 0x0004  Line nunbers stripped from file.
+#define EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED  BIT3     ///< 0x0008  Local symbols stripped from file.
+#define EFI_IMAGE_FILE_BYTES_REVERSED_LO    BIT7     ///< 0x0080  Bytes of machine word are reversed.
+#define EFI_IMAGE_FILE_32BIT_MACHINE        BIT8     ///< 0x0100  32 bit word machine.
+#define EFI_IMAGE_FILE_DEBUG_STRIPPED       BIT9     ///< 0x0200  Debugging info stripped from file in .DBG file.
+#define EFI_IMAGE_FILE_SYSTEM               BIT12    ///< 0x1000  System File.
+#define EFI_IMAGE_FILE_DLL                  BIT13    ///< 0x2000  File is a DLL.
+#define EFI_IMAGE_FILE_BYTES_REVERSED_HI    BIT15    ///< 0x8000  Bytes of machine word are reversed.
+
+///
+/// Header Data Directories.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  Size;
+} EFI_IMAGE_DATA_DIRECTORY;
+
+//
+// Directory Entries
+//
+#define EFI_IMAGE_DIRECTORY_ENTRY_EXPORT      0
+#define EFI_IMAGE_DIRECTORY_ENTRY_IMPORT      1
+#define EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE    2
+#define EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION   3
+#define EFI_IMAGE_DIRECTORY_ENTRY_SECURITY    4
+#define EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC   5
+#define EFI_IMAGE_DIRECTORY_ENTRY_DEBUG       6
+#define EFI_IMAGE_DIRECTORY_ENTRY_COPYRIGHT   7
+#define EFI_IMAGE_DIRECTORY_ENTRY_GLOBALPTR   8
+#define EFI_IMAGE_DIRECTORY_ENTRY_TLS         9
+#define EFI_IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10
+
+#define EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES 16
+
+///
+/// @attention
+/// EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC means PE32 and 
+/// EFI_IMAGE_OPTIONAL_HEADER32 must be used. The data structures only vary
+/// after NT additional fields.
+///
+#define EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC 0x10b
+          
+///
+/// Optional Header Standard Fields for PE32.
+///
+typedef struct {
+  ///
+  /// Standard fields.
+  ///
+  UINT16                    Magic;
+  UINT8                     MajorLinkerVersion;
+  UINT8                     MinorLinkerVersion;
+  UINT32                    SizeOfCode;
+  UINT32                    SizeOfInitializedData;
+  UINT32                    SizeOfUninitializedData;
+  UINT32                    AddressOfEntryPoint;
+  UINT32                    BaseOfCode;
+  UINT32                    BaseOfData;  ///< PE32 contains this additional field, which is absent in PE32+.
+  ///
+  /// Optional Header Windows-Specific Fields.
+  ///
+  UINT32                    ImageBase;
+  UINT32                    SectionAlignment;
+  UINT32                    FileAlignment;
+  UINT16                    MajorOperatingSystemVersion;
+  UINT16                    MinorOperatingSystemVersion;
+  UINT16                    MajorImageVersion;
+  UINT16                    MinorImageVersion;
+  UINT16                    MajorSubsystemVersion;
+  UINT16                    MinorSubsystemVersion;
+  UINT32                    Win32VersionValue;
+  UINT32                    SizeOfImage;
+  UINT32                    SizeOfHeaders;
+  UINT32                    CheckSum;
+  UINT16                    Subsystem;
+  UINT16                    DllCharacteristics;
+  UINT32                    SizeOfStackReserve;
+  UINT32                    SizeOfStackCommit;
+  UINT32                    SizeOfHeapReserve;
+  UINT32                    SizeOfHeapCommit;
+  UINT32                    LoaderFlags;
+  UINT32                    NumberOfRvaAndSizes;
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES];
+} EFI_IMAGE_OPTIONAL_HEADER32;
+
+///
+/// @attention
+/// EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC means PE32+ and 
+/// EFI_IMAGE_OPTIONAL_HEADER64 must be used. The data structures only vary
+/// after NT additional fields.
+///
+#define EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
+
+///
+/// Optional Header Standard Fields for PE32+.
+///
+typedef struct {
+  ///
+  /// Standard fields.
+  ///
+  UINT16                    Magic;
+  UINT8                     MajorLinkerVersion;
+  UINT8                     MinorLinkerVersion;
+  UINT32                    SizeOfCode;
+  UINT32                    SizeOfInitializedData;
+  UINT32                    SizeOfUninitializedData;
+  UINT32                    AddressOfEntryPoint;
+  UINT32                    BaseOfCode;
+  ///
+  /// Optional Header Windows-Specific Fields.
+  ///
+  UINT64                    ImageBase;
+  UINT32                    SectionAlignment;
+  UINT32                    FileAlignment;
+  UINT16                    MajorOperatingSystemVersion;
+  UINT16                    MinorOperatingSystemVersion;
+  UINT16                    MajorImageVersion;
+  UINT16                    MinorImageVersion;
+  UINT16                    MajorSubsystemVersion;
+  UINT16                    MinorSubsystemVersion;
+  UINT32                    Win32VersionValue;
+  UINT32                    SizeOfImage;
+  UINT32                    SizeOfHeaders;
+  UINT32                    CheckSum;
+  UINT16                    Subsystem;
+  UINT16                    DllCharacteristics;
+  UINT64                    SizeOfStackReserve;
+  UINT64                    SizeOfStackCommit;
+  UINT64                    SizeOfHeapReserve;
+  UINT64                    SizeOfHeapCommit;
+  UINT32                    LoaderFlags;
+  UINT32                    NumberOfRvaAndSizes;
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES];
+} EFI_IMAGE_OPTIONAL_HEADER64;
+
+
+///
+/// @attention
+/// EFI_IMAGE_NT_HEADERS32 is for use ONLY by tools.
+///
+typedef struct {
+  UINT32                      Signature;
+  EFI_IMAGE_FILE_HEADER       FileHeader;
+  EFI_IMAGE_OPTIONAL_HEADER32 OptionalHeader;
+} EFI_IMAGE_NT_HEADERS32;
+
+#define EFI_IMAGE_SIZEOF_NT_OPTIONAL32_HEADER sizeof (EFI_IMAGE_NT_HEADERS32)
+
+///
+/// @attention
+/// EFI_IMAGE_HEADERS64 is for use ONLY by tools.
+///
+typedef struct {
+  UINT32                      Signature;
+  EFI_IMAGE_FILE_HEADER       FileHeader;
+  EFI_IMAGE_OPTIONAL_HEADER64 OptionalHeader;
+} EFI_IMAGE_NT_HEADERS64;
+
+#define EFI_IMAGE_SIZEOF_NT_OPTIONAL64_HEADER sizeof (EFI_IMAGE_NT_HEADERS64)
+
+//
+// Other Windows Subsystem Values
+//
+#define EFI_IMAGE_SUBSYSTEM_UNKNOWN     0
+#define EFI_IMAGE_SUBSYSTEM_NATIVE      1
+#define EFI_IMAGE_SUBSYSTEM_WINDOWS_GUI 2
+#define EFI_IMAGE_SUBSYSTEM_WINDOWS_CUI 3
+#define EFI_IMAGE_SUBSYSTEM_OS2_CUI     5
+#define EFI_IMAGE_SUBSYSTEM_POSIX_CUI   7
+
+///
+/// Length of ShortName.
+///
+#define EFI_IMAGE_SIZEOF_SHORT_NAME 8
+
+///
+/// Section Table. This table immediately follows the optional header.
+///
+typedef struct {
+  UINT8 Name[EFI_IMAGE_SIZEOF_SHORT_NAME];
+  union {
+    UINT32  PhysicalAddress;
+    UINT32  VirtualSize;
+  } Misc;
+  UINT32  VirtualAddress;
+  UINT32  SizeOfRawData;
+  UINT32  PointerToRawData;
+  UINT32  PointerToRelocations;
+  UINT32  PointerToLinenumbers;
+  UINT16  NumberOfRelocations;
+  UINT16  NumberOfLinenumbers;
+  UINT32  Characteristics;
+} EFI_IMAGE_SECTION_HEADER;
+
+///
+/// Size of EFI_IMAGE_SECTION_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_SECTION_HEADER       40
+         
+//
+// Section Flags Values
+//
+#define EFI_IMAGE_SCN_TYPE_NO_PAD                  BIT3   ///< 0x00000008  ///< Reserved.
+#define EFI_IMAGE_SCN_CNT_CODE                     BIT5   ///< 0x00000020
+#define EFI_IMAGE_SCN_CNT_INITIALIZED_DATA         BIT6   ///< 0x00000040
+#define EFI_IMAGE_SCN_CNT_UNINITIALIZED_DATA       BIT7   ///< 0x00000080
+                                                   
+#define EFI_IMAGE_SCN_LNK_OTHER                    BIT8   ///< 0x00000100  ///< Reserved.
+#define EFI_IMAGE_SCN_LNK_INFO                     BIT9   ///< 0x00000200  ///< Section contains comments or some other type of information.
+#define EFI_IMAGE_SCN_LNK_REMOVE                   BIT11  ///< 0x00000800  ///< Section contents will not become part of image.
+#define EFI_IMAGE_SCN_LNK_COMDAT                   BIT12  ///< 0x00001000
+                                                   
+#define EFI_IMAGE_SCN_ALIGN_1BYTES                 BIT20  ///< 0x00100000
+#define EFI_IMAGE_SCN_ALIGN_2BYTES                 BIT21  ///< 0x00200000
+#define EFI_IMAGE_SCN_ALIGN_4BYTES          (BIT20|BIT21) ///< 0x00300000
+#define EFI_IMAGE_SCN_ALIGN_8BYTES                 BIT22  ///< 0x00400000
+#define EFI_IMAGE_SCN_ALIGN_16BYTES         (BIT20|BIT22) ///< 0x00500000
+#define EFI_IMAGE_SCN_ALIGN_32BYTES         (BIT21|BIT22) ///< 0x00600000
+#define EFI_IMAGE_SCN_ALIGN_64BYTES   (BIT20|BIT21|BIT22) ///< 0x00700000
+                                              
+#define EFI_IMAGE_SCN_MEM_DISCARDABLE              BIT25  ///< 0x02000000
+#define EFI_IMAGE_SCN_MEM_NOT_CACHED               BIT26  ///< 0x04000000
+#define EFI_IMAGE_SCN_MEM_NOT_PAGED                BIT27  ///< 0x08000000
+#define EFI_IMAGE_SCN_MEM_SHARED                   BIT28  ///< 0x10000000
+#define EFI_IMAGE_SCN_MEM_EXECUTE                  BIT29  ///< 0x20000000
+#define EFI_IMAGE_SCN_MEM_READ                     BIT30  ///< 0x40000000
+#define EFI_IMAGE_SCN_MEM_WRITE                    BIT31  ///< 0x80000000
+
+///
+/// Size of a Symbol Table Record.
+///
+#define EFI_IMAGE_SIZEOF_SYMBOL 18
+
+//
+// Symbols have a section number of the section in which they are
+// defined. Otherwise, section numbers have the following meanings:
+//
+#define EFI_IMAGE_SYM_UNDEFINED (UINT16) 0  ///< Symbol is undefined or is common.
+#define EFI_IMAGE_SYM_ABSOLUTE  (UINT16) -1 ///< Symbol is an absolute value.
+#define EFI_IMAGE_SYM_DEBUG     (UINT16) -2 ///< Symbol is a special debug item.
+
+//
+// Symbol Type (fundamental) values.
+//
+#define EFI_IMAGE_SYM_TYPE_NULL   0   ///< no type.
+#define EFI_IMAGE_SYM_TYPE_VOID   1   ///< no valid type.
+#define EFI_IMAGE_SYM_TYPE_CHAR   2   ///< type character.
+#define EFI_IMAGE_SYM_TYPE_SHORT  3   ///< type short integer.
+#define EFI_IMAGE_SYM_TYPE_INT    4
+#define EFI_IMAGE_SYM_TYPE_LONG   5
+#define EFI_IMAGE_SYM_TYPE_FLOAT  6
+#define EFI_IMAGE_SYM_TYPE_DOUBLE 7
+#define EFI_IMAGE_SYM_TYPE_STRUCT 8
+#define EFI_IMAGE_SYM_TYPE_UNION  9
+#define EFI_IMAGE_SYM_TYPE_ENUM   10  ///< enumeration.
+#define EFI_IMAGE_SYM_TYPE_MOE    11  ///< member of enumeration.
+#define EFI_IMAGE_SYM_TYPE_BYTE   12
+#define EFI_IMAGE_SYM_TYPE_WORD   13
+#define EFI_IMAGE_SYM_TYPE_UINT   14
+#define EFI_IMAGE_SYM_TYPE_DWORD  15
+
+//
+// Symbol Type (derived) values.
+//
+#define EFI_IMAGE_SYM_DTYPE_NULL      0 ///< no derived type.
+#define EFI_IMAGE_SYM_DTYPE_POINTER   1
+#define EFI_IMAGE_SYM_DTYPE_FUNCTION  2
+#define EFI_IMAGE_SYM_DTYPE_ARRAY     3
+
+//
+// Storage classes.
+//
+#define EFI_IMAGE_SYM_CLASS_END_OF_FUNCTION   ((UINT8) -1)
+#define EFI_IMAGE_SYM_CLASS_NULL              0
+#define EFI_IMAGE_SYM_CLASS_AUTOMATIC         1
+#define EFI_IMAGE_SYM_CLASS_EXTERNAL          2
+#define EFI_IMAGE_SYM_CLASS_STATIC            3
+#define EFI_IMAGE_SYM_CLASS_REGISTER          4
+#define EFI_IMAGE_SYM_CLASS_EXTERNAL_DEF      5
+#define EFI_IMAGE_SYM_CLASS_LABEL             6
+#define EFI_IMAGE_SYM_CLASS_UNDEFINED_LABEL   7
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_STRUCT  8
+#define EFI_IMAGE_SYM_CLASS_ARGUMENT          9
+#define EFI_IMAGE_SYM_CLASS_STRUCT_TAG        10
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_UNION   11
+#define EFI_IMAGE_SYM_CLASS_UNION_TAG         12
+#define EFI_IMAGE_SYM_CLASS_TYPE_DEFINITION   13
+#define EFI_IMAGE_SYM_CLASS_UNDEFINED_STATIC  14
+#define EFI_IMAGE_SYM_CLASS_ENUM_TAG          15
+#define EFI_IMAGE_SYM_CLASS_MEMBER_OF_ENUM    16
+#define EFI_IMAGE_SYM_CLASS_REGISTER_PARAM    17
+#define EFI_IMAGE_SYM_CLASS_BIT_FIELD         18
+#define EFI_IMAGE_SYM_CLASS_BLOCK             100
+#define EFI_IMAGE_SYM_CLASS_FUNCTION          101
+#define EFI_IMAGE_SYM_CLASS_END_OF_STRUCT     102
+#define EFI_IMAGE_SYM_CLASS_FILE              103
+#define EFI_IMAGE_SYM_CLASS_SECTION           104
+#define EFI_IMAGE_SYM_CLASS_WEAK_EXTERNAL     105
+
+//
+// type packing constants
+//
+#define EFI_IMAGE_N_BTMASK  017
+#define EFI_IMAGE_N_TMASK   060
+#define EFI_IMAGE_N_TMASK1  0300
+#define EFI_IMAGE_N_TMASK2  0360
+#define EFI_IMAGE_N_BTSHFT  4
+#define EFI_IMAGE_N_TSHIFT  2
+
+//
+// Communal selection types.
+//
+#define EFI_IMAGE_COMDAT_SELECT_NODUPLICATES    1
+#define EFI_IMAGE_COMDAT_SELECT_ANY             2
+#define EFI_IMAGE_COMDAT_SELECT_SAME_SIZE       3
+#define EFI_IMAGE_COMDAT_SELECT_EXACT_MATCH     4
+#define EFI_IMAGE_COMDAT_SELECT_ASSOCIATIVE     5
+                                       
+//
+// the following values only be referred in PeCoff, not defined in PECOFF.
+//
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY  1
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_LIBRARY    2
+#define EFI_IMAGE_WEAK_EXTERN_SEARCH_ALIAS      3
+
+///
+/// Relocation format.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  SymbolTableIndex;
+  UINT16  Type;
+} EFI_IMAGE_RELOCATION;
+
+///
+/// Size of EFI_IMAGE_RELOCATION
+///
+#define EFI_IMAGE_SIZEOF_RELOCATION 10
+
+//
+// I386 relocation types.
+//
+#define EFI_IMAGE_REL_I386_ABSOLUTE 0x0000  ///< Reference is absolute, no relocation is necessary.
+#define EFI_IMAGE_REL_I386_DIR16    0x0001  ///< Direct 16-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_REL16    0x0002  ///< PC-relative 16-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_DIR32    0x0006  ///< Direct 32-bit reference to the symbols virtual address.
+#define EFI_IMAGE_REL_I386_DIR32NB  0x0007  ///< Direct 32-bit reference to the symbols virtual address, base not included.
+#define EFI_IMAGE_REL_I386_SEG12    0x0009  ///< Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address.
+#define EFI_IMAGE_REL_I386_SECTION  0x000A
+#define EFI_IMAGE_REL_I386_SECREL   0x000B
+#define EFI_IMAGE_REL_I386_REL32    0x0014  ///< PC-relative 32-bit reference to the symbols virtual address.
+
+// 
+// x64 processor relocation types.
+// 
+#define IMAGE_REL_AMD64_ABSOLUTE  0x0000
+#define IMAGE_REL_AMD64_ADDR64    0x0001
+#define IMAGE_REL_AMD64_ADDR32    0x0002
+#define IMAGE_REL_AMD64_ADDR32NB  0x0003
+#define IMAGE_REL_AMD64_REL32     0x0004
+#define IMAGE_REL_AMD64_REL32_1   0x0005
+#define IMAGE_REL_AMD64_REL32_2   0x0006
+#define IMAGE_REL_AMD64_REL32_3   0x0007
+#define IMAGE_REL_AMD64_REL32_4   0x0008
+#define IMAGE_REL_AMD64_REL32_5   0x0009
+#define IMAGE_REL_AMD64_SECTION   0x000A
+#define IMAGE_REL_AMD64_SECREL    0x000B
+#define IMAGE_REL_AMD64_SECREL7   0x000C
+#define IMAGE_REL_AMD64_TOKEN     0x000D
+#define IMAGE_REL_AMD64_SREL32    0x000E
+#define IMAGE_REL_AMD64_PAIR      0x000F
+#define IMAGE_REL_AMD64_SSPAN32   0x0010
+
+///
+/// Based relocation format.
+///
+typedef struct {
+  UINT32  VirtualAddress;
+  UINT32  SizeOfBlock;
+} EFI_IMAGE_BASE_RELOCATION;
+
+///
+/// Size of EFI_IMAGE_BASE_RELOCATION.
+///
+#define EFI_IMAGE_SIZEOF_BASE_RELOCATION  8
+
+//
+// Based relocation types.
+//
+#define EFI_IMAGE_REL_BASED_ABSOLUTE        0
+#define EFI_IMAGE_REL_BASED_HIGH            1
+#define EFI_IMAGE_REL_BASED_LOW             2
+#define EFI_IMAGE_REL_BASED_HIGHLOW         3
+#define EFI_IMAGE_REL_BASED_HIGHADJ         4
+#define EFI_IMAGE_REL_BASED_MIPS_JMPADDR    5
+#define EFI_IMAGE_REL_BASED_ARM_MOV32A      5
+#define EFI_IMAGE_REL_BASED_ARM_MOV32T      7
+#define EFI_IMAGE_REL_BASED_IA64_IMM64      9
+#define EFI_IMAGE_REL_BASED_MIPS_JMPADDR16  9
+#define EFI_IMAGE_REL_BASED_DIR64           10
+
+///
+/// Line number format.
+///
+typedef struct {
+  union {
+    UINT32  SymbolTableIndex; ///< Symbol table index of function name if Linenumber is 0.
+    UINT32  VirtualAddress;   ///< Virtual address of line number.
+  } Type;
+  UINT16  Linenumber;         ///< Line number.
+} EFI_IMAGE_LINENUMBER;
+
+///
+/// Size of EFI_IMAGE_LINENUMBER.
+///
+#define EFI_IMAGE_SIZEOF_LINENUMBER 6
+
+//
+// Archive format.
+//
+#define EFI_IMAGE_ARCHIVE_START_SIZE        8
+#define EFI_IMAGE_ARCHIVE_START             "!<arch>\n"
+#define EFI_IMAGE_ARCHIVE_END               "`\n"
+#define EFI_IMAGE_ARCHIVE_PAD               "\n"
+#define EFI_IMAGE_ARCHIVE_LINKER_MEMBER     "/               "
+#define EFI_IMAGE_ARCHIVE_LONGNAMES_MEMBER  "//              "
+
+///
+/// Archive Member Headers
+///
+typedef struct {
+  UINT8 Name[16];     ///< File member name - `/' terminated.
+  UINT8 Date[12];     ///< File member date - decimal.
+  UINT8 UserID[6];    ///< File member user id - decimal.
+  UINT8 GroupID[6];   ///< File member group id - decimal.
+  UINT8 Mode[8];      ///< File member mode - octal.
+  UINT8 Size[10];     ///< File member size - decimal.
+  UINT8 EndHeader[2]; ///< String to end header. (0x60 0x0A).
+} EFI_IMAGE_ARCHIVE_MEMBER_HEADER;
+
+///
+/// Size of EFI_IMAGE_ARCHIVE_MEMBER_HEADER.
+///
+#define EFI_IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR 60
+
+
+//
+// DLL Support
+//
+
+///
+/// Export Directory Table.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT32  Name;
+  UINT32  Base;
+  UINT32  NumberOfFunctions;
+  UINT32  NumberOfNames;
+  UINT32  AddressOfFunctions;
+  UINT32  AddressOfNames;
+  UINT32  AddressOfNameOrdinals;
+} EFI_IMAGE_EXPORT_DIRECTORY;
+
+///
+/// Hint/Name Table.
+///
+typedef struct {
+  UINT16  Hint;
+  UINT8   Name[1];
+} EFI_IMAGE_IMPORT_BY_NAME;
+
+///
+/// Import Address Table RVA (Thunk Table).
+///
+typedef struct {
+  union {
+    UINT32                    Function;
+    UINT32                    Ordinal;
+    EFI_IMAGE_IMPORT_BY_NAME  *AddressOfData;
+  } u1;
+} EFI_IMAGE_THUNK_DATA;
+
+#define EFI_IMAGE_ORDINAL_FLAG              BIT31    ///< Flag for PE32.
+#define EFI_IMAGE_SNAP_BY_ORDINAL(Ordinal)  ((Ordinal & EFI_IMAGE_ORDINAL_FLAG) != 0)
+#define EFI_IMAGE_ORDINAL(Ordinal)          (Ordinal & 0xffff)
+
+///
+/// Import Directory Table
+///
+typedef struct {
+  UINT32                Characteristics;
+  UINT32                TimeDateStamp;
+  UINT32                ForwarderChain;
+  UINT32                Name;
+  EFI_IMAGE_THUNK_DATA  *FirstThunk;
+} EFI_IMAGE_IMPORT_DESCRIPTOR;
+
+
+///
+/// Debug Directory Format.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT32  Type;
+  UINT32  SizeOfData;
+  UINT32  RVA;           ///< The address of the debug data when loaded, relative to the image base.
+  UINT32  FileOffset;    ///< The file pointer to the debug data.
+} EFI_IMAGE_DEBUG_DIRECTORY_ENTRY;
+
+#define EFI_IMAGE_DEBUG_TYPE_CODEVIEW 2     ///< The Visual C++ debug information.
+
+///
+/// Debug Data Structure defined in Microsoft C++.
+///
+#define CODEVIEW_SIGNATURE_NB10  SIGNATURE_32('N', 'B', '1', '0')
+typedef struct {
+  UINT32  Signature;                        ///< "NB10"
+  UINT32  Unknown;
+  UINT32  Unknown2;
+  UINT32  Unknown3;
+  //
+  // Filename of .PDB goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY;
+
+///
+/// Debug Data Structure defined in Microsoft C++.
+///
+#define CODEVIEW_SIGNATURE_RSDS  SIGNATURE_32('R', 'S', 'D', 'S')
+typedef struct {
+  UINT32  Signature;                        ///< "RSDS".
+  UINT32  Unknown;
+  UINT32  Unknown2;
+  UINT32  Unknown3;
+  UINT32  Unknown4;
+  UINT32  Unknown5;
+  //
+  // Filename of .PDB goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY;
+
+
+///
+/// Debug Data Structure defined by Apple Mach-O to Coff utility.
+///
+#define CODEVIEW_SIGNATURE_MTOC  SIGNATURE_32('M', 'T', 'O', 'C')
+typedef struct {
+  UINT32    Signature;                       ///< "MTOC".
+  GUID      MachOUuid;
+  //
+  //  Filename of .DLL (Mach-O with debug info) goes here
+  //
+} EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY;
+
+///
+/// Resource format.
+///
+typedef struct {
+  UINT32  Characteristics;
+  UINT32  TimeDateStamp;
+  UINT16  MajorVersion;
+  UINT16  MinorVersion;
+  UINT16  NumberOfNamedEntries;
+  UINT16  NumberOfIdEntries;
+  //
+  // Array of EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY entries goes here.
+  //
+} EFI_IMAGE_RESOURCE_DIRECTORY;
+
+///
+/// Resource directory entry format.
+///
+typedef struct {
+  union {
+    struct {
+      UINT32  NameOffset:31;
+      UINT32  NameIsString:1;
+    } s;
+    UINT32  Id;
+  } u1;
+  union {
+    UINT32  OffsetToData;
+    struct {
+      UINT32  OffsetToDirectory:31;
+      UINT32  DataIsDirectory:1;
+    } s;
+  } u2;
+} EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY;
+
+///
+/// Resource directory entry for string.
+///
+typedef struct {
+  UINT16  Length;
+  CHAR16  String[1];
+} EFI_IMAGE_RESOURCE_DIRECTORY_STRING;
+
+///
+/// Resource directory entry for data array.
+///
+typedef struct {
+  UINT32  OffsetToData;
+  UINT32  Size;
+  UINT32  CodePage;
+  UINT32  Reserved;
+} EFI_IMAGE_RESOURCE_DATA_ENTRY;
+
+///
+/// Header format for TE images, defined in the PI Specification, 1.0.
+///
+typedef struct {
+  UINT16                    Signature;            ///< The signature for TE format = "VZ".
+  UINT16                    Machine;              ///< From the original file header.
+  UINT8                     NumberOfSections;     ///< From the original file header.
+  UINT8                     Subsystem;            ///< From original optional header.
+  UINT16                    StrippedSize;         ///< Number of bytes we removed from the header.
+  UINT32                    AddressOfEntryPoint;  ///< Offset to entry point -- from original optional header.
+  UINT32                    BaseOfCode;           ///< From original image -- required for ITP debug.
+  UINT64                    ImageBase;            ///< From original file header.
+  EFI_IMAGE_DATA_DIRECTORY  DataDirectory[2];     ///< Only base relocation and debug directory.
+} EFI_TE_IMAGE_HEADER;
+
+
+#define EFI_TE_IMAGE_HEADER_SIGNATURE  SIGNATURE_16('V', 'Z')
+
+//
+// Data directory indexes in our TE image header
+//
+#define EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC  0
+#define EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG      1
+
+
+///
+/// Union of PE32, PE32+, and TE headers.
+///
+typedef union {
+  EFI_IMAGE_NT_HEADERS32   Pe32;
+  EFI_IMAGE_NT_HEADERS64   Pe32Plus;
+  EFI_TE_IMAGE_HEADER      Te;
+} EFI_IMAGE_OPTIONAL_HEADER_UNION;
+
+typedef union {
+  EFI_IMAGE_NT_HEADERS32            *Pe32;
+  EFI_IMAGE_NT_HEADERS64            *Pe32Plus;
+  EFI_TE_IMAGE_HEADER               *Te;
+  EFI_IMAGE_OPTIONAL_HEADER_UNION   *Union;
+} EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION;
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Sal.h b/MdePkg/Include/IndustryStandard/Sal.h
new file mode 100644
index 000000000000..cda4e28bcde1
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Sal.h
@@ -0,0 +1,915 @@
+/** @file
+  Main SAL API's defined in Intel Itanium Processor Family System Abstraction
+  Layer Specification Revision 3.2 (December 2003)
+
+Copyright (c) 2006 - 2010, 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 __SAL_API_H__
+#define __SAL_API_H__
+
+///
+/// SAL return status type 
+///
+typedef INTN EFI_SAL_STATUS;
+
+///
+/// Call completed without error. 
+///
+#define EFI_SAL_SUCCESS               ((EFI_SAL_STATUS) 0)
+///
+/// Call completed without error, but some information was lost due to overflow. 
+///
+#define EFI_SAL_OVERFLOW              ((EFI_SAL_STATUS) 1)
+///
+/// Call completed without error; effect a warm boot of the system to complete the update.
+///
+#define EFI_SAL_WARM_BOOT_NEEDED      ((EFI_SAL_STATUS) 2)
+///
+/// More information is available for retrieval. 
+///
+#define EFI_SAL_MORE_RECORDS          ((EFI_SAL_STATUS) 3)
+///
+/// Not implemented.
+///
+#define EFI_SAL_NOT_IMPLEMENTED       ((EFI_SAL_STATUS) - 1)
+///
+/// Invalid Argument.
+///
+#define EFI_SAL_INVALID_ARGUMENT      ((EFI_SAL_STATUS) - 2)
+///
+/// Call completed without error. 
+///
+#define EFI_SAL_ERROR                 ((EFI_SAL_STATUS) - 3)
+///
+/// Virtual address not registered. 
+///
+#define EFI_SAL_VIRTUAL_ADDRESS_ERROR ((EFI_SAL_STATUS) - 4)
+///
+/// No information available. 
+///
+#define EFI_SAL_NO_INFORMATION        ((EFI_SAL_STATUS) - 5)
+///
+/// Scratch buffer required.
+///
+#define EFI_SAL_NOT_ENOUGH_SCRATCH    ((EFI_SAL_STATUS) - 9)
+
+///
+/// Return registers from SAL.
+///
+typedef struct {
+  ///
+  /// SAL return status value in r8.
+  ///
+  EFI_SAL_STATUS  Status;
+  ///
+  /// SAL returned value in r9.
+  ///
+  UINTN           r9;
+  ///
+  /// SAL returned value in r10.
+  ///
+  UINTN           r10;
+  ///
+  /// SAL returned value in r11.
+  ///
+  UINTN           r11;
+} SAL_RETURN_REGS;
+
+/**
+  Prototype of SAL procedures.
+
+  @param  FunctionId         Functional identifier.
+                             The upper 32 bits are ignored and only the lower 32 bits
+                             are used. The following functional identifiers are defined:
+                             0x01XXXXXX - Architected SAL functional group.
+                             0x02XXXXXX to 0x03XXXXXX - OEM SAL functional group. Each OEM is
+                             allowed to use the entire range in the 0x02XXXXXX to 0x03XXXXXX range.
+                             0x04XXXXXX to 0xFFFFFFFF - Reserved.
+  @param  Arg1               The first parameter of the architected/OEM specific SAL functions.
+  @param  Arg2               The second parameter of the architected/OEM specific SAL functions.
+  @param  Arg3               The third parameter passed to the ESAL function based.
+  @param  Arg4               The fourth parameter passed to the ESAL function based.
+  @param  Arg5               The fifth parameter passed to the ESAL function based.
+  @param  Arg6               The sixth parameter passed to the ESAL function.
+  @param  Arg7               The seventh parameter passed to the ESAL function based.
+
+  @return r8                 Return status: positive number indicates successful,
+                             negative number indicates failure.
+          r9                 Other return parameter in r9.
+          r10                Other return parameter in r10.
+          r11                Other return parameter in r11.
+
+**/
+typedef
+SAL_RETURN_REGS
+(EFIAPI *SAL_PROC)(
+  IN UINT64 FunctionId,
+  IN UINT64 Arg1,
+  IN UINT64 Arg2,
+  IN UINT64 Arg3,
+  IN UINT64 Arg4,
+  IN UINT64 Arg5,
+  IN UINT64 Arg6,
+  IN UINT64 Arg7
+  );
+
+//
+// SAL Procedure FunctionId definition
+//
+
+///
+/// Register software code locations with SAL.
+///
+#define EFI_SAL_SET_VECTORS             0x01000000
+///
+/// Return Machine State information obtained by SAL.
+///
+#define EFI_SAL_GET_STATE_INFO          0x01000001
+///
+/// Obtain size of Machine State information.
+///
+#define EFI_SAL_GET_STATE_INFO_SIZE     0x01000002
+///
+/// Clear Machine State information.
+///
+#define EFI_SAL_CLEAR_STATE_INFO        0x01000003
+///
+/// Cause the processor to go into a spin loop within SAL.
+///
+#define EFI_SAL_MC_RENDEZ               0x01000004
+///
+/// Register the machine check interface layer with SAL.
+///
+#define EFI_SAL_MC_SET_PARAMS           0x01000005
+///
+/// Register the physical addresses of locations needed by SAL.
+///
+#define EFI_SAL_REGISTER_PHYSICAL_ADDR  0x01000006
+///
+/// Flush the instruction or data caches.
+///
+#define EFI_SAL_CACHE_FLUSH             0x01000008
+///
+/// Initialize the instruction and data caches.
+///
+#define EFI_SAL_CACHE_INIT              0x01000009
+///
+/// Read from the PCI configuration space.
+///
+#define EFI_SAL_PCI_CONFIG_READ         0x01000010
+///
+/// Write to the PCI configuration space.
+///
+#define EFI_SAL_PCI_CONFIG_WRITE        0x01000011
+///
+/// Return the base frequency of the platform.
+///
+#define EFI_SAL_FREQ_BASE               0x01000012
+///
+/// Returns information on the physical processor mapping within the platform.
+///
+#define EFI_SAL_PHYSICAL_ID_INFO        0x01000013
+///
+/// Update the contents of firmware blocks.
+///
+#define EFI_SAL_UPDATE_PAL              0x01000020
+
+#define EFI_SAL_FUNCTION_ID_MASK        0x0000ffff
+#define EFI_SAL_MAX_SAL_FUNCTION_ID     0x00000021
+
+//
+// SAL Procedure parameter definitions
+// Not much point in using typedefs or enums because all params
+// are UINT64 and the entry point is common
+//
+
+//
+// Parameter of EFI_SAL_SET_VECTORS
+//
+// Vector type
+//
+#define EFI_SAL_SET_MCA_VECTOR          0x0
+#define EFI_SAL_SET_INIT_VECTOR         0x1
+#define EFI_SAL_SET_BOOT_RENDEZ_VECTOR  0x2
+///
+/// The format of a length_cs_n argument.
+///
+typedef struct {
+  UINT64  Length : 32;
+  UINT64  ChecksumValid : 1;
+  UINT64  Reserved1 : 7;
+  UINT64  ByteChecksum : 8;
+  UINT64  Reserved2 : 16;
+} SAL_SET_VECTORS_CS_N;
+
+//
+// Parameter of EFI_SAL_GET_STATE_INFO, EFI_SAL_GET_STATE_INFO_SIZE, and EFI_SAL_CLEAR_STATE_INFO
+// 
+// Type of information
+//
+#define EFI_SAL_MCA_STATE_INFO  0x0
+#define EFI_SAL_INIT_STATE_INFO 0x1
+#define EFI_SAL_CMC_STATE_INFO  0x2
+#define EFI_SAL_CP_STATE_INFO   0x3
+
+//
+// Parameter of EFI_SAL_MC_SET_PARAMS
+//
+// Unsigned 64-bit integer value for the parameter type of the machine check interface
+//
+#define EFI_SAL_MC_SET_RENDEZ_PARAM 0x1
+#define EFI_SAL_MC_SET_WAKEUP_PARAM 0x2
+#define EFI_SAL_MC_SET_CPE_PARAM    0x3
+//
+// Unsigned 64-bit integer value indicating whether interrupt vector or
+// memory address is specified
+//
+#define EFI_SAL_MC_SET_INTR_PARAM   0x1
+#define EFI_SAL_MC_SET_MEM_PARAM    0x2
+
+//
+// Parameter of EFI_SAL_REGISTER_PAL_PHYSICAL_ADDR
+//
+// The encoded value of the entity whose physical address is registered
+//
+#define EFI_SAL_REGISTER_PAL_ADDR 0x0
+
+//
+// Parameter of EFI_SAL_CACHE_FLUSH
+//
+// Unsigned 64-bit integer denoting type of cache flush operation
+//
+#define EFI_SAL_FLUSH_I_CACHE       0x01
+#define EFI_SAL_FLUSH_D_CACHE       0x02
+#define EFI_SAL_FLUSH_BOTH_CACHE    0x03
+#define EFI_SAL_FLUSH_MAKE_COHERENT 0x04
+
+//
+// Parameter of EFI_SAL_PCI_CONFIG_READ and EFI_SAL_PCI_CONFIG_WRITE
+//
+// PCI config size
+//
+#define EFI_SAL_PCI_CONFIG_ONE_BYTE   0x1
+#define EFI_SAL_PCI_CONFIG_TWO_BYTES  0x2
+#define EFI_SAL_PCI_CONFIG_FOUR_BYTES 0x4
+//
+// The type of PCI configuration address
+//
+#define EFI_SAL_PCI_COMPATIBLE_ADDRESS         0x0
+#define EFI_SAL_PCI_EXTENDED_REGISTER_ADDRESS  0x1
+///
+/// The format of PCI Compatible Address.
+///
+typedef struct {
+  UINT64  Register : 8;
+  UINT64  Function : 3;
+  UINT64  Device : 5;
+  UINT64  Bus : 8;
+  UINT64  Segment : 8;
+  UINT64  Reserved : 32;
+} SAL_PCI_ADDRESS;
+///
+/// The format of Extended Register Address.
+///
+typedef struct {
+  UINT64  Register : 8;
+  UINT64  ExtendedRegister : 4;
+  UINT64  Function : 3;
+  UINT64  Device : 5;
+  UINT64  Bus : 8;
+  UINT64  Segment : 16;
+  UINT64  Reserved : 20;
+} SAL_PCI_EXTENDED_REGISTER_ADDRESS;
+
+//
+// Parameter of EFI_SAL_FREQ_BASE
+//
+// Unsigned 64-bit integer specifying the type of clock source
+//
+#define EFI_SAL_CPU_INPUT_FREQ_BASE     0x0
+#define EFI_SAL_PLATFORM_IT_FREQ_BASE   0x1
+#define EFI_SAL_PLATFORM_RTC_FREQ_BASE  0x2
+
+//
+// Parameter and return value of EFI_SAL_UPDATE_PAL
+//
+// Return parameter provides additional information on the
+// failure when the status field contains a value of -3,
+// returned in r9.
+//
+#define EFI_SAL_UPDATE_BAD_PAL_VERSION  ((UINT64) -1)
+#define EFI_SAL_UPDATE_PAL_AUTH_FAIL    ((UINT64) -2)
+#define EFI_SAL_UPDATE_PAL_BAD_TYPE     ((UINT64) -3)
+#define EFI_SAL_UPDATE_PAL_READONLY     ((UINT64) -4)
+#define EFI_SAL_UPDATE_PAL_WRITE_FAIL   ((UINT64) -10)
+#define EFI_SAL_UPDATE_PAL_ERASE_FAIL   ((UINT64) -11)
+#define EFI_SAL_UPDATE_PAL_READ_FAIL    ((UINT64) -12)
+#define EFI_SAL_UPDATE_PAL_CANT_FIT     ((UINT64) -13)
+///
+/// 64-byte header of update data block.
+///
+typedef struct {
+  UINT32  Size;
+  UINT32  MmddyyyyDate;
+  UINT16  Version;
+  UINT8   Type;
+  UINT8   Reserved[5];
+  UINT64  FwVendorId;
+  UINT8   Reserved2[40];
+} SAL_UPDATE_PAL_DATA_BLOCK;
+///
+/// Data structure pointed by the parameter param_buf.
+/// It is a 16-byte aligned data structure in memory with a length of 32 bytes
+/// that describes the new firmware. This information is organized in the form
+/// of a linked list with each element describing one firmware component.
+///
+typedef struct _SAL_UPDATE_PAL_INFO_BLOCK {
+  struct _SAL_UPDATE_PAL_INFO_BLOCK *Next;
+  struct SAL_UPDATE_PAL_DATA_BLOCK  *DataBlock;
+  UINT8                             StoreChecksum;
+  UINT8                             Reserved[15];
+} SAL_UPDATE_PAL_INFO_BLOCK;
+
+///
+/// SAL System Table Definitions.
+///
+#pragma pack(1)
+typedef struct {
+  ///
+  /// The ASCII string representation of "SST_" that confirms the presence of the table. 
+  /// 
+  UINT32  Signature;
+  ///
+  /// The length of the entire table in bytes, starting from offset zero and including the
+  /// header and all entries indicated by the EntryCount field.
+  ///
+  UINT32  Length;
+  ///
+  /// The revision number of the Itanium Processor Family System Abstraction Layer
+  /// Specification supported by the SAL implementation, in binary coded decimal (BCD) format.
+  ///
+  UINT16  SalRevision;
+  ///
+  /// The number of entries in the variable portion of the table.
+  ///
+  UINT16  EntryCount;
+  ///
+  /// A modulo checksum of the entire table and the entries following this table.
+  ///
+  UINT8   CheckSum;
+  ///
+  /// Unused, must be zero.
+  ///
+  UINT8   Reserved[7];
+  ///
+  /// Version Number of the SAL_A firmware implementation in BCD format.
+  ///
+  UINT16  SalAVersion;
+  ///
+  /// Version Number of the SAL_B firmware implementation in BCD format.
+  ///
+  UINT16  SalBVersion;
+  ///
+  /// An ASCII identification string which uniquely identifies the manufacturer
+  /// of the system hardware.
+  ///
+  UINT8   OemId[32];
+  ///
+  /// An ASCII identification string which uniquely identifies a family of
+  /// compatible products from the manufacturer.
+  ///
+  UINT8   ProductId[32];
+  ///
+  /// Unused, must be zero.
+  ///
+  UINT8   Reserved2[8];
+} SAL_SYSTEM_TABLE_HEADER;
+
+#define EFI_SAL_ST_HEADER_SIGNATURE "SST_"
+#define EFI_SAL_REVISION            0x0320
+//
+// SAL System Types
+//
+#define EFI_SAL_ST_ENTRY_POINT        0
+#define EFI_SAL_ST_MEMORY_DESCRIPTOR  1
+#define EFI_SAL_ST_PLATFORM_FEATURES  2
+#define EFI_SAL_ST_TR_USAGE           3
+#define EFI_SAL_ST_PTC                4
+#define EFI_SAL_ST_AP_WAKEUP          5
+
+//
+// SAL System Type Sizes
+//
+#define EFI_SAL_ST_ENTRY_POINT_SIZE        48
+#define EFI_SAL_ST_MEMORY_DESCRIPTOR_SIZE  32
+#define EFI_SAL_ST_PLATFORM_FEATURES_SIZE  16
+#define EFI_SAL_ST_TR_USAGE_SIZE           32
+#define EFI_SAL_ST_PTC_SIZE                16
+#define EFI_SAL_ST_AP_WAKEUP_SIZE          16
+
+///
+/// Format of Entrypoint Descriptor Entry.
+///
+typedef struct {
+  UINT8   Type;         ///< Type here should be 0.
+  UINT8   Reserved[7];
+  UINT64  PalProcEntry;
+  UINT64  SalProcEntry;
+  UINT64  SalGlobalDataPointer;
+  UINT64  Reserved2[2];
+} SAL_ST_ENTRY_POINT_DESCRIPTOR;
+
+///
+/// Format of Platform Features Descriptor Entry.
+///
+typedef struct {
+  UINT8 Type;           ///< Type here should be 2.
+  UINT8 PlatformFeatures;
+  UINT8 Reserved[14];
+} SAL_ST_PLATFORM_FEATURES;
+
+//
+// Value of Platform Feature List
+//
+#define SAL_PLAT_FEAT_BUS_LOCK      0x01
+#define SAL_PLAT_FEAT_PLAT_IPI_HINT 0x02
+#define SAL_PLAT_FEAT_PROC_IPI_HINT 0x04
+
+///
+/// Format of Translation Register Descriptor Entry.
+///
+typedef struct {
+  UINT8   Type;         ///< Type here should be 3.
+  UINT8   TRType;
+  UINT8   TRNumber;
+  UINT8   Reserved[5];
+  UINT64  VirtualAddress;
+  UINT64  EncodedPageSize;
+  UINT64  Reserved1;
+} SAL_ST_TR_DECRIPTOR;
+
+//
+// Type of Translation Register
+//
+#define EFI_SAL_ST_TR_USAGE_INSTRUCTION 00
+#define EFI_SAL_ST_TR_USAGE_DATA        01
+
+///
+/// Definition of Coherence Domain Information.
+///
+typedef struct {
+  UINT64  NumberOfProcessors;
+  UINT64  LocalIDRegister;
+} SAL_COHERENCE_DOMAIN_INFO;
+           
+///
+/// Format of Purge Translation Cache Coherence Domain Entry.
+///
+typedef struct {
+  UINT8                     Type;       ///< Type here should be 4.
+  UINT8                     Reserved[3];
+  UINT32                    NumberOfDomains;
+  SAL_COHERENCE_DOMAIN_INFO *DomainInformation;
+} SAL_ST_CACHE_COHERENCE_DECRIPTOR;
+
+///
+/// Format of Application Processor Wake-Up Descriptor Entry.
+///
+typedef struct {
+  UINT8   Type;                   ///< Type here should be 5.
+  UINT8   WakeUpType;
+  UINT8   Reserved[6];
+  UINT64  ExternalInterruptVector;
+} SAL_ST_AP_WAKEUP_DECRIPTOR;
+
+///
+/// Format of Firmware Interface Table (FIT) Entry.
+///
+typedef struct {
+  UINT64  Address;
+  UINT8   Size[3];
+  UINT8   Reserved;
+  UINT16  Revision;
+  UINT8   Type : 7;
+  UINT8   CheckSumValid : 1;
+  UINT8   CheckSum;
+} EFI_SAL_FIT_ENTRY;
+//
+// FIT Types 
+//
+#define EFI_SAL_FIT_FIT_HEADER_TYPE                0x00
+#define EFI_SAL_FIT_PAL_B_TYPE                     0x01
+//
+// Type from 0x02 to 0x0D is reserved.
+//
+#define EFI_SAL_FIT_PROCESSOR_SPECIFIC_PAL_A_TYPE  0x0E
+#define EFI_SAL_FIT_PAL_A_TYPE                     0x0F
+//
+// OEM-defined type range is from 0x10 to 0x7E.
+// Here we defined the PEI_CORE type as 0x10
+//
+#define EFI_SAL_FIT_PEI_CORE_TYPE                  0x10
+#define EFI_SAL_FIT_UNUSED_TYPE                    0x7F
+
+//
+// FIT Entry
+//
+#define EFI_SAL_FIT_ENTRY_PTR   (0x100000000 - 32)  // 4GB - 24
+#define EFI_SAL_FIT_PALA_ENTRY  (0x100000000 - 48)  // 4GB - 32
+#define EFI_SAL_FIT_PALB_TYPE   01
+
+//
+// Following definitions are for Error Record Structure
+//
+
+///
+/// Format of TimeStamp field in Record Header.
+///
+typedef struct {
+  UINT8 Seconds;
+  UINT8 Minutes;
+  UINT8 Hours;
+  UINT8 Reserved;
+  UINT8 Day;
+  UINT8 Month;
+  UINT8 Year;
+  UINT8 Century;
+} SAL_TIME_STAMP;
+///
+/// Definition of Record Header.
+///
+typedef struct {
+  UINT64          RecordId;
+  UINT16          Revision;
+  UINT8           ErrorSeverity;
+  UINT8           ValidationBits;
+  UINT32          RecordLength;
+  SAL_TIME_STAMP  TimeStamp;
+  UINT8           OemPlatformId[16];
+} SAL_RECORD_HEADER;
+///
+/// Definition of Section Header.
+///
+typedef struct {
+  GUID      Guid;
+  UINT16    Revision;
+  UINT8     ErrorRecoveryInfo;
+  UINT8     Reserved;
+  UINT32    SectionLength;
+} SAL_SEC_HEADER;
+
+///
+/// GUID of Processor Machine Check Errors.
+///
+#define SAL_PROCESSOR_ERROR_RECORD_INFO \
+  { \
+    0xe429faf1, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for valid bits of MOD_ERROR_INFO
+//
+#define CHECK_INFO_VALID_BIT_MASK   0x1
+#define REQUESTOR_ID_VALID_BIT_MASK 0x2
+#define RESPONDER_ID_VALID_BIT_MASK 0x4
+#define TARGER_ID_VALID_BIT_MASK    0x8
+#define PRECISE_IP_VALID_BIT_MASK   0x10
+///
+/// Definition of MOD_ERROR_INFO_STRUCT.
+///
+typedef struct {
+  UINT64  InfoValid : 1;
+  UINT64  ReqValid : 1;
+  UINT64  RespValid : 1;
+  UINT64  TargetValid : 1;
+  UINT64  IpValid : 1;
+  UINT64  Reserved : 59;
+  UINT64  Info;
+  UINT64  Req;
+  UINT64  Resp;
+  UINT64  Target;
+  UINT64  Ip;
+} MOD_ERROR_INFO;
+///
+/// Definition of CPUID_INFO_STRUCT.
+///
+typedef struct {
+  UINT8 CpuidInfo[40];
+  UINT8 Reserved;
+} CPUID_INFO;
+
+typedef struct {
+  UINT64  FrLow;
+  UINT64  FrHigh;
+} FR_STRUCT;
+//
+// Bit masks for PSI_STATIC_STRUCT.ValidFieldBits
+//
+#define MIN_STATE_VALID_BIT_MASK  0x1
+#define BR_VALID_BIT_MASK         0x2
+#define CR_VALID_BIT_MASK         0x4
+#define AR_VALID_BIT_MASK         0x8
+#define RR_VALID_BIT_MASK         0x10
+#define FR_VALID_BIT_MASK         0x20
+///
+/// Definition of PSI_STATIC_STRUCT.
+///
+typedef struct {
+  UINT64    ValidFieldBits;
+  UINT8     MinStateInfo[1024];
+  UINT64    Br[8];
+  UINT64    Cr[128];
+  UINT64    Ar[128];
+  UINT64    Rr[8];
+  FR_STRUCT Fr[128];
+} PSI_STATIC_STRUCT;
+//
+// Bit masks for SAL_PROCESSOR_ERROR_RECORD.ValidationBits
+//
+#define PROC_ERROR_MAP_VALID_BIT_MASK       0x1
+#define PROC_STATE_PARAMETER_VALID_BIT_MASK 0x2
+#define PROC_CR_LID_VALID_BIT_MASK          0x4
+#define PROC_STATIC_STRUCT_VALID_BIT_MASK   0x8
+#define CPU_INFO_VALID_BIT_MASK             0x1000000
+///
+/// Definition of Processor Machine Check Error Record.
+///
+typedef struct {
+  SAL_SEC_HEADER    SectionHeader;
+  UINT64            ValidationBits;
+  UINT64            ProcErrorMap;
+  UINT64            ProcStateParameter;
+  UINT64            ProcCrLid;
+  MOD_ERROR_INFO    CacheError[15];
+  MOD_ERROR_INFO    TlbError[15];
+  MOD_ERROR_INFO    BusError[15];
+  MOD_ERROR_INFO    RegFileCheck[15];
+  MOD_ERROR_INFO    MsCheck[15];
+  CPUID_INFO        CpuInfo;
+  PSI_STATIC_STRUCT PsiValidData;
+} SAL_PROCESSOR_ERROR_RECORD;
+
+///
+/// GUID of Platform Memory Device Error Info.
+///
+#define SAL_MEMORY_ERROR_RECORD_INFO \
+  { \
+    0xe429faf2, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_MEMORY_ERROR_RECORD.ValidationBits
+//
+#define MEMORY_ERROR_STATUS_VALID_BIT_MASK                0x1
+#define MEMORY_PHYSICAL_ADDRESS_VALID_BIT_MASK            0x2
+#define MEMORY_ADDR_BIT_MASK                              0x4
+#define MEMORY_NODE_VALID_BIT_MASK                        0x8
+#define MEMORY_CARD_VALID_BIT_MASK                        0x10
+#define MEMORY_MODULE_VALID_BIT_MASK                      0x20
+#define MEMORY_BANK_VALID_BIT_MASK                        0x40
+#define MEMORY_DEVICE_VALID_BIT_MASK                      0x80
+#define MEMORY_ROW_VALID_BIT_MASK                         0x100
+#define MEMORY_COLUMN_VALID_BIT_MASK                      0x200
+#define MEMORY_BIT_POSITION_VALID_BIT_MASK                0x400
+#define MEMORY_PLATFORM_REQUESTOR_ID_VALID_BIT_MASK       0x800
+#define MEMORY_PLATFORM_RESPONDER_ID_VALID_BIT_MASK       0x1000
+#define MEMORY_PLATFORM_TARGET_VALID_BIT_MASK             0x2000
+#define MEMORY_PLATFORM_BUS_SPECIFIC_DATA_VALID_BIT_MASK  0x4000
+#define MEMORY_PLATFORM_OEM_ID_VALID_BIT_MASK             0x8000
+#define MEMORY_PLATFORM_OEM_DATA_STRUCT_VALID_BIT_MASK    0x10000
+///
+/// Definition of Platform Memory Device Error Info Record.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT64          MemErrorStatus;
+  UINT64          MemPhysicalAddress;
+  UINT64          MemPhysicalAddressMask;
+  UINT16          MemNode;
+  UINT16          MemCard;
+  UINT16          MemModule;
+  UINT16          MemBank;
+  UINT16          MemDevice;
+  UINT16          MemRow;
+  UINT16          MemColumn;
+  UINT16          MemBitPosition;
+  UINT64          ModRequestorId;
+  UINT64          ModResponderId;
+  UINT64          ModTargetId;
+  UINT64          BusSpecificData;
+  UINT8           MemPlatformOemId[16];
+} SAL_MEMORY_ERROR_RECORD;
+
+///
+/// GUID of Platform PCI Bus Error Info.
+///
+#define SAL_PCI_BUS_ERROR_RECORD_INFO \
+  { \
+    0xe429faf4, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_PCI_BUS_ERROR_RECORD.ValidationBits
+//
+#define PCI_BUS_ERROR_STATUS_VALID_BIT_MASK     0x1
+#define PCI_BUS_ERROR_TYPE_VALID_BIT_MASK       0x2
+#define PCI_BUS_ID_VALID_BIT_MASK               0x4
+#define PCI_BUS_ADDRESS_VALID_BIT_MASK          0x8
+#define PCI_BUS_DATA_VALID_BIT_MASK             0x10
+#define PCI_BUS_CMD_VALID_BIT_MASK              0x20
+#define PCI_BUS_REQUESTOR_ID_VALID_BIT_MASK     0x40
+#define PCI_BUS_RESPONDER_ID_VALID_BIT_MASK     0x80
+#define PCI_BUS_TARGET_VALID_BIT_MASK           0x100
+#define PCI_BUS_OEM_ID_VALID_BIT_MASK           0x200
+#define PCI_BUS_OEM_DATA_STRUCT_VALID_BIT_MASK  0x400
+
+///
+/// Designated PCI Bus identifier.
+///
+typedef struct {
+  UINT8 BusNumber;
+  UINT8 SegmentNumber;
+} PCI_BUS_ID;
+
+///
+/// Definition of Platform PCI Bus Error Info Record.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT64          PciBusErrorStatus;
+  UINT16          PciBusErrorType;
+  PCI_BUS_ID      PciBusId;
+  UINT32          Reserved;
+  UINT64          PciBusAddress;
+  UINT64          PciBusData;
+  UINT64          PciBusCommand;
+  UINT64          PciBusRequestorId;
+  UINT64          PciBusResponderId;
+  UINT64          PciBusTargetId;
+  UINT8           PciBusOemId[16];
+} SAL_PCI_BUS_ERROR_RECORD;
+
+///
+/// GUID of Platform PCI Component Error Info.
+///
+#define SAL_PCI_COMP_ERROR_RECORD_INFO \
+  { \
+    0xe429faf6, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_PCI_COMPONENT_ERROR_RECORD.ValidationBits
+//
+#define PCI_COMP_ERROR_STATUS_VALID_BIT_MASK    0x1
+#define PCI_COMP_INFO_VALID_BIT_MASK            0x2
+#define PCI_COMP_MEM_NUM_VALID_BIT_MASK         0x4
+#define PCI_COMP_IO_NUM_VALID_BIT_MASK          0x8
+#define PCI_COMP_REG_DATA_PAIR_VALID_BIT_MASK   0x10
+#define PCI_COMP_OEM_DATA_STRUCT_VALID_BIT_MASK 0x20
+///
+/// Format of PCI Component Information to identify the device.
+///
+typedef struct {
+  UINT16  VendorId;
+  UINT16  DeviceId;
+  UINT8   ClassCode[3];
+  UINT8   FunctionNumber;
+  UINT8   DeviceNumber;
+  UINT8   BusNumber;
+  UINT8   SegmentNumber;
+  UINT8   Reserved[5];
+} PCI_COMP_INFO;
+///
+/// Definition of Platform PCI Component Error Info.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT64          PciComponentErrorStatus;
+  PCI_COMP_INFO   PciComponentInfo;
+  UINT32          PciComponentMemNum;
+  UINT32          PciComponentIoNum;
+  UINT8           PciBusOemId[16];
+} SAL_PCI_COMPONENT_ERROR_RECORD;
+
+///
+/// Platform SEL Device Error Info.
+///
+#define SAL_SEL_DEVICE_ERROR_RECORD_INFO \
+  { \
+    0xe429faf3, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_SEL_DEVICE_ERROR_RECORD.ValidationBits
+//
+#define SEL_RECORD_ID_VALID_BIT_MASK      0x1;
+#define SEL_RECORD_TYPE_VALID_BIT_MASK    0x2;
+#define SEL_GENERATOR_ID_VALID_BIT_MASK   0x4;
+#define SEL_EVM_REV_VALID_BIT_MASK        0x8;
+#define SEL_SENSOR_TYPE_VALID_BIT_MASK    0x10;
+#define SEL_SENSOR_NUM_VALID_BIT_MASK     0x20;
+#define SEL_EVENT_DIR_TYPE_VALID_BIT_MASK 0x40;
+#define SEL_EVENT_DATA1_VALID_BIT_MASK    0x80;
+#define SEL_EVENT_DATA2_VALID_BIT_MASK    0x100;
+#define SEL_EVENT_DATA3_VALID_BIT_MASK    0x200;
+///
+/// Definition of Platform SEL Device Error Info Record.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT16          SelRecordId;
+  UINT8           SelRecordType;
+  UINT32          TimeStamp;
+  UINT16          GeneratorId;
+  UINT8           EvmRevision;
+  UINT8           SensorType;
+  UINT8           SensorNum;
+  UINT8           EventDirType;
+  UINT8           Data1;
+  UINT8           Data2;
+  UINT8           Data3;
+} SAL_SEL_DEVICE_ERROR_RECORD;
+
+///
+/// GUID of Platform SMBIOS Device Error Info.
+///
+#define SAL_SMBIOS_ERROR_RECORD_INFO \
+  { \
+    0xe429faf5, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_SMBIOS_DEVICE_ERROR_RECORD.ValidationBits
+//
+#define SMBIOS_EVENT_TYPE_VALID_BIT_MASK  0x1
+#define SMBIOS_LENGTH_VALID_BIT_MASK      0x2
+#define SMBIOS_TIME_STAMP_VALID_BIT_MASK  0x4
+#define SMBIOS_DATA_VALID_BIT_MASK        0x8
+///
+/// Definition of Platform SMBIOS Device Error Info Record.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT8           SmbiosEventType;
+  UINT8           SmbiosLength;
+  UINT8           SmbiosBcdTimeStamp[6];
+} SAL_SMBIOS_DEVICE_ERROR_RECORD;
+
+///
+/// GUID of Platform Specific Error Info.
+///
+#define SAL_PLATFORM_ERROR_RECORD_INFO \
+  { \
+    0xe429faf7, 0x3cb7, 0x11d4, {0xbc, 0xa7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
+//
+// Bit masks for SAL_PLATFORM_SPECIFIC_ERROR_RECORD.ValidationBits
+//
+#define PLATFORM_ERROR_STATUS_VALID_BIT_MASK    0x1
+#define PLATFORM_REQUESTOR_ID_VALID_BIT_MASK    0x2
+#define PLATFORM_RESPONDER_ID_VALID_BIT_MASK    0x4
+#define PLATFORM_TARGET_VALID_BIT_MASK          0x8
+#define PLATFORM_SPECIFIC_DATA_VALID_BIT_MASK   0x10
+#define PLATFORM_OEM_ID_VALID_BIT_MASK          0x20
+#define PLATFORM_OEM_DATA_STRUCT_VALID_BIT_MASK 0x40
+#define PLATFORM_OEM_DEVICE_PATH_VALID_BIT_MASK 0x80
+///
+/// Definition of Platform Specific Error Info Record.
+///
+typedef struct {
+  SAL_SEC_HEADER  SectionHeader;
+  UINT64          ValidationBits;
+  UINT64          PlatformErrorStatus;
+  UINT64          PlatformRequestorId;
+  UINT64          PlatformResponderId;
+  UINT64          PlatformTargetId;
+  UINT64          PlatformBusSpecificData;
+  UINT8           OemComponentId[16];
+} SAL_PLATFORM_SPECIFIC_ERROR_RECORD;
+
+///
+/// Union of all the possible SAL Error Record Types.
+///
+typedef union {
+  SAL_RECORD_HEADER                   *RecordHeader;
+  SAL_PROCESSOR_ERROR_RECORD          *SalProcessorRecord;
+  SAL_PCI_BUS_ERROR_RECORD            *SalPciBusRecord;
+  SAL_PCI_COMPONENT_ERROR_RECORD      *SalPciComponentRecord;
+  SAL_SEL_DEVICE_ERROR_RECORD         *ImpiRecord;
+  SAL_SMBIOS_DEVICE_ERROR_RECORD      *SmbiosRecord;
+  SAL_PLATFORM_SPECIFIC_ERROR_RECORD  *PlatformRecord;
+  SAL_MEMORY_ERROR_RECORD             *MemoryRecord;
+  UINT8                               *Raw;
+} SAL_ERROR_RECORDS_POINTERS;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Scsi.h b/MdePkg/Include/IndustryStandard/Scsi.h
new file mode 100644
index 000000000000..6de1cfd978e7
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Scsi.h
@@ -0,0 +1,412 @@
+/** @file
+  Support for SCSI-2 standard
+
+  Copyright (c) 2006 - 2016, 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 __SCSI_H__
+#define __SCSI_H__
+
+//
+// SCSI command OP Code
+//
+//
+// Commands for all device types
+//
+#define EFI_SCSI_OP_CHANGE_DEFINITION 0x40
+#define EFI_SCSI_OP_COMPARE           0x39
+#define EFI_SCSI_OP_COPY              0x18
+#define EFI_SCSI_OP_COPY_VERIFY       0x3a
+#define EFI_SCSI_OP_INQUIRY           0x12
+#define EFI_SCSI_OP_LOG_SELECT        0x4c
+#define EFI_SCSI_OP_LOG_SENSE         0x4d
+#define EFI_SCSI_OP_MODE_SEL6         0x15
+#define EFI_SCSI_OP_MODE_SEL10        0x55
+#define EFI_SCSI_OP_MODE_SEN6         0x1a
+#define EFI_SCSI_OP_MODE_SEN10        0x5a
+#define EFI_SCSI_OP_READ_BUFFER       0x3c
+#define EFI_SCSI_OP_RECEIVE_DIAG      0x1c
+#define EFI_SCSI_OP_REQUEST_SENSE     0x03
+#define EFI_SCSI_OP_SEND_DIAG         0x1d
+#define EFI_SCSI_OP_TEST_UNIT_READY   0x00
+#define EFI_SCSI_OP_WRITE_BUFF        0x3b
+
+//
+// Additional commands for Direct Access Devices
+//
+#define EFI_SCSI_OP_FORMAT          0x04
+#define EFI_SCSI_OP_LOCK_UN_CACHE   0x36
+#define EFI_SCSI_OP_PREFETCH        0x34
+#define EFI_SCSI_OP_MEDIA_REMOVAL   0x1e
+#define EFI_SCSI_OP_READ6           0x08
+#define EFI_SCSI_OP_READ10          0x28
+#define EFI_SCSI_OP_READ16          0x88
+#define EFI_SCSI_OP_READ_CAPACITY   0x25
+#define EFI_SCSI_OP_READ_CAPACITY16 0x9e
+#define EFI_SCSI_OP_READ_DEFECT     0x37
+#define EFI_SCSI_OP_READ_LONG       0x3e
+#define EFI_SCSI_OP_REASSIGN_BLK    0x07
+#define EFI_SCSI_OP_RELEASE         0x17
+#define EFI_SCSI_OP_REZERO          0x01
+#define EFI_SCSI_OP_SEARCH_DATA_E   0x31
+#define EFI_SCSI_OP_SEARCH_DATA_H   0x30
+#define EFI_SCSI_OP_SEARCH_DATA_L   0x32
+#define EFI_SCSI_OP_SEEK6           0x0b
+#define EFI_SCSI_OP_SEEK10          0x2b
+#define EFI_SCSI_OP_SEND_DIAG       0x1d
+#define EFI_SCSI_OP_SET_LIMIT       0x33
+#define EFI_SCSI_OP_START_STOP_UNIT 0x1b
+#define EFI_SCSI_OP_SYNC_CACHE      0x35
+#define EFI_SCSI_OP_VERIFY          0x2f
+#define EFI_SCSI_OP_WRITE6          0x0a
+#define EFI_SCSI_OP_WRITE10         0x2a
+#define EFI_SCSI_OP_WRITE16         0x8a
+#define EFI_SCSI_OP_WRITE_VERIFY    0x2e
+#define EFI_SCSI_OP_WRITE_LONG      0x3f
+#define EFI_SCSI_OP_WRITE_SAME      0x41
+#define EFI_SCSI_OP_UNMAP           0x42
+
+//
+// Additional commands for Sequential Access Devices
+//
+#define EFI_SCSI_OP_ERASE             0x19
+#define EFI_SCSI_OP_LOAD_UNLOAD       0x1b
+#define EFI_SCSI_OP_LOCATE            0x2b
+#define EFI_SCSI_OP_READ_BLOCK_LIMIT  0x05
+#define EFI_SCSI_OP_READ_POS          0x34
+#define EFI_SCSI_OP_READ_REVERSE      0x0f
+#define EFI_SCSI_OP_RECOVER_BUF_DATA  0x14
+#define EFI_SCSI_OP_RESERVE_UNIT      0x16
+#define EFI_SCSI_OP_REWIND            0x01
+#define EFI_SCSI_OP_SPACE             0x11
+#define EFI_SCSI_OP_VERIFY_TAPE       0x13
+#define EFI_SCSI_OP_WRITE_FILEMARK    0x10
+
+//
+// Additional commands for Printer Devices
+//
+#define EFI_SCSI_OP_PRINT       0x0a
+#define EFI_SCSI_OP_SLEW_PRINT  0x0b
+#define EFI_SCSI_OP_STOP_PRINT  0x1b
+#define EFI_SCSI_OP_SYNC_BUFF   0x10
+
+//
+// Additional commands for Processor Devices
+//
+#define EFI_SCSI_OP_RECEIVE 0x08
+#define EFI_SCSI_OP_SEND    0x0a
+
+//
+// Additional commands for Write-Once Devices
+//
+#define EFI_SCSI_OP_MEDIUM_SCAN     0x38
+#define EFI_SCSI_OP_SEARCH_DAT_E10  0x31
+#define EFI_SCSI_OP_SEARCH_DAT_E12  0xb1
+#define EFI_SCSI_OP_SEARCH_DAT_H10  0x30
+#define EFI_SCSI_OP_SEARCH_DAT_H12  0xb0
+#define EFI_SCSI_OP_SEARCH_DAT_L10  0x32
+#define EFI_SCSI_OP_SEARCH_DAT_L12  0xb2
+#define EFI_SCSI_OP_SET_LIMIT10     0x33
+#define EFI_SCSI_OP_SET_LIMIT12     0xb3
+#define EFI_SCSI_OP_VERIFY10        0x2f
+#define EFI_SCSI_OP_VERIFY12        0xaf
+#define EFI_SCSI_OP_WRITE12         0xaa
+#define EFI_SCSI_OP_WRITE_VERIFY10  0x2e
+#define EFI_SCSI_OP_WRITE_VERIFY12  0xae
+
+//
+// Additional commands for CD-ROM Devices
+//
+#define EFI_SCSI_OP_PLAY_AUD_10       0x45
+#define EFI_SCSI_OP_PLAY_AUD_12       0xa5
+#define EFI_SCSI_OP_PLAY_AUD_MSF      0x47
+#define EFI_SCSI_OP_PLAY_AUD_TKIN     0x48
+#define EFI_SCSI_OP_PLAY_TK_REL10     0x49
+#define EFI_SCSI_OP_PLAY_TK_REL12     0xa9
+#define EFI_SCSI_OP_READ_CD_CAPACITY  0x25
+#define EFI_SCSI_OP_READ_HEADER       0x44
+#define EFI_SCSI_OP_READ_SUB_CHANNEL  0x42
+#define EFI_SCSI_OP_READ_TOC          0x43
+
+//
+// Additional commands for Scanner Devices
+//
+#define EFI_SCSI_OP_GET_DATABUFF_STAT 0x34
+#define EFI_SCSI_OP_GET_WINDOW        0x25
+#define EFI_SCSI_OP_OBJECT_POS        0x31
+#define EFI_SCSI_OP_SCAN              0x1b
+#define EFI_SCSI_OP_SET_WINDOW        0x24
+
+//
+// Additional commands for Optical Memory Devices
+//
+#define EFI_SCSI_OP_UPDATE_BLOCK  0x3d
+
+//
+// Additional commands for Medium Changer Devices
+//
+#define EFI_SCSI_OP_EXCHANGE_MEDIUM   0xa6
+#define EFI_SCSI_OP_INIT_ELEMENT_STAT 0x07
+#define EFI_SCSI_OP_POS_TO_ELEMENT    0x2b
+#define EFI_SCSI_OP_REQUEST_VE_ADDR   0xb5
+#define EFI_SCSI_OP_SEND_VOL_TAG      0xb6
+
+//
+// Additional commands for Communition Devices
+//
+#define EFI_SCSI_OP_GET_MESSAGE6    0x08
+#define EFI_SCSI_OP_GET_MESSAGE10   0x28
+#define EFI_SCSI_OP_GET_MESSAGE12   0xa8
+#define EFI_SCSI_OP_SEND_MESSAGE6   0x0a
+#define EFI_SCSI_OP_SEND_MESSAGE10  0x2a
+#define EFI_SCSI_OP_SEND_MESSAGE12  0xaa
+
+//
+// SCSI Data Transfer Direction
+//
+#define EFI_SCSI_DATA_IN  0
+#define EFI_SCSI_DATA_OUT 1
+
+//
+// Peripheral Device Type Definitions
+//
+#define EFI_SCSI_TYPE_DISK          0x00  ///< Direct-access device (e.g. magnetic disk)
+#define EFI_SCSI_TYPE_TAPE          0x01  ///< Sequential-access device (e.g. magnetic tape)
+#define EFI_SCSI_TYPE_PRINTER       0x02  ///< Printer device
+#define EFI_SCSI_TYPE_PROCESSOR     0x03  ///< Processor device
+#define EFI_SCSI_TYPE_WORM          0x04  ///< Write-once device (e.g. some optical disks)
+#define EFI_SCSI_TYPE_CDROM         0x05  ///< CD-ROM device
+#define EFI_SCSI_TYPE_SCANNER       0x06  ///< Scanner device
+#define EFI_SCSI_TYPE_OPTICAL       0x07  ///< Optical memory device (e.g. some optical disks)
+#define EFI_SCSI_TYPE_MEDIUMCHANGER 0x08  ///< Medium changer device (e.g. jukeboxes)
+#define EFI_SCSI_TYPE_COMMUNICATION 0x09  ///< Communications device
+#define EFI_SCSI_TYPE_ASCIT8_1      0x0A  ///< Defined by ASC IT8 (Graphic arts pre-press devices)
+#define EFI_SCSI_TYPE_ASCIT8_2      0x0B  ///< Defined by ASC IT8 (Graphic arts pre-press devices)
+//
+// 0Ch - 1Eh are reserved
+//
+#define EFI_SCSI_TYPE_UNKNOWN       0x1F  ///< Unknown or no device type
+
+//
+// Page Codes for INQUIRY command
+//
+#define EFI_SCSI_PAGE_CODE_SUPPORTED_VPD    0x00
+#define EFI_SCSI_PAGE_CODE_BLOCK_LIMITS_VPD 0xB0
+
+#pragma pack(1)
+///
+/// Standard INQUIRY data format
+///
+typedef struct {
+  UINT8 Peripheral_Type : 5;
+  UINT8 Peripheral_Qualifier : 3;
+  UINT8 DeviceType_Modifier : 7;
+  UINT8 Rmb : 1;
+  UINT8 Version;
+  UINT8 Response_Data_Format;
+  UINT8 Addnl_Length;
+  UINT8 Reserved_5_95[95 - 5 + 1];
+} EFI_SCSI_INQUIRY_DATA;
+
+///
+/// Supported VPD Pages VPD page
+///
+typedef struct {
+  UINT8 Peripheral_Type : 5;
+  UINT8 Peripheral_Qualifier : 3;
+  UINT8 PageCode;
+  UINT8 PageLength2;
+  UINT8 PageLength1;
+  UINT8 SupportedVpdPageList[0x100];
+} EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE;
+
+///
+/// Block Limits VPD page
+///
+typedef struct {
+  UINT8 Peripheral_Type : 5;
+  UINT8 Peripheral_Qualifier : 3;
+  UINT8 PageCode;
+  UINT8 PageLength2;
+  UINT8 PageLength1;
+  UINT8 WriteSameNonZero : 1;
+  UINT8 Reserved_4 : 7;
+  UINT8 MaximumCompareAndWriteLength;
+  UINT8 OptimalTransferLengthGranularity2;
+  UINT8 OptimalTransferLengthGranularity1;
+  UINT8 MaximumTransferLength4;
+  UINT8 MaximumTransferLength3;
+  UINT8 MaximumTransferLength2;
+  UINT8 MaximumTransferLength1;
+  UINT8 OptimalTransferLength4;
+  UINT8 OptimalTransferLength3;
+  UINT8 OptimalTransferLength2;
+  UINT8 OptimalTransferLength1;
+  UINT8 MaximumPrefetchXdreadXdwriteTransferLength4;
+  UINT8 MaximumPrefetchXdreadXdwriteTransferLength3;
+  UINT8 MaximumPrefetchXdreadXdwriteTransferLength2;
+  UINT8 MaximumPrefetchXdreadXdwriteTransferLength1;
+  UINT8 MaximumUnmapLbaCount4;
+  UINT8 MaximumUnmapLbaCount3;
+  UINT8 MaximumUnmapLbaCount2;
+  UINT8 MaximumUnmapLbaCount1;
+  UINT8 MaximumUnmapBlockDescriptorCount4;
+  UINT8 MaximumUnmapBlockDescriptorCount3;
+  UINT8 MaximumUnmapBlockDescriptorCount2;
+  UINT8 MaximumUnmapBlockDescriptorCount1;
+  UINT8 OptimalUnmapGranularity4;
+  UINT8 OptimalUnmapGranularity3;
+  UINT8 OptimalUnmapGranularity2;
+  UINT8 OptimalUnmapGranularity1;
+  UINT8 UnmapGranularityAlignment4 : 7;
+  UINT8 UnmapGranularityAlignmentValid : 1;
+  UINT8 UnmapGranularityAlignment3;
+  UINT8 UnmapGranularityAlignment2;
+  UINT8 UnmapGranularityAlignment1;
+  UINT8 MaximumWriteSameLength4;
+  UINT8 MaximumWriteSameLength3;
+  UINT8 MaximumWriteSameLength2;
+  UINT8 MaximumWriteSameLength1;
+  UINT8 MaximumAtomicTransferLength4;
+  UINT8 MaximumAtomicTransferLength3;
+  UINT8 MaximumAtomicTransferLength2;
+  UINT8 MaximumAtomicTransferLength1;
+  UINT8 AtomicAlignment4;
+  UINT8 AtomicAlignment3;
+  UINT8 AtomicAlignment2;
+  UINT8 AtomicAlignment1;
+  UINT8 AtomicTransferLengthGranularity4;
+  UINT8 AtomicTransferLengthGranularity3;
+  UINT8 AtomicTransferLengthGranularity2;
+  UINT8 AtomicTransferLengthGranularity1;
+  UINT8 MaximumAtomicTransferLengthWithAtomicBoundary4;
+  UINT8 MaximumAtomicTransferLengthWithAtomicBoundary3;
+  UINT8 MaximumAtomicTransferLengthWithAtomicBoundary2;
+  UINT8 MaximumAtomicTransferLengthWithAtomicBoundary1;
+  UINT8 MaximumAtomicBoundarySize4;
+  UINT8 MaximumAtomicBoundarySize3;
+  UINT8 MaximumAtomicBoundarySize2;
+  UINT8 MaximumAtomicBoundarySize1;
+} EFI_SCSI_BLOCK_LIMITS_VPD_PAGE;
+
+///
+/// Error codes 70h and 71h sense data format
+///
+typedef struct {
+  UINT8 Error_Code : 7;
+  UINT8 Valid : 1;
+  UINT8 Segment_Number;
+  UINT8 Sense_Key : 4;
+  UINT8 Reserved_21 : 1;
+  UINT8 Ili : 1;
+  UINT8 Reserved_22 : 2;
+  UINT8 Information_3_6[4];
+  UINT8 Addnl_Sense_Length;           ///< Additional sense length (n-7)
+  UINT8 Vendor_Specific_8_11[4];
+  UINT8 Addnl_Sense_Code;             ///< Additional sense code
+  UINT8 Addnl_Sense_Code_Qualifier;   ///< Additional sense code qualifier
+  UINT8 Field_Replaceable_Unit_Code;  ///< Field replaceable unit code
+  UINT8 Reserved_15_17[3];
+} EFI_SCSI_SENSE_DATA;
+
+///
+/// SCSI Disk READ CAPACITY Data
+///
+typedef struct {
+  UINT8 LastLba3;
+  UINT8 LastLba2;
+  UINT8 LastLba1;
+  UINT8 LastLba0;
+  UINT8 BlockSize3;
+  UINT8 BlockSize2;
+  UINT8 BlockSize1;
+  UINT8 BlockSize0;
+} EFI_SCSI_DISK_CAPACITY_DATA;
+
+typedef struct {
+  UINT8 LastLba7;
+  UINT8 LastLba6;
+  UINT8 LastLba5;
+  UINT8 LastLba4;
+  UINT8 LastLba3;
+  UINT8 LastLba2;
+  UINT8 LastLba1;
+  UINT8 LastLba0;
+  UINT8 BlockSize3;
+  UINT8 BlockSize2;
+  UINT8 BlockSize1;
+  UINT8 BlockSize0;
+  UINT8 Protection;
+  UINT8 LogicPerPhysical;
+  UINT8 LowestAlignLogic2;  
+  UINT8 LowestAlignLogic1;    
+  UINT8 Reserved[16];  
+} EFI_SCSI_DISK_CAPACITY_DATA16;
+
+typedef struct {
+  UINT16 DataLen;
+  UINT16 BlkDespDataLen;
+  UINT8  Reserved[4];
+} EFI_SCSI_DISK_UNMAP_PARAM_LIST_HEADER;
+
+typedef struct {
+  UINT64 Lba;
+  UINT32 BlockNum;
+  UINT8  Reserved[4];
+} EFI_SCSI_DISK_UNMAP_BLOCK_DESP;
+
+
+#pragma pack()
+
+//
+// Sense Key
+//
+#define EFI_SCSI_SK_NO_SENSE          (0x0)
+#define EFI_SCSI_SK_RECOVERY_ERROR    (0x1)
+#define EFI_SCSI_SK_NOT_READY         (0x2)
+#define EFI_SCSI_SK_MEDIUM_ERROR      (0x3)
+#define EFI_SCSI_SK_HARDWARE_ERROR    (0x4)
+#define EFI_SCSI_SK_ILLEGAL_REQUEST   (0x5)
+#define EFI_SCSI_SK_UNIT_ATTENTION    (0x6)
+#define EFI_SCSI_SK_DATA_PROTECT      (0x7)
+#define EFI_SCSI_SK_BLANK_CHECK       (0x8)
+#define EFI_SCSI_SK_VENDOR_SPECIFIC   (0x9)
+#define EFI_SCSI_SK_RESERVED_A        (0xA)
+#define EFI_SCSI_SK_ABORT             (0xB)
+#define EFI_SCSI_SK_RESERVED_C        (0xC)
+#define EFI_SCSI_SK_OVERFLOW          (0xD)
+#define EFI_SCSI_SK_MISCOMPARE        (0xE)
+#define EFI_SCSI_SK_RESERVED_F        (0xF)
+
+//
+// Additional Sense Codes and Sense Code Qualifiers.
+// Only some frequently used additional sense codes and qualifiers are
+// defined here. Please refer to SCSI standard for full value definition.
+//
+#define EFI_SCSI_ASC_NOT_READY                    (0x04)
+#define EFI_SCSI_ASCQ_IN_PROGRESS                 (0x01)
+
+#define EFI_SCSI_ASC_MEDIA_ERR1                   (0x10)
+#define EFI_SCSI_ASC_MEDIA_ERR2                   (0x11)
+#define EFI_SCSI_ASC_MEDIA_ERR3                   (0x14)
+#define EFI_SCSI_ASC_MEDIA_ERR4                   (0x30)
+#define EFI_SCSI_ASC_MEDIA_UPSIDE_DOWN            (0x06)
+#define EFI_SCSI_ASC_INVALID_CMD                  (0x20)
+#define EFI_SCSI_ASC_LBA_OUT_OF_RANGE             (0x21)
+#define EFI_SCSI_ASC_INVALID_FIELD                (0x24)
+#define EFI_SCSI_ASC_WRITE_PROTECTED              (0x27)
+#define EFI_SCSI_ASC_MEDIA_CHANGE                 (0x28)
+#define EFI_SCSI_ASC_RESET                        (0x29)   ///< Power On Reset or Bus Reset occurred
+#define EFI_SCSI_ASC_ILLEGAL_FIELD                (0x26)
+#define EFI_SCSI_ASC_NO_MEDIA                     (0x3A)
+#define EFI_SCSI_ASC_ILLEGAL_MODE_FOR_THIS_TRACK  (0x64)
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Sd.h b/MdePkg/Include/IndustryStandard/Sd.h
new file mode 100644
index 000000000000..693dfcf6dcfb
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Sd.h
@@ -0,0 +1,181 @@
+/** @file
+  Header file for SD memory card support.
+
+  This header file contains some definitions defined in SD Physical Layer Simplified
+  Specification Version 4.10 spec.
+
+  Copyright (c) 2015, 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 __SD_H__
+#define __SD_H__
+
+//
+// SD command index
+//
+#define  SD_GO_IDLE_STATE           0
+#define  SD_ALL_SEND_CID            2
+#define  SD_SET_RELATIVE_ADDR       3
+#define  SD_SET_DSR                 4
+#define  SDIO_SEND_OP_COND          5
+#define  SD_SWITCH_FUNC             6
+#define  SD_SELECT_DESELECT_CARD    7
+#define  SD_SEND_IF_COND            8
+#define  SD_SEND_CSD                9
+#define  SD_SEND_CID                10
+#define  SD_VOLTAGE_SWITCH          11
+#define  SD_STOP_TRANSMISSION       12
+#define  SD_SEND_STATUS             13
+#define  SD_GO_INACTIVE_STATE       15
+#define  SD_SET_BLOCKLEN            16
+#define  SD_READ_SINGLE_BLOCK       17
+#define  SD_READ_MULTIPLE_BLOCK     18
+#define  SD_SEND_TUNING_BLOCK       19
+#define  SD_SPEED_CLASS_CONTROL     20
+#define  SD_SET_BLOCK_COUNT         23
+#define  SD_WRITE_SINGLE_BLOCK      24
+#define  SD_WRITE_MULTIPLE_BLOCK    25
+#define  SD_PROGRAM_CSD             27
+#define  SD_SET_WRITE_PROT          28
+#define  SD_CLR_WRITE_PROT          29
+#define  SD_SEND_WRITE_PROT         30
+#define  SD_ERASE_WR_BLK_START      32
+#define  SD_ERASE_WR_BLK_END        33
+#define  SD_ERASE                   38
+#define  SD_LOCK_UNLOCK             42
+#define  SD_READ_EXTR_SINGLE        48
+#define  SD_WRITE_EXTR_SINGLE       49
+#define  SDIO_RW_DIRECT             52
+#define  SDIO_RW_EXTENDED           53
+#define  SD_APP_CMD                 55
+#define  SD_GEN_CMD                 56
+#define  SD_READ_EXTR_MULTI         58
+#define  SD_WRITE_EXTR_MULTI        59
+
+#define  SD_SET_BUS_WIDTH           6           // ACMD6
+#define  SD_STATUS                  13          // ACMD13
+#define  SD_SEND_NUM_WR_BLOCKS      22          // ACMD22
+#define  SD_SET_WR_BLK_ERASE_COUNT  23          // ACMD23
+#define  SD_SEND_OP_COND            41          // ACMD41
+#define  SD_SET_CLR_CARD_DETECT     42          // ACMD42
+#define  SD_SEND_SCR                51          // ACMD51
+
+#pragma pack(1)
+typedef struct {
+  UINT8   NotUsed:1;                            // Not used [0:0]
+  UINT8   Crc:7;                                // CRC [7:1]
+  UINT16  ManufacturingDate:12;                 // Manufacturing date [19:8]
+  UINT16  Reserved:4;                           // Reserved [23:20]
+  UINT8   ProductSerialNumber[4];               // Product serial number [55:24]
+  UINT8   ProductRevision;                      // Product revision [63:56]
+  UINT8   ProductName[5];                       // Product name [103:64]
+  UINT8   OemId[2];                             // OEM/Application ID [119:104]
+  UINT8   ManufacturerId;                       // Manufacturer ID [127:120]
+} SD_CID;
+
+typedef struct {
+  UINT32  NotUsed:1;                            // Not used [0:0]
+  UINT32  Crc:7;                                // CRC [7:1]
+  UINT32  Reserved:2;                           // Reserved [9:8]
+  UINT32  FileFormat:2;                         // File format [11:10]
+  UINT32  TmpWriteProtect:1;                    // Temporary write protection [12:12]
+  UINT32  PermWriteProtect:1;                   // Permanent write protection [13:13]
+  UINT32  Copy:1;                               // Copy flag (OTP) [14:14]
+  UINT32  FileFormatGrp:1;                      // File format group [15:15]
+  UINT32  Reserved1:5;                          // Reserved [20:16]
+  UINT32  WriteBlPartial:1;                     // Partial blocks for write allowed [21:21]
+  UINT32  WriteBlLen:4;                         // Max. write data block length [25:22]
+  UINT32  R2WFactor:3;                          // Write speed factor [28:26]
+  UINT32  Reserved2:2;                          // Manufacturer default ECC [30:29]
+  UINT32  WpGrpEnable:1;                        // Write protect group enable [31:31]
+
+  UINT32  WpGrpSize:7;                          // Write protect group size [38:32]
+  UINT32  SectorSize:7;                         // Erase sector size [45:39]
+  UINT32  EraseBlkEn:1;                         // Erase single block enable [46:46]
+  UINT32  CSizeMul:3;                           // device size multiplier [49:47]
+  UINT32  VddWCurrMax:3;                        // max. write current @VDD max [52:50]
+  UINT32  VddWCurrMin:3;                        // max. write current @VDD min [55:53]
+  UINT32  VddRCurrMax:3;                        // max. read current @VDD max [58:56]
+  UINT32  VddRCurrMin:3;                        // max. read current @VDD min [61:59]
+  UINT32  CSizeLow:2;                           // Device size low 2 bits [63:62]
+
+  UINT32  CSizeHigh:10;                         // Device size high 10 bits [73:64]
+  UINT32  Reserved4:2;                          // Reserved [75:74]
+  UINT32  DsrImp:1;                             // DSR implemented [76:76]
+  UINT32  ReadBlkMisalign:1;                    // Read block misalignment [77:77]
+  UINT32  WriteBlkMisalign:1;                   // Write block misalignment [78:78]
+  UINT32  ReadBlPartial:1;                      // Partial blocks for read allowed [79:79]
+  UINT32  ReadBlLen:4;                          // Max. read data block length [83:80]
+  UINT32  Ccc:12;                               // Card command classes [95:84]
+
+  UINT32  TranSpeed:8;                          // Max. data transfer rate [103:96]
+  UINT32  Nsac:8;                               // Data read access-time in CLK cycles (NSAC*100) [111:104]
+  UINT32  Taac:8;                               // Data read access-time [119:112]
+  UINT32  Reserved5:6;                          // Reserved [125:120]
+  UINT32  CsdStructure:2;                       // CSD structure [127:126]
+} SD_CSD;
+
+typedef struct {
+  UINT32  NotUsed:1;                            // Not used [0:0]
+  UINT32  Crc:7;                                // CRC [7:1]
+  UINT32  Reserved:2;                           // Reserved [9:8]
+  UINT32  FileFormat:2;                         // File format [11:10]
+  UINT32  TmpWriteProtect:1;                    // Temporary write protection [12:12]
+  UINT32  PermWriteProtect:1;                   // Permanent write protection [13:13]
+  UINT32  Copy:1;                               // Copy flag (OTP) [14:14]
+  UINT32  FileFormatGrp:1;                      // File format group [15:15]
+  UINT32  Reserved1:5;                          // Reserved [20:16]
+  UINT32  WriteBlPartial:1;                     // Partial blocks for write allowed [21:21]
+  UINT32  WriteBlLen:4;                         // Max. write data block length [25:22]
+  UINT32  R2WFactor:3;                          // Write speed factor [28:26]
+  UINT32  Reserved2:2;                          // Manufacturer default ECC [30:29]
+  UINT32  WpGrpEnable:1;                        // Write protect group enable [31:31]
+
+  UINT32  WpGrpSize:7;                          // Write protect group size [38:32]
+  UINT32  SectorSize:7;                         // Erase sector size [45:39]
+  UINT32  EraseBlkEn:1;                         // Erase single block enable [46:46]
+  UINT32  Reserved3:1;                          // Reserved [47:47]
+  UINT32  CSizeLow:16;                          // Device size low 16 bits [63:48]
+
+  UINT32  CSizeHigh:6;                          // Device size high 6 bits [69:64]
+  UINT32  Reserved4:6;                          // Reserved [75:70]
+  UINT32  DsrImp:1;                             // DSR implemented [76:76]
+  UINT32  ReadBlkMisalign:1;                    // Read block misalignment [77:77]
+  UINT32  WriteBlkMisalign:1;                   // Write block misalignment [78:78]
+  UINT32  ReadBlPartial:1;                      // Partial blocks for read allowed [79:79]
+  UINT32  ReadBlLen:4;                          // Max. read data block length [83:80]
+  UINT32  Ccc:12;                               // Card command classes [95:84]
+
+  UINT32  TranSpeed:8;                          // Max. data transfer rate [103:96]
+  UINT32  Nsac:8;                               // Data read access-time in CLK cycles (NSAC*100) [111:104]
+  UINT32  Taac:8;                               // Data read access-time [119:112]
+  UINT32  Reserved5:6;                          // Reserved [125:120]
+  UINT32  CsdStructure:2;                       // CSD structure [127:126]
+} SD_CSD2;
+
+typedef struct {
+  UINT32  Reserved;                             // Reserved [31:0]
+
+  UINT32  CmdSupport:4;                         // Command Support bits [35:32]
+  UINT32  Reserved1:6;                          // Reserved [41:36]
+  UINT32  SdSpec4:1;                            // Spec. Version 4.00 or higher [42:42]
+  UINT32  ExSecurity:4;                         // Extended Security Support [46:43]
+  UINT32  SdSpec3:1;                            // Spec. Version 3.00 or higher [47:47]
+  UINT32  SdBusWidths:4;                        // DAT Bus widths supported [51:48]
+  UINT32  SdSecurity:3;                         // CPRM security support [54:52]
+  UINT32  DataStatAfterErase:1;                 // Data status after erases [55]
+  UINT32  SdSpec:4;                             // SD Memory Card Spec. Version [59:56]
+  UINT32  ScrStructure:4;                       // SCR Structure [63:60]
+} SD_SCR;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SdramSpd.h b/MdePkg/Include/IndustryStandard/SdramSpd.h
new file mode 100644
index 000000000000..0a4d8943c001
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SdramSpd.h
@@ -0,0 +1,74 @@
+/** @file
+  This file contains definitions for the SPD fields on an SDRAM.
+
+  Copyright (c) 2007 - 2016, 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 _SDRAM_SPD_H_
+#define _SDRAM_SPD_H_
+
+#include <IndustryStandard/SdramSpdDdr3.h>
+#include <IndustryStandard/SdramSpdDdr4.h>
+#include <IndustryStandard/SdramSpdLpDdr.h>
+
+//
+// SDRAM SPD field definitions
+//
+#define SPD_MEMORY_TYPE                 2
+#define SPD_SDRAM_ROW_ADDR              3
+#define SPD_SDRAM_COL_ADDR              4
+#define SPD_SDRAM_MODULE_ROWS           5
+#define SPD_SDRAM_MODULE_DATA_WIDTH_LSB 6
+#define SPD_SDRAM_MODULE_DATA_WIDTH_MSB 7
+#define SPD_SDRAM_ECC_SUPPORT           11
+#define SPD_SDRAM_REFRESH               12
+#define SPD_SDRAM_WIDTH                 13
+#define SPD_SDRAM_ERROR_WIDTH           14
+#define SPD_SDRAM_BURST_LENGTH          16
+#define SPD_SDRAM_NO_OF_BANKS           17
+#define SPD_SDRAM_CAS_LATENCY           18
+#define SPD_SDRAM_MODULE_ATTR           21
+
+#define SPD_SDRAM_TCLK1_PULSE           9   ///< cycle time for highest cas latency
+#define SPD_SDRAM_TAC1_PULSE            10  ///< access time for highest cas latency
+#define SPD_SDRAM_TCLK2_PULSE           23  ///< cycle time for 2nd highest cas latency
+#define SPD_SDRAM_TAC2_PULSE            24  ///< access time for 2nd highest cas latency
+#define SPD_SDRAM_TCLK3_PULSE           25  ///< cycle time for 3rd highest cas latency
+#define SPD_SDRAM_TAC3_PULSE            26  ///< access time for 3rd highest cas latency
+#define SPD_SDRAM_MIN_PRECHARGE         27
+#define SPD_SDRAM_ACTIVE_MIN            28
+#define SPD_SDRAM_RAS_CAS               29
+#define SPD_SDRAM_RAS_PULSE             30
+#define SPD_SDRAM_DENSITY               31
+
+//
+// Memory Type Definitions
+//
+#define SPD_VAL_SDR_TYPE  4       ///< SDR SDRAM memory
+#define SPD_VAL_DDR_TYPE  7       ///< DDR SDRAM memory
+#define SPD_VAL_DDR2_TYPE 8       ///< DDR2 SDRAM memory
+#define SPD_VAL_DDR3_TYPE 11      ///< DDR3 SDRAM memory
+#define SPD_VAL_DDR4_TYPE 12      ///< DDR4 SDRAM memory
+#define SPD_VAL_LPDDR3_TYPE 15    ///< LPDDR3 SDRAM memory
+#define SPD_VAL_LPDDR4_TYPE 16    ///< LPDDR4 SDRAM memory
+
+//
+// ECC Type Definitions
+//
+#define SPD_ECC_TYPE_NONE   0x00  ///< No error checking
+#define SPD_ECC_TYPE_PARITY 0x01  ///< No error checking
+#define SPD_ECC_TYPE_ECC    0x02  ///< Error checking only
+//
+// Module Attributes (Bit positions)
+//
+#define SPD_BUFFERED    0x01
+#define SPD_REGISTERED  0x02
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SdramSpdDdr3.h b/MdePkg/Include/IndustryStandard/SdramSpdDdr3.h
new file mode 100644
index 000000000000..4bcf706616f6
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SdramSpdDdr3.h
@@ -0,0 +1,769 @@
+/** @file
+  This file contains definitions for SPD DDR3.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+    - Serial Presence Detect (SPD) for DDR3 SDRAM Modules Document Release 6
+      http://www.jedec.org/sites/default/files/docs/4_01_02_11R21A.pdf
+**/
+
+#ifndef _SDRAM_SPD_DDR3_H_
+#define _SDRAM_SPD_DDR3_H_
+
+#pragma pack (push, 1)
+
+typedef union {
+  struct {
+    UINT8  BytesUsed                           :  4; ///< Bits 3:0
+    UINT8  BytesTotal                          :  3; ///< Bits 6:4
+    UINT8  CrcCoverage                         :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_DEVICE_DESCRIPTION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Minor                               :  4; ///< Bits 3:0
+    UINT8  Major                               :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_REVISION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Type                                :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_DRAM_DEVICE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ModuleType                          :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_MODULE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Density                             :  4; ///< Bits 3:0
+    UINT8  BankAddress                         :  3; ///< Bits 6:4
+    UINT8  Reserved                            :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_SDRAM_DENSITY_BANKS_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ColumnAddress                       :  3; ///< Bits 2:0
+    UINT8  RowAddress                          :  3; ///< Bits 5:3
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_SDRAM_ADDRESSING_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  OperationAt1_50                     :  1; ///< Bits 0:0
+    UINT8  OperationAt1_35                     :  1; ///< Bits 1:1
+    UINT8  OperationAt1_25                     :  1; ///< Bits 2:2
+    UINT8  Reserved                            :  5; ///< Bits 7:3
+  } Bits;
+  UINT8  Data;
+} SPD3_MODULE_NOMINAL_VOLTAGE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SdramDeviceWidth                    :  3; ///< Bits 2:0
+    UINT8  RankCount                           :  3; ///< Bits 5:3
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_MODULE_ORGANIZATION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  PrimaryBusWidth                     :  3; ///< Bits 2:0
+    UINT8  BusWidthExtension                   :  2; ///< Bits 4:3
+    UINT8  Reserved                            :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD3_MODULE_MEMORY_BUS_WIDTH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Divisor                             :  4; ///< Bits 3:0
+    UINT8  Dividend                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_FINE_TIMEBASE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Dividend                            :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_MEDIUM_TIMEBASE_DIVIDEND_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Divisor                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_MEDIUM_TIMEBASE_DIVISOR_STRUCT;
+
+typedef struct {
+  SPD3_MEDIUM_TIMEBASE_DIVIDEND_STRUCT Dividend; ///< Medium Timebase (MTB) Dividend
+  SPD3_MEDIUM_TIMEBASE_DIVISOR_STRUCT  Divisor;  ///< Medium Timebase (MTB) Divisor
+} SPD3_MEDIUM_TIMEBASE;
+
+typedef union {
+  struct {
+    UINT8  tCKmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TCK_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT16 Cl4                                 :  1; ///< Bits 0:0
+    UINT16 Cl5                                 :  1; ///< Bits 1:1
+    UINT16 Cl6                                 :  1; ///< Bits 2:2
+    UINT16 Cl7                                 :  1; ///< Bits 3:3
+    UINT16 Cl8                                 :  1; ///< Bits 4:4
+    UINT16 Cl9                                 :  1; ///< Bits 5:5
+    UINT16 Cl10                                :  1; ///< Bits 6:6
+    UINT16 Cl11                                :  1; ///< Bits 7:7
+    UINT16 Cl12                                :  1; ///< Bits 8:8
+    UINT16 Cl13                                :  1; ///< Bits 9:9
+    UINT16 Cl14                                :  1; ///< Bits 10:10
+    UINT16 Cl15                                :  1; ///< Bits 11:11
+    UINT16 Cl16                                :  1; ///< Bits 12:12
+    UINT16 Cl17                                :  1; ///< Bits 13:13
+    UINT16 Cl18                                :  1; ///< Bits 14:14
+    UINT16 Reserved                            :  1; ///< Bits 15:15
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD3_CAS_LATENCIES_SUPPORTED_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tAAmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TAA_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWRmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TWR_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRCDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRCD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRRDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRRD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRPmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRP_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRASminUpper                        :  4; ///< Bits 3:0
+    UINT8  tRCminUpper                         :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_TRAS_TRC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRASmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRAS_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRCmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT16 tRFCmin                             :  16; ///< Bits 15:0
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD3_TRFC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWTRmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TWTR_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRTPmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TRTP_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tFAWminUpper                        :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_TFAW_MIN_MTB_UPPER_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tFAWmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_TFAW_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Rzq6                                :  1; ///< Bits 0:0
+    UINT8  Rzq7                                :  1; ///< Bits 1:1
+    UINT8  Reserved                            :  5; ///< Bits 6:2
+    UINT8  DllOff                              :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_SDRAM_OPTIONAL_FEATURES_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ExtendedTemperatureRange            :  1; ///< Bits 0:0
+    UINT8  ExtendedTemperatureRefreshRate      :  1; ///< Bits 1:1
+    UINT8  AutoSelfRefresh                     :  1; ///< Bits 2:2
+    UINT8  OnDieThermalSensor                  :  1; ///< Bits 3:3
+    UINT8  Reserved                            :  3; ///< Bits 6:4
+    UINT8  PartialArraySelfRefresh             :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_SDRAM_THERMAL_REFRESH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ThermalSensorAccuracy               :  7; ///< Bits 6:0
+    UINT8  ThermalSensorPresence               :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_MODULE_THERMAL_SENSOR_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SignalLoading                       :  2; ///< Bits 1:0
+    UINT8  Reserved                            :  2; ///< Bits 3:2
+    UINT8  DieCount                            :  3; ///< Bits 6:4
+    UINT8  SdramDeviceType                     :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_SDRAM_DEVICE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCKminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD3_TCK_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tAAminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD3_TAA_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRCDminFine                          :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD3_TRCD_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRPminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD3_TRP_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRCminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD3_TRC_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  MaximumActivateCount                :  4; ///< Bits 3:0
+    UINT8  MaximumActivateWindow               :  2; ///< Bits 5:4
+    UINT8  VendorSpecific                      :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_MAXIMUM_ACTIVE_COUNT_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Height                              :  5; ///< Bits 4:0
+    UINT8  RawCardExtension                    :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD3_UNBUF_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                      :  4; ///< Bits 3:0
+    UINT8  BackThickness                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_UNBUF_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_UNBUF_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  MappingRank1                        :  1; ///< Bits 0:0
+    UINT8  Reserved                            :  7; ///< Bits 7:1
+  } Bits;
+  UINT8  Data;
+} SPD3_UNBUF_ADDRESS_MAPPING;
+
+typedef union {
+  struct {
+    UINT8  Height                              :  5; ///< Bits 4:0
+    UINT8  Reserved                            :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                      :  4; ///< Bits 3:0
+    UINT8  BackThickness                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  RegisterCount                       :  2; ///< Bits 1:0
+    UINT8  DramRowCount                        :  2; ///< Bits 3:2
+    UINT8  RegisterType                        :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_MODULE_ATTRIBUTES;
+
+typedef union {
+  struct {
+    UINT8  HeatSpreaderThermalCharacteristics  :  7; ///< Bits 6:0
+    UINT8  HeatSpreaderSolution                :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_THERMAL_HEAT_SPREADER_SOLUTION;
+
+typedef union {
+  struct {
+    UINT16 ContinuationCount                   :  7; ///< Bits 6:0
+    UINT16 ContinuationParity                  :  1; ///< Bits 7:7
+    UINT16 LastNonZeroByte                     :  8; ///< Bits 15:8
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD3_MANUFACTURER_ID_CODE;
+
+typedef union {
+  struct {
+    UINT8  RegisterRevisionNumber;             ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REGISTER_REVISION_NUMBER;
+
+typedef union {
+  struct {
+    UINT8 Bit0                                :  1; ///< Bits 0:0
+    UINT8 Bit1                                :  1; ///< Bits 1:1
+    UINT8 Bit2                                :  1; ///< Bits 2:2
+    UINT8 Reserved                            :  5; ///< Bits 7:3
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REGISTER_TYPE;
+
+typedef union {
+  struct {
+    UINT8 Reserved                            :  4; ///< Bits 0:3
+    UINT8 CommandAddressAOutputs              :  2; ///< Bits 5:4
+    UINT8 CommandAddressBOutputs              :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REGISTER_CONTROL_COMMAND_ADDRESS;
+
+typedef union {
+  struct {
+    UINT8 ControlSignalsAOutputs              :  2; ///< Bits 0:1
+    UINT8 ControlSignalsBOutputs              :  2; ///< Bits 3:2
+    UINT8 Y1Y3ClockOutputs                    :  2; ///< Bits 5:4
+    UINT8 Y0Y2ClockOutputs                    :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REGISTER_CONTROL_CONTROL_CLOCK;
+
+typedef union {
+  struct {
+    UINT8 Reserved0                           :  4; ///< Bits 0:3
+    UINT8 Reserved1                           :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_RDIMM_REGISTER_CONTROL_RESERVED;
+
+typedef union {
+  struct {
+    UINT8  Height                             :  5; ///< Bits 4:0
+    UINT8  Reserved                           :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                     :  4; ///< Bits 3:0
+    UINT8  BackThickness                      :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                               :  5; ///< Bits 4:0
+    UINT8  Revision                           :  2; ///< Bits 6:5
+    UINT8  Extension                          :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  RegisterCount                      :  2; ///< Bits 1:0
+    UINT8  DramRowCount                       :  2; ///< Bits 3:2
+    UINT8  RegisterType                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MODULE_ATTRIBUTES;
+
+typedef union {
+  struct {
+    UINT8 AddressCommandPrelaunch             :  1; ///< Bits 0:0
+    UINT8 Rank1Rank5Swap                      :  1; ///< Bits 1:1
+    UINT8 Reserved0                           :  1; ///< Bits 2:2
+    UINT8 Reserved1                           :  1; ///< Bits 3:3
+    UINT8 AddressCommandOutputs               :  2; ///< Bits 5:4
+    UINT8 QxCS_nOutputs                       :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_TIMING_CONTROL_DRIVE_STRENGTH;
+
+typedef union {
+  struct {
+    UINT8 QxOdtOutputs                        :  2; ///< Bits 1:0
+    UINT8 QxCkeOutputs                        :  2; ///< Bits 3:2
+    UINT8 Y1Y3ClockOutputs                    :  2; ///< Bits 5:4
+    UINT8 Y0Y2ClockOutputs                    :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_TIMING_DRIVE_STRENGTH;
+
+typedef union {
+  struct {
+    UINT8 YExtendedDelay                      :  2; ///< Bits 1:0
+    UINT8 QxCS_n                              :  2; ///< Bits 3:2
+    UINT8 QxOdt                               :  2; ///< Bits 5:4
+    UINT8 QxCke                               :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_EXTENDED_DELAY;
+
+typedef union {
+  struct {
+    UINT8 DelayY                              :  3; ///< Bits 2:0
+    UINT8 Reserved                            :  1; ///< Bits 3:3
+    UINT8 QxCS_n                              :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_ADDITIVE_DELAY_FOR_QXCS_N_QXCA;
+
+typedef union {
+  struct {
+    UINT8 QxCS_n                              :  4; ///< Bits 3:0
+    UINT8 QxOdt                               :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_ADDITIVE_DELAY_FOR_QXODT_QXCKE;
+
+typedef union {
+  struct {
+    UINT8 RC8MdqOdtStrength                   :  3; ///< Bits 2:0
+    UINT8 RC8Reserved                         :  1; ///< Bits 3:3
+    UINT8 RC9MdqOdtStrength                   :  3; ///< Bits 6:4
+    UINT8 RC9Reserved                         :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MDQ_TERMINATION_DRIVE_STRENGTH;
+
+typedef union {
+  struct {
+    UINT8 RC10DA3ValueR0                      :  1; ///< Bits 0:0
+    UINT8 RC10DA4ValueR0                      :  1; ///< Bits 1:1
+    UINT8 RC10DA3ValueR1                      :  1; ///< Bits 2:2
+    UINT8 RC10DA4ValueR1                      :  1; ///< Bits 3:3
+    UINT8 RC11DA3ValueR0                      :  1; ///< Bits 4:4
+    UINT8 RC11DA4ValueR0                      :  1; ///< Bits 5:5
+    UINT8 RC11DA3ValueR1                      :  1; ///< Bits 6:6
+    UINT8 RC11DA4ValueR1                      :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL;
+
+typedef union {
+  struct {
+    UINT8 Driver_Impedance                    :  2; ///< Bits 1:0
+    UINT8 Rtt_Nom                             :  3; ///< Bits 4:2
+    UINT8 Reserved                            :  1; ///< Bits 5:5
+    UINT8 Rtt_WR                              :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MR_1_2;
+
+typedef union {
+  struct {
+    UINT8 MinimumDelayTime                    :  7; ///< Bits 0:6
+    UINT8 Reserved                            :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD3_LRDIMM_MODULE_DELAY_TIME;
+
+typedef struct {
+  UINT8  Year;                                 ///< Year represented in BCD (00h = 2000)
+  UINT8  Week;                                 ///< Year represented in BCD (47h = week 47)
+} SPD3_MANUFACTURING_DATE;
+
+typedef union {
+  UINT32 Data;
+  UINT16 SerialNumber16[2];
+  UINT8  SerialNumber8[4];
+} SPD3_MANUFACTURER_SERIAL_NUMBER;
+
+typedef struct {
+  UINT8 Location;                              ///< Module Manufacturing Location
+} SPD3_MANUFACTURING_LOCATION;
+
+typedef struct {
+  SPD3_MANUFACTURER_ID_CODE            IdCode;                   ///< Module Manufacturer ID Code
+  SPD3_MANUFACTURING_LOCATION          Location;                 ///< Module Manufacturing Location
+  SPD3_MANUFACTURING_DATE              Date;                     ///< Module Manufacturing Year, in BCD (range: 2000-2255)
+  SPD3_MANUFACTURER_SERIAL_NUMBER      SerialNumber;             ///< Module Serial Number
+} SPD3_UNIQUE_MODULE_ID;
+
+typedef union {
+  UINT16 Crc[1];
+  UINT8  Data8[2];
+} SPD3_CYCLIC_REDUNDANCY_CODE;
+
+typedef struct {
+  SPD3_DEVICE_DESCRIPTION_STRUCT       Description;              ///< 0   Number of Serial PD Bytes Written / SPD Device Size / CRC Coverage 1, 2
+  SPD3_REVISION_STRUCT                 Revision;                 ///< 1   SPD Revision
+  SPD3_DRAM_DEVICE_TYPE_STRUCT         DramDeviceType;           ///< 2   DRAM Device Type
+  SPD3_MODULE_TYPE_STRUCT              ModuleType;               ///< 3   Module Type
+  SPD3_SDRAM_DENSITY_BANKS_STRUCT      SdramDensityAndBanks;     ///< 4   SDRAM Density and Banks
+  SPD3_SDRAM_ADDRESSING_STRUCT         SdramAddressing;          ///< 5   SDRAM Addressing
+  SPD3_MODULE_NOMINAL_VOLTAGE_STRUCT   ModuleNominalVoltage;     ///< 6   Module Nominal Voltage, VDD
+  SPD3_MODULE_ORGANIZATION_STRUCT      ModuleOrganization;       ///< 7   Module Organization
+  SPD3_MODULE_MEMORY_BUS_WIDTH_STRUCT  ModuleMemoryBusWidth;     ///< 8   Module Memory Bus Width
+  SPD3_FINE_TIMEBASE_STRUCT            FineTimebase;             ///< 9   Fine Timebase (FTB) Dividend / Divisor
+  SPD3_MEDIUM_TIMEBASE                 MediumTimebase;           ///< 10-11 Medium Timebase (MTB) Dividend
+  SPD3_TCK_MIN_MTB_STRUCT              tCKmin;                   ///< 12  SDRAM Minimum Cycle Time (tCKmin)
+  UINT8                                Reserved0;                ///< 13  Reserved
+  SPD3_CAS_LATENCIES_SUPPORTED_STRUCT  CasLatencies;             ///< 14-15 CAS Latencies Supported
+  SPD3_TAA_MIN_MTB_STRUCT              tAAmin;                   ///< 16  Minimum CAS Latency Time (tAAmin)
+  SPD3_TWR_MIN_MTB_STRUCT              tWRmin;                   ///< 17  Minimum Write Recovery Time (tWRmin)
+  SPD3_TRCD_MIN_MTB_STRUCT             tRCDmin;                  ///< 18  Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD3_TRRD_MIN_MTB_STRUCT             tRRDmin;                  ///< 19  Minimum Row Active to Row Active Delay Time (tRRDmin)
+  SPD3_TRP_MIN_MTB_STRUCT              tRPmin;                   ///< 20  Minimum Row Precharge Delay Time (tRPmin)
+  SPD3_TRAS_TRC_MIN_MTB_STRUCT         tRASMintRCMinUpper;       ///< 21  Upper Nibbles for tRAS and tRC
+  SPD3_TRAS_MIN_MTB_STRUCT             tRASmin;                  ///< 22  Minimum Active to Precharge Delay Time (tRASmin), Least Significant Byte
+  SPD3_TRC_MIN_MTB_STRUCT              tRCmin;                   ///< 23  Minimum Active to Active/Refresh Delay Time (tRCmin), Least Significant Byte
+  SPD3_TRFC_MIN_MTB_STRUCT             tRFCmin;                  ///< 24-25  Minimum Refresh Recovery Delay Time (tRFCmin)
+  SPD3_TWTR_MIN_MTB_STRUCT             tWTRmin;                  ///< 26  Minimum Internal Write to Read Command Delay Time (tWTRmin)
+  SPD3_TRTP_MIN_MTB_STRUCT             tRTPmin;                  ///< 27  Minimum Internal Read to Precharge Command Delay Time (tRTPmin)
+  SPD3_TFAW_MIN_MTB_UPPER_STRUCT       tFAWMinUpper;             ///< 28  Upper Nibble for tFAW
+  SPD3_TFAW_MIN_MTB_STRUCT             tFAWmin;                  ///< 29  Minimum Four Activate Window Delay Time (tFAWmin)
+  SPD3_SDRAM_OPTIONAL_FEATURES_STRUCT  SdramOptionalFeatures;    ///< 30  SDRAM Optional Features
+  SPD3_SDRAM_THERMAL_REFRESH_STRUCT    ThermalAndRefreshOptions; ///< 31  SDRAM Thermal And Refresh Options
+  SPD3_MODULE_THERMAL_SENSOR_STRUCT    ModuleThermalSensor;      ///< 32  Module Thermal Sensor
+  SPD3_SDRAM_DEVICE_TYPE_STRUCT        SdramDeviceType;          ///< 33  SDRAM Device Type
+  SPD3_TCK_MIN_FTB_STRUCT              tCKminFine;               ///< 34  Fine Offset for SDRAM Minimum Cycle Time (tCKmin)
+  SPD3_TAA_MIN_FTB_STRUCT              tAAminFine;               ///< 35  Fine Offset for Minimum CAS Latency Time (tAAmin)
+  SPD3_TRCD_MIN_FTB_STRUCT             tRCDminFine;              ///< 36  Fine Offset for Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD3_TRP_MIN_FTB_STRUCT              tRPminFine;               ///< 37  Minimum Row Precharge Delay Time (tRPmin)
+  SPD3_TRC_MIN_FTB_STRUCT              tRCminFine;               ///< 38  Fine Offset for Minimum Active to Active/Refresh Delay Time (tRCmin)
+  UINT8                                Reserved1[40 - 39 + 1];   ///< 39 - 40 Reserved
+  SPD3_MAXIMUM_ACTIVE_COUNT_STRUCT     MacValue;                 ///< 41  SDRAM Maximum Active Count (MAC) Value
+  UINT8                                Reserved2[59 - 42 + 1];   ///< 42 - 59 Reserved
+} SPD3_BASE_SECTION;
+
+typedef struct {
+  SPD3_UNBUF_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;      ///< 60  Module Nominal Height
+  SPD3_UNBUF_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness;   ///< 61  Module Maximum Thickness
+  SPD3_UNBUF_REFERENCE_RAW_CARD        ReferenceRawCardUsed;     ///< 62  Reference Raw Card Used
+  SPD3_UNBUF_ADDRESS_MAPPING           AddressMappingEdgeConn;   ///< 63  Address Mapping from Edge Connector to DRAM
+  UINT8                                Reserved[116 - 64 + 1];   ///< 64-116 Reserved
+} SPD3_MODULE_UNBUFFERED;
+
+typedef struct {
+  SPD3_RDIMM_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;      ///< 60  Module Nominal Height
+  SPD3_RDIMM_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness;   ///< 61  Module Maximum Thickness
+  SPD3_RDIMM_REFERENCE_RAW_CARD        ReferenceRawCardUsed;     ///< 62  Reference Raw Card Used
+  SPD3_RDIMM_MODULE_ATTRIBUTES         DimmModuleAttributes;     ///< 63  DIMM Module Attributes
+  SPD3_RDIMM_THERMAL_HEAT_SPREADER_SOLUTION       ThermalHeatSpreaderSolution; ///< 64     RDIMM Thermal Heat Spreader Solution
+  SPD3_MANUFACTURER_ID_CODE                       RegisterManufacturerIdCode;  ///< 65-66  Register Manufacturer ID Code
+  SPD3_RDIMM_REGISTER_REVISION_NUMBER             RegisterRevisionNumber;      ///< 67     Register Revision Number
+  SPD3_RDIMM_REGISTER_TYPE                        RegisterType; ///< 68  Register Type
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc1Rc0;       ///< 69  RC1 (MS Nibble) / RC0 (LS Nibble) - Reserved
+  SPD3_RDIMM_REGISTER_CONTROL_COMMAND_ADDRESS     Rc3Rc2;       ///< 70  RC3 (MS Nibble) / RC2 (LS Nibble) - Drive Strength, Command/Address
+  SPD3_RDIMM_REGISTER_CONTROL_CONTROL_CLOCK       Rc5Rc4;       ///< 71  RC5 (MS Nibble) / RC4 (LS Nibble) - Drive Strength, Control and Clock
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc7Rc6;       ///< 72  RC7 (MS Nibble) / RC6 (LS Nibble) - Reserved for Register Vendor
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc9Rc8;       ///< 73  RC9 (MS Nibble) / RC8 (LS Nibble) - Reserved
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc11Rc10;     ///< 74  RC11 (MS Nibble) / RC10 (LS Nibble) - Reserved
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc13Rc12;     ///< 75  RC12 (MS Nibble) / RC12 (LS Nibble) - Reserved
+  SPD3_RDIMM_REGISTER_CONTROL_RESERVED            Rc15Rc14;     ///< 76  RC15 (MS Nibble) / RC14 (LS Nibble) - Reserved
+  UINT8                               Reserved[116 - 77 + 1];   ///< 77-116 Reserved
+} SPD3_MODULE_REGISTERED;
+
+typedef struct {
+  SPD3_UNBUF_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;     ///< 60  Module Nominal Height
+  SPD3_UNBUF_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness;  ///< 61  Module Maximum Thickness
+  SPD3_UNBUF_REFERENCE_RAW_CARD        ReferenceRawCardUsed;    ///< 62  Reference Raw Card Used
+  UINT8                                Reserved[116 - 63 + 1];  ///< 63-116 Reserved
+} SPD3_MODULE_CLOCKED;
+
+typedef struct {
+  SPD3_LRDIMM_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;    ///< 60  Module Nominal Height
+  SPD3_LRDIMM_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness; ///< 61  Module Maximum Thickness
+  SPD3_LRDIMM_REFERENCE_RAW_CARD        ReferenceRawCardUsed;   ///< 62  Reference Raw Card Used
+  SPD3_LRDIMM_MODULE_ATTRIBUTES         DimmModuleAttributes;   ///< 63  Module Attributes
+  UINT8                                         MemoryBufferRevisionNumber;       ///< 64    Memory Buffer Revision Number
+  SPD3_MANUFACTURER_ID_CODE                     ManufacturerIdCode;               ///< 65-66 Memory Buffer Manufacturer ID Code
+  SPD3_LRDIMM_TIMING_CONTROL_DRIVE_STRENGTH     TimingControlDriveStrengthCaCs;   ///< 67    F0RC3 / F0RC2 - Timing Control & Drive Strength, CA & CS
+  SPD3_LRDIMM_TIMING_DRIVE_STRENGTH             DriveStrength;                    ///< 68    F0RC5 / F0RC4 - Drive Strength, ODT & CKE and Y
+  SPD3_LRDIMM_EXTENDED_DELAY                    ExtendedDelay;                    ///< 69    F1RC11 / F1RC8 - Extended Delay for Y, CS and ODT & CKE
+  SPD3_LRDIMM_ADDITIVE_DELAY_FOR_QXCS_N_QXCA    AdditiveDelayForCsCa;             ///< 70    F1RC13 / F1RC12 - Additive Delay for CS and CA
+  SPD3_LRDIMM_ADDITIVE_DELAY_FOR_QXODT_QXCKE    AdditiveDelayForOdtCke;           ///< 71    F1RC15 / F1RC14 - Additive Delay for ODT & CKE
+  SPD3_LRDIMM_MDQ_TERMINATION_DRIVE_STRENGTH    MdqTerminationDriveStrengthFor800_1066; ///< 72    F1RC15 / F1RC14 - Additive Delay for ODT & CKE
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_0_1QxOdtControlFor800_1066;  ///< 73    F[3,4]RC11 / F[3,4]RC10 - Rank 0 & 1 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_2_3QxOdtControlFor800_1066;  ///< 74    F[5,6]RC11 / F[5,6]RC10 - Rank 2 & 3 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_4_5QxOdtControlFor800_1066;  ///< 75    F[7,8]RC11 / F[7,8]RC10 - Rank 4 & 5 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_6_7QxOdtControlFor800_1066;  ///< 76    F[9,10]RC11 / F[9,10]RC10 - Rank 6 & 7 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_MR_1_2                            MR_1_2RegistersFor800_1066;       ///< 77    MR1,2 Registers for 800 & 1066
+  SPD3_LRDIMM_MDQ_TERMINATION_DRIVE_STRENGTH    MdqTerminationDriveStrengthFor1333_1600; ///< 78    F1RC15 / F1RC14 - Additive Delay for ODT & CKE
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_0_1QxOdtControlFor1333_1600; ///< 79    F[3,4]RC11 / F[3,4]RC10 - Rank 0 & 1 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_2_3QxOdtControlFor1333_1600; ///< 80    F[5,6]RC11 / F[5,6]RC10 - Rank 2 & 3 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_4_5QxOdtControlFor1333_1600; ///< 81    F[7,8]RC11 / F[7,8]RC10 - Rank 4 & 5 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_6_7QxOdtControlFor1333_1600; ///< 82    F[9,10]RC11 / F[9,10]RC10 - Rank 6 & 7 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_MR_1_2                            MR_1_2RegistersFor1333_1600;      ///< 83    MR1,2 Registers for 800 & 1066
+  SPD3_LRDIMM_MDQ_TERMINATION_DRIVE_STRENGTH    MdqTerminationDriveStrengthFor1866_2133; ///< 84    F1RC15 / F1RC14 - Additive Delay for ODT & CKE
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_0_1QxOdtControlFor1866_2133; ///< 85    F[3,4]RC11 / F[3,4]RC10 - Rank 0 & 1 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_2_3QxOdtControlFor1866_2133; ///< 86    F[5,6]RC11 / F[5,6]RC10 - Rank 2 & 3 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_4_5QxOdtControlFor1866_2133; ///< 87    F[7,8]RC11 / F[7,8]RC10 - Rank 4 & 5 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_RANK_READ_WRITE_QXODT_CONTROL     Rank_6_7QxOdtControlFor1866_2133; ///< 88    F[9,10]RC11 / F[9,10]RC10 - Rank 6 & 7 RD & WR QxODT Control for 800 & 1066
+  SPD3_LRDIMM_MR_1_2                            MR_1_2RegistersFor1866_2133;      ///< 89    MR1,2 Registers for 800 & 1066
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MinimumModuleDelayTimeFor1_5V;    ///< 90    Minimum Module Delay Time for 1.5 V
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MaximumModuleDelayTimeFor1_5V;    ///< 91    Maximum Module Delay Time for 1.5 V
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MinimumModuleDelayTimeFor1_35V;   ///< 92    Minimum Module Delay Time for 1.35 V
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MaximumModuleDelayTimeFor1_35V;   ///< 93    Maximum Module Delay Time for 1.35 V
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MinimumModuleDelayTimeFor1_25V;   ///< 94    Minimum Module Delay Time for 1.25 V
+  SPD3_LRDIMM_MODULE_DELAY_TIME                 MaximumModuleDelayTimeFor1_25V;   ///< 95    Maximum Module Delay Time for 1.25 V
+  UINT8                                         Reserved[101 - 96 + 1];           ///< 96-101  Reserved
+  UINT8                                         PersonalityByte[116 - 102 + 1];   ///< 102-116 Memory Buffer Personality Bytes
+} SPD3_MODULE_LOADREDUCED;
+
+typedef union {
+  SPD3_MODULE_UNBUFFERED              Unbuffered;               ///< 128-255 Unbuffered Memory Module Types
+  SPD3_MODULE_REGISTERED              Registered;               ///< 128-255 Registered Memory Module Types
+  SPD3_MODULE_CLOCKED                 Clocked;                  ///< 128-255 Registered Memory Module Types
+  SPD3_MODULE_LOADREDUCED             LoadReduced;              ///< 128-255 Load Reduced Memory Module Types
+} SPD3_MODULE_SPECIFIC;
+
+typedef struct {
+  UINT8                          ModulePartNumber[145 - 128 + 1];        ///< 128-145 Module Part Number
+} SPD3_MODULE_PART_NUMBER;
+
+typedef struct {
+  UINT8                          ModuleRevisionCode[147 - 146 + 1];      ///< 146-147 Module Revision Code
+} SPD3_MODULE_REVISION_CODE;
+
+typedef struct {
+  UINT8                          ManufacturerSpecificData[175 - 150 + 1];///< 150-175 Manufacturer's Specific Data
+} SPD3_MANUFACTURER_SPECIFIC;
+
+///
+/// DDR3 Serial Presence Detect structure
+///
+typedef struct {
+  SPD3_BASE_SECTION           General;                                ///< 0-59    General Section
+  SPD3_MODULE_SPECIFIC        Module;                                 ///< 60-116  Module-Specific Section
+  SPD3_UNIQUE_MODULE_ID       ModuleId;                               ///< 117-125 Unique Module ID
+  SPD3_CYCLIC_REDUNDANCY_CODE Crc;                                    ///< 126-127 Cyclical Redundancy Code (CRC)
+  SPD3_MODULE_PART_NUMBER     ModulePartNumber;                       ///< 128-145 Module Part Number
+  SPD3_MODULE_REVISION_CODE   ModuleRevisionCode;                     ///< 146-147 Module Revision Code
+  SPD3_MANUFACTURER_ID_CODE   DramIdCode;                             ///< 148-149 Dram Manufacturer ID Code
+  SPD3_MANUFACTURER_SPECIFIC  ManufacturerSpecificData;               ///< 150-175 Manufacturer's Specific Data
+  UINT8                       Reserved[255 - 176 + 1];                ///< 176-255 Open for Customer Use
+} SPD_DDR3;
+
+#pragma pack (pop)
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SdramSpdDdr4.h b/MdePkg/Include/IndustryStandard/SdramSpdDdr4.h
new file mode 100644
index 000000000000..d6bc76f6cf8d
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SdramSpdDdr4.h
@@ -0,0 +1,958 @@
+/** @file
+  This file contains definitions for SPD DDR4.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+    - Serial Presence Detect (SPD) for DDR4 SDRAM Modules Document Release 4
+      http://www.jedec.org/standards-documents/docs/spd412l-4
+**/
+
+#ifndef _SDRAM_SPD_DDR4_H_
+#define _SDRAM_SPD_DDR4_H_
+
+#pragma pack (push, 1)
+
+typedef union {
+  struct {
+    UINT8  BytesUsed                           :  4; ///< Bits 3:0
+    UINT8  BytesTotal                          :  3; ///< Bits 6:4
+    UINT8  CrcCoverage                         :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_DEVICE_DESCRIPTION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Minor                               :  4; ///< Bits 3:0
+    UINT8  Major                               :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_REVISION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Type                                :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_DRAM_DEVICE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ModuleType                          :  4; ///< Bits 3:0
+    UINT8  HybridMedia                         :  3; ///< Bits 6:4
+    UINT8  Hybrid                              :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_MODULE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Density                             :  4; ///< Bits 3:0
+    UINT8  BankAddress                         :  2; ///< Bits 5:4
+    UINT8  BankGroup                           :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_SDRAM_DENSITY_BANKS_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ColumnAddress                       :  3; ///< Bits 2:0
+    UINT8  RowAddress                          :  3; ///< Bits 5:3
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_SDRAM_ADDRESSING_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SignalLoading                       :  2; ///< Bits 1:0
+    UINT8  Reserved                            :  2; ///< Bits 3:2
+    UINT8  DieCount                            :  3; ///< Bits 6:4
+    UINT8  SdramPackageType                    :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_PRIMARY_SDRAM_PACKAGE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  MaximumActivateCount                :  4; ///< Bits 3:0
+    UINT8  MaximumActivateWindow               :  2; ///< Bits 5:4
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_SDRAM_OPTIONAL_FEATURES_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_SDRAM_THERMAL_REFRESH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  5; ///< Bits 4:0
+    UINT8  SoftPPR                             :  1; ///< Bits 5:5
+    UINT8  PostPackageRepair                   :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_OTHER_SDRAM_OPTIONAL_FEATURES_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SignalLoading                       :  2; ///< Bits 1:0
+    UINT8  DRAMDensityRatio                    :  2; ///< Bits 3:2
+    UINT8  DieCount                            :  3; ///< Bits 6:4
+    UINT8  SdramPackageType                    :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_SECONDARY_SDRAM_PACKAGE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  OperationAt1_20                     :  1; ///< Bits 0:0
+    UINT8  EndurantAt1_20                      :  1; ///< Bits 1:1
+    UINT8  Reserved                            :  6; ///< Bits 7:2
+  } Bits;
+  UINT8  Data;
+} SPD4_MODULE_NOMINAL_VOLTAGE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SdramDeviceWidth                    :  3; ///< Bits 2:0
+    UINT8  RankCount                           :  3; ///< Bits 5:3
+    UINT8  RankMix                             :  1; ///< Bits 6:6
+    UINT8  Reserved                            :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_MODULE_ORGANIZATION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  PrimaryBusWidth                     :  3; ///< Bits 2:0
+    UINT8  BusWidthExtension                   :  2; ///< Bits 4:3
+    UINT8  Reserved                            :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD4_MODULE_MEMORY_BUS_WIDTH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  7; ///< Bits 6:0
+    UINT8  ThermalSensorPresence               :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_MODULE_THERMAL_SENSOR_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ExtendedBaseModuleType              :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_EXTENDED_MODULE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Fine                                :  2; ///< Bits 1:0
+    UINT8  Medium                              :  2; ///< Bits 3:2
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_TIMEBASE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tCKmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TCK_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tCKmax                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TCK_MAX_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT32 Cl7                                 :  1; ///< Bits 0:0
+    UINT32 Cl8                                 :  1; ///< Bits 1:1
+    UINT32 Cl9                                 :  1; ///< Bits 2:2
+    UINT32 Cl10                                :  1; ///< Bits 3:3
+    UINT32 Cl11                                :  1; ///< Bits 4:4
+    UINT32 Cl12                                :  1; ///< Bits 5:5
+    UINT32 Cl13                                :  1; ///< Bits 6:6
+    UINT32 Cl14                                :  1; ///< Bits 7:7
+    UINT32 Cl15                                :  1; ///< Bits 8:8
+    UINT32 Cl16                                :  1; ///< Bits 9:9
+    UINT32 Cl17                                :  1; ///< Bits 10:10
+    UINT32 Cl18                                :  1; ///< Bits 11:11
+    UINT32 Cl19                                :  1; ///< Bits 12:12
+    UINT32 Cl20                                :  1; ///< Bits 13:13
+    UINT32 Cl21                                :  1; ///< Bits 14:14
+    UINT32 Cl22                                :  1; ///< Bits 15:15
+    UINT32 Cl23                                :  1; ///< Bits 16:16
+    UINT32 Cl24                                :  1; ///< Bits 17:17
+    UINT32 Cl25                                :  1; ///< Bits 18:18
+    UINT32 Cl26                                :  1; ///< Bits 19:19
+    UINT32 Cl27                                :  1; ///< Bits 20:20
+    UINT32 Cl28                                :  1; ///< Bits 21:21
+    UINT32 Cl29                                :  1; ///< Bits 22:22
+    UINT32 Cl30                                :  1; ///< Bits 23:23
+    UINT32 Cl31                                :  1; ///< Bits 24:24
+    UINT32 Cl32                                :  1; ///< Bits 25:25
+    UINT32 Cl33                                :  1; ///< Bits 26:26
+    UINT32 Cl34                                :  1; ///< Bits 27:27
+    UINT32 Cl35                                :  1; ///< Bits 28:28
+    UINT32 Cl36                                :  1; ///< Bits 29:29
+    UINT32 Reserved                            :  1; ///< Bits 30:30
+    UINT32 ClRange                             :  1; ///< Bits 31:31
+  } Bits;
+  struct {
+    UINT32 Cl23                                :  1; ///< Bits 0:0
+    UINT32 Cl24                                :  1; ///< Bits 1:1
+    UINT32 Cl25                                :  1; ///< Bits 2:2
+    UINT32 Cl26                                :  1; ///< Bits 3:3
+    UINT32 Cl27                                :  1; ///< Bits 4:4
+    UINT32 Cl28                                :  1; ///< Bits 5:5
+    UINT32 Cl29                                :  1; ///< Bits 6:6
+    UINT32 Cl30                                :  1; ///< Bits 7:7
+    UINT32 Cl31                                :  1; ///< Bits 8:8
+    UINT32 Cl32                                :  1; ///< Bits 9:9
+    UINT32 Cl33                                :  1; ///< Bits 10:10
+    UINT32 Cl34                                :  1; ///< Bits 11:11
+    UINT32 Cl35                                :  1; ///< Bits 12:12
+    UINT32 Cl36                                :  1; ///< Bits 13:13
+    UINT32 Cl37                                :  1; ///< Bits 14:14
+    UINT32 Cl38                                :  1; ///< Bits 15:15
+    UINT32 Cl39                                :  1; ///< Bits 16:16
+    UINT32 Cl40                                :  1; ///< Bits 17:17
+    UINT32 Cl41                                :  1; ///< Bits 18:18
+    UINT32 Cl42                                :  1; ///< Bits 19:19
+    UINT32 Cl43                                :  1; ///< Bits 20:20
+    UINT32 Cl44                                :  1; ///< Bits 21:21
+    UINT32 Cl45                                :  1; ///< Bits 22:22
+    UINT32 Cl46                                :  1; ///< Bits 23:23
+    UINT32 Cl47                                :  1; ///< Bits 24:24
+    UINT32 Cl48                                :  1; ///< Bits 25:25
+    UINT32 Cl49                                :  1; ///< Bits 26:26
+    UINT32 Cl50                                :  1; ///< Bits 27:27
+    UINT32 Cl51                                :  1; ///< Bits 28:28
+    UINT32 Cl52                                :  1; ///< Bits 29:29
+    UINT32 Reserved                            :  1; ///< Bits 30:30
+    UINT32 ClRange                             :  1; ///< Bits 31:31
+  } HighRangeBits;
+  UINT32 Data;
+  UINT16 Data16[2];
+  UINT8  Data8[4];
+} SPD4_CAS_LATENCIES_SUPPORTED_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tAAmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TAA_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRCDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TRCD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRPmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TRP_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRASminUpper                        :  4; ///< Bits 3:0
+    UINT8  tRCminUpper                         :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_TRAS_TRC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRASmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TRAS_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRCmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TRC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT16 tRFCmin                             :  16; ///< Bits 15:0
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD4_TRFC_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tFAWminUpper                        :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_TFAW_MIN_MTB_UPPER_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tFAWmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TFAW_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRRDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TRRD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tCCDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TCCD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWRminMostSignificantNibble         :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_TWR_UPPER_NIBBLE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWRmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TWR_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWTR_SminMostSignificantNibble      :  4; ///< Bits 3:0
+    UINT8  tWTR_LminMostSignificantNibble      :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_TWTR_UPPER_NIBBLE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tWTRmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_TWTR_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  BitOrderatSDRAM                     :  5; ///< Bits 4:0
+    UINT8  WiredtoUpperLowerNibble             :  1; ///< Bits 5:5
+    UINT8  PackageRankMap                      :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_CONNECTOR_BIT_MAPPING_BYTE_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCCDminFine                          :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TCCD_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRRDminFine                          :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TRRD_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRCminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TRC_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRPminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TRP_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRCDminFine                          :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TRCD_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tAAminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TAA_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCKmaxFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TCK_MAX_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCKminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD4_TCK_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Height                              :  5; ///< Bits 4:0
+    UINT8  RawCardExtension                    :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD4_UNBUF_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                      :  4; ///< Bits 3:0
+    UINT8  BackThickness                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_UNBUF_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_UNBUF_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  MappingRank1                        :  1; ///< Bits 0:0
+    UINT8  Reserved                            :  7; ///< Bits 7:1
+  } Bits;
+  UINT8  Data;
+} SPD4_UNBUF_ADDRESS_MAPPING;
+
+typedef union {
+  struct {
+    UINT8  Height                              :  5; ///< Bits 4:0
+    UINT8  Reserved                            :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                      :  4; ///< Bits 3:0
+    UINT8  BackThickness                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  RegisterCount                       :  2; ///< Bits 1:0
+    UINT8  DramRowCount                        :  2; ///< Bits 3:2
+    UINT8  RegisterType                        :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_MODULE_ATTRIBUTES;
+
+typedef union {
+  struct {
+    UINT8  HeatSpreaderThermalCharacteristics  :  7; ///< Bits 6:0
+    UINT8  HeatSpreaderSolution                :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_THERMAL_HEAT_SPREADER_SOLUTION;
+
+typedef union {
+  struct {
+    UINT16 ContinuationCount                   :  7; ///< Bits 6:0
+    UINT16 ContinuationParity                  :  1; ///< Bits 7:7
+    UINT16 LastNonZeroByte                     :  8; ///< Bits 15:8
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD4_MANUFACTURER_ID_CODE;
+
+typedef union {
+  struct {
+    UINT8  RegisterRevisionNumber;             ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_REGISTER_REVISION_NUMBER;
+
+typedef union {
+  struct {
+    UINT8 Rank1Mapping                        :  1; ///< Bits 0:0
+    UINT8 Reserved                            :  7; ///< Bits 7:1
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_ADDRESS_MAPPING_FROM_REGISTER_TO_DRAM;
+
+typedef union {
+  struct {
+    UINT8 Cke                                 :  2; ///< Bits 1:0
+    UINT8 Odt                                 :  2; ///< Bits 3:2
+    UINT8 CommandAddress                      :  2; ///< Bits 5:4
+    UINT8 ChipSelect                          :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CONTROL_COMMAND_ADDRESS;
+
+typedef union {
+  struct {
+    UINT8 Y0Y2                                :  2; ///< Bits 1:0
+    UINT8 Y1Y3                                :  2; ///< Bits 3:2
+    UINT8 Reserved0                           :  2; ///< Bits 5:4
+    UINT8 RcdOutputSlewRateControl            :  1; ///< Bits 6:6
+    UINT8 Reserved1                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_RDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CLOCK;
+
+typedef union {
+  struct {
+    UINT8  Height                             :  5; ///< Bits 4:0
+    UINT8  Reserved                           :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                     :  4; ///< Bits 3:0
+    UINT8  BackThickness                      :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_MODULE_NOMINAL_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Card                               :  5; ///< Bits 4:0
+    UINT8  Revision                           :  2; ///< Bits 6:5
+    UINT8  Extension                          :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  RegisterCount                      :  2; ///< Bits 1:0
+    UINT8  DramRowCount                       :  2; ///< Bits 3:2
+    UINT8  RegisterType                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_MODULE_ATTRIBUTES;
+
+typedef union {
+  struct {
+    UINT8  HeatSpreaderThermalCharacteristics :  7; ///< Bits 6:0
+    UINT8  HeatSpreaderSolution               :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_THERMAL_HEAT_SPREADER_SOLUTION;
+
+typedef union {
+  struct {
+    UINT8  RegisterRevisionNumber;                  ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_REGISTER_REVISION_NUMBER;
+
+typedef union {
+  struct {
+    UINT8 Rank1Mapping                        :  1; ///< Bits 0:0
+    UINT8 Reserved                            :  7; ///< Bits 7:1
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_ADDRESS_MAPPING_FROM_REGISTER_TO_DRAM;
+
+typedef union {
+  struct {
+    UINT8 Cke                                 :  2; ///< Bits 1:0
+    UINT8 Odt                                 :  2; ///< Bits 3:2
+    UINT8 CommandAddress                      :  2; ///< Bits 5:4
+    UINT8 ChipSelect                          :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CONTROL_COMMAND_ADDRESS;
+
+typedef union {
+  struct {
+    UINT8 Y0Y2                                :  2; ///< Bits 1:0
+    UINT8 Y1Y3                                :  2; ///< Bits 3:2
+    UINT8 Reserved0                           :  2; ///< Bits 5:4
+    UINT8 RcdOutputSlewRateControl            :  1; ///< Bits 6:6
+    UINT8 Reserved1                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CLOCK;
+
+typedef struct {
+  UINT8  DataBufferRevisionNumber;
+} SPD4_LRDIMM_DATA_BUFFER_REVISION_NUMBER;
+
+typedef union {
+  struct {
+    UINT8  DramVrefDQForPackageRank0          :  6; ///< Bits 5:0
+    UINT8  Reserved                           :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DRAM_VREFDQ_FOR_PACKAGE_RANK;
+
+typedef struct {
+  UINT8  DataBufferVrefDQforDramInterface;
+} SPD4_LRDIMM_DATA_BUFFER_VREFDQ_FOR_DRAM_INTERFACE;
+
+typedef union {
+  struct {
+    UINT8  DramInterfaceMdqDriveStrength           :  4; ///< Bits 3:0
+    UINT8  DramInterfaceMdqReadTerminationStrength :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DATA_BUFFER_MDQ_DRIVE_STRENGTH_RTT_FOR_DATA_RATE;
+
+typedef union {
+  struct {
+    UINT8  DataRateLe1866                           :  2; ///< Bits 1:0
+    UINT8  DataRateLe2400                           :  2; ///< Bits 3:2
+    UINT8  DataRateLe3200                           :  2; ///< Bits 5:4
+    UINT8  Reserved                                 :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DRAM_DRIVE_STRENGTH;
+
+typedef union {
+  struct {
+    UINT8  Rtt_Nom                                  :  3; ///< Bits 2:0
+    UINT8  Rtt_WR                                   :  3; ///< Bits 5:3
+    UINT8  Reserved                                 :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DRAM_ODT_RTT_WR_RTT_NOM_FOR_DATA_RATE;
+
+typedef union {
+  struct {
+    UINT8  PackageRanks0_1                          :  3; ///< Bits 2:0
+    UINT8  PackageRanks2_3                          :  3; ///< Bits 5:3
+    UINT8  Reserved                                 :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DRAM_ODT_RTT_PARK_FOR_DATA_RATE;
+
+typedef union {
+  struct {
+    UINT8  Rank0                                    :  1; ///< Bits 0:0
+    UINT8  Rank1                                    :  1; ///< Bits 1:1
+    UINT8  Rank2                                    :  1; ///< Bits 2:2
+    UINT8  Rank3                                    :  1; ///< Bits 3:3
+    UINT8  DataBuffer                               :  1; ///< Bits 4:4
+    UINT8  Reserved                                 :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DATA_BUFFER_VREFDQ_FOR_DRAM_INTERFACE_RANGE;
+
+typedef union {
+  struct {
+    UINT8  DataBufferGainAdjustment                 :  1; ///< Bits 0:0
+    UINT8  DataBufferDfe                            :  1; ///< Bits 1:1
+    UINT8  Reserved                                 :  6; ///< Bits 7:2
+  } Bits;
+  UINT8  Data;
+} SPD4_LRDIMM_DATA_BUFFER_DQ_DECISION_FEEDBACK_EQUALIZATION;
+
+typedef UINT16 SPD4_NVDIMM_MODULE_PRODUCT_IDENTIFIER;
+
+typedef union {
+  struct {
+    UINT16 ContinuationCount                   :  7; ///< Bits 6:0
+    UINT16 ContinuationParity                  :  1; ///< Bits 7:7
+    UINT16 LastNonZeroByte                     :  8; ///< Bits 15:8
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_MANUFACTURER_ID_CODE;
+
+typedef UINT16 SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_IDENTIFIER;
+
+typedef UINT8 SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_REVISION_CODE;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD4_NVDIMM_REFERENCE_RAW_CARD;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  4; ///< Bits 3:0
+    UINT8  Extension                           :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD4_NVDIMM_MODULE_CHARACTERISTICS;
+
+typedef struct {
+  UINT8  Reserved;
+  UINT8  MediaType;
+} SPD4_NVDIMM_HYBRID_MODULE_MEDIA_TYPES;
+
+typedef UINT8 SPD4_NVDIMM_MAXIMUM_NONVOLATILE_MEMORY_INITIALIZATION_TIME;
+
+typedef union {
+  struct {
+    UINT16 FunctionInterface                   :  5; ///< Bits 4:0
+    UINT16 FunctionClass                       :  5; ///< Bits 9:5
+    UINT16 BlockOffset                         :  4; ///< Bits 13:10
+    UINT16 Reserved                            :  1; ///< Bits 14:14
+    UINT16 Implemented                         :  1; ///< Bits 15:15
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD4_NVDIMM_FUNCTION_INTERFACE_DESCRIPTOR;
+
+typedef struct {
+  UINT8  Year;                                 ///< Year represented in BCD (00h = 2000)
+  UINT8  Week;                                 ///< Year represented in BCD (47h = week 47)
+} SPD4_MANUFACTURING_DATE;
+
+typedef union {
+  UINT32 Data;
+  UINT16 SerialNumber16[2];
+  UINT8  SerialNumber8[4];
+} SPD4_MANUFACTURER_SERIAL_NUMBER;
+
+typedef struct {
+  UINT8 Location;                              ///< Module Manufacturing Location
+} SPD4_MANUFACTURING_LOCATION;
+
+typedef struct {
+  SPD4_MANUFACTURER_ID_CODE            IdCode;                   ///< Module Manufacturer ID Code
+  SPD4_MANUFACTURING_LOCATION          Location;                 ///< Module Manufacturing Location
+  SPD4_MANUFACTURING_DATE              Date;                     ///< Module Manufacturing Year, in BCD (range: 2000-2255)
+  SPD4_MANUFACTURER_SERIAL_NUMBER      SerialNumber;             ///< Module Serial Number
+} SPD4_UNIQUE_MODULE_ID;
+
+typedef union {
+  UINT16 Crc[1];
+  UINT8  Data8[2];
+} SPD4_CYCLIC_REDUNDANCY_CODE;
+
+typedef struct {
+  SPD4_DEVICE_DESCRIPTION_STRUCT            Description;              ///< 0       Number of Serial PD Bytes Written / SPD Device Size / CRC Coverage 1, 2
+  SPD4_REVISION_STRUCT                      Revision;                 ///< 1       SPD Revision
+  SPD4_DRAM_DEVICE_TYPE_STRUCT              DramDeviceType;           ///< 2       DRAM Device Type
+  SPD4_MODULE_TYPE_STRUCT                   ModuleType;               ///< 3       Module Type
+  SPD4_SDRAM_DENSITY_BANKS_STRUCT           SdramDensityAndBanks;     ///< 4       SDRAM Density and Banks
+  SPD4_SDRAM_ADDRESSING_STRUCT              SdramAddressing;          ///< 5       SDRAM Addressing
+  SPD4_PRIMARY_SDRAM_PACKAGE_TYPE_STRUCT    PrimarySdramPackageType;  ///< 6       Primary SDRAM Package Type
+  SPD4_SDRAM_OPTIONAL_FEATURES_STRUCT       SdramOptionalFeatures;    ///< 7       SDRAM Optional Features
+  SPD4_SDRAM_THERMAL_REFRESH_STRUCT         ThermalAndRefreshOptions; ///< 8       SDRAM Thermal and Refresh Options
+  SPD4_OTHER_SDRAM_OPTIONAL_FEATURES_STRUCT OtherOptionalFeatures;    ///< 9       Other SDRAM Optional Features
+  SPD4_SECONDARY_SDRAM_PACKAGE_TYPE_STRUCT  SecondarySdramPackageType;///< 10      Secondary SDRAM Package Type
+  SPD4_MODULE_NOMINAL_VOLTAGE_STRUCT        ModuleNominalVoltage;     ///< 11      Module Nominal Voltage, VDD
+  SPD4_MODULE_ORGANIZATION_STRUCT           ModuleOrganization;       ///< 12      Module Organization
+  SPD4_MODULE_MEMORY_BUS_WIDTH_STRUCT       ModuleMemoryBusWidth;     ///< 13      Module Memory Bus Width
+  SPD4_MODULE_THERMAL_SENSOR_STRUCT         ModuleThermalSensor;      ///< 14      Module Thermal Sensor
+  SPD4_EXTENDED_MODULE_TYPE_STRUCT          ExtendedModuleType;       ///< 15      Extended Module Type
+  UINT8                                     Reserved0;                ///< 16      Reserved
+  SPD4_TIMEBASE_STRUCT                      Timebase;                 ///< 17      Timebases
+  SPD4_TCK_MIN_MTB_STRUCT                   tCKmin;                   ///< 18      SDRAM Minimum Cycle Time (tCKmin)
+  SPD4_TCK_MAX_MTB_STRUCT                   tCKmax;                   ///< 19      SDRAM Maximum Cycle Time (tCKmax)
+  SPD4_CAS_LATENCIES_SUPPORTED_STRUCT       CasLatencies;             ///< 20-23   CAS Latencies Supported
+  SPD4_TAA_MIN_MTB_STRUCT                   tAAmin;                   ///< 24      Minimum CAS Latency Time (tAAmin)
+  SPD4_TRCD_MIN_MTB_STRUCT                  tRCDmin;                  ///< 25      Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD4_TRP_MIN_MTB_STRUCT                   tRPmin;                   ///< 26      Minimum Row Precharge Delay Time (tRPmin)
+  SPD4_TRAS_TRC_MIN_MTB_STRUCT              tRASMintRCMinUpper;       ///< 27      Upper Nibbles for tRAS and tRC
+  SPD4_TRAS_MIN_MTB_STRUCT                  tRASmin;                  ///< 28      Minimum Active to Precharge Delay Time (tRASmin), Least Significant Byte
+  SPD4_TRC_MIN_MTB_STRUCT                   tRCmin;                   ///< 29      Minimum Active to Active/Refresh Delay Time (tRCmin), Least Significant Byte
+  SPD4_TRFC_MIN_MTB_STRUCT                  tRFC1min;                 ///< 30-31   Minimum Refresh Recovery Delay Time (tRFC1min)
+  SPD4_TRFC_MIN_MTB_STRUCT                  tRFC2min;                 ///< 32-33   Minimum Refresh Recovery Delay Time (tRFC2min)
+  SPD4_TRFC_MIN_MTB_STRUCT                  tRFC4min;                 ///< 34-35   Minimum Refresh Recovery Delay Time (tRFC4min)
+  SPD4_TFAW_MIN_MTB_UPPER_STRUCT            tFAWMinUpper;             ///< 36      Upper Nibble for tFAW
+  SPD4_TFAW_MIN_MTB_STRUCT                  tFAWmin;                  ///< 37      Minimum Four Activate Window Delay Time (tFAWmin)
+  SPD4_TRRD_MIN_MTB_STRUCT                  tRRD_Smin;                ///< 38      Minimum Activate to Activate Delay Time (tRRD_Smin), different bank group
+  SPD4_TRRD_MIN_MTB_STRUCT                  tRRD_Lmin;                ///< 39      Minimum Activate to Activate Delay Time (tRRD_Lmin), same bank group
+  SPD4_TCCD_MIN_MTB_STRUCT                  tCCD_Lmin;                ///< 40      Minimum CAS to CAS Delay Time (tCCD_Lmin), Same Bank Group
+  SPD4_TWR_UPPER_NIBBLE_STRUCT              tWRUpperNibble;           ///< 41      Upper Nibble for tWRmin
+  SPD4_TWR_MIN_MTB_STRUCT                   tWRmin;                   ///< 42      Minimum Write Recovery Time (tWRmin)
+  SPD4_TWTR_UPPER_NIBBLE_STRUCT             tWTRUpperNibble;          ///< 43      Upper Nibbles for tWTRmin
+  SPD4_TWTR_MIN_MTB_STRUCT                  tWTR_Smin;                ///< 44      Minimum Write to Read Time (tWTR_Smin), Different Bank Group
+  SPD4_TWTR_MIN_MTB_STRUCT                  tWTR_Lmin;                ///< 45      Minimum Write to Read Time (tWTR_Lmin), Same Bank Group
+  UINT8                                     Reserved1[59 - 46 + 1];   ///< 46-59   Reserved
+  SPD4_CONNECTOR_BIT_MAPPING_BYTE_STRUCT    BitMapping[77 - 60 + 1];  ///< 60-77   Connector to SDRAM Bit Mapping
+  UINT8                                     Reserved2[116 - 78 + 1];  ///< 78-116  Reserved
+  SPD4_TCCD_MIN_FTB_STRUCT                  tCCD_LminFine;            ///< 117     Fine Offset for Minimum CAS to CAS Delay Time (tCCD_Lmin), same bank group
+  SPD4_TRRD_MIN_FTB_STRUCT                  tRRD_LminFine;            ///< 118     Fine Offset for Minimum Activate to Activate Delay Time (tRRD_Lmin), different bank group
+  SPD4_TRRD_MIN_FTB_STRUCT                  tRRD_SminFine;            ///< 119     Fine Offset for Minimum Activate to Activate Delay Time (tRRD_Smin), same bank group
+  SPD4_TRC_MIN_FTB_STRUCT                   tRCminFine;               ///< 120     Fine Offset for Minimum Active to Active/Refresh Delay Time (tRCmin)
+  SPD4_TRP_MIN_FTB_STRUCT                   tRPminFine;               ///< 121     Fine Offset for Minimum Row Precharge Delay Time (tRPabmin)
+  SPD4_TRCD_MIN_FTB_STRUCT                  tRCDminFine;              ///< 122     Fine Offset for Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD4_TAA_MIN_FTB_STRUCT                   tAAminFine;               ///< 123     Fine Offset for Minimum CAS Latency Time (tAAmin)
+  SPD4_TCK_MAX_FTB_STRUCT                   tCKmaxFine;               ///< 124     Fine Offset for SDRAM Minimum Cycle Time (tCKmax)
+  SPD4_TCK_MIN_FTB_STRUCT                   tCKminFine;               ///< 125     Fine Offset for SDRAM Maximum Cycle Time (tCKmin)
+  SPD4_CYCLIC_REDUNDANCY_CODE               Crc;                      ///< 126-127 Cyclical Redundancy Code (CRC)
+} SPD4_BASE_SECTION;
+
+typedef struct {
+  SPD4_UNBUF_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;      ///< 128     Module Nominal Height
+  SPD4_UNBUF_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness;   ///< 129     Module Maximum Thickness
+  SPD4_UNBUF_REFERENCE_RAW_CARD        ReferenceRawCardUsed;     ///< 130     Reference Raw Card Used
+  SPD4_UNBUF_ADDRESS_MAPPING           AddressMappingEdgeConn;   ///< 131     Address Mapping from Edge Connector to DRAM
+  UINT8                                Reserved[253 - 132 + 1];  ///< 132-253 Reserved
+  SPD4_CYCLIC_REDUNDANCY_CODE          Crc;                      ///< 254-255 Cyclical Redundancy Code (CRC)
+} SPD4_MODULE_UNBUFFERED;
+
+typedef struct {
+  SPD4_RDIMM_MODULE_NOMINAL_HEIGHT     ModuleNominalHeight;      ///< 128     Module Nominal Height
+  SPD4_RDIMM_MODULE_NOMINAL_THICKNESS  ModuleMaximumThickness;   ///< 129     Module Maximum Thickness
+  SPD4_RDIMM_REFERENCE_RAW_CARD        ReferenceRawCardUsed;     ///< 130     Reference Raw Card Used
+  SPD4_RDIMM_MODULE_ATTRIBUTES         DimmModuleAttributes;     ///< 131     DIMM Module Attributes
+  SPD4_RDIMM_THERMAL_HEAT_SPREADER_SOLUTION                             DimmThermalHeatSpreaderSolution;     ///< 132     RDIMM Thermal Heat Spreader Solution
+  SPD4_MANUFACTURER_ID_CODE                                             RegisterManufacturerIdCode;          ///< 133-134 Register Manufacturer ID Code
+  SPD4_RDIMM_REGISTER_REVISION_NUMBER                                   RegisterRevisionNumber;              ///< 135     Register Revision Number
+  SPD4_RDIMM_ADDRESS_MAPPING_FROM_REGISTER_TO_DRAM                      AddressMappingFromRegisterToDRAM;    ///< 136     Address Mapping from Register to DRAM
+  SPD4_RDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CONTROL_COMMAND_ADDRESS RegisterOutputDriveStrengthForControlCommandAddress; ///< 137 Register Output Drive Strength for Control and Command Address
+  SPD4_RDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CLOCK                   RegisterOutputDriveStrengthForClock; ///< 138     Register Output Drive Strength for Clock
+  UINT8                                                                 Reserved[253 - 139 + 1];             ///< 253-139 Reserved
+  SPD4_CYCLIC_REDUNDANCY_CODE                                           Crc;                                 ///< 254-255 Cyclical Redundancy Code (CRC)
+} SPD4_MODULE_REGISTERED;
+
+typedef struct {
+  SPD4_LRDIMM_MODULE_NOMINAL_HEIGHT           ModuleNominalHeight;         ///< 128     Module Nominal Height
+  SPD4_LRDIMM_MODULE_NOMINAL_THICKNESS        ModuleMaximumThickness;      ///< 129     Module Maximum Thickness
+  SPD4_LRDIMM_REFERENCE_RAW_CARD              ReferenceRawCardUsed;        ///< 130     Reference Raw Card Used
+  SPD4_LRDIMM_MODULE_ATTRIBUTES               DimmModuleAttributes;        ///< 131     DIMM Module Attributes
+  SPD4_LRDIMM_THERMAL_HEAT_SPREADER_SOLUTION  ThermalHeatSpreaderSolution; ///< 132     RDIMM Thermal Heat Spreader Solution
+  SPD4_MANUFACTURER_ID_CODE                   RegisterManufacturerIdCode;  ///< 133-134 Register Manufacturer ID Code
+  SPD4_LRDIMM_REGISTER_REVISION_NUMBER        RegisterRevisionNumber;      ///< 135     Register Revision Number
+  SPD4_LRDIMM_ADDRESS_MAPPING_FROM_REGISTER_TO_DRAM                           AddressMappingFromRegisterToDram;                       ///< 136 Address Mapping from Register to DRAM
+  SPD4_LRDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CONTROL_COMMAND_ADDRESS      RegisterOutputDriveStrengthForControlCommandAddress;    ///< 137 Register Output Drive Strength for Control and Command Address
+  SPD4_LRDIMM_REGISTER_OUTPUT_DRIVE_STRENGTH_FOR_CLOCK                        RegisterOutputDriveStrengthForClock;                    ///< 138 Register Output Drive Strength for Clock
+  SPD4_LRDIMM_DATA_BUFFER_REVISION_NUMBER     DataBufferRevisionNumber;    ///< 139     Data Buffer Revision Number
+  SPD4_LRDIMM_DRAM_VREFDQ_FOR_PACKAGE_RANK    DramVrefDQForPackageRank0;   ///< 140     DRAM VrefDQ for Package Rank 0
+  SPD4_LRDIMM_DRAM_VREFDQ_FOR_PACKAGE_RANK    DramVrefDQForPackageRank1;   ///< 141     DRAM VrefDQ for Package Rank 1
+  SPD4_LRDIMM_DRAM_VREFDQ_FOR_PACKAGE_RANK    DramVrefDQForPackageRank2;   ///< 142     DRAM VrefDQ for Package Rank 2
+  SPD4_LRDIMM_DRAM_VREFDQ_FOR_PACKAGE_RANK    DramVrefDQForPackageRank3;   ///< 143     DRAM VrefDQ for Package Rank 3
+  SPD4_LRDIMM_DATA_BUFFER_VREFDQ_FOR_DRAM_INTERFACE                   DataBufferVrefDQForDramInterface;               ///< 144     Data Buffer VrefDQ for DRAM Interface
+  SPD4_LRDIMM_DATA_BUFFER_MDQ_DRIVE_STRENGTH_RTT_FOR_DATA_RATE        DataBufferMdqDriveStrengthRttForDataRateLe1866; ///< 145     Data Buffer MDQ Drive Strength and RTT for data rate <= 1866
+  SPD4_LRDIMM_DATA_BUFFER_MDQ_DRIVE_STRENGTH_RTT_FOR_DATA_RATE        DataBufferMdqDriveStrengthRttForDataRateLe2400; ///< 146     Data Buffer MDQ Drive Strength and RTT for data rate <=2400
+  SPD4_LRDIMM_DATA_BUFFER_MDQ_DRIVE_STRENGTH_RTT_FOR_DATA_RATE        DataBufferMdqDriveStrengthRttForDataRateLe3200; ///< 147     Data Buffer MDQ Drive Strength and RTT for data rate <=3200
+  SPD4_LRDIMM_DRAM_DRIVE_STRENGTH                                     DramDriveStrength;                              ///< 148     DRAM Drive Strength
+  SPD4_LRDIMM_DRAM_ODT_RTT_WR_RTT_NOM_FOR_DATA_RATE                   DramOdtRttWrRttNomForDataRateLe1866;            ///< 149     DRAM ODT (RTT_WR and RTT_NOM) for data rate <= 1866
+  SPD4_LRDIMM_DRAM_ODT_RTT_WR_RTT_NOM_FOR_DATA_RATE                   DramOdtRttWrRttNomForDataRateLe2400;            ///< 150     DRAM ODT (RTT_WR and RTT_NOM) for data rate <= 2400
+  SPD4_LRDIMM_DRAM_ODT_RTT_WR_RTT_NOM_FOR_DATA_RATE                   DramOdtRttWrRttNomForDataRateLe3200;            ///< 151     DRAM ODT (RTT_WR and RTT_NOM) for data rate <= 3200
+  SPD4_LRDIMM_DRAM_ODT_RTT_PARK_FOR_DATA_RATE                         DramOdtRttParkForDataRateLe1866;                ///< 152     DRAM ODT (RTT_PARK) for data rate <= 1866
+  SPD4_LRDIMM_DRAM_ODT_RTT_PARK_FOR_DATA_RATE                         DramOdtRttParkForDataRateLe2400;                ///< 153     DRAM ODT (RTT_PARK) for data rate <= 2400
+  SPD4_LRDIMM_DRAM_ODT_RTT_PARK_FOR_DATA_RATE                         DramOdtRttParkForDataRateLe3200;                ///< 154     DRAM ODT (RTT_PARK) for data rate <= 3200
+  SPD4_LRDIMM_DATA_BUFFER_VREFDQ_FOR_DRAM_INTERFACE_RANGE             DataBufferVrefDQForDramInterfaceRange;          ///< 155     Data Buffer VrefDQ for DRAM Interface Range
+  SPD4_LRDIMM_DATA_BUFFER_DQ_DECISION_FEEDBACK_EQUALIZATION           DataBufferDqDecisionFeedbackEqualization;       ///< 156     Data Buffer DQ Decision Feedback Equalization
+  UINT8                                                               Reserved[253 - 157 + 1];                        ///< 253-132 Reserved
+  SPD4_CYCLIC_REDUNDANCY_CODE                                         Crc;                                            ///< 254-255 Cyclical Redundancy Code (CRC)
+} SPD4_MODULE_LOADREDUCED;
+
+typedef struct {
+  UINT8                                                      Reserved0[191 - 128 + 1];              ///< 128-191  Reserved
+  SPD4_NVDIMM_MODULE_PRODUCT_IDENTIFIER                      ModuleProductIdentifier;               ///< 192-193  Module Product Identifier
+  SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_MANUFACTURER_ID_CODE      SubsystemControllerManufacturerIdCode; ///< 194-195  Subsystem Controller Manufacturer's ID Code
+  SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_IDENTIFIER                SubsystemControllerIdentifier;         ///< 196-197  Subsystem Controller Identifier
+  SPD4_NVDIMM_SUBSYSTEM_CONTROLLER_REVISION_CODE             SubsystemControllerRevisionCode;       ///< 198      Subsystem Controller Revision Code
+  SPD4_NVDIMM_REFERENCE_RAW_CARD                             ReferenceRawCardUsed;                  ///< 199      Reference Raw Card Used
+  SPD4_NVDIMM_MODULE_CHARACTERISTICS                         ModuleCharacteristics;                 ///< 200      Module Characteristics
+  SPD4_NVDIMM_HYBRID_MODULE_MEDIA_TYPES                      HybridModuleMediaTypes;                ///< 201-202  Hybrid Module Media Types
+  SPD4_NVDIMM_MAXIMUM_NONVOLATILE_MEMORY_INITIALIZATION_TIME MaximumNonVolatileMemoryInitializationTime; ///< 203 Maximum Non-Volatile Memory Initialization Time
+  SPD4_NVDIMM_FUNCTION_INTERFACE_DESCRIPTOR                  FunctionInterfaceDescriptors[8];       ///< 204-219  Function Interface Descriptors
+  UINT8                                                      Reserved[253 - 220 + 1];               ///< 220-253  Reserved
+  SPD4_CYCLIC_REDUNDANCY_CODE                                Crc;                                   ///< 254-255  Cyclical Redundancy Code (CRC)
+} SPD4_MODULE_NVDIMM;
+
+typedef union {
+  SPD4_MODULE_UNBUFFERED              Unbuffered;               ///< 128-255 Unbuffered Memory Module Types
+  SPD4_MODULE_REGISTERED              Registered;               ///< 128-255 Registered Memory Module Types
+  SPD4_MODULE_LOADREDUCED             LoadReduced;              ///< 128-255 Load Reduced Memory Module Types
+  SPD4_MODULE_NVDIMM                  NonVolatile;              ///< 128-255 Non-Volatile (NVDIMM-N) Hybrid Memory Parameters
+} SPD4_MODULE_SPECIFIC;
+
+typedef struct {
+  UINT8                               ModulePartNumber[348 - 329 + 1]; ///< 329-348 Module Part Number
+} SPD4_MODULE_PART_NUMBER;
+
+typedef struct {
+  UINT8                               ManufacturerSpecificData[381 - 353 + 1]; ///< 353-381 Manufacturer's Specific Data
+} SPD4_MANUFACTURER_SPECIFIC;
+
+typedef UINT8                         SPD4_MODULE_REVISION_CODE;///< 349     Module Revision Code
+typedef UINT8                         SPD4_DRAM_STEPPING;       ///< 352     Dram Stepping
+
+typedef struct {
+  SPD4_UNIQUE_MODULE_ID               ModuleId;                 ///< 320-328 Unique Module ID
+  SPD4_MODULE_PART_NUMBER             ModulePartNumber;         ///< 329-348 Module Part Number
+  SPD4_MODULE_REVISION_CODE           ModuleRevisionCode;       ///< 349     Module Revision Code
+  SPD4_MANUFACTURER_ID_CODE           DramIdCode;               ///< 350-351 Dram Manufacturer ID Code
+  SPD4_DRAM_STEPPING                  DramStepping;             ///< 352     Dram Stepping
+  SPD4_MANUFACTURER_SPECIFIC          ManufacturerSpecificData; ///< 353-381 Manufacturer's Specific Data
+  UINT8                               Reserved[2];              ///< 382-383 Reserved
+} SPD4_MANUFACTURING_DATA;
+
+typedef struct {
+  UINT8                               Reserved[511 - 384 + 1];  ///< 384-511 Unbuffered Memory Module Types
+} SPD4_END_USER_SECTION;
+
+///
+/// DDR4 Serial Presence Detect structure
+///
+typedef struct {
+  SPD4_BASE_SECTION                   Base;                     ///< 0-127   Base Configuration and DRAM Parameters
+  SPD4_MODULE_SPECIFIC                Module;                   ///< 128-255 Module-Specific Section
+  UINT8                               Reserved[319 - 256 + 1];  ///< 256-319 Reserved
+  SPD4_MANUFACTURING_DATA             ManufactureInfo;          ///< 320-383 Manufacturing Information
+  SPD4_END_USER_SECTION               EndUser;                  ///< 384-511 End User Programmable
+} SPD_DDR4;
+
+#pragma pack (pop)
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SdramSpdLpDdr.h b/MdePkg/Include/IndustryStandard/SdramSpdLpDdr.h
new file mode 100644
index 000000000000..1f2302b42423
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SdramSpdLpDdr.h
@@ -0,0 +1,474 @@
+/** @file
+  This file contains definitions for SPD LPDDR.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+    - Serial Presence Detect (SPD) for LPDDR3 and LPDDR4 SDRAM Modules Document Release 2
+      http://www.jedec.org/standards-documents/docs/spd412m-2
+**/
+
+#ifndef _SDRAM_SPD_LPDDR_H_
+#define _SDRAM_SPD_LPDDR_H_
+
+#pragma pack (push, 1)
+
+typedef union {
+  struct {
+    UINT8  BytesUsed                           :  4; ///< Bits 3:0
+    UINT8  BytesTotal                          :  3; ///< Bits 6:4
+    UINT8  CrcCoverage                         :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_DEVICE_DESCRIPTION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Minor                               :  4; ///< Bits 3:0
+    UINT8  Major                               :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_REVISION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Type                                :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_DRAM_DEVICE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ModuleType                          :  4; ///< Bits 3:0
+    UINT8  HybridMedia                         :  3; ///< Bits 6:4
+    UINT8  Hybrid                              :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Density                             :  4; ///< Bits 3:0
+    UINT8  BankAddress                         :  2; ///< Bits 5:4
+    UINT8  BankGroup                           :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SDRAM_DENSITY_BANKS_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ColumnAddress                       :  3; ///< Bits 2:0
+    UINT8  RowAddress                          :  3; ///< Bits 5:3
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SDRAM_ADDRESSING_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SignalLoading                       :  2; ///< Bits 1:0
+    UINT8  ChannelsPerDie                      :  2; ///< Bits 3:2
+    UINT8  DieCount                            :  3; ///< Bits 6:4
+    UINT8  SdramPackageType                    :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SDRAM_PACKAGE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  MaximumActivateCount                :  4; ///< Bits 3:0
+    UINT8  MaximumActivateWindow               :  2; ///< Bits 5:4
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SDRAM_OPTIONAL_FEATURES_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SDRAM_THERMAL_REFRESH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  5; ///< Bits 4:0
+    UINT8  SoftPPR                             :  1; ///< Bits 5:5
+    UINT8  PostPackageRepair                   :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_OTHER_SDRAM_OPTIONAL_FEATURES_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  OperationAt1_20                     :  1; ///< Bits 0:0
+    UINT8  EndurantAt1_20                      :  1; ///< Bits 1:1
+    UINT8  OperationAt1_10                     :  1; ///< Bits 2:2
+    UINT8  EndurantAt1_10                      :  1; ///< Bits 3:3
+    UINT8  OperationAtTBD2V                    :  1; ///< Bits 4:4
+    UINT8  EndurantAtTBD2V                     :  1; ///< Bits 5:5
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_NOMINAL_VOLTAGE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  SdramDeviceWidth                    :  3; ///< Bits 2:0
+    UINT8  RankCount                           :  3; ///< Bits 5:3
+    UINT8  Reserved                            :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_ORGANIZATION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  PrimaryBusWidth                     :  3; ///< Bits 2:0
+    UINT8  BusWidthExtension                   :  2; ///< Bits 4:3
+    UINT8  NumberofChannels                    :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_MEMORY_BUS_WIDTH_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Reserved                            :  7; ///< Bits 6:0
+    UINT8  ThermalSensorPresence               :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_THERMAL_SENSOR_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ExtendedBaseModuleType              :  4; ///< Bits 3:0
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_EXTENDED_MODULE_TYPE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ChipSelectLoading                   :  3; ///< Bits 2:0
+    UINT8  CommandAddressControlClockLoading   :  3; ///< Bits 5:3
+    UINT8  DataStrobeMaskLoading               :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_SIGNAL_LOADING_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  Fine                                :  2; ///< Bits 1:0
+    UINT8  Medium                              :  2; ///< Bits 3:2
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TIMEBASE_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tCKmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TCK_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tCKmax                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TCK_MAX_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT32 Cl3                                 :  1;  ///< Bits 0:0
+    UINT32 Cl6                                 :  1;  ///< Bits 1:1
+    UINT32 Cl8                                 :  1;  ///< Bits 2:2
+    UINT32 Cl9                                 :  1;  ///< Bits 3:3
+    UINT32 Cl10                                :  1;  ///< Bits 4:4
+    UINT32 Cl11                                :  1;  ///< Bits 5:5
+    UINT32 Cl12                                :  1;  ///< Bits 6:6
+    UINT32 Cl14                                :  1;  ///< Bits 7:7
+    UINT32 Cl16                                :  1;  ///< Bits 8:8
+    UINT32 Reserved0                           :  1;  ///< Bits 9:9
+    UINT32 Cl20                                :  1;  ///< Bits 10:10
+    UINT32 Cl22                                :  1;  ///< Bits 11:11
+    UINT32 Cl24                                :  1;  ///< Bits 12:12
+    UINT32 Reserved1                           :  1;  ///< Bits 13:13
+    UINT32 Cl28                                :  1;  ///< Bits 14:14
+    UINT32 Reserved2                           :  1;  ///< Bits 15:15
+    UINT32 Cl32                                :  1;  ///< Bits 16:16
+    UINT32 Reserved3                           :  1;  ///< Bits 17:17
+    UINT32 Cl36                                :  1;  ///< Bits 18:18
+    UINT32 Reserved4                           :  1;  ///< Bits 19:19
+    UINT32 Cl40                                :  1;  ///< Bits 20:20
+    UINT32 Reserved5                           :  11; ///< Bits 31:21
+  } Bits;
+  UINT32 Data;
+  UINT16 Data16[2];
+  UINT8  Data8[4];
+} SPD_LPDDR_CAS_LATENCIES_SUPPORTED_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tAAmin                              :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TAA_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  ReadLatencyMode                     :  2; ///< Bits 1:0
+    UINT8  WriteLatencySet                     :  2; ///< Bits 3:2
+    UINT8  Reserved                            :  4; ///< Bits 7:4
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_RW_LATENCY_OPTION_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRCDmin                             :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TRCD_MIN_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRPab                               :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TRP_AB_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  tRPpb                               :  8; ///< Bits 7:0
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_TRP_PB_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT16  tRFCab                             :  16; ///< Bits 15:0
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD_LPDDR_TRFC_AB_MTB_STRUCT;
+
+typedef union {
+struct {
+    UINT16  tRFCpb                             :  16; ///< Bits 15:0
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD_LPDDR_TRFC_PB_MTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT8  BitOrderatSDRAM                     :  5; ///< Bits 4:0
+    UINT8  WiredtoUpperLowerNibble             :  1; ///< Bits 5:5
+    UINT8  PackageRankMap                      :  2; ///< Bits 7:6
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_CONNECTOR_BIT_MAPPING_BYTE_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRPpbFine                            :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TRP_PB_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRPabFine                            :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TRP_AB_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tRCDminFine                          :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TRCD_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tAAminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TAA_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCKmaxFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TCK_MAX_FTB_STRUCT;
+
+typedef union {
+  struct {
+    INT8  tCKminFine                           :  8; ///< Bits 7:0
+  } Bits;
+  INT8  Data;
+} SPD_LPDDR_TCK_MIN_FTB_STRUCT;
+
+typedef union {
+  struct {
+    UINT16 ContinuationCount                   :  7; ///< Bits 6:0
+    UINT16 ContinuationParity                  :  1; ///< Bits 7:7
+    UINT16 LastNonZeroByte                     :  8; ///< Bits 15:8
+  } Bits;
+  UINT16 Data;
+  UINT8  Data8[2];
+} SPD_LPDDR_MANUFACTURER_ID_CODE;
+
+typedef struct {
+  UINT8 Location;                              ///< Module Manufacturing Location
+} SPD_LPDDR_MANUFACTURING_LOCATION;
+
+typedef struct {
+  UINT8  Year;                                 ///< Year represented in BCD (00h = 2000)
+  UINT8  Week;                                 ///< Year represented in BCD (47h = week 47)
+} SPD_LPDDR_MANUFACTURING_DATE;
+
+typedef union {
+  UINT32 Data;
+  UINT16 SerialNumber16[2];
+  UINT8  SerialNumber8[4];
+} SPD_LPDDR_MANUFACTURER_SERIAL_NUMBER;
+
+typedef struct {
+  SPD_LPDDR_MANUFACTURER_ID_CODE            IdCode;                   ///< Module Manufacturer ID Code
+  SPD_LPDDR_MANUFACTURING_LOCATION          Location;                 ///< Module Manufacturing Location
+  SPD_LPDDR_MANUFACTURING_DATE              Date;                     ///< Module Manufacturing Year, in BCD (range: 2000-2255)
+  SPD_LPDDR_MANUFACTURER_SERIAL_NUMBER      SerialNumber;             ///< Module Serial Number
+} SPD_LPDDR_UNIQUE_MODULE_ID;
+
+typedef union {
+  struct {
+    UINT8  FrontThickness                      :  4; ///< Bits 3:0
+    UINT8  BackThickness                       :  4; ///< Bits 7:4
+  } Bits;
+  UINT8 Data;
+} SPD_LPDDR_MODULE_MAXIMUM_THICKNESS;
+
+typedef union {
+  struct {
+    UINT8  Height                              :  5; ///< Bits 4:0
+    UINT8  RawCardExtension                    :  3; ///< Bits 7:5
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_MODULE_NOMINAL_HEIGHT;
+
+typedef union {
+  struct {
+    UINT8  Card                                :  5; ///< Bits 4:0
+    UINT8  Revision                            :  2; ///< Bits 6:5
+    UINT8  Extension                           :  1; ///< Bits 7:7
+  } Bits;
+  UINT8  Data;
+} SPD_LPDDR_REFERENCE_RAW_CARD;
+
+typedef union {
+  UINT16 Crc[1];
+  UINT8  Data8[2];
+} SPD_LPDDR_CYCLIC_REDUNDANCY_CODE;
+
+typedef struct {
+  SPD_LPDDR_DEVICE_DESCRIPTION_STRUCT            Description;              ///< 0       Number of Serial PD Bytes Written / SPD Device Size / CRC Coverage 1, 2
+  SPD_LPDDR_REVISION_STRUCT                      Revision;                 ///< 1       SPD Revision
+  SPD_LPDDR_DRAM_DEVICE_TYPE_STRUCT              DramDeviceType;           ///< 2       DRAM Device Type
+  SPD_LPDDR_MODULE_TYPE_STRUCT                   ModuleType;               ///< 3       Module Type
+  SPD_LPDDR_SDRAM_DENSITY_BANKS_STRUCT           SdramDensityAndBanks;     ///< 4       SDRAM Density and Banks
+  SPD_LPDDR_SDRAM_ADDRESSING_STRUCT              SdramAddressing;          ///< 5       SDRAM Addressing
+  SPD_LPDDR_SDRAM_PACKAGE_TYPE_STRUCT            SdramPackageType;         ///< 6       SDRAM Package Type
+  SPD_LPDDR_SDRAM_OPTIONAL_FEATURES_STRUCT       SdramOptionalFeatures;    ///< 7       SDRAM Optional Features
+  SPD_LPDDR_SDRAM_THERMAL_REFRESH_STRUCT         ThermalAndRefreshOptions; ///< 8       SDRAM Thermal and Refresh Options
+  SPD_LPDDR_OTHER_SDRAM_OPTIONAL_FEATURES_STRUCT OtherOptionalFeatures;    ///< 9      Other SDRAM Optional Features
+  UINT8                                          Reserved0;                ///< 10      Reserved
+  SPD_LPDDR_MODULE_NOMINAL_VOLTAGE_STRUCT        ModuleNominalVoltage;     ///< 11      Module Nominal Voltage, VDD
+  SPD_LPDDR_MODULE_ORGANIZATION_STRUCT           ModuleOrganization;       ///< 12      Module Organization
+  SPD_LPDDR_MODULE_MEMORY_BUS_WIDTH_STRUCT       ModuleMemoryBusWidth;     ///< 13      Module Memory Bus Width
+  SPD_LPDDR_MODULE_THERMAL_SENSOR_STRUCT         ModuleThermalSensor;      ///< 14      Module Thermal Sensor
+  SPD_LPDDR_EXTENDED_MODULE_TYPE_STRUCT          ExtendedModuleType;       ///< 15      Extended Module Type
+  SPD_LPDDR_SIGNAL_LOADING_STRUCT                SignalLoading;            ///< 16      Signal Loading
+  SPD_LPDDR_TIMEBASE_STRUCT                      Timebase;                 ///< 17      Timebases
+  SPD_LPDDR_TCK_MIN_MTB_STRUCT                   tCKmin;                   ///< 18      SDRAM Minimum Cycle Time (tCKmin)
+  SPD_LPDDR_TCK_MAX_MTB_STRUCT                   tCKmax;                   ///< 19      SDRAM Maximum Cycle Time (tCKmax)
+  SPD_LPDDR_CAS_LATENCIES_SUPPORTED_STRUCT       CasLatencies;             ///< 20-23   CAS Latencies Supported
+  SPD_LPDDR_TAA_MIN_MTB_STRUCT                   tAAmin;                   ///< 24      Minimum CAS Latency Time (tAAmin)
+  SPD_LPDDR_RW_LATENCY_OPTION_STRUCT             LatencySetOptions;        ///< 25      Read and Write Latency Set Options
+  SPD_LPDDR_TRCD_MIN_MTB_STRUCT                  tRCDmin;                  ///< 26      Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD_LPDDR_TRP_AB_MTB_STRUCT                    tRPab;                    ///< 27      Minimum Row Precharge Delay Time (tRPab), all banks
+  SPD_LPDDR_TRP_PB_MTB_STRUCT                    tRPpb;                    ///< 28      Minimum Row Precharge Delay Time (tRPpb), per bank
+  SPD_LPDDR_TRFC_AB_MTB_STRUCT                   tRFCab;                   ///< 29-30   Minimum Refresh Recovery Delay Time (tRFCab), all banks
+  SPD_LPDDR_TRFC_PB_MTB_STRUCT                   tRFCpb;                   ///< 31-32   Minimum Refresh Recovery Delay Time (tRFCpb), per bank
+  UINT8                                          Reserved1[59 - 33 + 1];   ///< 33-59   Reserved
+  SPD_LPDDR_CONNECTOR_BIT_MAPPING_BYTE_STRUCT    BitMapping[77 - 60 + 1];  ///< 60-77   Connector to SDRAM Bit Mapping
+  UINT8                                          Reserved2[119 - 78 + 1];  ///< 78-119  Reserved
+  SPD_LPDDR_TRP_PB_FTB_STRUCT                    tRPpbFine;                ///< 120     Fine Offset for Minimum Row Precharge Delay Time (tRPpbFine), per bank
+  SPD_LPDDR_TRP_AB_FTB_STRUCT                    tRPabFine;                ///< 121     Fine Offset for Minimum Row Precharge Delay Time (tRPabFine), all ranks
+  SPD_LPDDR_TRCD_MIN_FTB_STRUCT                  tRCDminFine;              ///< 122     Fine Offset for Minimum RAS# to CAS# Delay Time (tRCDmin)
+  SPD_LPDDR_TAA_MIN_FTB_STRUCT                   tAAminFine;               ///< 123     Fine Offset for Minimum CAS Latency Time (tAAmin)
+  SPD_LPDDR_TCK_MAX_FTB_STRUCT                   tCKmaxFine;               ///< 124     Fine Offset for SDRAM Maximum Cycle Time (tCKmax)
+  SPD_LPDDR_TCK_MIN_FTB_STRUCT                   tCKminFine;               ///< 125     Fine Offset for SDRAM Minimum Cycle Time (tCKmin)
+  SPD_LPDDR_CYCLIC_REDUNDANCY_CODE               Crc;                      ///< 126-127 Cyclical Redundancy Code (CRC)
+} SPD_LPDDR_BASE_SECTION;
+
+typedef struct {
+  SPD_LPDDR_MODULE_NOMINAL_HEIGHT         ModuleNominalHeight;      ///< 128     Module Nominal Height
+  SPD_LPDDR_MODULE_MAXIMUM_THICKNESS      ModuleMaximumThickness;   ///< 129     Module Maximum Thickness
+  SPD_LPDDR_REFERENCE_RAW_CARD            ReferenceRawCardUsed;     ///< 130     Reference Raw Card Used
+  UINT8                                   Reserved[253 - 131 + 1];  ///< 131-253 Reserved
+  SPD_LPDDR_CYCLIC_REDUNDANCY_CODE        Crc;                      ///< 254-255 Cyclical Redundancy Code (CRC)
+} SPD_LPDDR_MODULE_LPDIMM;
+
+typedef struct {
+  SPD_LPDDR_MODULE_LPDIMM                 LpDimm;                   ///< 128-255 Unbuffered Memory Module Types
+} SPD_LPDDR_MODULE_SPECIFIC;
+
+typedef struct {
+  UINT8                                   ModulePartNumber[348 - 329 + 1]; ///< 329-348 Module Part Number
+} SPD_LPDDR_MODULE_PART_NUMBER;
+
+typedef struct {
+  UINT8                                   ManufacturerSpecificData[381 - 353 + 1]; ///< 353-381 Manufacturer's Specific Data
+} SPD_LPDDR_MANUFACTURER_SPECIFIC;
+
+typedef UINT8                             SPD_LPDDR_MODULE_REVISION_CODE;///< 349     Module Revision Code
+typedef UINT8                             SPD_LPDDR_DRAM_STEPPING;       ///< 352     Dram Stepping
+
+typedef struct {
+  SPD_LPDDR_UNIQUE_MODULE_ID              ModuleId;                 ///< 320-328 Unique Module ID
+  SPD_LPDDR_MODULE_PART_NUMBER            ModulePartNumber;         ///< 329-348 Module Part Number
+  SPD_LPDDR_MODULE_REVISION_CODE          ModuleRevisionCode;       ///< 349     Module Revision Code
+  SPD_LPDDR_MANUFACTURER_ID_CODE          DramIdCode;               ///< 350-351 Dram Manufacturer ID Code
+  SPD_LPDDR_DRAM_STEPPING                 DramStepping;             ///< 352     Dram Stepping
+  SPD_LPDDR_MANUFACTURER_SPECIFIC         ManufacturerSpecificData; ///< 353-381 Manufacturer's Specific Data
+  UINT8                                   Reserved[383 - 382 + 1];  ///< 382-383 Reserved
+} SPD_LPDDR_MANUFACTURING_DATA;
+
+typedef struct {
+  UINT8                                   Reserved[511 - 384 + 1];  ///< 384-511 End User Programmable
+} SPD_LPDDR_END_USER_SECTION;
+
+///
+/// LPDDR Serial Presence Detect structure
+///
+typedef struct {
+  SPD_LPDDR_BASE_SECTION                  Base;                     ///< 0-127   Base Configuration and DRAM Parameters
+  SPD_LPDDR_MODULE_SPECIFIC               Module;                   ///< 128-255 Module-Specific Section
+  UINT8                                   Reserved[319 - 256 + 1];  ///< 256-319 Hybrid Memory Parameters
+  SPD_LPDDR_MANUFACTURING_DATA            ManufactureInfo;          ///< 320-383 Manufacturing Information
+  SPD_LPDDR_END_USER_SECTION              EndUser;                  ///< 384-511 End User Programmable
+} SPD_LPDDR;
+
+#pragma pack (pop)
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SerialPortConsoleRedirectionTable.h b/MdePkg/Include/IndustryStandard/SerialPortConsoleRedirectionTable.h
new file mode 100644
index 000000000000..e3fe03e3199b
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SerialPortConsoleRedirectionTable.h
@@ -0,0 +1,163 @@
+/** @file
+  ACPI Serial Port Console Redirection Table as defined by Microsoft in
+  http://www.microsoft.com/whdc/system/platform/server/spcr.mspx
+    
+  Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
+  Copyright (c) 2014 - 2016, ARM Limited. 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 _SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_H_
+#define _SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_H_
+
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// SPCR Revision (defined in spec)
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_REVISION 0x02
+
+///
+/// Serial Port Console Redirection Table Format
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT8                                   InterfaceType;
+  UINT8                                   Reserved1[3];
+  EFI_ACPI_5_0_GENERIC_ADDRESS_STRUCTURE  BaseAddress;
+  UINT8                                   InterruptType;
+  UINT8                                   Irq;
+  UINT32                                  GlobalSystemInterrupt;
+  UINT8                                   BaudRate;
+  UINT8                                   Parity;
+  UINT8                                   StopBits;
+  UINT8                                   FlowControl;
+  UINT8                                   TerminalType;
+  UINT8                                   Reserved2;
+  UINT16                                  PciDeviceId;
+  UINT16                                  PciVendorId;
+  UINT8                                   PciBusNumber;
+  UINT8                                   PciDeviceNumber;
+  UINT8                                   PciFunctionNumber;
+  UINT32                                  PciFlags;
+  UINT8                                   PciSegment;
+  UINT32                                  Reserved3;
+} EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE;
+
+#pragma pack()
+
+//
+// SPCR Definitions
+//
+
+//
+// Interface Type
+//
+
+///
+/// Full 16550 interface
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_16550                     0
+///
+/// Full 16450 interface
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_16450                     1
+
+
+//
+// The Serial Port Subtypes for ARM are documented in Table 3 of the DBG2 Specification
+//
+
+///
+/// ARM PL011 UART
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_PL011_UART            0x03
+
+///
+/// ARM SBSA Generic UART (2.x) supporting 32-bit only accesses [deprecated]
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_SBSA_GENERIC_UART_2X  0x0d
+
+///
+/// ARM SBSA Generic UART
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_SBSA_GENERIC_UART     0x0e
+
+//
+// Interrupt Type
+//
+
+///
+/// PC-AT-compatible dual-8259 IRQ interrupt
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_8259    0x1
+///
+/// I/O APIC interrupt (Global System Interrupt)
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_APIC    0x2
+///
+/// I/O SAPIC interrupt (Global System Interrupt)
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_SAPIC   0x4
+///
+/// ARMH GIC interrupt (Global System Interrupt)
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_GIC     0x8
+
+//
+// Baud Rate
+//
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_9600         3
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_19200        4
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_57600        6
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_115200       7
+
+//
+// Parity
+//
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_PARITY_NO_PARITY       0
+
+//
+// Stop Bits
+//
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_STOP_BITS_1            1
+
+//
+// Flow Control
+//
+
+///
+/// DCD required for transmit
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_FLOW_CONTROL_DCD       0x1
+///
+/// RTS/CTS hardware flow control
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_FLOW_CONTROL_RTS_CTS   0x2
+///
+///  XON/XOFF software control
+///
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_FLOW_CONTROL_XON_XOFF  0x4
+
+//
+// Terminal Type
+//
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT100      0
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT100_PLUS 1
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT_UTF8    2
+#define EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_ANSI       3
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SmBios.h b/MdePkg/Include/IndustryStandard/SmBios.h
new file mode 100644
index 000000000000..8548f62261ed
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SmBios.h
@@ -0,0 +1,2517 @@
+/** @file
+  Industry Standard Definitions of SMBIOS Table Specification v3.1.0.
+
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+(C) Copyright 2015-2017 Hewlett Packard Enterprise Development LP<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 __SMBIOS_STANDARD_H__
+#define __SMBIOS_STANDARD_H__
+
+///
+/// Reference SMBIOS 2.6, chapter 3.1.2.
+/// For v2.1 and later, handle values in the range 0FF00h to 0FFFFh are reserved for
+/// use by this specification.
+///
+#define SMBIOS_HANDLE_RESERVED_BEGIN 0xFF00
+
+///
+/// Reference SMBIOS 2.7, chapter 6.1.2.
+/// The UEFI Platform Initialization Specification reserves handle number FFFEh for its
+/// EFI_SMBIOS_PROTOCOL.Add() function to mean "assign an unused handle number automatically."
+/// This number is not used for any other purpose by the SMBIOS specification.
+///
+#define SMBIOS_HANDLE_PI_RESERVED 0xFFFE
+
+///
+/// Reference SMBIOS 2.6, chapter 3.1.3.
+/// Each text string is limited to 64 significant characters due to system MIF limitations.
+/// Reference SMBIOS 2.7, chapter 6.1.3.
+/// It will have no limit on the length of each individual text string.
+///
+#define SMBIOS_STRING_MAX_LENGTH     64
+
+//
+// The length of the entire structure table (including all strings) must be reported
+// in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
+// which is a WORD field limited to 65,535 bytes.
+//
+#define SMBIOS_TABLE_MAX_LENGTH 0xFFFF
+
+//
+// For SMBIOS 3.0, Structure table maximum size in Entry Point structure is DWORD field limited to 0xFFFFFFFF bytes.
+//
+#define SMBIOS_3_0_TABLE_MAX_LENGTH 0xFFFFFFFF
+
+//
+// SMBIOS type macros which is according to SMBIOS 2.7 specification.
+//
+#define SMBIOS_TYPE_BIOS_INFORMATION                     0
+#define SMBIOS_TYPE_SYSTEM_INFORMATION                   1
+#define SMBIOS_TYPE_BASEBOARD_INFORMATION                2
+#define SMBIOS_TYPE_SYSTEM_ENCLOSURE                     3
+#define SMBIOS_TYPE_PROCESSOR_INFORMATION                4
+#define SMBIOS_TYPE_MEMORY_CONTROLLER_INFORMATION        5
+#define SMBIOS_TYPE_MEMORY_MODULE_INFORMATON             6
+#define SMBIOS_TYPE_CACHE_INFORMATION                    7
+#define SMBIOS_TYPE_PORT_CONNECTOR_INFORMATION           8
+#define SMBIOS_TYPE_SYSTEM_SLOTS                         9
+#define SMBIOS_TYPE_ONBOARD_DEVICE_INFORMATION           10
+#define SMBIOS_TYPE_OEM_STRINGS                          11
+#define SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS         12
+#define SMBIOS_TYPE_BIOS_LANGUAGE_INFORMATION            13
+#define SMBIOS_TYPE_GROUP_ASSOCIATIONS                   14
+#define SMBIOS_TYPE_SYSTEM_EVENT_LOG                     15
+#define SMBIOS_TYPE_PHYSICAL_MEMORY_ARRAY                16
+#define SMBIOS_TYPE_MEMORY_DEVICE                        17
+#define SMBIOS_TYPE_32BIT_MEMORY_ERROR_INFORMATION       18
+#define SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS          19
+#define SMBIOS_TYPE_MEMORY_DEVICE_MAPPED_ADDRESS         20
+#define SMBIOS_TYPE_BUILT_IN_POINTING_DEVICE             21
+#define SMBIOS_TYPE_PORTABLE_BATTERY                     22
+#define SMBIOS_TYPE_SYSTEM_RESET                         23
+#define SMBIOS_TYPE_HARDWARE_SECURITY                    24
+#define SMBIOS_TYPE_SYSTEM_POWER_CONTROLS                25
+#define SMBIOS_TYPE_VOLTAGE_PROBE                        26
+#define SMBIOS_TYPE_COOLING_DEVICE                       27
+#define SMBIOS_TYPE_TEMPERATURE_PROBE                    28
+#define SMBIOS_TYPE_ELECTRICAL_CURRENT_PROBE             29
+#define SMBIOS_TYPE_OUT_OF_BAND_REMOTE_ACCESS            30
+#define SMBIOS_TYPE_BOOT_INTEGRITY_SERVICE               31
+#define SMBIOS_TYPE_SYSTEM_BOOT_INFORMATION              32
+#define SMBIOS_TYPE_64BIT_MEMORY_ERROR_INFORMATION       33
+#define SMBIOS_TYPE_MANAGEMENT_DEVICE                    34
+#define SMBIOS_TYPE_MANAGEMENT_DEVICE_COMPONENT          35
+#define SMBIOS_TYPE_MANAGEMENT_DEVICE_THRESHOLD_DATA     36
+#define SMBIOS_TYPE_MEMORY_CHANNEL                       37
+#define SMBIOS_TYPE_IPMI_DEVICE_INFORMATION              38
+#define SMBIOS_TYPE_SYSTEM_POWER_SUPPLY                  39
+#define SMBIOS_TYPE_ADDITIONAL_INFORMATION               40
+#define SMBIOS_TYPE_ONBOARD_DEVICES_EXTENDED_INFORMATION 41
+#define SMBIOS_TYPE_MANAGEMENT_CONTROLLER_HOST_INTERFACE 42
+#define SMBIOS_TYPE_TPM_DEVICE                           43
+
+///
+/// Inactive type is added from SMBIOS 2.2. Reference SMBIOS 2.6, chapter 3.3.43.
+/// Upper-level software that interprets the SMBIOS structure-table should bypass an 
+/// Inactive structure just like a structure type that the software does not recognize.
+///
+#define SMBIOS_TYPE_INACTIVE         0x007E    
+
+///
+/// End-of-table type is added from SMBIOS 2.2. Reference SMBIOS 2.6, chapter 3.3.44.
+/// The end-of-table indicator is used in the last physical structure in a table
+///
+#define SMBIOS_TYPE_END_OF_TABLE     0x007F
+
+#define SMBIOS_OEM_BEGIN             128
+#define SMBIOS_OEM_END               255
+
+///
+/// Types 0 through 127 (7Fh) are reserved for and defined by this
+/// specification. Types 128 through 256 (80h to FFh) are available for system- and OEM-specific information.  
+///
+typedef UINT8  SMBIOS_TYPE;
+
+///
+/// Specifies the structure's handle, a unique 16-bit number in the range 0 to 0FFFEh (for version
+/// 2.0) or 0 to 0FEFFh (for version 2.1 and later). The handle can be used with the Get SMBIOS
+/// Structure function to retrieve a specific structure; the handle numbers are not required to be
+/// contiguous. For v2.1 and later, handle values in the range 0FF00h to 0FFFFh are reserved for
+/// use by this specification.
+/// If the system configuration changes, a previously assigned handle might no longer exist.
+/// However once a handle has been assigned by the BIOS, the BIOS cannot re-assign that handle
+/// number to another structure.
+///
+typedef UINT16 SMBIOS_HANDLE;
+
+///
+/// Smbios Table Entry Point Structure.
+///
+#pragma pack(1)
+typedef struct {
+  UINT8   AnchorString[4];
+  UINT8   EntryPointStructureChecksum;
+  UINT8   EntryPointLength;
+  UINT8   MajorVersion;
+  UINT8   MinorVersion;
+  UINT16  MaxStructureSize;
+  UINT8   EntryPointRevision;
+  UINT8   FormattedArea[5];
+  UINT8   IntermediateAnchorString[5];
+  UINT8   IntermediateChecksum;
+  UINT16  TableLength;
+  UINT32  TableAddress;
+  UINT16  NumberOfSmbiosStructures;
+  UINT8   SmbiosBcdRevision;
+} SMBIOS_TABLE_ENTRY_POINT;
+
+typedef struct {
+  UINT8   AnchorString[5];
+  UINT8   EntryPointStructureChecksum;
+  UINT8   EntryPointLength;
+  UINT8   MajorVersion;
+  UINT8   MinorVersion;
+  UINT8   DocRev;
+  UINT8   EntryPointRevision;
+  UINT8   Reserved;
+  UINT32  TableMaximumSize;
+  UINT64  TableAddress;
+} SMBIOS_TABLE_3_0_ENTRY_POINT;
+
+///
+/// The Smbios structure header.
+///
+typedef struct {
+  SMBIOS_TYPE    Type;
+  UINT8          Length;
+  SMBIOS_HANDLE  Handle;
+} SMBIOS_STRUCTURE;
+
+///
+/// Text strings associated with a given SMBIOS structure are returned in the dmiStrucBuffer, appended directly after
+/// the formatted portion of the structure. This method of returning string information eliminates the need for
+/// application software to deal with pointers embedded in the SMBIOS structure. Each string is terminated with a null
+/// (00h) BYTE and the set of strings is terminated with an additional null (00h) BYTE. When the formatted portion of
+/// a SMBIOS structure references a string, it does so by specifying a non-zero string number within the structure's
+/// string-set. For example, if a string field contains 02h, it references the second string following the formatted portion
+/// of the SMBIOS structure. If a string field references no string, a null (0) is placed in that string field. If the
+/// formatted portion of the structure contains string-reference fields and all the string fields are set to 0 (no string
+/// references), the formatted section of the structure is followed by two null (00h) BYTES.
+///
+typedef UINT8 SMBIOS_TABLE_STRING;
+
+///
+/// BIOS Characteristics
+/// Defines which functions the BIOS supports. PCI, PCMCIA, Flash, etc.
+///
+typedef struct {
+  UINT32  Reserved                          :2;  ///< Bits 0-1.
+  UINT32  Unknown                           :1;
+  UINT32  BiosCharacteristicsNotSupported   :1;
+  UINT32  IsaIsSupported                    :1;
+  UINT32  McaIsSupported                    :1;
+  UINT32  EisaIsSupported                   :1;
+  UINT32  PciIsSupported                    :1;
+  UINT32  PcmciaIsSupported                 :1;
+  UINT32  PlugAndPlayIsSupported            :1;
+  UINT32  ApmIsSupported                    :1;
+  UINT32  BiosIsUpgradable                  :1;
+  UINT32  BiosShadowingAllowed              :1;
+  UINT32  VlVesaIsSupported                 :1;
+  UINT32  EscdSupportIsAvailable            :1;
+  UINT32  BootFromCdIsSupported             :1;
+  UINT32  SelectableBootIsSupported         :1;
+  UINT32  RomBiosIsSocketed                 :1;
+  UINT32  BootFromPcmciaIsSupported         :1;
+  UINT32  EDDSpecificationIsSupported       :1;
+  UINT32  JapaneseNecFloppyIsSupported      :1;
+  UINT32  JapaneseToshibaFloppyIsSupported  :1;
+  UINT32  Floppy525_360IsSupported          :1;
+  UINT32  Floppy525_12IsSupported           :1;
+  UINT32  Floppy35_720IsSupported           :1;
+  UINT32  Floppy35_288IsSupported           :1;
+  UINT32  PrintScreenIsSupported            :1;
+  UINT32  Keyboard8042IsSupported           :1;
+  UINT32  SerialIsSupported                 :1;
+  UINT32  PrinterIsSupported                :1;
+  UINT32  CgaMonoIsSupported                :1;
+  UINT32  NecPc98                           :1;
+  UINT32  ReservedForVendor                 :32; ///< Bits 32-63. Bits 32-47 reserved for BIOS vendor 
+                                                 ///< and bits 48-63 reserved for System Vendor. 
+} MISC_BIOS_CHARACTERISTICS;
+
+///
+/// BIOS Characteristics Extension Byte 1.
+/// This information, available for SMBIOS version 2.1 and later, appears at offset 12h
+/// within the BIOS Information structure.
+///
+typedef struct {
+  UINT8  AcpiIsSupported                   :1;
+  UINT8  UsbLegacyIsSupported              :1;
+  UINT8  AgpIsSupported                    :1;
+  UINT8  I2OBootIsSupported                :1;
+  UINT8  Ls120BootIsSupported              :1;
+  UINT8  AtapiZipDriveBootIsSupported      :1;
+  UINT8  Boot1394IsSupported               :1;
+  UINT8  SmartBatteryIsSupported           :1;
+} MBCE_BIOS_RESERVED;
+
+///
+/// BIOS Characteristics Extension Byte 2.
+/// This information, available for SMBIOS version 2.3 and later, appears at offset 13h
+/// within the BIOS Information structure.
+///
+typedef struct {
+  UINT8  BiosBootSpecIsSupported              :1;
+  UINT8  FunctionKeyNetworkBootIsSupported    :1;
+  UINT8  TargetContentDistributionEnabled     :1;
+  UINT8  UefiSpecificationSupported           :1;
+  UINT8  VirtualMachineSupported              :1;
+  UINT8  ExtensionByte2Reserved               :3;
+} MBCE_SYSTEM_RESERVED;
+
+///
+/// BIOS Characteristics Extension Bytes.
+///
+typedef struct {
+  MBCE_BIOS_RESERVED    BiosReserved;
+  MBCE_SYSTEM_RESERVED  SystemReserved;
+} MISC_BIOS_CHARACTERISTICS_EXTENSION;
+
+///
+/// Extended BIOS ROM size.
+///
+typedef struct {
+  UINT16 Size           :14;
+  UINT16 Unit           :2;
+} EXTENDED_BIOS_ROM_SIZE;
+
+///
+/// BIOS Information (Type 0).
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  SMBIOS_TABLE_STRING       Vendor;
+  SMBIOS_TABLE_STRING       BiosVersion;
+  UINT16                    BiosSegment;
+  SMBIOS_TABLE_STRING       BiosReleaseDate;
+  UINT8                     BiosSize;
+  MISC_BIOS_CHARACTERISTICS BiosCharacteristics;
+  UINT8                     BIOSCharacteristicsExtensionBytes[2];
+  UINT8                     SystemBiosMajorRelease;
+  UINT8                     SystemBiosMinorRelease;
+  UINT8                     EmbeddedControllerFirmwareMajorRelease;
+  UINT8                     EmbeddedControllerFirmwareMinorRelease;
+  //
+  // Add for smbios 3.1.0
+  //
+  EXTENDED_BIOS_ROM_SIZE    ExtendedBiosSize;
+} SMBIOS_TABLE_TYPE0;
+
+///
+///  System Wake-up Type.
+///
+typedef enum {  
+  SystemWakeupTypeReserved         = 0x00,
+  SystemWakeupTypeOther            = 0x01,
+  SystemWakeupTypeUnknown          = 0x02,
+  SystemWakeupTypeApmTimer         = 0x03,
+  SystemWakeupTypeModemRing        = 0x04,
+  SystemWakeupTypeLanRemote        = 0x05,
+  SystemWakeupTypePowerSwitch      = 0x06,
+  SystemWakeupTypePciPme           = 0x07,
+  SystemWakeupTypeAcPowerRestored  = 0x08
+} MISC_SYSTEM_WAKEUP_TYPE;
+
+///
+/// System Information (Type 1).
+/// 
+/// The information in this structure defines attributes of the overall system and is 
+/// intended to be associated with the Component ID group of the system's MIF.
+/// An SMBIOS implementation is associated with a single system instance and contains 
+/// one and only one System Information (Type 1) structure.
+///
+typedef struct {
+  SMBIOS_STRUCTURE        Hdr;
+  SMBIOS_TABLE_STRING     Manufacturer;
+  SMBIOS_TABLE_STRING     ProductName;
+  SMBIOS_TABLE_STRING     Version;
+  SMBIOS_TABLE_STRING     SerialNumber;
+  GUID                    Uuid;
+  UINT8                   WakeUpType;           ///< The enumeration value from MISC_SYSTEM_WAKEUP_TYPE.
+  SMBIOS_TABLE_STRING     SKUNumber;
+  SMBIOS_TABLE_STRING     Family;
+} SMBIOS_TABLE_TYPE1;
+
+///
+///  Base Board - Feature Flags. 
+///
+typedef struct {
+  UINT8  Motherboard           :1;
+  UINT8  RequiresDaughterCard  :1;
+  UINT8  Removable             :1;
+  UINT8  Replaceable           :1;
+  UINT8  HotSwappable          :1;
+  UINT8  Reserved              :3;
+} BASE_BOARD_FEATURE_FLAGS;
+
+///
+///  Base Board - Board Type.
+///
+typedef enum {  
+  BaseBoardTypeUnknown                  = 0x1,
+  BaseBoardTypeOther                    = 0x2,
+  BaseBoardTypeServerBlade              = 0x3,
+  BaseBoardTypeConnectivitySwitch       = 0x4,
+  BaseBoardTypeSystemManagementModule   = 0x5,
+  BaseBoardTypeProcessorModule          = 0x6,
+  BaseBoardTypeIOModule                 = 0x7,
+  BaseBoardTypeMemoryModule             = 0x8,
+  BaseBoardTypeDaughterBoard            = 0x9,
+  BaseBoardTypeMotherBoard              = 0xA,
+  BaseBoardTypeProcessorMemoryModule    = 0xB,
+  BaseBoardTypeProcessorIOModule        = 0xC,
+  BaseBoardTypeInterconnectBoard        = 0xD
+} BASE_BOARD_TYPE;
+
+///
+/// Base Board (or Module) Information (Type 2).
+///
+/// The information in this structure defines attributes of a system baseboard - 
+/// for example a motherboard, planar, or server blade or other standard system module.
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  SMBIOS_TABLE_STRING       Manufacturer;
+  SMBIOS_TABLE_STRING       ProductName;
+  SMBIOS_TABLE_STRING       Version;
+  SMBIOS_TABLE_STRING       SerialNumber;
+  SMBIOS_TABLE_STRING       AssetTag;
+  BASE_BOARD_FEATURE_FLAGS  FeatureFlag;
+  SMBIOS_TABLE_STRING       LocationInChassis;
+  UINT16                    ChassisHandle;
+  UINT8                     BoardType;              ///< The enumeration value from BASE_BOARD_TYPE.
+  UINT8                     NumberOfContainedObjectHandles;
+  UINT16                    ContainedObjectHandles[1];
+} SMBIOS_TABLE_TYPE2;
+
+///
+/// System Enclosure or Chassis Types
+///
+typedef enum {  
+  MiscChassisTypeOther                = 0x01,
+  MiscChassisTypeUnknown              = 0x02,
+  MiscChassisTypeDeskTop              = 0x03,
+  MiscChassisTypeLowProfileDesktop    = 0x04,
+  MiscChassisTypePizzaBox             = 0x05,
+  MiscChassisTypeMiniTower            = 0x06,
+  MiscChassisTypeTower                = 0x07,
+  MiscChassisTypePortable             = 0x08,
+  MiscChassisTypeLapTop               = 0x09,
+  MiscChassisTypeNotebook             = 0x0A,
+  MiscChassisTypeHandHeld             = 0x0B,
+  MiscChassisTypeDockingStation       = 0x0C,
+  MiscChassisTypeAllInOne             = 0x0D,
+  MiscChassisTypeSubNotebook          = 0x0E,
+  MiscChassisTypeSpaceSaving          = 0x0F,
+  MiscChassisTypeLunchBox             = 0x10,
+  MiscChassisTypeMainServerChassis    = 0x11,
+  MiscChassisTypeExpansionChassis     = 0x12,
+  MiscChassisTypeSubChassis           = 0x13,
+  MiscChassisTypeBusExpansionChassis  = 0x14,
+  MiscChassisTypePeripheralChassis    = 0x15,
+  MiscChassisTypeRaidChassis          = 0x16,
+  MiscChassisTypeRackMountChassis     = 0x17,
+  MiscChassisTypeSealedCasePc         = 0x18,
+  MiscChassisMultiSystemChassis       = 0x19,
+  MiscChassisCompactPCI               = 0x1A,
+  MiscChassisAdvancedTCA              = 0x1B,
+  MiscChassisBlade                    = 0x1C,
+  MiscChassisBladeEnclosure           = 0x1D,
+  MiscChassisTablet                   = 0x1E,
+  MiscChassisConvertible              = 0x1F,
+  MiscChassisDetachable               = 0x20,
+  MiscChassisIoTGateway               = 0x21,
+  MiscChassisEmbeddedPc               = 0x22,
+  MiscChassisMiniPc                   = 0x23,
+  MiscChassisStickPc                  = 0x24
+} MISC_CHASSIS_TYPE;
+
+///
+/// System Enclosure or Chassis States .
+///
+typedef enum {  
+  ChassisStateOther           = 0x01,
+  ChassisStateUnknown         = 0x02,
+  ChassisStateSafe            = 0x03,
+  ChassisStateWarning         = 0x04,
+  ChassisStateCritical        = 0x05,
+  ChassisStateNonRecoverable  = 0x06
+} MISC_CHASSIS_STATE;
+
+///
+/// System Enclosure or Chassis Security Status.
+///
+typedef enum {  
+  ChassisSecurityStatusOther                          = 0x01,
+  ChassisSecurityStatusUnknown                        = 0x02,
+  ChassisSecurityStatusNone                           = 0x03,
+  ChassisSecurityStatusExternalInterfaceLockedOut     = 0x04,
+  ChassisSecurityStatusExternalInterfaceLockedEnabled = 0x05
+} MISC_CHASSIS_SECURITY_STATE;
+
+///
+/// Contained Element record
+///
+typedef struct {
+  UINT8                 ContainedElementType;
+  UINT8                 ContainedElementMinimum;
+  UINT8                 ContainedElementMaximum;
+} CONTAINED_ELEMENT;
+
+
+///
+/// System Enclosure or Chassis (Type 3).
+///
+/// The information in this structure defines attributes of the system's mechanical enclosure(s).  
+/// For example, if a system included a separate enclosure for its peripheral devices, 
+/// two structures would be returned: one for the main, system enclosure and the second for
+/// the peripheral device enclosure.  The additions to this structure in v2.1 of this specification
+/// support the population of the CIM_Chassis class. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE            Hdr;
+  SMBIOS_TABLE_STRING         Manufacturer;
+  UINT8                       Type;
+  SMBIOS_TABLE_STRING         Version;
+  SMBIOS_TABLE_STRING         SerialNumber;
+  SMBIOS_TABLE_STRING         AssetTag;
+  UINT8                       BootupState;            ///< The enumeration value from MISC_CHASSIS_STATE.
+  UINT8                       PowerSupplyState;       ///< The enumeration value from MISC_CHASSIS_STATE.
+  UINT8                       ThermalState;           ///< The enumeration value from MISC_CHASSIS_STATE.
+  UINT8                       SecurityStatus;         ///< The enumeration value from MISC_CHASSIS_SECURITY_STATE.
+  UINT8                       OemDefined[4];
+  UINT8                       Height;
+  UINT8                       NumberofPowerCords;
+  UINT8                       ContainedElementCount;
+  UINT8                       ContainedElementRecordLength;
+  //
+  // Can have 0 to (ContainedElementCount * ContainedElementRecordLength) contained elements
+  //
+  CONTAINED_ELEMENT           ContainedElements[1];
+  //
+  // Add for smbios 2.7
+  //
+  // Since ContainedElements has a variable number of entries, must not define SKUNumber in
+  // the structure.  Need to reference it by starting at offset 0x15 and adding
+  // (ContainedElementCount * ContainedElementRecordLength) bytes.
+  //
+  // SMBIOS_TABLE_STRING         SKUNumber;
+} SMBIOS_TABLE_TYPE3;
+
+///
+/// Processor Information - Processor Type.
+///
+typedef enum {
+  ProcessorOther   = 0x01,
+  ProcessorUnknown = 0x02,
+  CentralProcessor = 0x03,
+  MathProcessor    = 0x04,
+  DspProcessor     = 0x05,
+  VideoProcessor   = 0x06
+} PROCESSOR_TYPE_DATA;
+
+///
+/// Processor Information - Processor Family.
+///
+typedef enum {
+  ProcessorFamilyOther                  = 0x01, 
+  ProcessorFamilyUnknown                = 0x02,
+  ProcessorFamily8086                   = 0x03, 
+  ProcessorFamily80286                  = 0x04,
+  ProcessorFamilyIntel386               = 0x05, 
+  ProcessorFamilyIntel486               = 0x06,
+  ProcessorFamily8087                   = 0x07,
+  ProcessorFamily80287                  = 0x08,
+  ProcessorFamily80387                  = 0x09, 
+  ProcessorFamily80487                  = 0x0A,
+  ProcessorFamilyPentium                = 0x0B, 
+  ProcessorFamilyPentiumPro             = 0x0C,
+  ProcessorFamilyPentiumII              = 0x0D,
+  ProcessorFamilyPentiumMMX             = 0x0E,
+  ProcessorFamilyCeleron                = 0x0F,
+  ProcessorFamilyPentiumIIXeon          = 0x10,
+  ProcessorFamilyPentiumIII             = 0x11, 
+  ProcessorFamilyM1                     = 0x12,
+  ProcessorFamilyM2                     = 0x13,
+  ProcessorFamilyIntelCeleronM          = 0x14,
+  ProcessorFamilyIntelPentium4Ht        = 0x15,
+  ProcessorFamilyAmdDuron               = 0x18,
+  ProcessorFamilyK5                     = 0x19, 
+  ProcessorFamilyK6                     = 0x1A,
+  ProcessorFamilyK6_2                   = 0x1B,
+  ProcessorFamilyK6_3                   = 0x1C,
+  ProcessorFamilyAmdAthlon              = 0x1D,
+  ProcessorFamilyAmd29000               = 0x1E,
+  ProcessorFamilyK6_2Plus               = 0x1F,
+  ProcessorFamilyPowerPC                = 0x20,
+  ProcessorFamilyPowerPC601             = 0x21,
+  ProcessorFamilyPowerPC603             = 0x22,
+  ProcessorFamilyPowerPC603Plus         = 0x23,
+  ProcessorFamilyPowerPC604             = 0x24,
+  ProcessorFamilyPowerPC620             = 0x25,
+  ProcessorFamilyPowerPCx704            = 0x26,
+  ProcessorFamilyPowerPC750             = 0x27,
+  ProcessorFamilyIntelCoreDuo           = 0x28,
+  ProcessorFamilyIntelCoreDuoMobile     = 0x29,
+  ProcessorFamilyIntelCoreSoloMobile    = 0x2A,
+  ProcessorFamilyIntelAtom              = 0x2B,
+  ProcessorFamilyIntelCoreM             = 0x2C,
+  ProcessorFamilyIntelCorem3            = 0x2D,
+  ProcessorFamilyIntelCorem5            = 0x2E,
+  ProcessorFamilyIntelCorem7            = 0x2F,
+  ProcessorFamilyAlpha                  = 0x30,
+  ProcessorFamilyAlpha21064             = 0x31,
+  ProcessorFamilyAlpha21066             = 0x32,
+  ProcessorFamilyAlpha21164             = 0x33,
+  ProcessorFamilyAlpha21164PC           = 0x34,
+  ProcessorFamilyAlpha21164a            = 0x35,
+  ProcessorFamilyAlpha21264             = 0x36,
+  ProcessorFamilyAlpha21364             = 0x37,
+  ProcessorFamilyAmdTurionIIUltraDualCoreMobileM    = 0x38,
+  ProcessorFamilyAmdTurionIIDualCoreMobileM         = 0x39,
+  ProcessorFamilyAmdAthlonIIDualCoreM   = 0x3A,
+  ProcessorFamilyAmdOpteron6100Series   = 0x3B,
+  ProcessorFamilyAmdOpteron4100Series   = 0x3C,
+  ProcessorFamilyAmdOpteron6200Series   = 0x3D,
+  ProcessorFamilyAmdOpteron4200Series   = 0x3E,
+  ProcessorFamilyAmdFxSeries            = 0x3F,
+  ProcessorFamilyMips                   = 0x40,
+  ProcessorFamilyMIPSR4000              = 0x41,
+  ProcessorFamilyMIPSR4200              = 0x42,
+  ProcessorFamilyMIPSR4400              = 0x43,
+  ProcessorFamilyMIPSR4600              = 0x44,
+  ProcessorFamilyMIPSR10000             = 0x45,
+  ProcessorFamilyAmdCSeries             = 0x46,
+  ProcessorFamilyAmdESeries             = 0x47,
+  ProcessorFamilyAmdASeries             = 0x48,    ///< SMBIOS spec 2.8.0 updated the name
+  ProcessorFamilyAmdGSeries             = 0x49,
+  ProcessorFamilyAmdZSeries             = 0x4A,
+  ProcessorFamilyAmdRSeries             = 0x4B,
+  ProcessorFamilyAmdOpteron4300         = 0x4C,
+  ProcessorFamilyAmdOpteron6300         = 0x4D,
+  ProcessorFamilyAmdOpteron3300         = 0x4E,
+  ProcessorFamilyAmdFireProSeries       = 0x4F,
+  ProcessorFamilySparc                  = 0x50,
+  ProcessorFamilySuperSparc             = 0x51,
+  ProcessorFamilymicroSparcII           = 0x52,
+  ProcessorFamilymicroSparcIIep         = 0x53,
+  ProcessorFamilyUltraSparc             = 0x54,
+  ProcessorFamilyUltraSparcII           = 0x55,
+  ProcessorFamilyUltraSparcIii          = 0x56,
+  ProcessorFamilyUltraSparcIII          = 0x57,
+  ProcessorFamilyUltraSparcIIIi         = 0x58,
+  ProcessorFamily68040                  = 0x60,
+  ProcessorFamily68xxx                  = 0x61,
+  ProcessorFamily68000                  = 0x62,
+  ProcessorFamily68010                  = 0x63,
+  ProcessorFamily68020                  = 0x64,
+  ProcessorFamily68030                  = 0x65,
+  ProcessorFamilyAmdAthlonX4QuadCore    = 0x66,
+  ProcessorFamilyAmdOpteronX1000Series  = 0x67,
+  ProcessorFamilyAmdOpteronX2000Series  = 0x68,
+  ProcessorFamilyAmdOpteronASeries      = 0x69,
+  ProcessorFamilyAmdOpteronX3000Series  = 0x6A,
+  ProcessorFamilyAmdZen                 = 0x6B,
+  ProcessorFamilyHobbit                 = 0x70,
+  ProcessorFamilyCrusoeTM5000           = 0x78,
+  ProcessorFamilyCrusoeTM3000           = 0x79,
+  ProcessorFamilyEfficeonTM8000         = 0x7A,
+  ProcessorFamilyWeitek                 = 0x80,
+  ProcessorFamilyItanium                = 0x82,
+  ProcessorFamilyAmdAthlon64            = 0x83,
+  ProcessorFamilyAmdOpteron             = 0x84,
+  ProcessorFamilyAmdSempron             = 0x85,
+  ProcessorFamilyAmdTurion64Mobile      = 0x86,
+  ProcessorFamilyDualCoreAmdOpteron     = 0x87,
+  ProcessorFamilyAmdAthlon64X2DualCore  = 0x88,
+  ProcessorFamilyAmdTurion64X2Mobile    = 0x89,
+  ProcessorFamilyQuadCoreAmdOpteron     = 0x8A,
+  ProcessorFamilyThirdGenerationAmdOpteron = 0x8B,
+  ProcessorFamilyAmdPhenomFxQuadCore    = 0x8C,
+  ProcessorFamilyAmdPhenomX4QuadCore    = 0x8D,
+  ProcessorFamilyAmdPhenomX2DualCore    = 0x8E,
+  ProcessorFamilyAmdAthlonX2DualCore    = 0x8F,  
+  ProcessorFamilyPARISC                 = 0x90,
+  ProcessorFamilyPaRisc8500             = 0x91,
+  ProcessorFamilyPaRisc8000             = 0x92,
+  ProcessorFamilyPaRisc7300LC           = 0x93,
+  ProcessorFamilyPaRisc7200             = 0x94,
+  ProcessorFamilyPaRisc7100LC           = 0x95,
+  ProcessorFamilyPaRisc7100             = 0x96,
+  ProcessorFamilyV30                    = 0xA0,
+  ProcessorFamilyQuadCoreIntelXeon3200Series  = 0xA1,
+  ProcessorFamilyDualCoreIntelXeon3000Series  = 0xA2,
+  ProcessorFamilyQuadCoreIntelXeon5300Series  = 0xA3,
+  ProcessorFamilyDualCoreIntelXeon5100Series  = 0xA4,
+  ProcessorFamilyDualCoreIntelXeon5000Series  = 0xA5,
+  ProcessorFamilyDualCoreIntelXeonLV          = 0xA6,
+  ProcessorFamilyDualCoreIntelXeonULV         = 0xA7,
+  ProcessorFamilyDualCoreIntelXeon7100Series  = 0xA8,
+  ProcessorFamilyQuadCoreIntelXeon5400Series  = 0xA9,
+  ProcessorFamilyQuadCoreIntelXeon            = 0xAA,
+  ProcessorFamilyDualCoreIntelXeon5200Series  = 0xAB,
+  ProcessorFamilyDualCoreIntelXeon7200Series  = 0xAC,
+  ProcessorFamilyQuadCoreIntelXeon7300Series  = 0xAD,
+  ProcessorFamilyQuadCoreIntelXeon7400Series  = 0xAE,
+  ProcessorFamilyMultiCoreIntelXeon7400Series = 0xAF,
+  ProcessorFamilyPentiumIIIXeon         = 0xB0,
+  ProcessorFamilyPentiumIIISpeedStep    = 0xB1,
+  ProcessorFamilyPentium4               = 0xB2,
+  ProcessorFamilyIntelXeon              = 0xB3,
+  ProcessorFamilyAS400                  = 0xB4,
+  ProcessorFamilyIntelXeonMP            = 0xB5,
+  ProcessorFamilyAMDAthlonXP            = 0xB6,
+  ProcessorFamilyAMDAthlonMP            = 0xB7,
+  ProcessorFamilyIntelItanium2          = 0xB8,
+  ProcessorFamilyIntelPentiumM          = 0xB9,
+  ProcessorFamilyIntelCeleronD          = 0xBA,
+  ProcessorFamilyIntelPentiumD          = 0xBB,
+  ProcessorFamilyIntelPentiumEx         = 0xBC,
+  ProcessorFamilyIntelCoreSolo          = 0xBD,  ///< SMBIOS spec 2.6 updated this value
+  ProcessorFamilyReserved               = 0xBE,
+  ProcessorFamilyIntelCore2             = 0xBF,
+  ProcessorFamilyIntelCore2Solo         = 0xC0,
+  ProcessorFamilyIntelCore2Extreme      = 0xC1,
+  ProcessorFamilyIntelCore2Quad         = 0xC2,
+  ProcessorFamilyIntelCore2ExtremeMobile = 0xC3,
+  ProcessorFamilyIntelCore2DuoMobile    = 0xC4,
+  ProcessorFamilyIntelCore2SoloMobile   = 0xC5,
+  ProcessorFamilyIntelCoreI7            = 0xC6,
+  ProcessorFamilyDualCoreIntelCeleron   = 0xC7,  
+  ProcessorFamilyIBM390                 = 0xC8,
+  ProcessorFamilyG4                     = 0xC9,
+  ProcessorFamilyG5                     = 0xCA,
+  ProcessorFamilyG6                     = 0xCB,
+  ProcessorFamilyzArchitecture          = 0xCC,
+  ProcessorFamilyIntelCoreI5            = 0xCD,
+  ProcessorFamilyIntelCoreI3            = 0xCE,
+  ProcessorFamilyViaC7M                 = 0xD2,
+  ProcessorFamilyViaC7D                 = 0xD3,
+  ProcessorFamilyViaC7                  = 0xD4,
+  ProcessorFamilyViaEden                = 0xD5,
+  ProcessorFamilyMultiCoreIntelXeon           = 0xD6,
+  ProcessorFamilyDualCoreIntelXeon3Series     = 0xD7,
+  ProcessorFamilyQuadCoreIntelXeon3Series     = 0xD8,
+  ProcessorFamilyViaNano                      = 0xD9,
+  ProcessorFamilyDualCoreIntelXeon5Series     = 0xDA,
+  ProcessorFamilyQuadCoreIntelXeon5Series     = 0xDB,
+  ProcessorFamilyDualCoreIntelXeon7Series     = 0xDD,
+  ProcessorFamilyQuadCoreIntelXeon7Series     = 0xDE,
+  ProcessorFamilyMultiCoreIntelXeon7Series    = 0xDF,
+  ProcessorFamilyMultiCoreIntelXeon3400Series = 0xE0,
+  ProcessorFamilyAmdOpteron3000Series         = 0xE4,
+  ProcessorFamilyAmdSempronII                 = 0xE5,
+  ProcessorFamilyEmbeddedAmdOpteronQuadCore   = 0xE6,
+  ProcessorFamilyAmdPhenomTripleCore          = 0xE7,
+  ProcessorFamilyAmdTurionUltraDualCoreMobile = 0xE8,
+  ProcessorFamilyAmdTurionDualCoreMobile      = 0xE9,
+  ProcessorFamilyAmdAthlonDualCore            = 0xEA,
+  ProcessorFamilyAmdSempronSI                 = 0xEB,
+  ProcessorFamilyAmdPhenomII                  = 0xEC,
+  ProcessorFamilyAmdAthlonII                  = 0xED,
+  ProcessorFamilySixCoreAmdOpteron            = 0xEE,
+  ProcessorFamilyAmdSempronM                  = 0xEF,
+  ProcessorFamilyi860                   = 0xFA,
+  ProcessorFamilyi960                   = 0xFB,
+  ProcessorFamilyIndicatorFamily2       = 0xFE,
+  ProcessorFamilyReserved1              = 0xFF
+} PROCESSOR_FAMILY_DATA;
+
+///
+/// Processor Information2 - Processor Family2.
+///
+typedef enum {
+  ProcessorFamilyARMv7                 = 0x0100,
+  ProcessorFamilyARMv8                 = 0x0101,
+  ProcessorFamilySH3                   = 0x0104,
+  ProcessorFamilySH4                   = 0x0105,
+  ProcessorFamilyARM                   = 0x0118,
+  ProcessorFamilyStrongARM             = 0x0119,
+  ProcessorFamily6x86                  = 0x012C,
+  ProcessorFamilyMediaGX               = 0x012D,
+  ProcessorFamilyMII                   = 0x012E,
+  ProcessorFamilyWinChip               = 0x0140,
+  ProcessorFamilyDSP                   = 0x015E,
+  ProcessorFamilyVideoProcessor        = 0x01F4
+} PROCESSOR_FAMILY2_DATA;
+
+///
+/// Processor Information - Voltage. 
+///
+typedef struct {
+  UINT8  ProcessorVoltageCapability5V        :1; 
+  UINT8  ProcessorVoltageCapability3_3V      :1;  
+  UINT8  ProcessorVoltageCapability2_9V      :1;  
+  UINT8  ProcessorVoltageCapabilityReserved  :1; ///< Bit 3, must be zero.
+  UINT8  ProcessorVoltageReserved            :3; ///< Bits 4-6, must be zero.
+  UINT8  ProcessorVoltageIndicateLegacy      :1;
+} PROCESSOR_VOLTAGE;
+
+///
+/// Processor Information - Processor Upgrade.
+///
+typedef enum {
+  ProcessorUpgradeOther         = 0x01,
+  ProcessorUpgradeUnknown       = 0x02,
+  ProcessorUpgradeDaughterBoard = 0x03,
+  ProcessorUpgradeZIFSocket     = 0x04,
+  ProcessorUpgradePiggyBack     = 0x05, ///< Replaceable.
+  ProcessorUpgradeNone          = 0x06,
+  ProcessorUpgradeLIFSocket     = 0x07,
+  ProcessorUpgradeSlot1         = 0x08,
+  ProcessorUpgradeSlot2         = 0x09,
+  ProcessorUpgrade370PinSocket  = 0x0A,
+  ProcessorUpgradeSlotA         = 0x0B,
+  ProcessorUpgradeSlotM         = 0x0C,
+  ProcessorUpgradeSocket423     = 0x0D,
+  ProcessorUpgradeSocketA       = 0x0E, ///< Socket 462.
+  ProcessorUpgradeSocket478     = 0x0F,
+  ProcessorUpgradeSocket754     = 0x10,
+  ProcessorUpgradeSocket940     = 0x11,
+  ProcessorUpgradeSocket939     = 0x12,
+  ProcessorUpgradeSocketmPGA604 = 0x13,
+  ProcessorUpgradeSocketLGA771  = 0x14,
+  ProcessorUpgradeSocketLGA775  = 0x15,
+  ProcessorUpgradeSocketS1      = 0x16,
+  ProcessorUpgradeAM2           = 0x17,
+  ProcessorUpgradeF1207         = 0x18,
+  ProcessorSocketLGA1366        = 0x19,
+  ProcessorUpgradeSocketG34     = 0x1A,
+  ProcessorUpgradeSocketAM3     = 0x1B,
+  ProcessorUpgradeSocketC32     = 0x1C,
+  ProcessorUpgradeSocketLGA1156 = 0x1D,
+  ProcessorUpgradeSocketLGA1567 = 0x1E,
+  ProcessorUpgradeSocketPGA988A = 0x1F,
+  ProcessorUpgradeSocketBGA1288 = 0x20,
+  ProcessorUpgradeSocketrPGA988B = 0x21,
+  ProcessorUpgradeSocketBGA1023 = 0x22,
+  ProcessorUpgradeSocketBGA1224 = 0x23,
+  ProcessorUpgradeSocketLGA1155 = 0x24,  ///< SMBIOS spec 2.8.0 updated the name
+  ProcessorUpgradeSocketLGA1356 = 0x25,
+  ProcessorUpgradeSocketLGA2011 = 0x26,
+  ProcessorUpgradeSocketFS1     = 0x27,
+  ProcessorUpgradeSocketFS2     = 0x28,
+  ProcessorUpgradeSocketFM1     = 0x29,
+  ProcessorUpgradeSocketFM2     = 0x2A,
+  ProcessorUpgradeSocketLGA2011_3 = 0x2B,
+  ProcessorUpgradeSocketLGA1356_3 = 0x2C,
+  ProcessorUpgradeSocketLGA1150   = 0x2D,
+  ProcessorUpgradeSocketBGA1168   = 0x2E,
+  ProcessorUpgradeSocketBGA1234   = 0x2F,
+  ProcessorUpgradeSocketBGA1364   = 0x30,
+  ProcessorUpgradeSocketAM4       = 0x31,
+  ProcessorUpgradeSocketLGA1151   = 0x32,
+  ProcessorUpgradeSocketBGA1356   = 0x33,
+  ProcessorUpgradeSocketBGA1440   = 0x34,
+  ProcessorUpgradeSocketBGA1515   = 0x35,
+  ProcessorUpgradeSocketLGA3647_1 = 0x36,
+  ProcessorUpgradeSocketSP3       = 0x37,
+  ProcessorUpgradeSocketSP3r2     = 0x38
+} PROCESSOR_UPGRADE;
+
+///
+/// Processor ID Field Description
+///
+typedef struct {
+  UINT32  ProcessorSteppingId:4;
+  UINT32  ProcessorModel:     4;
+  UINT32  ProcessorFamily:    4;
+  UINT32  ProcessorType:      2;
+  UINT32  ProcessorReserved1: 2;
+  UINT32  ProcessorXModel:    4;
+  UINT32  ProcessorXFamily:   8;
+  UINT32  ProcessorReserved2: 4;
+} PROCESSOR_SIGNATURE;
+
+typedef struct {
+  UINT32  ProcessorFpu       :1;
+  UINT32  ProcessorVme       :1;
+  UINT32  ProcessorDe        :1;
+  UINT32  ProcessorPse       :1;
+  UINT32  ProcessorTsc       :1;
+  UINT32  ProcessorMsr       :1;
+  UINT32  ProcessorPae       :1;
+  UINT32  ProcessorMce       :1;
+  UINT32  ProcessorCx8       :1;
+  UINT32  ProcessorApic      :1;
+  UINT32  ProcessorReserved1 :1;
+  UINT32  ProcessorSep       :1;
+  UINT32  ProcessorMtrr      :1;
+  UINT32  ProcessorPge       :1;
+  UINT32  ProcessorMca       :1;
+  UINT32  ProcessorCmov      :1;
+  UINT32  ProcessorPat       :1;
+  UINT32  ProcessorPse36     :1;
+  UINT32  ProcessorPsn       :1;
+  UINT32  ProcessorClfsh     :1;
+  UINT32  ProcessorReserved2 :1;
+  UINT32  ProcessorDs        :1;
+  UINT32  ProcessorAcpi      :1;
+  UINT32  ProcessorMmx       :1;
+  UINT32  ProcessorFxsr      :1;
+  UINT32  ProcessorSse       :1;
+  UINT32  ProcessorSse2      :1;
+  UINT32  ProcessorSs        :1;
+  UINT32  ProcessorReserved3 :1;
+  UINT32  ProcessorTm        :1;
+  UINT32  ProcessorReserved4 :2;
+} PROCESSOR_FEATURE_FLAGS;
+
+typedef struct {
+  PROCESSOR_SIGNATURE     Signature;
+  PROCESSOR_FEATURE_FLAGS FeatureFlags;
+} PROCESSOR_ID_DATA;
+
+///
+/// Processor Information (Type 4).
+///
+/// The information in this structure defines the attributes of a single processor; 
+/// a separate structure instance is provided for each system processor socket/slot. 
+/// For example, a system with an IntelDX2 processor would have a single 
+/// structure instance, while a system with an IntelSX2 processor would have a structure
+/// to describe the main CPU, and a second structure to describe the 80487 co-processor. 
+///
+typedef struct { 
+  SMBIOS_STRUCTURE      Hdr;
+  SMBIOS_TABLE_STRING   Socket;
+  UINT8                 ProcessorType;          ///< The enumeration value from PROCESSOR_TYPE_DATA.
+  UINT8                 ProcessorFamily;        ///< The enumeration value from PROCESSOR_FAMILY_DATA.
+  SMBIOS_TABLE_STRING   ProcessorManufacture;
+  PROCESSOR_ID_DATA     ProcessorId;
+  SMBIOS_TABLE_STRING   ProcessorVersion;
+  PROCESSOR_VOLTAGE     Voltage;
+  UINT16                ExternalClock;
+  UINT16                MaxSpeed;
+  UINT16                CurrentSpeed;
+  UINT8                 Status;
+  UINT8                 ProcessorUpgrade;      ///< The enumeration value from PROCESSOR_UPGRADE.
+  UINT16                L1CacheHandle;
+  UINT16                L2CacheHandle;
+  UINT16                L3CacheHandle;
+  SMBIOS_TABLE_STRING   SerialNumber;
+  SMBIOS_TABLE_STRING   AssetTag;
+  SMBIOS_TABLE_STRING   PartNumber;
+  //
+  // Add for smbios 2.5
+  //
+  UINT8                 CoreCount;
+  UINT8                 EnabledCoreCount;
+  UINT8                 ThreadCount;
+  UINT16                ProcessorCharacteristics;
+  //
+  // Add for smbios 2.6
+  //
+  UINT16                ProcessorFamily2;
+  //
+  // Add for smbios 3.0
+  //
+  UINT16                CoreCount2;
+  UINT16                EnabledCoreCount2;
+  UINT16                ThreadCount2;
+} SMBIOS_TABLE_TYPE4;
+
+///
+/// Memory Controller Error Detecting Method.
+///
+typedef enum {  
+  ErrorDetectingMethodOther   = 0x01,
+  ErrorDetectingMethodUnknown = 0x02,
+  ErrorDetectingMethodNone    = 0x03,
+  ErrorDetectingMethodParity  = 0x04,
+  ErrorDetectingMethod32Ecc   = 0x05,
+  ErrorDetectingMethod64Ecc   = 0x06,
+  ErrorDetectingMethod128Ecc  = 0x07,
+  ErrorDetectingMethodCrc     = 0x08
+} MEMORY_ERROR_DETECT_METHOD;
+
+///
+/// Memory Controller Error Correcting Capability.
+///
+typedef struct {
+  UINT8  Other                 :1;
+  UINT8  Unknown               :1;
+  UINT8  None                  :1;
+  UINT8  SingleBitErrorCorrect :1;
+  UINT8  DoubleBitErrorCorrect :1;
+  UINT8  ErrorScrubbing        :1;
+  UINT8  Reserved              :2;
+} MEMORY_ERROR_CORRECT_CAPABILITY;
+
+///
+/// Memory Controller Information - Interleave Support.
+///
+typedef enum {  
+  MemoryInterleaveOther      = 0x01,
+  MemoryInterleaveUnknown    = 0x02,
+  MemoryInterleaveOneWay     = 0x03,
+  MemoryInterleaveTwoWay     = 0x04,
+  MemoryInterleaveFourWay    = 0x05,
+  MemoryInterleaveEightWay   = 0x06,
+  MemoryInterleaveSixteenWay = 0x07
+} MEMORY_SUPPORT_INTERLEAVE_TYPE;
+
+///
+/// Memory Controller Information - Memory Speeds.
+///
+typedef struct {
+  UINT16     Other    :1;
+  UINT16     Unknown  :1;
+  UINT16     SeventyNs:1;
+  UINT16     SixtyNs  :1;
+  UINT16     FiftyNs  :1;
+  UINT16     Reserved :11;
+} MEMORY_SPEED_TYPE;
+
+///
+/// Memory Controller Information (Type 5, Obsolete).
+///
+/// The information in this structure defines the attributes of the system's memory controller(s) 
+/// and the supported attributes of any memory-modules present in the sockets controlled by 
+/// this controller. 
+/// Note: This structure, and its companion Memory Module Information (Type 6, Obsolete), 
+/// are obsolete starting with version 2.1 of this specification. The Physical Memory Array (Type 16)
+/// and Memory Device (Type 17) structures should be used instead.  BIOS providers might
+/// choose to implement both memory description types to allow existing DMI browsers
+/// to properly display the system's memory attributes.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                Hdr;
+  UINT8                           ErrDetectMethod;            ///< The enumeration value from MEMORY_ERROR_DETECT_METHOD.
+  MEMORY_ERROR_CORRECT_CAPABILITY ErrCorrectCapability;
+  UINT8                           SupportInterleave;          ///< The enumeration value from MEMORY_SUPPORT_INTERLEAVE_TYPE.
+  UINT8                           CurrentInterleave;          ///< The enumeration value from MEMORY_SUPPORT_INTERLEAVE_TYPE .     
+  UINT8                           MaxMemoryModuleSize;
+  MEMORY_SPEED_TYPE               SupportSpeed;
+  UINT16                          SupportMemoryType;
+  UINT8                           MemoryModuleVoltage;
+  UINT8                           AssociatedMemorySlotNum;
+  UINT16                          MemoryModuleConfigHandles[1];
+} SMBIOS_TABLE_TYPE5;
+
+///
+/// Memory Module Information - Memory Types
+///
+typedef struct {
+  UINT16  Other       :1;
+  UINT16  Unknown     :1;
+  UINT16  Standard    :1;
+  UINT16  FastPageMode:1;
+  UINT16  Edo         :1;
+  UINT16  Parity      :1;
+  UINT16  Ecc         :1;
+  UINT16  Simm        :1;
+  UINT16  Dimm        :1;
+  UINT16  BurstEdo    :1;
+  UINT16  Sdram       :1;
+  UINT16  Reserved    :5;
+} MEMORY_CURRENT_TYPE;
+
+///
+/// Memory Module Information - Memory Size.
+///
+typedef struct {
+  UINT8   InstalledOrEnabledSize  :7; ///< Size (n), where 2**n is the size in MB.
+  UINT8   SingleOrDoubleBank      :1;
+} MEMORY_INSTALLED_ENABLED_SIZE;
+
+///
+/// Memory Module Information (Type 6, Obsolete)
+///
+/// One Memory Module Information structure is included for each memory-module socket 
+/// in the system.  The structure describes the speed, type, size, and error status
+/// of each system memory module.  The supported attributes of each module are described 
+/// by the "owning" Memory Controller Information structure.  
+/// Note:  This structure, and its companion Memory Controller Information (Type 5, Obsolete), 
+/// are obsolete starting with version 2.1 of this specification. The Physical Memory Array (Type 16)
+/// and Memory Device (Type 17) structures should be used instead.
+///
+typedef struct {
+  SMBIOS_STRUCTURE              Hdr;
+  SMBIOS_TABLE_STRING           SocketDesignation;
+  UINT8                         BankConnections;
+  UINT8                         CurrentSpeed;
+  MEMORY_CURRENT_TYPE           CurrentMemoryType;
+  MEMORY_INSTALLED_ENABLED_SIZE InstalledSize;
+  MEMORY_INSTALLED_ENABLED_SIZE EnabledSize;
+  UINT8                         ErrorStatus;
+} SMBIOS_TABLE_TYPE6;
+
+///
+/// Cache Information - SRAM Type.
+///
+typedef struct {
+  UINT16  Other         :1;
+  UINT16  Unknown       :1;
+  UINT16  NonBurst      :1;
+  UINT16  Burst         :1;
+  UINT16  PipelineBurst :1;
+  UINT16  Synchronous   :1;
+  UINT16  Asynchronous  :1;
+  UINT16  Reserved      :9;
+} CACHE_SRAM_TYPE_DATA;
+
+///
+/// Cache Information - Error Correction Type.
+///
+typedef enum {
+  CacheErrorOther     = 0x01,
+  CacheErrorUnknown   = 0x02,
+  CacheErrorNone      = 0x03,
+  CacheErrorParity    = 0x04,
+  CacheErrorSingleBit = 0x05, ///< ECC
+  CacheErrorMultiBit  = 0x06  ///< ECC
+} CACHE_ERROR_TYPE_DATA;
+
+///
+/// Cache Information - System Cache Type. 
+///
+typedef enum {
+  CacheTypeOther       = 0x01,
+  CacheTypeUnknown     = 0x02,
+  CacheTypeInstruction = 0x03,
+  CacheTypeData        = 0x04,
+  CacheTypeUnified     = 0x05
+} CACHE_TYPE_DATA;
+
+///
+/// Cache Information - Associativity. 
+///
+typedef enum {
+  CacheAssociativityOther        = 0x01,
+  CacheAssociativityUnknown      = 0x02,
+  CacheAssociativityDirectMapped = 0x03,
+  CacheAssociativity2Way         = 0x04,
+  CacheAssociativity4Way         = 0x05,
+  CacheAssociativityFully        = 0x06,
+  CacheAssociativity8Way         = 0x07,
+  CacheAssociativity16Way        = 0x08,
+  CacheAssociativity12Way        = 0x09,
+  CacheAssociativity24Way        = 0x0A,
+  CacheAssociativity32Way        = 0x0B,
+  CacheAssociativity48Way        = 0x0C,
+  CacheAssociativity64Way        = 0x0D,
+  CacheAssociativity20Way        = 0x0E
+} CACHE_ASSOCIATIVITY_DATA;
+
+///
+/// Cache Information (Type 7).
+///
+/// The information in this structure defines the attributes of CPU cache device in the system. 
+/// One structure is specified for each such device, whether the device is internal to
+/// or external to the CPU module.  Cache modules can be associated with a processor structure
+/// in one or two ways, depending on the SMBIOS version.
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  SMBIOS_TABLE_STRING       SocketDesignation;
+  UINT16                    CacheConfiguration;
+  UINT16                    MaximumCacheSize;
+  UINT16                    InstalledSize;
+  CACHE_SRAM_TYPE_DATA      SupportedSRAMType;
+  CACHE_SRAM_TYPE_DATA      CurrentSRAMType;
+  UINT8                     CacheSpeed;
+  UINT8                     ErrorCorrectionType;            ///< The enumeration value from CACHE_ERROR_TYPE_DATA.
+  UINT8                     SystemCacheType;                ///< The enumeration value from CACHE_TYPE_DATA.
+  UINT8                     Associativity;                  ///< The enumeration value from CACHE_ASSOCIATIVITY_DATA.
+  //
+  // Add for smbios 3.1.0
+  //
+  UINT32                    MaximumCacheSize2;
+  UINT32                    InstalledSize2;
+} SMBIOS_TABLE_TYPE7;
+
+///
+/// Port Connector Information - Connector Types. 
+///
+typedef enum {
+  PortConnectorTypeNone                   = 0x00,
+  PortConnectorTypeCentronics             = 0x01,
+  PortConnectorTypeMiniCentronics         = 0x02,
+  PortConnectorTypeProprietary            = 0x03,
+  PortConnectorTypeDB25Male               = 0x04,
+  PortConnectorTypeDB25Female             = 0x05,
+  PortConnectorTypeDB15Male               = 0x06,
+  PortConnectorTypeDB15Female             = 0x07,
+  PortConnectorTypeDB9Male                = 0x08,
+  PortConnectorTypeDB9Female              = 0x09,
+  PortConnectorTypeRJ11                   = 0x0A,
+  PortConnectorTypeRJ45                   = 0x0B,
+  PortConnectorType50PinMiniScsi          = 0x0C,
+  PortConnectorTypeMiniDin                = 0x0D,
+  PortConnectorTypeMicroDin               = 0x0E,
+  PortConnectorTypePS2                    = 0x0F,
+  PortConnectorTypeInfrared               = 0x10,
+  PortConnectorTypeHpHil                  = 0x11,
+  PortConnectorTypeUsb                    = 0x12,
+  PortConnectorTypeSsaScsi                = 0x13,
+  PortConnectorTypeCircularDin8Male       = 0x14,
+  PortConnectorTypeCircularDin8Female     = 0x15,
+  PortConnectorTypeOnboardIde             = 0x16,
+  PortConnectorTypeOnboardFloppy          = 0x17,
+  PortConnectorType9PinDualInline         = 0x18,
+  PortConnectorType25PinDualInline        = 0x19,
+  PortConnectorType50PinDualInline        = 0x1A,
+  PortConnectorType68PinDualInline        = 0x1B,
+  PortConnectorTypeOnboardSoundInput      = 0x1C,
+  PortConnectorTypeMiniCentronicsType14   = 0x1D,
+  PortConnectorTypeMiniCentronicsType26   = 0x1E,
+  PortConnectorTypeHeadPhoneMiniJack      = 0x1F,
+  PortConnectorTypeBNC                    = 0x20,
+  PortConnectorType1394                   = 0x21,
+  PortConnectorTypeSasSata                = 0x22,
+  PortConnectorTypePC98                   = 0xA0,
+  PortConnectorTypePC98Hireso             = 0xA1,
+  PortConnectorTypePCH98                  = 0xA2,
+  PortConnectorTypePC98Note               = 0xA3,
+  PortConnectorTypePC98Full               = 0xA4,
+  PortConnectorTypeOther                  = 0xFF
+} MISC_PORT_CONNECTOR_TYPE;
+
+///
+/// Port Connector Information - Port Types 
+///
+typedef enum {
+  PortTypeNone                      = 0x00,
+  PortTypeParallelXtAtCompatible    = 0x01,
+  PortTypeParallelPortPs2           = 0x02,
+  PortTypeParallelPortEcp           = 0x03,
+  PortTypeParallelPortEpp           = 0x04,
+  PortTypeParallelPortEcpEpp        = 0x05,
+  PortTypeSerialXtAtCompatible      = 0x06,
+  PortTypeSerial16450Compatible     = 0x07,
+  PortTypeSerial16550Compatible     = 0x08,
+  PortTypeSerial16550ACompatible    = 0x09,
+  PortTypeScsi                      = 0x0A,
+  PortTypeMidi                      = 0x0B,
+  PortTypeJoyStick                  = 0x0C,
+  PortTypeKeyboard                  = 0x0D,
+  PortTypeMouse                     = 0x0E,
+  PortTypeSsaScsi                   = 0x0F,
+  PortTypeUsb                       = 0x10,
+  PortTypeFireWire                  = 0x11,
+  PortTypePcmciaTypeI               = 0x12,
+  PortTypePcmciaTypeII              = 0x13,
+  PortTypePcmciaTypeIII             = 0x14,
+  PortTypeCardBus                   = 0x15,
+  PortTypeAccessBusPort             = 0x16,
+  PortTypeScsiII                    = 0x17,
+  PortTypeScsiWide                  = 0x18,
+  PortTypePC98                      = 0x19,
+  PortTypePC98Hireso                = 0x1A,
+  PortTypePCH98                     = 0x1B,
+  PortTypeVideoPort                 = 0x1C,
+  PortTypeAudioPort                 = 0x1D,
+  PortTypeModemPort                 = 0x1E,
+  PortTypeNetworkPort               = 0x1F,
+  PortTypeSata                      = 0x20,
+  PortTypeSas                       = 0x21,
+  PortType8251Compatible            = 0xA0,
+  PortType8251FifoCompatible        = 0xA1,
+  PortTypeOther                     = 0xFF
+} MISC_PORT_TYPE;
+
+///
+/// Port Connector Information (Type 8).
+///
+/// The information in this structure defines the attributes of a system port connector, 
+/// e.g. parallel, serial, keyboard, or mouse ports.  The port's type and connector information 
+/// are provided. One structure is present for each port provided by the system.
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  SMBIOS_TABLE_STRING       InternalReferenceDesignator;
+  UINT8                     InternalConnectorType;          ///< The enumeration value from MISC_PORT_CONNECTOR_TYPE.
+  SMBIOS_TABLE_STRING       ExternalReferenceDesignator;
+  UINT8                     ExternalConnectorType;          ///< The enumeration value from MISC_PORT_CONNECTOR_TYPE.
+  UINT8                     PortType;                       ///< The enumeration value from MISC_PORT_TYPE.
+} SMBIOS_TABLE_TYPE8;
+
+///
+/// System Slots - Slot Type
+///
+typedef enum {
+  SlotTypeOther                        = 0x01,
+  SlotTypeUnknown                      = 0x02,
+  SlotTypeIsa                          = 0x03,
+  SlotTypeMca                          = 0x04,
+  SlotTypeEisa                         = 0x05,
+  SlotTypePci                          = 0x06,
+  SlotTypePcmcia                       = 0x07,
+  SlotTypeVlVesa                       = 0x08,
+  SlotTypeProprietary                  = 0x09,
+  SlotTypeProcessorCardSlot            = 0x0A,
+  SlotTypeProprietaryMemoryCardSlot    = 0x0B,
+  SlotTypeIORiserCardSlot              = 0x0C,
+  SlotTypeNuBus                        = 0x0D,
+  SlotTypePci66MhzCapable              = 0x0E,
+  SlotTypeAgp                          = 0x0F,
+  SlotTypeApg2X                        = 0x10,
+  SlotTypeAgp4X                        = 0x11,
+  SlotTypePciX                         = 0x12,
+  SlotTypeAgp8X                        = 0x13,
+  SlotTypeM2Socket1_DP                 = 0x14,
+  SlotTypeM2Socket1_SD                 = 0x15,
+  SlotTypeM2Socket2                    = 0x16,
+  SlotTypeM2Socket3                    = 0x17,
+  SlotTypeMxmTypeI                     = 0x18,
+  SlotTypeMxmTypeII                    = 0x19,
+  SlotTypeMxmTypeIIIStandard           = 0x1A,
+  SlotTypeMxmTypeIIIHe                 = 0x1B,
+  SlotTypeMxmTypeIV                    = 0x1C,
+  SlotTypeMxm30TypeA                   = 0x1D,
+  SlotTypeMxm30TypeB                   = 0x1E,
+  SlotTypePciExpressGen2Sff_8639       = 0x1F,
+  SlotTypePciExpressGen3Sff_8639       = 0x20,
+  SlotTypePciExpressMini52pinWithBSKO  = 0x21,      ///< PCI Express Mini 52-pin (CEM spec. 2.0) with bottom-side keep-outs.
+  SlotTypePciExpressMini52pinWithoutBSKO = 0x22,    ///< PCI Express Mini 52-pin (CEM spec. 2.0) without bottom-side keep-outs.
+  SlotTypePciExpressMini76pin          = 0x23,      ///< PCI Express Mini 76-pin (CEM spec. 2.0) Corresponds to Display-Mini card.
+  SlotTypePC98C20                      = 0xA0,
+  SlotTypePC98C24                      = 0xA1,
+  SlotTypePC98E                        = 0xA2,
+  SlotTypePC98LocalBus                 = 0xA3,
+  SlotTypePC98Card                     = 0xA4,
+  SlotTypePciExpress                   = 0xA5,
+  SlotTypePciExpressX1                 = 0xA6,
+  SlotTypePciExpressX2                 = 0xA7,
+  SlotTypePciExpressX4                 = 0xA8,
+  SlotTypePciExpressX8                 = 0xA9,
+  SlotTypePciExpressX16                = 0xAA,
+  SlotTypePciExpressGen2               = 0xAB,
+  SlotTypePciExpressGen2X1             = 0xAC,
+  SlotTypePciExpressGen2X2             = 0xAD,
+  SlotTypePciExpressGen2X4             = 0xAE,
+  SlotTypePciExpressGen2X8             = 0xAF,
+  SlotTypePciExpressGen2X16            = 0xB0,
+  SlotTypePciExpressGen3               = 0xB1,
+  SlotTypePciExpressGen3X1             = 0xB2,
+  SlotTypePciExpressGen3X2             = 0xB3,
+  SlotTypePciExpressGen3X4             = 0xB4,
+  SlotTypePciExpressGen3X8             = 0xB5,
+  SlotTypePciExpressGen3X16            = 0xB6
+} MISC_SLOT_TYPE;
+
+///
+/// System Slots - Slot Data Bus Width.
+///
+typedef enum {
+  SlotDataBusWidthOther      = 0x01,
+  SlotDataBusWidthUnknown    = 0x02,
+  SlotDataBusWidth8Bit       = 0x03,
+  SlotDataBusWidth16Bit      = 0x04,
+  SlotDataBusWidth32Bit      = 0x05,
+  SlotDataBusWidth64Bit      = 0x06,
+  SlotDataBusWidth128Bit     = 0x07,
+  SlotDataBusWidth1X         = 0x08, ///< Or X1
+  SlotDataBusWidth2X         = 0x09, ///< Or X2
+  SlotDataBusWidth4X         = 0x0A, ///< Or X4
+  SlotDataBusWidth8X         = 0x0B, ///< Or X8
+  SlotDataBusWidth12X        = 0x0C, ///< Or X12
+  SlotDataBusWidth16X        = 0x0D, ///< Or X16
+  SlotDataBusWidth32X        = 0x0E  ///< Or X32
+} MISC_SLOT_DATA_BUS_WIDTH;
+
+///
+/// System Slots - Current Usage.
+///
+typedef enum {
+  SlotUsageOther     = 0x01,
+  SlotUsageUnknown   = 0x02,
+  SlotUsageAvailable = 0x03,
+  SlotUsageInUse     = 0x04
+} MISC_SLOT_USAGE;
+
+///
+/// System Slots - Slot Length. 
+///
+typedef enum {
+  SlotLengthOther   = 0x01,
+  SlotLengthUnknown = 0x02,
+  SlotLengthShort   = 0x03,
+  SlotLengthLong    = 0x04
+} MISC_SLOT_LENGTH;
+
+///
+/// System Slots - Slot Characteristics 1. 
+///
+typedef struct {
+  UINT8  CharacteristicsUnknown  :1;
+  UINT8  Provides50Volts         :1;
+  UINT8  Provides33Volts         :1;
+  UINT8  SharedSlot              :1;
+  UINT8  PcCard16Supported       :1;
+  UINT8  CardBusSupported        :1;
+  UINT8  ZoomVideoSupported      :1;
+  UINT8  ModemRingResumeSupported:1;
+} MISC_SLOT_CHARACTERISTICS1;
+///
+/// System Slots - Slot Characteristics 2.  
+///
+typedef struct {
+  UINT8  PmeSignalSupported      :1;
+  UINT8  HotPlugDevicesSupported :1;
+  UINT8  SmbusSignalSupported    :1;
+  UINT8  Reserved                :5;  ///< Set to 0.
+} MISC_SLOT_CHARACTERISTICS2;
+
+///
+/// System Slots (Type 9)
+///
+/// The information in this structure defines the attributes of a system slot. 
+/// One structure is provided for each slot in the system.
+///
+///
+typedef struct {
+  SMBIOS_STRUCTURE            Hdr;
+  SMBIOS_TABLE_STRING         SlotDesignation;
+  UINT8                       SlotType;                 ///< The enumeration value from MISC_SLOT_TYPE.
+  UINT8                       SlotDataBusWidth;         ///< The enumeration value from MISC_SLOT_DATA_BUS_WIDTH.
+  UINT8                       CurrentUsage;             ///< The enumeration value from MISC_SLOT_USAGE.
+  UINT8                       SlotLength;               ///< The enumeration value from MISC_SLOT_LENGTH.
+  UINT16                      SlotID;
+  MISC_SLOT_CHARACTERISTICS1  SlotCharacteristics1;
+  MISC_SLOT_CHARACTERISTICS2  SlotCharacteristics2;
+  //
+  // Add for smbios 2.6
+  //
+  UINT16                      SegmentGroupNum;
+  UINT8                       BusNum;
+  UINT8                       DevFuncNum;
+} SMBIOS_TABLE_TYPE9;
+
+///
+/// On Board Devices Information - Device Types. 
+///
+typedef enum {
+  OnBoardDeviceTypeOther          = 0x01,
+  OnBoardDeviceTypeUnknown        = 0x02,
+  OnBoardDeviceTypeVideo          = 0x03,
+  OnBoardDeviceTypeScsiController = 0x04,
+  OnBoardDeviceTypeEthernet       = 0x05,
+  OnBoardDeviceTypeTokenRing      = 0x06,
+  OnBoardDeviceTypeSound          = 0x07,
+  OnBoardDeviceTypePATAController = 0x08,
+  OnBoardDeviceTypeSATAController = 0x09,
+  OnBoardDeviceTypeSASController  = 0x0A
+} MISC_ONBOARD_DEVICE_TYPE;
+
+///
+/// Device Item Entry
+///
+typedef struct {
+  UINT8                     DeviceType;             ///< Bit [6:0] - enumeration type of device from MISC_ONBOARD_DEVICE_TYPE.
+                                                    ///< Bit 7     - 1 : device enabled, 0 : device disabled.
+  SMBIOS_TABLE_STRING       DescriptionString;
+} DEVICE_STRUCT;
+
+///
+/// On Board Devices Information (Type 10, obsolete).
+///
+/// Note: This structure is obsolete starting with version 2.6 specification; the Onboard Devices Extended 
+/// Information (Type 41) structure should be used instead . BIOS providers can choose to implement both 
+/// types to allow existing SMBIOS browsers to properly display the system's onboard devices information.  
+/// The information in this structure defines the attributes of devices that are onboard (soldered onto) 
+/// a system element, usually the baseboard.  In general, an entry in this table implies that the BIOS
+/// has some level of control over the enabling of the associated device for use by the system.
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  DEVICE_STRUCT         Device[1];
+} SMBIOS_TABLE_TYPE10;
+
+///
+/// OEM Strings (Type 11).
+/// This structure contains free form strings defined by the OEM. Examples of this are: 
+/// Part Numbers for Reference Documents for the system, contact information for the manufacturer, etc. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 StringCount;
+} SMBIOS_TABLE_TYPE11;
+
+///
+/// System Configuration Options (Type 12).
+///
+/// This structure contains information required to configure the base board's Jumpers and Switches. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 StringCount;
+} SMBIOS_TABLE_TYPE12;
+
+
+///
+/// BIOS Language Information (Type 13).
+///
+/// The information in this structure defines the installable language attributes of the BIOS.  
+/// 
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 InstallableLanguages;
+  UINT8                 Flags;
+  UINT8                 Reserved[15];
+  SMBIOS_TABLE_STRING   CurrentLanguages;
+} SMBIOS_TABLE_TYPE13;
+
+///
+/// Group Item Entry
+///
+typedef struct {
+  UINT8                 ItemType;
+  UINT16                ItemHandle;
+} GROUP_STRUCT;
+
+///
+/// Group Associations (Type 14).
+///
+/// The Group Associations structure is provided for OEMs who want to specify 
+/// the arrangement or hierarchy of certain components (including other Group Associations) 
+/// within the system. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  SMBIOS_TABLE_STRING   GroupName;
+  GROUP_STRUCT          Group[1];
+} SMBIOS_TABLE_TYPE14;
+
+///
+/// System Event Log - Event Log Types.
+/// 
+typedef enum {
+  EventLogTypeReserved         = 0x00,
+  EventLogTypeSingleBitECC     = 0x01,
+  EventLogTypeMultiBitECC      = 0x02,
+  EventLogTypeParityMemErr     = 0x03,
+  EventLogTypeBusTimeOut       = 0x04,
+  EventLogTypeIOChannelCheck   = 0x05,
+  EventLogTypeSoftwareNMI      = 0x06,
+  EventLogTypePOSTMemResize    = 0x07,
+  EventLogTypePOSTErr          = 0x08,
+  EventLogTypePCIParityErr     = 0x09,
+  EventLogTypePCISystemErr     = 0x0A,
+  EventLogTypeCPUFailure       = 0x0B,
+  EventLogTypeEISATimeOut      = 0x0C,
+  EventLogTypeMemLogDisabled   = 0x0D,
+  EventLogTypeLoggingDisabled  = 0x0E,
+  EventLogTypeSysLimitExce     = 0x10,
+  EventLogTypeAsyncHWTimer     = 0x11,
+  EventLogTypeSysConfigInfo    = 0x12,
+  EventLogTypeHDInfo           = 0x13,
+  EventLogTypeSysReconfig      = 0x14,
+  EventLogTypeUncorrectCPUErr  = 0x15,
+  EventLogTypeAreaResetAndClr  = 0x16,
+  EventLogTypeSystemBoot       = 0x17,
+  EventLogTypeUnused           = 0x18, ///< 0x18 - 0x7F
+  EventLogTypeAvailForSys      = 0x80, ///< 0x80 - 0xFE
+  EventLogTypeEndOfLog         = 0xFF
+} EVENT_LOG_TYPE_DATA;
+
+///
+/// System Event Log - Variable Data Format Types. 
+/// 
+typedef enum {
+  EventLogVariableNone                        = 0x00,
+  EventLogVariableHandle                      = 0x01,
+  EventLogVariableMutilEvent                  = 0x02,
+  EventLogVariableMutilEventHandle            = 0x03,
+  EventLogVariablePOSTResultBitmap            = 0x04,
+  EventLogVariableSysManagementType           = 0x05,
+  EventLogVariableMutliEventSysManagmentType  = 0x06,                               
+  EventLogVariableUnused                      = 0x07,
+  EventLogVariableOEMAssigned                 = 0x80
+} EVENT_LOG_VARIABLE_DATA;
+
+///
+/// Event Log Type Descriptors
+///
+typedef struct {
+  UINT8                 LogType;                    ///< The enumeration value from EVENT_LOG_TYPE_DATA.
+  UINT8                 DataFormatType;
+} EVENT_LOG_TYPE;
+
+///
+/// System Event Log (Type 15).
+///
+/// The presence of this structure within the SMBIOS data returned for a system indicates 
+/// that the system supports an event log.  An event log is a fixed-length area within a 
+/// non-volatile storage element, starting with a fixed-length (and vendor-specific) header 
+/// record, followed by one or more variable-length log records. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT16                LogAreaLength;
+  UINT16                LogHeaderStartOffset;
+  UINT16                LogDataStartOffset;
+  UINT8                 AccessMethod;
+  UINT8                 LogStatus;
+  UINT32                LogChangeToken;
+  UINT32                AccessMethodAddress;
+  UINT8                 LogHeaderFormat;
+  UINT8                 NumberOfSupportedLogTypeDescriptors;
+  UINT8                 LengthOfLogTypeDescriptor;
+  EVENT_LOG_TYPE        EventLogTypeDescriptors[1];
+} SMBIOS_TABLE_TYPE15;
+
+///
+/// Physical Memory Array - Location.
+///
+typedef enum {
+  MemoryArrayLocationOther                 = 0x01,
+  MemoryArrayLocationUnknown               = 0x02,
+  MemoryArrayLocationSystemBoard           = 0x03,
+  MemoryArrayLocationIsaAddonCard          = 0x04,
+  MemoryArrayLocationEisaAddonCard         = 0x05,
+  MemoryArrayLocationPciAddonCard          = 0x06,
+  MemoryArrayLocationMcaAddonCard          = 0x07,
+  MemoryArrayLocationPcmciaAddonCard       = 0x08,
+  MemoryArrayLocationProprietaryAddonCard  = 0x09,
+  MemoryArrayLocationNuBus                 = 0x0A,
+  MemoryArrayLocationPc98C20AddonCard      = 0xA0,
+  MemoryArrayLocationPc98C24AddonCard      = 0xA1,
+  MemoryArrayLocationPc98EAddonCard        = 0xA2,
+  MemoryArrayLocationPc98LocalBusAddonCard = 0xA3
+} MEMORY_ARRAY_LOCATION;
+
+///
+/// Physical Memory Array - Use.
+///
+typedef enum {
+  MemoryArrayUseOther                      = 0x01,
+  MemoryArrayUseUnknown                    = 0x02,
+  MemoryArrayUseSystemMemory               = 0x03,
+  MemoryArrayUseVideoMemory                = 0x04,
+  MemoryArrayUseFlashMemory                = 0x05,
+  MemoryArrayUseNonVolatileRam             = 0x06,
+  MemoryArrayUseCacheMemory                = 0x07
+} MEMORY_ARRAY_USE;
+
+///
+/// Physical Memory Array - Error Correction Types. 
+///
+typedef enum {
+  MemoryErrorCorrectionOther               = 0x01,
+  MemoryErrorCorrectionUnknown             = 0x02,
+  MemoryErrorCorrectionNone                = 0x03,
+  MemoryErrorCorrectionParity              = 0x04,
+  MemoryErrorCorrectionSingleBitEcc        = 0x05,
+  MemoryErrorCorrectionMultiBitEcc         = 0x06,
+  MemoryErrorCorrectionCrc                 = 0x07
+} MEMORY_ERROR_CORRECTION;
+
+///
+/// Physical Memory Array (Type 16).
+///
+/// This structure describes a collection of memory devices that operate 
+/// together to form a memory address space. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  UINT8                     Location;                       ///< The enumeration value from MEMORY_ARRAY_LOCATION.
+  UINT8                     Use;                            ///< The enumeration value from MEMORY_ARRAY_USE.
+  UINT8                     MemoryErrorCorrection;          ///< The enumeration value from MEMORY_ERROR_CORRECTION.
+  UINT32                    MaximumCapacity;
+  UINT16                    MemoryErrorInformationHandle;
+  UINT16                    NumberOfMemoryDevices;
+  //
+  // Add for smbios 2.7
+  //
+  UINT64                    ExtendedMaximumCapacity;
+} SMBIOS_TABLE_TYPE16;
+
+///
+/// Memory Device - Form Factor.
+///
+typedef enum {
+  MemoryFormFactorOther                    = 0x01,
+  MemoryFormFactorUnknown                  = 0x02,
+  MemoryFormFactorSimm                     = 0x03,
+  MemoryFormFactorSip                      = 0x04,
+  MemoryFormFactorChip                     = 0x05,
+  MemoryFormFactorDip                      = 0x06,
+  MemoryFormFactorZip                      = 0x07,
+  MemoryFormFactorProprietaryCard          = 0x08,
+  MemoryFormFactorDimm                     = 0x09,
+  MemoryFormFactorTsop                     = 0x0A,
+  MemoryFormFactorRowOfChips               = 0x0B,
+  MemoryFormFactorRimm                     = 0x0C,
+  MemoryFormFactorSodimm                   = 0x0D,
+  MemoryFormFactorSrimm                    = 0x0E,
+  MemoryFormFactorFbDimm                   = 0x0F
+} MEMORY_FORM_FACTOR;
+
+///
+/// Memory Device - Type
+///
+typedef enum {
+  MemoryTypeOther                          = 0x01,
+  MemoryTypeUnknown                        = 0x02,
+  MemoryTypeDram                           = 0x03,
+  MemoryTypeEdram                          = 0x04,
+  MemoryTypeVram                           = 0x05,
+  MemoryTypeSram                           = 0x06,
+  MemoryTypeRam                            = 0x07,
+  MemoryTypeRom                            = 0x08,
+  MemoryTypeFlash                          = 0x09,
+  MemoryTypeEeprom                         = 0x0A,
+  MemoryTypeFeprom                         = 0x0B,
+  MemoryTypeEprom                          = 0x0C,
+  MemoryTypeCdram                          = 0x0D,
+  MemoryType3Dram                          = 0x0E,
+  MemoryTypeSdram                          = 0x0F,
+  MemoryTypeSgram                          = 0x10,
+  MemoryTypeRdram                          = 0x11,
+  MemoryTypeDdr                            = 0x12,
+  MemoryTypeDdr2                           = 0x13,
+  MemoryTypeDdr2FbDimm                     = 0x14,
+  MemoryTypeDdr3                           = 0x18,
+  MemoryTypeFbd2                           = 0x19,
+  MemoryTypeDdr4                           = 0x1A,
+  MemoryTypeLpddr                          = 0x1B,
+  MemoryTypeLpddr2                         = 0x1C,
+  MemoryTypeLpddr3                         = 0x1D,
+  MemoryTypeLpddr4                         = 0x1E
+} MEMORY_DEVICE_TYPE;
+
+typedef struct {
+  UINT16    Reserved        :1;
+  UINT16    Other           :1;
+  UINT16    Unknown         :1;
+  UINT16    FastPaged       :1;
+  UINT16    StaticColumn    :1;
+  UINT16    PseudoStatic    :1;
+  UINT16    Rambus          :1;
+  UINT16    Synchronous     :1;
+  UINT16    Cmos            :1;
+  UINT16    Edo             :1;
+  UINT16    WindowDram      :1;
+  UINT16    CacheDram       :1;
+  UINT16    Nonvolatile     :1;
+  UINT16    Registered      :1;
+  UINT16    Unbuffered      :1;
+  UINT16    LrDimm          :1;
+} MEMORY_DEVICE_TYPE_DETAIL;
+
+///
+/// Memory Device (Type 17).
+///
+/// This structure describes a single memory device that is part of 
+/// a larger Physical Memory Array (Type 16).
+/// Note:  If a system includes memory-device sockets, the SMBIOS implementation 
+/// includes a Memory Device structure instance for each slot, whether or not the 
+/// socket is currently populated.
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  UINT16                    MemoryArrayHandle;
+  UINT16                    MemoryErrorInformationHandle;
+  UINT16                    TotalWidth;
+  UINT16                    DataWidth;
+  UINT16                    Size;
+  UINT8                     FormFactor;                     ///< The enumeration value from MEMORY_FORM_FACTOR.
+  UINT8                     DeviceSet;
+  SMBIOS_TABLE_STRING       DeviceLocator;
+  SMBIOS_TABLE_STRING       BankLocator;
+  UINT8                     MemoryType;                     ///< The enumeration value from MEMORY_DEVICE_TYPE.
+  MEMORY_DEVICE_TYPE_DETAIL TypeDetail;
+  UINT16                    Speed;
+  SMBIOS_TABLE_STRING       Manufacturer;
+  SMBIOS_TABLE_STRING       SerialNumber;
+  SMBIOS_TABLE_STRING       AssetTag;
+  SMBIOS_TABLE_STRING       PartNumber;
+  //
+  // Add for smbios 2.6
+  //  
+  UINT8                     Attributes;
+  //
+  // Add for smbios 2.7
+  //
+  UINT32                    ExtendedSize;
+  UINT16                    ConfiguredMemoryClockSpeed;
+  //
+  // Add for smbios 2.8.0
+  //
+  UINT16                    MinimumVoltage;
+  UINT16                    MaximumVoltage;
+  UINT16                    ConfiguredVoltage;
+} SMBIOS_TABLE_TYPE17;
+
+///
+/// 32-bit Memory Error Information - Error Type. 
+///
+typedef enum {  
+  MemoryErrorOther             = 0x01,
+  MemoryErrorUnknown           = 0x02,
+  MemoryErrorOk                = 0x03,
+  MemoryErrorBadRead           = 0x04,
+  MemoryErrorParity            = 0x05,
+  MemoryErrorSigleBit          = 0x06,
+  MemoryErrorDoubleBit         = 0x07,
+  MemoryErrorMultiBit          = 0x08,
+  MemoryErrorNibble            = 0x09,
+  MemoryErrorChecksum          = 0x0A,
+  MemoryErrorCrc               = 0x0B,
+  MemoryErrorCorrectSingleBit  = 0x0C,
+  MemoryErrorCorrected         = 0x0D,
+  MemoryErrorUnCorrectable     = 0x0E
+} MEMORY_ERROR_TYPE;
+
+///
+/// 32-bit Memory Error Information - Error Granularity. 
+///
+typedef enum {  
+  MemoryGranularityOther               = 0x01,
+  MemoryGranularityOtherUnknown        = 0x02,
+  MemoryGranularityDeviceLevel         = 0x03,
+  MemoryGranularityMemPartitionLevel   = 0x04
+} MEMORY_ERROR_GRANULARITY;
+
+///
+/// 32-bit Memory Error Information - Error Operation. 
+///
+typedef enum {  
+  MemoryErrorOperationOther            = 0x01,
+  MemoryErrorOperationUnknown          = 0x02,
+  MemoryErrorOperationRead             = 0x03,
+  MemoryErrorOperationWrite            = 0x04,
+  MemoryErrorOperationPartialWrite     = 0x05
+} MEMORY_ERROR_OPERATION;
+
+///
+/// 32-bit Memory Error Information (Type 18).
+/// 
+/// This structure identifies the specifics of an error that might be detected 
+/// within a Physical Memory Array.
+///
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  UINT8                     ErrorType;                  ///< The enumeration value from MEMORY_ERROR_TYPE.
+  UINT8                     ErrorGranularity;           ///< The enumeration value from MEMORY_ERROR_GRANULARITY.
+  UINT8                     ErrorOperation;             ///< The enumeration value from MEMORY_ERROR_OPERATION.
+  UINT32                    VendorSyndrome;
+  UINT32                    MemoryArrayErrorAddress;
+  UINT32                    DeviceErrorAddress;
+  UINT32                    ErrorResolution;
+} SMBIOS_TABLE_TYPE18;
+
+///
+/// Memory Array Mapped Address (Type 19).
+///
+/// This structure provides the address mapping for a Physical Memory Array.  
+/// One structure is present for each contiguous address range described.
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT32                StartingAddress;
+  UINT32                EndingAddress;
+  UINT16                MemoryArrayHandle;
+  UINT8                 PartitionWidth;
+  //
+  // Add for smbios 2.7
+  //
+  UINT64                ExtendedStartingAddress;
+  UINT64                ExtendedEndingAddress;
+} SMBIOS_TABLE_TYPE19;
+
+///
+/// Memory Device Mapped Address (Type 20).
+///
+/// This structure maps memory address space usually to a device-level granularity.  
+/// One structure is present for each contiguous address range described. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT32                StartingAddress;
+  UINT32                EndingAddress;
+  UINT16                MemoryDeviceHandle;
+  UINT16                MemoryArrayMappedAddressHandle;
+  UINT8                 PartitionRowPosition;
+  UINT8                 InterleavePosition;
+  UINT8                 InterleavedDataDepth;
+  //
+  // Add for smbios 2.7
+  //
+  UINT64                ExtendedStartingAddress;
+  UINT64                ExtendedEndingAddress;
+} SMBIOS_TABLE_TYPE20;
+
+///
+/// Built-in Pointing Device - Type
+///
+typedef enum {
+  PointingDeviceTypeOther         = 0x01,
+  PointingDeviceTypeUnknown       = 0x02,
+  PointingDeviceTypeMouse         = 0x03,
+  PointingDeviceTypeTrackBall     = 0x04,
+  PointingDeviceTypeTrackPoint    = 0x05,
+  PointingDeviceTypeGlidePoint    = 0x06,
+  PointingDeviceTouchPad          = 0x07,
+  PointingDeviceTouchScreen       = 0x08,
+  PointingDeviceOpticalSensor     = 0x09
+} BUILTIN_POINTING_DEVICE_TYPE;
+
+///
+/// Built-in Pointing Device - Interface.
+///
+typedef enum {
+  PointingDeviceInterfaceOther              = 0x01,
+  PointingDeviceInterfaceUnknown            = 0x02,
+  PointingDeviceInterfaceSerial             = 0x03,
+  PointingDeviceInterfacePs2                = 0x04,
+  PointingDeviceInterfaceInfrared           = 0x05,
+  PointingDeviceInterfaceHpHil              = 0x06,
+  PointingDeviceInterfaceBusMouse           = 0x07,
+  PointingDeviceInterfaceADB                = 0x08,
+  PointingDeviceInterfaceBusMouseDB9        = 0xA0,
+  PointingDeviceInterfaceBusMouseMicroDin   = 0xA1,
+  PointingDeviceInterfaceUsb                = 0xA2
+} BUILTIN_POINTING_DEVICE_INTERFACE;
+
+///
+/// Built-in Pointing Device (Type 21).
+///
+/// This structure describes the attributes of the built-in pointing device for the 
+/// system. The presence of this structure does not imply that the built-in
+/// pointing device is active for the system's use! 
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  UINT8                             Type;                   ///< The enumeration value from BUILTIN_POINTING_DEVICE_TYPE.
+  UINT8                             Interface;              ///< The enumeration value from BUILTIN_POINTING_DEVICE_INTERFACE.
+  UINT8                             NumberOfButtons;
+} SMBIOS_TABLE_TYPE21;
+
+///
+/// Portable Battery - Device Chemistry
+///
+typedef enum {  
+  PortableBatteryDeviceChemistryOther               = 0x01,
+  PortableBatteryDeviceChemistryUnknown             = 0x02,
+  PortableBatteryDeviceChemistryLeadAcid            = 0x03,
+  PortableBatteryDeviceChemistryNickelCadmium       = 0x04,
+  PortableBatteryDeviceChemistryNickelMetalHydride  = 0x05,
+  PortableBatteryDeviceChemistryLithiumIon          = 0x06,
+  PortableBatteryDeviceChemistryZincAir             = 0x07,
+  PortableBatteryDeviceChemistryLithiumPolymer      = 0x08
+} PORTABLE_BATTERY_DEVICE_CHEMISTRY;
+
+///
+/// Portable Battery (Type 22).
+///
+/// This structure describes the attributes of the portable battery(s) for the system.  
+/// The structure contains the static attributes for the group.  Each structure describes 
+/// a single battery pack's attributes.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  SMBIOS_TABLE_STRING               Location;
+  SMBIOS_TABLE_STRING               Manufacturer;
+  SMBIOS_TABLE_STRING               ManufactureDate;
+  SMBIOS_TABLE_STRING               SerialNumber;
+  SMBIOS_TABLE_STRING               DeviceName;
+  UINT8                             DeviceChemistry;              ///< The enumeration value from PORTABLE_BATTERY_DEVICE_CHEMISTRY.
+  UINT16                            DeviceCapacity;
+  UINT16                            DesignVoltage;
+  SMBIOS_TABLE_STRING               SBDSVersionNumber;
+  UINT8                             MaximumErrorInBatteryData;
+  UINT16                            SBDSSerialNumber;
+  UINT16                            SBDSManufactureDate;
+  SMBIOS_TABLE_STRING               SBDSDeviceChemistry;
+  UINT8                             DesignCapacityMultiplier;
+  UINT32                            OEMSpecific;
+} SMBIOS_TABLE_TYPE22;
+
+///
+/// System Reset (Type 23)
+///
+/// This structure describes whether Automatic System Reset functions enabled (Status).  
+/// If the system has a watchdog Timer and the timer is not reset (Timer Reset)
+/// before the Interval elapses, an automatic system reset will occur. The system will re-boot 
+/// according to the Boot Option. This function may repeat until the Limit is reached, at which time 
+/// the system will re-boot according to the Boot Option at Limit.  
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 Capabilities;
+  UINT16                ResetCount;
+  UINT16                ResetLimit;
+  UINT16                TimerInterval;
+  UINT16                Timeout;
+} SMBIOS_TABLE_TYPE23;
+
+///
+/// Hardware Security (Type 24).
+///
+/// This structure describes the system-wide hardware security settings. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 HardwareSecuritySettings;
+} SMBIOS_TABLE_TYPE24;
+
+///
+/// System Power Controls (Type 25).
+///
+/// This structure describes the attributes for controlling the main power supply to the system. 
+/// Software that interprets this structure uses the month, day, hour, minute, and second values 
+/// to determine the number of seconds until the next power-on of the system.  The presence of  
+/// this structure implies that a timed power-on facility is available for the system. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 NextScheduledPowerOnMonth;
+  UINT8                 NextScheduledPowerOnDayOfMonth;
+  UINT8                 NextScheduledPowerOnHour;
+  UINT8                 NextScheduledPowerOnMinute;
+  UINT8                 NextScheduledPowerOnSecond;
+} SMBIOS_TABLE_TYPE25;
+
+///
+/// Voltage Probe - Location and Status.
+///
+typedef struct {
+  UINT8 VoltageProbeSite      :5;
+  UINT8  VoltageProbeStatus   :3;
+} MISC_VOLTAGE_PROBE_LOCATION;
+
+///
+/// Voltage Probe (Type 26)
+///
+/// This describes the attributes for a voltage probe in the system.   
+/// Each structure describes a single voltage probe.
+///
+typedef struct {
+  SMBIOS_STRUCTURE              Hdr;
+  SMBIOS_TABLE_STRING           Description;
+  MISC_VOLTAGE_PROBE_LOCATION   LocationAndStatus;
+  UINT16                        MaximumValue;
+  UINT16                        MinimumValue;
+  UINT16                        Resolution;
+  UINT16                        Tolerance;
+  UINT16                        Accuracy;
+  UINT32                        OEMDefined;
+  UINT16                        NominalValue;
+} SMBIOS_TABLE_TYPE26;
+
+///
+/// Cooling Device - Device Type and Status.
+///
+typedef struct {
+  UINT8 CoolingDevice       :5;
+  UINT8 CoolingDeviceStatus :3;
+} MISC_COOLING_DEVICE_TYPE;
+
+///
+/// Cooling Device (Type 27)
+///
+/// This structure describes the attributes for a cooling device in the system.  
+/// Each structure describes a single cooling device. 
+/// 
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  UINT16                            TemperatureProbeHandle;
+  MISC_COOLING_DEVICE_TYPE          DeviceTypeAndStatus;
+  UINT8                             CoolingUnitGroup;
+  UINT32                            OEMDefined;
+  UINT16                            NominalSpeed;
+  //
+  // Add for smbios 2.7
+  //
+  SMBIOS_TABLE_STRING               Description;
+} SMBIOS_TABLE_TYPE27;
+
+///
+/// Temperature Probe - Location and Status.
+///
+typedef struct {
+  UINT8 TemperatureProbeSite   :5;
+  UINT8 TemperatureProbeStatus :3;
+} MISC_TEMPERATURE_PROBE_LOCATION;
+
+///
+/// Temperature Probe (Type 28).
+///
+/// This structure describes the attributes for a temperature probe in the system.  
+/// Each structure describes a single temperature probe. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  SMBIOS_TABLE_STRING               Description;
+  MISC_TEMPERATURE_PROBE_LOCATION   LocationAndStatus;
+  UINT16                            MaximumValue;
+  UINT16                            MinimumValue;
+  UINT16                            Resolution;
+  UINT16                            Tolerance;
+  UINT16                            Accuracy;
+  UINT32                            OEMDefined;
+  UINT16                            NominalValue;
+} SMBIOS_TABLE_TYPE28;
+
+///
+/// Electrical Current Probe - Location and Status.
+///
+typedef struct {
+  UINT8 ElectricalCurrentProbeSite   :5;
+  UINT8 ElectricalCurrentProbeStatus :3;
+} MISC_ELECTRICAL_CURRENT_PROBE_LOCATION;
+
+///
+/// Electrical Current Probe (Type 29).
+///
+/// This structure describes the attributes for an electrical current probe in the system.
+/// Each structure describes a single electrical current probe. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE                        Hdr;
+  SMBIOS_TABLE_STRING                     Description;
+  MISC_ELECTRICAL_CURRENT_PROBE_LOCATION  LocationAndStatus;
+  UINT16                                  MaximumValue;
+  UINT16                                  MinimumValue;
+  UINT16                                  Resolution;
+  UINT16                                  Tolerance;
+  UINT16                                  Accuracy;
+  UINT32                                  OEMDefined;
+  UINT16                                  NominalValue;
+} SMBIOS_TABLE_TYPE29;
+
+///
+/// Out-of-Band Remote Access (Type 30).
+///
+/// This structure describes the attributes and policy settings of a hardware facility 
+/// that may be used to gain remote access to a hardware system when the operating system 
+/// is not available due to power-down status, hardware failures, or boot failures. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  SMBIOS_TABLE_STRING   ManufacturerName;
+  UINT8                 Connections;
+} SMBIOS_TABLE_TYPE30;
+
+///
+/// Boot Integrity Services (BIS) Entry Point (Type 31).
+///
+/// Structure type 31 (decimal) is reserved for use by the Boot Integrity Services (BIS). 
+/// 
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 Checksum;
+  UINT8                 Reserved1;
+  UINT16                Reserved2;
+  UINT32                BisEntry16;
+  UINT32                BisEntry32;
+  UINT64                Reserved3;
+  UINT32                Reserved4;
+} SMBIOS_TABLE_TYPE31;
+
+///
+/// System Boot Information - System Boot Status.
+///
+typedef enum {
+  BootInformationStatusNoError                  = 0x00,
+  BootInformationStatusNoBootableMedia          = 0x01,
+  BootInformationStatusNormalOSFailedLoading    = 0x02,
+  BootInformationStatusFirmwareDetectedFailure  = 0x03,
+  BootInformationStatusOSDetectedFailure        = 0x04,
+  BootInformationStatusUserRequestedBoot        = 0x05,
+  BootInformationStatusSystemSecurityViolation  = 0x06,
+  BootInformationStatusPreviousRequestedImage   = 0x07,
+  BootInformationStatusWatchdogTimerExpired     = 0x08,
+  BootInformationStatusStartReserved            = 0x09,
+  BootInformationStatusStartOemSpecific         = 0x80,
+  BootInformationStatusStartProductSpecific     = 0xC0
+} MISC_BOOT_INFORMATION_STATUS_DATA_TYPE;
+
+///
+/// System Boot Information (Type 32).
+///
+/// The client system firmware, e.g. BIOS, communicates the System Boot Status to the 
+/// client's Pre-boot Execution Environment (PXE) boot image or OS-present management 
+/// application via this structure. When used in the PXE environment, for example, 
+/// this code identifies the reason the PXE was initiated and can be used by boot-image 
+/// software to further automate an enterprise's PXE sessions.  For example, an enterprise  
+/// could choose to automatically download a hardware-diagnostic image to a client whose 
+/// reason code indicated either a firmware- or operating system-detected hardware failure.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                        Hdr;
+  UINT8                                   Reserved[6];
+  UINT8                                   BootStatus;     ///< The enumeration value from MISC_BOOT_INFORMATION_STATUS_DATA_TYPE.
+} SMBIOS_TABLE_TYPE32;
+
+///
+/// 64-bit Memory Error Information (Type 33).
+///
+/// This structure describes an error within a Physical Memory Array, 
+/// when the error address is above 4G (0xFFFFFFFF).
+///    
+typedef struct {
+  SMBIOS_STRUCTURE          Hdr;
+  UINT8                     ErrorType;                    ///< The enumeration value from MEMORY_ERROR_TYPE.
+  UINT8                     ErrorGranularity;             ///< The enumeration value from MEMORY_ERROR_GRANULARITY.
+  UINT8                     ErrorOperation;               ///< The enumeration value from MEMORY_ERROR_OPERATION.
+  UINT32                    VendorSyndrome;
+  UINT64                    MemoryArrayErrorAddress;
+  UINT64                    DeviceErrorAddress;
+  UINT32                    ErrorResolution;
+} SMBIOS_TABLE_TYPE33;
+
+///
+/// Management Device -  Type. 
+///
+typedef enum {
+  ManagementDeviceTypeOther      = 0x01,
+  ManagementDeviceTypeUnknown    = 0x02,
+  ManagementDeviceTypeLm75       = 0x03,
+  ManagementDeviceTypeLm78       = 0x04,
+  ManagementDeviceTypeLm79       = 0x05,
+  ManagementDeviceTypeLm80       = 0x06,
+  ManagementDeviceTypeLm81       = 0x07,
+  ManagementDeviceTypeAdm9240    = 0x08,
+  ManagementDeviceTypeDs1780     = 0x09,
+  ManagementDeviceTypeMaxim1617  = 0x0A,
+  ManagementDeviceTypeGl518Sm    = 0x0B,
+  ManagementDeviceTypeW83781D    = 0x0C,
+  ManagementDeviceTypeHt82H791   = 0x0D
+} MISC_MANAGEMENT_DEVICE_TYPE;
+
+///
+/// Management Device -  Address Type. 
+///
+typedef enum {
+  ManagementDeviceAddressTypeOther   = 0x01,
+  ManagementDeviceAddressTypeUnknown = 0x02,
+  ManagementDeviceAddressTypeIOPort  = 0x03,
+  ManagementDeviceAddressTypeMemory  = 0x04,
+  ManagementDeviceAddressTypeSmbus   = 0x05
+} MISC_MANAGEMENT_DEVICE_ADDRESS_TYPE;
+
+///
+/// Management Device (Type 34).
+///
+/// The information in this structure defines the attributes of a Management Device.  
+/// A Management Device might control one or more fans or voltage, current, or temperature
+/// probes as defined by one or more Management Device Component structures.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                      Hdr;
+  SMBIOS_TABLE_STRING                   Description;
+  UINT8                                 Type;                     ///< The enumeration value from MISC_MANAGEMENT_DEVICE_TYPE.
+  UINT32                                Address;
+  UINT8                                 AddressType;              ///< The enumeration value from MISC_MANAGEMENT_DEVICE_ADDRESS_TYPE.
+} SMBIOS_TABLE_TYPE34;
+
+///
+/// Management Device Component (Type 35)
+///
+/// This structure associates a cooling device or environmental probe with structures 
+/// that define the controlling hardware device and (optionally) the component's thresholds. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  SMBIOS_TABLE_STRING   Description;
+  UINT16                ManagementDeviceHandle;
+  UINT16                ComponentHandle;
+  UINT16                ThresholdHandle;
+} SMBIOS_TABLE_TYPE35;
+
+///
+/// Management Device Threshold Data (Type 36).
+///
+/// The information in this structure defines threshold information for 
+/// a component (probe or cooling-unit) contained within a Management Device.  
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT16                LowerThresholdNonCritical;
+  UINT16                UpperThresholdNonCritical;
+  UINT16                LowerThresholdCritical;
+  UINT16                UpperThresholdCritical;
+  UINT16                LowerThresholdNonRecoverable;
+  UINT16                UpperThresholdNonRecoverable;
+} SMBIOS_TABLE_TYPE36;
+
+///
+/// Memory Channel Entry.
+///
+typedef struct {
+  UINT8                 DeviceLoad;
+  UINT16                DeviceHandle;
+} MEMORY_DEVICE;
+
+///
+/// Memory Channel - Channel Type.
+///
+typedef enum {
+  MemoryChannelTypeOther       = 0x01,
+  MemoryChannelTypeUnknown     = 0x02,
+  MemoryChannelTypeRambus      = 0x03,
+  MemoryChannelTypeSyncLink    = 0x04
+} MEMORY_CHANNEL_TYPE;
+
+///
+/// Memory Channel (Type 37)
+///
+/// The information in this structure provides the correlation between a Memory Channel
+/// and its associated Memory Devices.  Each device presents one or more loads to the channel. 
+/// The sum of all device loads cannot exceed the channel's defined maximum.
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 ChannelType;
+  UINT8                 MaximumChannelLoad;
+  UINT8                 MemoryDeviceCount;
+  MEMORY_DEVICE         MemoryDevice[1];
+} SMBIOS_TABLE_TYPE37;
+
+///
+/// IPMI Device Information - BMC Interface Type
+///
+typedef enum {
+  IPMIDeviceInfoInterfaceTypeUnknown       = 0x00,
+  IPMIDeviceInfoInterfaceTypeKCS           = 0x01, ///< The Keyboard Controller Style.
+  IPMIDeviceInfoInterfaceTypeSMIC          = 0x02, ///< The Server Management Interface Chip.
+  IPMIDeviceInfoInterfaceTypeBT            = 0x03, ///< The Block Transfer
+  IPMIDeviceInfoInterfaceTypeReserved      = 0x04
+} BMC_INTERFACE_TYPE;
+
+///
+/// IPMI Device Information (Type 38).
+///
+/// The information in this structure defines the attributes of an
+/// Intelligent Platform Management Interface (IPMI) Baseboard Management Controller (BMC).
+///
+/// The Type 42 structure can also be used to describe a physical management controller
+/// host interface and one or more protocols that share that interface. If IPMI is not
+/// shared with other protocols, either the Type 38 or Type 42 structures can be used.
+/// Providing Type 38 is recommended for backward compatibility.
+///
+typedef struct {
+  SMBIOS_STRUCTURE      Hdr;
+  UINT8                 InterfaceType;              ///< The enumeration value from BMC_INTERFACE_TYPE.
+  UINT8                 IPMISpecificationRevision;
+  UINT8                 I2CSlaveAddress;
+  UINT8                 NVStorageDeviceAddress;
+  UINT64                BaseAddress;
+  UINT8                 BaseAddressModifier_InterruptInfo;
+  UINT8                 InterruptNumber;
+} SMBIOS_TABLE_TYPE38;
+
+///
+/// System Power Supply - Power Supply Characteristics.
+///
+typedef struct {
+  UINT16                        PowerSupplyHotReplaceable:1;
+  UINT16                        PowerSupplyPresent       :1;
+  UINT16                        PowerSupplyUnplugged     :1;
+  UINT16                        InputVoltageRangeSwitch  :4;
+  UINT16                        PowerSupplyStatus        :3;
+  UINT16                        PowerSupplyType          :4;
+  UINT16                        Reserved                 :2;
+} SYS_POWER_SUPPLY_CHARACTERISTICS;
+
+///
+/// System Power Supply (Type 39).
+///
+/// This structure identifies attributes of a system power supply. One instance
+/// of this record is present for each possible power supply in a system.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  UINT8                             PowerUnitGroup;
+  SMBIOS_TABLE_STRING               Location;
+  SMBIOS_TABLE_STRING               DeviceName;
+  SMBIOS_TABLE_STRING               Manufacturer;
+  SMBIOS_TABLE_STRING               SerialNumber;
+  SMBIOS_TABLE_STRING               AssetTagNumber;
+  SMBIOS_TABLE_STRING               ModelPartNumber;
+  SMBIOS_TABLE_STRING               RevisionLevel;
+  UINT16                            MaxPowerCapacity;
+  SYS_POWER_SUPPLY_CHARACTERISTICS  PowerSupplyCharacteristics;
+  UINT16                            InputVoltageProbeHandle;
+  UINT16                            CoolingDeviceHandle;
+  UINT16                            InputCurrentProbeHandle;
+} SMBIOS_TABLE_TYPE39;
+
+///
+/// Additional Information Entry Format. 
+///
+typedef struct {                       
+  UINT8                   EntryLength; 
+  UINT16                  ReferencedHandle;
+  UINT8                   ReferencedOffset;
+  SMBIOS_TABLE_STRING     EntryString;
+  UINT8                   Value[1];
+}ADDITIONAL_INFORMATION_ENTRY;
+
+///
+/// Additional Information (Type 40).
+///
+/// This structure is intended to provide additional information for handling unspecified 
+/// enumerated values and interim field updates in another structure. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE                      Hdr;
+  UINT8                                 NumberOfAdditionalInformationEntries;
+  ADDITIONAL_INFORMATION_ENTRY          AdditionalInfoEntries[1];  
+} SMBIOS_TABLE_TYPE40;
+
+///
+/// Onboard Devices Extended Information - Onboard Device Types.
+///
+typedef enum{
+  OnBoardDeviceExtendedTypeOther          = 0x01,
+  OnBoardDeviceExtendedTypeUnknown        = 0x02,
+  OnBoardDeviceExtendedTypeVideo          = 0x03,
+  OnBoardDeviceExtendedTypeScsiController = 0x04,
+  OnBoardDeviceExtendedTypeEthernet       = 0x05,
+  OnBoardDeviceExtendedTypeTokenRing      = 0x06,
+  OnBoardDeviceExtendedTypeSound          = 0x07,
+  OnBoardDeviceExtendedTypePATAController = 0x08,
+  OnBoardDeviceExtendedTypeSATAController = 0x09,
+  OnBoardDeviceExtendedTypeSASController  = 0x0A
+} ONBOARD_DEVICE_EXTENDED_INFO_TYPE;
+
+///
+/// Onboard Devices Extended Information (Type 41).
+///
+/// The information in this structure defines the attributes of devices that 
+/// are onboard (soldered onto) a system element, usually the baseboard.  
+/// In general, an entry in this table implies that the BIOS has some level of 
+/// control over the enabling of the associated device for use by the system. 
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  SMBIOS_TABLE_STRING               ReferenceDesignation;
+  UINT8                             DeviceType;             ///< The enumeration value from ONBOARD_DEVICE_EXTENDED_INFO_TYPE
+  UINT8                             DeviceTypeInstance;
+  UINT16                            SegmentGroupNum;
+  UINT8                             BusNum;
+  UINT8                             DevFuncNum;
+} SMBIOS_TABLE_TYPE41;
+
+///
+/// Management Controller Host Interface - Interface Types.
+/// 00h - 3Fh: MCTP Host Interfaces
+///
+typedef enum{
+  MCHostInterfaceTypeNetworkHostInterface       = 0x40,
+  MCHostInterfaceTypeOemDefined                 = 0xF0
+} MC_HOST_INTERFACE_TYPE;
+
+///
+/// Management Controller Host Interface - Protocol Types.
+///
+typedef enum{
+  MCHostInterfaceProtocolTypeIPMI               = 0x02,
+  MCHostInterfaceProtocolTypeMCTP               = 0x03,
+  MCHostInterfaceProtocolTypeRedfishOverIP      = 0x04,
+  MCHostInterfaceProtocolTypeOemDefined         = 0xF0
+} MC_HOST_INTERFACE_PROTOCOL_TYPE;
+
+///
+/// Management Controller Host Interface (Type 42).
+///
+/// The information in this structure defines the attributes of a Management
+/// Controller Host Interface that is not discoverable by "Plug and Play" mechanisms.
+///
+/// Type 42 should be used for management controller host interfaces that use protocols
+/// other than IPMI or that use multiple protocols on a single host interface type.
+///
+/// This structure should also be provided if IPMI is shared with other protocols
+/// over the same interface hardware. If IPMI is not shared with other protocols,
+/// either the Type 38 or Type 42 structures can be used. Providing Type 38 is
+/// recommended for backward compatibility. The structures are not required to
+/// be mutually exclusive. Type 38 and Type 42 structures may be implemented
+/// simultaneously to provide backward compatibility with IPMI applications or drivers
+/// that do not yet recognize the Type 42 structure.
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  UINT8                             InterfaceType;          ///< The enumeration value from MC_HOST_INTERFACE_TYPE
+  UINT8                             MCHostInterfaceData[1]; ///< This field has a minimum of four bytes
+} SMBIOS_TABLE_TYPE42;
+
+///
+/// TPM Device (Type 43).
+///
+typedef struct {
+  SMBIOS_STRUCTURE                  Hdr;
+  UINT8                             VendorID[4];
+  UINT8                             MajorSpecVersion;
+  UINT8                             MinorSpecVersion;
+  UINT32                            FirmwareVersion1;
+  UINT32                            FirmwareVersion2;
+  SMBIOS_TABLE_STRING               Description;
+  UINT64                            Characteristics;
+  UINT32                            OemDefined;
+} SMBIOS_TABLE_TYPE43;
+
+///
+/// Inactive (Type 126)
+///
+typedef struct {
+  SMBIOS_STRUCTURE   Hdr;
+} SMBIOS_TABLE_TYPE126;
+
+///
+/// End-of-Table (Type 127)
+///
+typedef struct {
+  SMBIOS_STRUCTURE   Hdr;
+} SMBIOS_TABLE_TYPE127;
+
+///
+/// Union of all the possible SMBIOS record types.
+///
+typedef union {
+  SMBIOS_STRUCTURE      *Hdr;
+  SMBIOS_TABLE_TYPE0    *Type0;
+  SMBIOS_TABLE_TYPE1    *Type1;
+  SMBIOS_TABLE_TYPE2    *Type2;
+  SMBIOS_TABLE_TYPE3    *Type3;
+  SMBIOS_TABLE_TYPE4    *Type4;
+  SMBIOS_TABLE_TYPE5    *Type5;
+  SMBIOS_TABLE_TYPE6    *Type6;
+  SMBIOS_TABLE_TYPE7    *Type7;
+  SMBIOS_TABLE_TYPE8    *Type8;
+  SMBIOS_TABLE_TYPE9    *Type9;
+  SMBIOS_TABLE_TYPE10   *Type10;
+  SMBIOS_TABLE_TYPE11   *Type11;
+  SMBIOS_TABLE_TYPE12   *Type12;
+  SMBIOS_TABLE_TYPE13   *Type13;
+  SMBIOS_TABLE_TYPE14   *Type14;
+  SMBIOS_TABLE_TYPE15   *Type15;
+  SMBIOS_TABLE_TYPE16   *Type16;
+  SMBIOS_TABLE_TYPE17   *Type17;
+  SMBIOS_TABLE_TYPE18   *Type18;
+  SMBIOS_TABLE_TYPE19   *Type19;
+  SMBIOS_TABLE_TYPE20   *Type20;
+  SMBIOS_TABLE_TYPE21   *Type21;
+  SMBIOS_TABLE_TYPE22   *Type22;
+  SMBIOS_TABLE_TYPE23   *Type23;
+  SMBIOS_TABLE_TYPE24   *Type24;
+  SMBIOS_TABLE_TYPE25   *Type25;
+  SMBIOS_TABLE_TYPE26   *Type26;
+  SMBIOS_TABLE_TYPE27   *Type27;
+  SMBIOS_TABLE_TYPE28   *Type28;
+  SMBIOS_TABLE_TYPE29   *Type29;
+  SMBIOS_TABLE_TYPE30   *Type30;
+  SMBIOS_TABLE_TYPE31   *Type31;
+  SMBIOS_TABLE_TYPE32   *Type32;
+  SMBIOS_TABLE_TYPE33   *Type33;
+  SMBIOS_TABLE_TYPE34   *Type34;
+  SMBIOS_TABLE_TYPE35   *Type35;
+  SMBIOS_TABLE_TYPE36   *Type36;
+  SMBIOS_TABLE_TYPE37   *Type37;
+  SMBIOS_TABLE_TYPE38   *Type38;
+  SMBIOS_TABLE_TYPE39   *Type39;
+  SMBIOS_TABLE_TYPE40   *Type40;
+  SMBIOS_TABLE_TYPE41   *Type41;
+  SMBIOS_TABLE_TYPE42   *Type42;
+  SMBIOS_TABLE_TYPE43   *Type43;
+  SMBIOS_TABLE_TYPE126  *Type126;
+  SMBIOS_TABLE_TYPE127  *Type127;
+  UINT8                 *Raw;
+} SMBIOS_STRUCTURE_POINTER;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/SmBus.h b/MdePkg/Include/IndustryStandard/SmBus.h
new file mode 100644
index 000000000000..be6851800c71
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/SmBus.h
@@ -0,0 +1,81 @@
+/** @file
+  This file declares the SMBus definitions defined in SmBus Specifciation V2.0
+  and defined in PI1.0 specification volume 5.
+
+  Copyright (c) 2007 - 2008, 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 _SMBUS_H_
+#define _SMBUS_H_
+
+
+///
+/// UDID of SMBUS device.
+///
+typedef struct {
+  UINT32  VendorSpecificId;
+  UINT16  SubsystemDeviceId;
+  UINT16  SubsystemVendorId;
+  UINT16  Interface;
+  UINT16  DeviceId;
+  UINT16  VendorId;
+  UINT8   VendorRevision;
+  UINT8   DeviceCapabilities;
+} EFI_SMBUS_UDID;
+
+///
+/// Smbus Device Address
+///
+typedef struct {
+  ///
+  /// The SMBUS hardware address to which the SMBUS device is preassigned or allocated.
+  ///
+  UINTN SmbusDeviceAddress : 7;
+} EFI_SMBUS_DEVICE_ADDRESS;
+
+typedef struct {
+  ///
+  /// The SMBUS hardware address to which the SMBUS device is preassigned or
+  /// allocated. Type EFI_SMBUS_DEVICE_ADDRESS is defined in EFI_PEI_SMBUS2_PPI.Execute().
+  ///
+  EFI_SMBUS_DEVICE_ADDRESS  SmbusDeviceAddress;
+  ///
+  /// The SMBUS Unique Device Identifier (UDID) as defined in EFI_SMBUS_UDID.
+  /// Type EFI_SMBUS_UDID is defined in EFI_PEI_SMBUS2_PPI.ArpDevice().
+  ///
+  EFI_SMBUS_UDID            SmbusDeviceUdid;
+} EFI_SMBUS_DEVICE_MAP;
+
+///
+/// Smbus Operations
+///
+typedef enum _EFI_SMBUS_OPERATION {
+  EfiSmbusQuickRead,
+  EfiSmbusQuickWrite,
+  EfiSmbusReceiveByte,
+  EfiSmbusSendByte,
+  EfiSmbusReadByte,
+  EfiSmbusWriteByte,
+  EfiSmbusReadWord,
+  EfiSmbusWriteWord,
+  EfiSmbusReadBlock,
+  EfiSmbusWriteBlock,
+  EfiSmbusProcessCall,
+  EfiSmbusBWBRProcessCall
+} EFI_SMBUS_OPERATION;
+
+///
+/// EFI_SMBUS_DEVICE_COMMAND
+///
+typedef UINTN   EFI_SMBUS_DEVICE_COMMAND;
+
+#endif
+
diff --git a/MdePkg/Include/IndustryStandard/TcgPhysicalPresence.h b/MdePkg/Include/IndustryStandard/TcgPhysicalPresence.h
new file mode 100644
index 000000000000..23d7a09c44fa
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TcgPhysicalPresence.h
@@ -0,0 +1,129 @@
+/** @file
+  TCG Physical Presence definition.
+
+Copyright (c) 2015, 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 _TCG_PHYSICAL_PRESENCE_H_
+#define _TCG_PHYSICAL_PRESENCE_H_
+
+//
+// TCG PP definition for physical presence ACPI function
+//
+#define TCG_ACPI_FUNCTION_GET_PHYSICAL_PRESENCE_INTERFACE_VERSION      1
+#define TCG_ACPI_FUNCTION_SUBMIT_REQUEST_TO_BIOS                       2
+#define TCG_ACPI_FUNCTION_GET_PENDING_REQUEST_BY_OS                    3
+#define TCG_ACPI_FUNCTION_GET_PLATFORM_ACTION_TO_TRANSITION_TO_BIOS    4
+#define TCG_ACPI_FUNCTION_RETURN_REQUEST_RESPONSE_TO_OS                5
+#define TCG_ACPI_FUNCTION_SUBMIT_PREFERRED_USER_LANGUAGE               6
+#define TCG_ACPI_FUNCTION_SUBMIT_REQUEST_TO_BIOS_2                     7
+#define TCG_ACPI_FUNCTION_GET_USER_CONFIRMATION_STATUS_FOR_REQUEST     8
+
+//
+// TCG PP definition for TPM Operation Response to OS Environment
+//
+#define TCG_PP_OPERATION_RESPONSE_SUCCESS              0x0
+#define TCG_PP_OPERATION_RESPONSE_USER_ABORT           0xFFFFFFF0
+#define TCG_PP_OPERATION_RESPONSE_BIOS_FAILURE         0xFFFFFFF1
+
+//
+// TCG PP definition of return code for Return TPM Operation Response to OS Environment
+//
+#define TCG_PP_RETURN_TPM_OPERATION_RESPONSE_SUCCESS                   0
+#define TCG_PP_RETURN_TPM_OPERATION_RESPONSE_FAILURE                   1
+
+//
+// TCG PP definition of return code for Submit TPM Request to Pre-OS Environment
+// and Submit TPM Request to Pre-OS Environment 2
+//
+#define TCG_PP_SUBMIT_REQUEST_TO_PREOS_SUCCESS                                  0
+#define TCG_PP_SUBMIT_REQUEST_TO_PREOS_NOT_IMPLEMENTED                          1
+#define TCG_PP_SUBMIT_REQUEST_TO_PREOS_GENERAL_FAILURE                          2
+#define TCG_PP_SUBMIT_REQUEST_TO_PREOS_BLOCKED_BY_BIOS_SETTINGS                 3
+
+//
+// TCG PP definition of return code for Get User Confirmation Status for Operation
+//
+#define TCG_PP_GET_USER_CONFIRMATION_NOT_IMPLEMENTED                                 0
+#define TCG_PP_GET_USER_CONFIRMATION_BIOS_ONLY                                       1
+#define TCG_PP_GET_USER_CONFIRMATION_BLOCKED_BY_BIOS_CONFIGURATION                   2
+#define TCG_PP_GET_USER_CONFIRMATION_ALLOWED_AND_PPUSER_REQUIRED                     3
+#define TCG_PP_GET_USER_CONFIRMATION_ALLOWED_AND_PPUSER_NOT_REQUIRED                 4
+
+//
+// TCG PP definition of physical presence operation actions for TPM12
+//
+#define TCG_PHYSICAL_PRESENCE_NO_ACTION                               0
+#define TCG_PHYSICAL_PRESENCE_ENABLE                                  1
+#define TCG_PHYSICAL_PRESENCE_DISABLE                                 2
+#define TCG_PHYSICAL_PRESENCE_ACTIVATE                                3
+#define TCG_PHYSICAL_PRESENCE_DEACTIVATE                              4 
+#define TCG_PHYSICAL_PRESENCE_CLEAR                                   5
+#define TCG_PHYSICAL_PRESENCE_ENABLE_ACTIVATE                         6
+#define TCG_PHYSICAL_PRESENCE_DEACTIVATE_DISABLE                      7
+#define TCG_PHYSICAL_PRESENCE_SET_OWNER_INSTALL_TRUE                  8
+#define TCG_PHYSICAL_PRESENCE_SET_OWNER_INSTALL_FALSE                 9
+#define TCG_PHYSICAL_PRESENCE_ENABLE_ACTIVATE_OWNER_TRUE              10
+#define TCG_PHYSICAL_PRESENCE_DEACTIVATE_DISABLE_OWNER_FALSE          11
+#define TCG_PHYSICAL_PRESENCE_DEFERRED_PP_UNOWNERED_FIELD_UPGRADE     12
+#define TCG_PHYSICAL_PRESENCE_SET_OPERATOR_AUTH                       13
+#define TCG_PHYSICAL_PRESENCE_CLEAR_ENABLE_ACTIVATE                   14
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_FALSE              15
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_PROVISION_TRUE               16
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_FALSE                  17
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_CLEAR_TRUE                   18
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_FALSE            19
+#define TCG_PHYSICAL_PRESENCE_SET_NO_PPI_MAINTENANCE_TRUE             20
+#define TCG_PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR                   21
+#define TCG_PHYSICAL_PRESENCE_ENABLE_ACTIVATE_CLEAR_ENABLE_ACTIVATE   22
+
+#define TCG_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION               128
+
+//
+// TCG PP definition of physical presence operation actions for TPM2
+//
+#define TCG2_PHYSICAL_PRESENCE_NO_ACTION                                         0
+#define TCG2_PHYSICAL_PRESENCE_ENABLE                                            1
+#define TCG2_PHYSICAL_PRESENCE_DISABLE                                           2
+#define TCG2_PHYSICAL_PRESENCE_CLEAR                                             5
+#define TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR                                      14
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_TRUE                    17
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CLEAR_FALSE                   18
+#define TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_2                                    21
+#define TCG2_PHYSICAL_PRESENCE_ENABLE_CLEAR_3                                    22
+#define TCG2_PHYSICAL_PRESENCE_SET_PCR_BANKS                                     23
+#define TCG2_PHYSICAL_PRESENCE_CHANGE_EPS                                        24
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CHANGE_PCRS_FALSE             25
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CHANGE_PCRS_TRUE              26
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_TURN_ON_FALSE                 27
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_TURN_ON_TRUE                  28
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_TURN_OFF_FALSE                29
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_TURN_OFF_TRUE                 30
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CHANGE_EPS_FALSE              31
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_CHANGE_EPS_TRUE               32
+#define TCG2_PHYSICAL_PRESENCE_LOG_ALL_DIGESTS                                   33
+#define TCG2_PHYSICAL_PRESENCE_DISABLE_ENDORSEMENT_ENABLE_STORAGE_HIERARCHY      34
+#define TCG2_PHYSICAL_PRESENCE_NO_ACTION_MAX                                     34
+
+//
+// TCG PP definition of physical presence operation actions for storage management
+//
+#define TCG2_PHYSICAL_PRESENCE_STORAGE_MANAGEMENT_BEGIN                          96
+#define TCG2_PHYSICAL_PRESENCE_ENABLE_BLOCK_SID                                  96
+#define TCG2_PHYSICAL_PRESENCE_DISABLE_BLOCK_SID                                 97
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_TRUE    98
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_ENABLE_BLOCK_SID_FUNC_FALSE   99
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_TRUE   100
+#define TCG2_PHYSICAL_PRESENCE_SET_PP_REQUIRED_FOR_DISABLE_BLOCK_SID_FUNC_FALSE  101
+
+#define TCG2_PHYSICAL_PRESENCE_VENDOR_SPECIFIC_OPERATION                         128
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/TcgStorageCore.h b/MdePkg/Include/IndustryStandard/TcgStorageCore.h
new file mode 100644
index 000000000000..79954df5ad37
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TcgStorageCore.h
@@ -0,0 +1,394 @@
+/** @file
+  TCG defined values and structures.
+
+Copyright (c) 2016, 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 _TCG_STORAGE_CORE_H_
+#define _TCG_STORAGE_CORE_H_
+
+#include <Base.h>
+
+#pragma pack(1)
+
+/// UID in host native byte order
+typedef UINT64 TCG_UID;
+
+#define TCG_TO_UID(b0, b1, b2, b3, b4, b5, b6, b7) (TCG_UID)( \
+  (UINT64)(b0)         | \
+  ((UINT64)(b1) << 8)  | \
+  ((UINT64)(b2) << 16) | \
+  ((UINT64)(b3) << 24) | \
+  ((UINT64)(b4) << 32) | \
+  ((UINT64)(b5) << 40) | \
+  ((UINT64)(b6) << 48) | \
+  ((UINT64)(b7) << 56))
+
+typedef struct {
+  UINT32     ReservedBE;
+  UINT16     ComIDBE;
+  UINT16     ComIDExtensionBE;
+  UINT32     OutstandingDataBE;
+  UINT32     MinTransferBE;
+  UINT32     LengthBE;
+  UINT8      Payload[0];
+} TCG_COM_PACKET;
+
+typedef struct {
+  UINT32     TperSessionNumberBE;
+  UINT32     HostSessionNumberBE;
+  UINT32     SequenceNumberBE;
+  UINT16     ReservedBE;
+  UINT16     AckTypeBE;
+  UINT32     AcknowledgementBE;
+  UINT32     LengthBE;
+  UINT8      Payload[0];
+} TCG_PACKET;
+
+#define TCG_SUBPACKET_ALIGNMENT 4 // 4-byte alignment per spec
+
+typedef struct {
+  UINT8      ReservedBE[6];
+  UINT16     KindBE;
+  UINT32     LengthBE;
+  UINT8      Payload[0];
+} TCG_SUB_PACKET;
+
+#define SUBPACKET_KIND_DATA           0x0000
+#define SUBPACKET_KIND_CREDIT_CONTROL 0x8001
+
+#define TCG_ATOM_TYPE_INTEGER 0x0
+#define TCG_ATOM_TYPE_BYTE    0x1
+typedef struct {
+  UINT8   Data : 6;
+  UINT8   Sign : 1;
+  UINT8   IsZero : 1;
+} TCG_TINY_ATOM_BITS;
+
+typedef union {
+  UINT8               Raw;
+  TCG_TINY_ATOM_BITS  TinyAtomBits;
+} TCG_SIMPLE_TOKEN_TINY_ATOM;
+
+
+typedef struct {
+  UINT8   Length : 4;
+  UINT8   SignOrCont : 1;
+  UINT8   ByteOrInt : 1;
+  UINT8   IsZero : 1;
+  UINT8   IsOne : 1;
+} TCG_SHORT_ATOM_BITS;
+
+typedef union {
+  UINT8                 RawHeader;
+  TCG_SHORT_ATOM_BITS   ShortAtomBits;
+} TCG_SIMPLE_TOKEN_SHORT_ATOM;
+
+
+#define TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT 0x8
+#define TCG_MEDIUM_ATOM_LENGTH_HIGH_MASK  0x7
+
+typedef struct {
+  UINT8  LengthHigh : 3;
+  UINT8  SignOrCont : 1;
+  UINT8  ByteOrInt : 1;
+  UINT8  IsZero : 1;
+  UINT8  IsOne1 : 1;
+  UINT8  IsOne2 : 1;
+  UINT8  LengthLow;
+} TCG_MEDIUM_ATOM_BITS;
+
+typedef union {
+  UINT16                RawHeader;
+  TCG_MEDIUM_ATOM_BITS  MediumAtomBits;
+} TCG_SIMPLE_TOKEN_MEDIUM_ATOM;
+
+
+#define TCG_LONG_ATOM_LENGTH_HIGH_SHIFT 16
+#define TCG_LONG_ATOM_LENGTH_MID_SHIFT  8
+
+typedef  struct {
+  UINT8   SignOrCont : 1;
+  UINT8   ByteOrInt : 1;
+  UINT8   Reserved : 2;
+  UINT8   IsZero : 1;
+  UINT8   IsOne1 : 1;
+  UINT8   IsOne2 : 1;
+  UINT8   IsOne3 : 1;
+  UINT8   LengthHigh;
+  UINT8   LengthMid;
+  UINT8   LengthLow;
+} TCG_LONG_ATOM_BITS;
+
+typedef union {
+  UINT32              RawHeader;
+  TCG_LONG_ATOM_BITS  LongAtomBits;
+} TCG_SIMPLE_TOKEN_LONG_ATOM;
+
+
+// TCG Core Spec v2 - Table 04 - Token Types
+typedef enum {
+  TcgTokenTypeReserved,
+  TcgTokenTypeTinyAtom,
+  TcgTokenTypeShortAtom,
+  TcgTokenTypeMediumAtom,
+  TcgTokenTypeLongAtom,
+  TcgTokenTypeStartList,
+  TcgTokenTypeEndList,
+  TcgTokenTypeStartName,
+  TcgTokenTypeEndName,
+  TcgTokenTypeCall,
+  TcgTokenTypeEndOfData,
+  TcgTokenTypeEndOfSession,
+  TcgTokenTypeStartTransaction,
+  TcgTokenTypeEndTransaction,
+  TcgTokenTypeEmptyAtom,
+} TCG_TOKEN_TYPE;
+
+#pragma pack()
+
+#define TCG_TOKEN_SHORTATOM_MAX_BYTE_SIZE   0x0F
+#define TCG_TOKEN_MEDIUMATOM_MAX_BYTE_SIZE  0x7FF
+#define TCG_TOKEN_LONGATOM_MAX_BYTE_SIZE    0xFFFFFF
+
+#define TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE 0x3F
+#define TCG_TOKEN_TINYATOM_SIGNED_MAX_VALUE   0x1F
+#define TCG_TOKEN_TINYATOM_SIGNED_MIN_VALUE   -32
+
+// TOKEN TYPES
+#define TCG_TOKEN_TINYATOM          0x00
+#define TCG_TOKEN_TINYSIGNEDATOM    0x40
+#define TCG_TOKEN_SHORTATOM         0x80
+#define TCG_TOKEN_SHORTSIGNEDATOM   0x90
+#define TCG_TOKEN_SHORTBYTESATOM    0xA0
+#define TCG_TOKEN_MEDIUMATOM        0xC0
+#define TCG_TOKEN_MEDIUMSIGNEDATOM  0xC8
+#define TCG_TOKEN_MEDIUMBYTESATOM   0xD0
+#define TCG_TOKEN_LONGATOM          0xE0
+#define TCG_TOKEN_LONGSIGNEDATOM    0xE1
+#define TCG_TOKEN_LONGBYTESATOM     0xE2
+#define TCG_TOKEN_STARTLIST         0xF0
+#define TCG_TOKEN_ENDLIST           0xF1
+#define TCG_TOKEN_STARTNAME         0xF2
+#define TCG_TOKEN_ENDNAME           0xF3
+// 0xF4 - 0xF7 TCG Reserved
+#define TCG_TOKEN_CALL              0xF8
+#define TCG_TOKEN_ENDDATA           0xF9
+#define TCG_TOKEN_ENDSESSION        0xFA
+#define TCG_TOKEN_STARTTRANSACTION  0xFB
+#define TCG_TOKEN_ENDTRANSACTION    0xFC
+// 0xFD - 0xFE TCG Reserved
+#define TCG_TOKEN_EMPTY             0xFF
+
+// CELLBLOCK reserved Names
+#define TCG_CELL_BLOCK_TABLE_NAME           (UINT8)0x00
+#define TCG_CELL_BLOCK_START_ROW_NAME       (UINT8)0x01
+#define TCG_CELL_BLOCK_END_ROW_NAME         (UINT8)0x02
+#define TCG_CELL_BLOCK_START_COLUMN_NAME    (UINT8)0x03
+#define TCG_CELL_BLOCK_END_COLUMN_NAME      (UINT8)0x04
+
+// METHOD STATUS CODES
+#define TCG_METHOD_STATUS_CODE_SUCCESS                  0x00
+#define TCG_METHOD_STATUS_CODE_NOT_AUTHORIZED           0x01
+#define TCG_METHOD_STATUS_CODE_OBSOLETE                 0x02
+#define TCG_METHOD_STATUS_CODE_SP_BUSY                  0x03
+#define TCG_METHOD_STATUS_CODE_SP_FAILED                0x04
+#define TCG_METHOD_STATUS_CODE_SP_DISABLED              0x05
+#define TCG_METHOD_STATUS_CODE_SP_FROZEN                0x06
+#define TCG_METHOD_STATUS_CODE_NO_SESSIONS_AVAILABLE    0x07
+#define TCG_METHOD_STATUS_CODE_UNIQUENESS_CONFLICT      0x08
+#define TCG_METHOD_STATUS_CODE_INSUFFICIENT_SPACE       0x09
+#define TCG_METHOD_STATUS_CODE_INSUFFICIENT_ROWS        0x0A
+#define TCG_METHOD_STATUS_CODE_INVALID_PARAMETER        0x0C
+#define TCG_METHOD_STATUS_CODE_OBSOLETE2                0x0D
+#define TCG_METHOD_STATUS_CODE_OBSOLETE3                0x0E
+#define TCG_METHOD_STATUS_CODE_TPER_MALFUNCTION         0x0F
+#define TCG_METHOD_STATUS_CODE_TRANSACTION_FAILURE      0x10
+#define TCG_METHOD_STATUS_CODE_RESPONSE_OVERFLOW        0x11
+#define TCG_METHOD_STATUS_CODE_AUTHORITY_LOCKED_OUT     0x12
+#define TCG_METHOD_STATUS_CODE_FAIL                     0x3F
+
+
+// Feature Codes
+#define TCG_FEATURE_INVALID             (UINT16)0x0000
+#define TCG_FEATURE_TPER                (UINT16)0x0001
+#define TCG_FEATURE_LOCKING             (UINT16)0x0002
+#define TCG_FEATURE_GEOMETRY_REPORTING  (UINT16)0x0003
+#define TCG_FEATURE_SINGLE_USER_MODE    (UINT16)0x0201
+#define TCG_FEATURE_DATASTORE_TABLE     (UINT16)0x0202
+#define TCG_FEATURE_OPAL_SSC_V1_0_0     (UINT16)0x0200
+#define TCG_FEATURE_OPAL_SSC_V2_0_0     (UINT16)0x0203
+#define TCG_FEATURE_OPAL_SSC_LITE       (UINT16)0x0301
+#define TCG_FEATURE_PYRITE_SSC          (UINT16)0x0302
+#define TCG_FEATURE_BLOCK_SID           (UINT16)0x0402
+
+// ACE Expression values
+#define TCG_ACE_EXPRESSION_AND 0x0
+#define TCG_ACE_EXPRESSION_OR  0x1
+
+/****************************************************************************
+TRUSTED RECEIVE - supported security protocols list (SP_Specific = 0000h)
+ATA 8 Rev6a Table 68 7.57.6.2
+****************************************************************************/
+// Security Protocol IDs
+#define TCG_SECURITY_PROTOCOL_INFO                   0x00
+#define TCG_OPAL_SECURITY_PROTOCOL_1                 0x01
+#define TCG_OPAL_SECURITY_PROTOCOL_2                 0x02
+#define TCG_SECURITY_PROTOCOL_TCG3                   0x03
+#define TCG_SECURITY_PROTOCOL_TCG4                   0x04
+#define TCG_SECURITY_PROTOCOL_TCG5                   0x05
+#define TCG_SECURITY_PROTOCOL_TCG6                   0x06
+#define TCG_SECURITY_PROTOCOL_CBCS                   0x07
+#define TCG_SECURITY_PROTOCOL_TAPE_DATA              0x20
+#define TCG_SECURITY_PROTOCOL_DATA_ENCRYPT_CONFIG    0x21
+#define TCG_SECURITY_PROTOCOL_SA_CREATION_CAPS       0x40
+#define TCG_SECURITY_PROTOCOL_IKEV2_SCSI             0x41
+#define TCG_SECURITY_PROTOCOL_JEDEC_UFS              0xEC
+#define TCG_SECURITY_PROTOCOL_SDCARD_SECURITY        0xED
+#define TCG_SECURITY_PROTOCOL_IEEE_1667              0xEE
+#define TCG_SECURITY_PROTOCOL_ATA_DEVICE_SERVER_PASS 0xEF
+
+// Security Protocol Specific IDs
+#define TCG_SP_SPECIFIC_PROTOCOL_LIST               0x0000
+#define TCG_SP_SPECIFIC_PROTOCOL_LEVEL0_DISCOVERY   0x0001
+
+#define TCG_RESERVED_COMID 0x0000
+
+// Defined in TCG Storage Feature Set:Block SID Authentication spec,
+// ComId used for BlockSid command is hardcode 0x0005.
+#define TCG_BLOCKSID_COMID 0x0005
+
+#pragma pack(1)
+typedef struct {
+  UINT8   Reserved[6];
+  UINT16  ListLength_BE;  // 6 - 7
+  UINT8   List[504];      // 8...
+} TCG_SUPPORTED_SECURITY_PROTOCOLS;
+
+
+// Level 0 Discovery
+typedef struct {
+  UINT32 LengthBE;    // number of valid bytes in discovery response, not including length field
+  UINT16 VerMajorBE;
+  UINT16 VerMinorBE;
+  UINT8  Reserved[8];
+  UINT8  VendorUnique[32];
+} TCG_LEVEL0_DISCOVERY_HEADER;
+
+typedef struct _TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER {
+  UINT16 FeatureCode_BE;
+  UINT8  Reserved : 4;
+  UINT8  Version : 4;
+  UINT8  Length;     // length of feature dependent data in bytes
+} TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER;
+
+
+typedef struct {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT8                                LockingSupported : 1;
+  UINT8                                LockingEnabled : 1;   // means the locking security provider (SP) is enabled
+  UINT8                                Locked : 1;   // means at least 1 locking range is enabled
+  UINT8                                MediaEncryption : 1;
+  UINT8                                MbrEnabled : 1;
+  UINT8                                MbrDone : 1;
+  UINT8                                Reserved : 2;
+  UINT8                                Reserved515[11];
+} TCG_LOCKING_FEATURE_DESCRIPTOR;
+
+typedef struct {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT8                                SIDValueState : 1;
+  UINT8                                SIDBlockedState : 1;
+  UINT8                                Reserved4 : 6;
+  UINT8                                HardwareReset : 1;
+  UINT8                                Reserved5 : 7;
+  UINT8                                Reserved615[10];
+} TCG_BLOCK_SID_FEATURE_DESCRIPTOR;
+
+
+typedef struct {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT8                                SyncSupported : 1;
+  UINT8                                AsyncSupported : 1;
+  UINT8                                AckNakSupported : 1;
+  UINT8                                BufferMgmtSupported : 1;
+  UINT8                                StreamingSupported : 1;
+  UINT8                                Reserved4b5 : 1;
+  UINT8                                ComIdMgmtSupported : 1;
+  UINT8                                Reserved4b7 : 1;
+  UINT8                                Reserved515[11];
+} TCG_TPER_FEATURE_DESCRIPTOR;
+
+#pragma pack()
+
+// Special Purpose UIDs
+#define TCG_UID_NULL                            TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
+#define TCG_UID_THIS_SP                         TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01)
+#define TCG_UID_SMUID                           TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF)
+
+// Session Manager Method UIDS
+#define TCG_UID_SM_PROPERTIES                   TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x01)
+#define TCG_UID_SM_START_SESSION                TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x02)
+#define TCG_UID_SM_SYNC_SESSION                 TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03)
+#define TCG_UID_SM_START_TRUSTED_SESSION        TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x04)
+#define TCG_UID_SM_SYNC_TRUSTED_SESSION         TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x05)
+#define TCG_UID_SM_CLOSE_SESSION                TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x06)
+
+// MethodID UIDs
+#define TCG_UID_METHOD_DELETE_SP                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01)
+#define TCG_UID_METHOD_CREATE_TABLE             TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02)
+#define TCG_UID_METHOD_DELETE                   TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03)
+#define TCG_UID_METHOD_CREATE_ROW               TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04)
+#define TCG_UID_METHOD_DELETE_ROW               TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05)
+#define TCG_UID_METHOD_NEXT                     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08)
+#define TCG_UID_METHOD_GET_FREE_SPACE           TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09)
+#define TCG_UID_METHOD_GET_FREE_ROWS            TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0A)
+#define TCG_UID_METHOD_DELETE_METHOD            TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0B)
+#define TCG_UID_METHOD_GET_ACL                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0D)
+#define TCG_UID_METHOD_ADD_ACE                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E)
+#define TCG_UID_METHOD_REMOVE_ACE               TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0F)
+#define TCG_UID_METHOD_GEN_KEY                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10)
+#define TCG_UID_METHOD_GET_PACKAGE              TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12)
+#define TCG_UID_METHOD_SET_PACKAGE              TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x13)
+#define TCG_UID_METHOD_GET                      TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16)
+#define TCG_UID_METHOD_SET                      TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17)
+#define TCG_UID_METHOD_AUTHENTICATE             TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1C)
+#define TCG_UID_METHOD_ISSUE_SP                 TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x01)
+#define TCG_UID_METHOD_GET_CLOCK                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x01)
+#define TCG_UID_METHOD_RESET_CLOCK              TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x02)
+#define TCG_UID_METHOD_SET_CLOCK_HIGH           TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x03)
+#define TCG_UID_METHOD_SET_LAG_HIGH             TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x04)
+#define TCG_UID_METHOD_SET_CLOCK_LOW            TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x05)
+#define TCG_UID_METHOD_SET_LAG_LOW              TCG_TO_UID(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x06)
+#define TCG_UID_METHOD_INCREMENT_COUNTER        TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x07)
+#define TCG_UID_METHOD_RANDOM                   TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x01)
+#define TCG_UID_METHOD_SALT                     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x02)
+#define TCG_UID_METHOD_DECRYPT_INIT             TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x03)
+#define TCG_UID_METHOD_DECRYPT                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x04)
+#define TCG_UID_METHOD_DECRYPT_FINALIZE         TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x05)
+#define TCG_UID_METHOD_ENCRYPT_INIT             TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x06)
+#define TCG_UID_METHOD_ENCRYPT                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x07)
+#define TCG_UID_METHOD_ENCRYPT_FINALIZE         TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x08)
+#define TCG_UID_METHOD_HMAC_INIT                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x09)
+#define TCG_UID_METHOD_HMAC                     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0A)
+#define TCG_UID_METHOD_HMAC_FINALIZE            TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0B)
+#define TCG_UID_METHOD_HASH_INIT                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0C)
+#define TCG_UID_METHOD_HASH                     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0D)
+#define TCG_UID_METHOD_HASH_FINALIZE            TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0E)
+#define TCG_UID_METHOD_SIGN                     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0F)
+#define TCG_UID_METHOD_VERIFY                   TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x10)
+#define TCG_UID_METHOD_XOR                      TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x11)
+#define TCG_UID_METHOD_ADD_LOG                  TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0A, 0x01)
+#define TCG_UID_METHOD_CREATE_LOG               TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0A, 0x02)
+#define TCG_UID_METHOD_CLEAR_LOG                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0A, 0x03)
+#define TCG_UID_METHOD_FLUSH_LOG                TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0A, 0x04)
+
+#endif // TCG_H_
diff --git a/MdePkg/Include/IndustryStandard/TcgStorageOpal.h b/MdePkg/Include/IndustryStandard/TcgStorageOpal.h
new file mode 100644
index 000000000000..1f32b7ecca6b
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TcgStorageOpal.h
@@ -0,0 +1,181 @@
+/** @file
+  Opal Specification defined values and structures.
+
+Copyright (c) 2016, 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 _TCG_STORAGE_OPAL_H_
+#define _TCG_STORAGE_OPAL_H_
+
+#include <IndustryStandard/TcgStorageCore.h>
+
+#define OPAL_UID_ADMIN_SP                   TCG_TO_UID(0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x01)
+#define OPAL_UID_ADMIN_SP_C_PIN_MSID        TCG_TO_UID(0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x84, 0x02)
+#define OPAL_UID_ADMIN_SP_C_PIN_SID         TCG_TO_UID(0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01)
+#define OPAL_UID_LOCKING_SP                 TCG_TO_UID(0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x02)
+
+// ADMIN_SP
+// Authorities
+#define OPAL_ADMIN_SP_ANYBODY_AUTHORITY     TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01)
+#define OPAL_ADMIN_SP_ADMINS_AUTHORITY      TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02)
+#define OPAL_ADMIN_SP_MAKERS_AUTHORITY      TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03)
+#define OPAL_ADMIN_SP_SID_AUTHORITY         TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06)
+#define OPAL_ADMIN_SP_ADMIN1_AUTHORITY      TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x02, 0x01)
+#define OPAL_ADMIN_SP_PSID_AUTHORITY        TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0xFF, 0x01)
+
+#define OPAL_ADMIN_SP_ACTIVATE_METHOD       TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x03)
+#define OPAL_ADMIN_SP_REVERT_METHOD         TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x02)
+
+
+// LOCKING SP
+// Authorities
+#define OPAL_LOCKING_SP_ANYBODY_AUTHORITY   TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01)
+#define OPAL_LOCKING_SP_ADMINS_AUTHORITY    TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02)
+#define OPAL_LOCKING_SP_ADMIN1_AUTHORITY    TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x01)
+#define OPAL_LOCKING_SP_USERS_AUTHORITY     TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x00)
+#define OPAL_LOCKING_SP_USER1_AUTHORITY     TCG_TO_UID(0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x01)
+
+#define OPAL_LOCKING_SP_REVERTSP_METHOD     TCG_TO_UID(0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11)
+
+// C_PIN Table Rows
+#define OPAL_LOCKING_SP_C_PIN_ADMIN1        TCG_TO_UID( 0x00, 0x00, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x01 )
+#define OPAL_LOCKING_SP_C_PIN_USER1         TCG_TO_UID( 0x00, 0x00, 0x00, 0x0B, 0x00, 0x03, 0x00, 0x01 )
+
+// Locking Table
+#define OPAL_LOCKING_SP_LOCKING_GLOBALRANGE TCG_TO_UID( 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 )
+#define OPAL_LOCKING_SP_LOCKING_RANGE1      TCG_TO_UID( 0x00, 0x00, 0x08, 0x02, 0x00, 0x03, 0x00, 0x01 )
+
+
+// LOCKING SP ACE Table Preconfiguration
+#define OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_GET_ALL      TCG_TO_UID( 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xD0, 0x00 )
+#define OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_SET_RDLOCKED TCG_TO_UID( 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE0, 0x00 )
+#define OPAL_LOCKING_SP_ACE_LOCKING_GLOBALRANGE_SET_WRLOCKED TCG_TO_UID( 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE8, 0x00 )
+
+#define OPAL_LOCKING_SP_ACE_K_AES_256_GLOBALRANGE_GENKEY TCG_TO_UID( 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xB8, 0x00 )
+#define OPAL_LOCKING_SP_ACE_K_AES_128_GLOBALRANGE_GENKEY TCG_TO_UID( 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xB0, 0x00 )
+
+
+// LOCKING SP LockingInfo Table Preconfiguration
+#define OPAL_LOCKING_SP_LOCKING_INFO TCG_TO_UID( 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01 )
+
+#define OPAL_LOCKING_SP_LOCKINGINFO_ALIGNMENTREQUIRED_COL       0x7
+#define OPAL_LOCKING_SP_LOCKINGINFO_LOGICALBLOCKSIZE_COL        0x8
+#define OPAL_LOCKING_SP_LOCKINGINFO_ALIGNMENTGRANULARITY_COL    0x9
+#define OPAL_LOCKING_SP_LOCKINGINFO_LOWESTALIGNEDLBA_COL        0xA
+
+// K_AES_256 Table Preconfiguration
+#define OPAL_LOCKING_SP_K_AES_256_GLOBALRANGE_KEY TCG_TO_UID( 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x01 )
+
+// K_AES_128 Table Preconfiguration
+#define OPAL_LOCKING_SP_K_AES_128_GLOBALRANGE_KEY TCG_TO_UID( 0x00, 0x00, 0x08, 0x05, 0x00, 0x00, 0x00, 0x01 )
+
+// Minimum Properties that an Opal Compliant SD Shall support
+#define OPAL_MIN_MAX_COM_PACKET_SIZE            2048
+#define OPAL_MIN_MAX_REPONSE_COM_PACKET_SIZE    2048
+#define OPAL_MIN_MAX_PACKET_SIZE                2028
+#define OPAL_MIN_MAX_IND_TOKEN_SIZE             1992
+#define OPAL_MIN_MAX_PACKETS                    1
+#define OPAL_MIN_MAX_SUBPACKETS                 1
+#define OPAL_MIN_MAX_METHODS                    1
+#define OPAL_MIN_MAX_SESSIONS                   1
+#define OPAL_MIN_MAX_AUTHENTICATIONS            2
+#define OPAL_MIN_MAX_TRANSACTION_LIMIT          1
+
+#define OPAL_ADMIN_SP_PIN_COL  3
+#define OPAL_LOCKING_SP_C_PIN_TRYLIMIT_COL 5
+#define OPAL_RANDOM_METHOD_MAX_COUNT_SIZE 32
+
+#pragma pack(1)
+
+typedef struct _OPAL_GEOMETRY_REPORTING_FEATURE {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT8                                Reserved[8];
+  UINT32                               LogicalBlockSizeBE;
+  UINT64                               AlignmentGranularityBE;
+  UINT64                               LowestAlignedLBABE;
+} OPAL_GEOMETRY_REPORTING_FEATURE;
+
+typedef struct _OPAL_SINGLE_USER_MODE_FEATURE  {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT32                               NumLockingObjectsSupportedBE;
+  UINT8                                Any : 1;
+  UINT8                                All : 1;
+  UINT8                                Policy : 1;
+  UINT8                                Reserved : 5;
+  UINT8                                Reserved2[7];
+} OPAL_SINGLE_USER_MODE_FEATURE;
+
+typedef struct _OPAL_DATASTORE_TABLE_FEATURE {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT16                               Reserved;
+  UINT16                               MaxNumTablesBE;
+  UINT32                               MaxTotalSizeBE;
+  UINT32                               SizeAlignmentBE;
+} OPAL_DATASTORE_TABLE_FEATURE;
+
+typedef struct _OPAL_SSCV1_FEATURE_DESCRIPTOR {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT16                               BaseComdIdBE;
+  UINT16                               NumComIdsBE;
+  UINT8                                RangeCrossing : 1;
+  UINT8                                Reserved : 7;
+  UINT8                                Future[11];
+} OPAL_SSCV1_FEATURE_DESCRIPTOR;
+
+typedef struct _OPAL_SSCV2_FEATURE_DESCRIPTOR {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT16                               BaseComdIdBE;
+  UINT16                               NumComIdsBE;
+  UINT8                                Reserved;
+  UINT16                               NumLockingSpAdminAuthoritiesSupportedBE;
+  UINT16                               NumLockingSpUserAuthoritiesSupportedBE;
+  UINT8                                InitialCPINSIDPIN;
+  UINT8                                CPINSIDPINRevertBehavior;
+  UINT8                                Future[5];
+} OPAL_SSCV2_FEATURE_DESCRIPTOR;
+
+typedef struct _OPAL_SSCLITE_FEATURE_DESCRIPTOR {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT16                               BaseComdIdBE;
+  UINT16                               NumComIdsBE;
+  UINT8                                Reserved[5];
+  UINT8                                InitialCPINSIDPIN;
+  UINT8                                CPINSIDPINRevertBehavior;
+  UINT8                                Future[5];
+} OPAL_SSCLITE_FEATURE_DESCRIPTOR;
+
+typedef struct _PYRITE_SSC_FEATURE_DESCRIPTOR {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER Header;
+  UINT16                               BaseComdIdBE;
+  UINT16                               NumComIdsBE;
+  UINT8                                Reserved[5];
+  UINT8                                InitialCPINSIDPIN;
+  UINT8                                CPINSIDPINRevertBehavior;
+  UINT8                                Future[5];
+} PYRITE_SSC_FEATURE_DESCRIPTOR;
+
+typedef union {
+  TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER     CommonHeader;
+  TCG_TPER_FEATURE_DESCRIPTOR              Tper;
+  TCG_LOCKING_FEATURE_DESCRIPTOR           Locking;
+  OPAL_GEOMETRY_REPORTING_FEATURE          Geometry;
+  OPAL_SINGLE_USER_MODE_FEATURE            SingleUser;
+  OPAL_DATASTORE_TABLE_FEATURE             DataStore;
+  OPAL_SSCV1_FEATURE_DESCRIPTOR            OpalSscV1;
+  OPAL_SSCV2_FEATURE_DESCRIPTOR            OpalSscV2;
+  OPAL_SSCLITE_FEATURE_DESCRIPTOR          OpalSscLite;
+  PYRITE_SSC_FEATURE_DESCRIPTOR            PyriteSsc;
+  TCG_BLOCK_SID_FEATURE_DESCRIPTOR         BlockSid;
+} OPAL_LEVEL0_FEATURE_DESCRIPTOR;
+
+#pragma pack()
+
+#endif // _OPAL_H_
diff --git a/MdePkg/Include/IndustryStandard/TcpaAcpi.h b/MdePkg/Include/IndustryStandard/TcpaAcpi.h
new file mode 100644
index 000000000000..fde31ab8b23a
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TcpaAcpi.h
@@ -0,0 +1,58 @@
+/** @file
+  TCPA ACPI table definition.
+
+Copyright (c) 2013, 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 _TCPA_ACPI_H_
+#define _TCPA_ACPI_H_
+
+#include <IndustryStandard/Acpi.h>
+
+#pragma pack (1)
+
+typedef struct _EFI_TCG_CLIENT_ACPI_TABLE {
+  EFI_ACPI_DESCRIPTION_HEADER       Header;
+  UINT16                            PlatformClass;
+  UINT32                            Laml;
+  UINT64                            Lasa;
+} EFI_TCG_CLIENT_ACPI_TABLE;
+
+typedef struct _EFI_TCG_SERVER_ACPI_TABLE {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT16                                  PlatformClass;
+  UINT16                                  Reserved0;
+  UINT64                                  Laml;
+  UINT64                                  Lasa;
+  UINT16                                  SpecRev;
+  UINT8                                   DeviceFlags;
+  UINT8                                   InterruptFlags;
+  UINT8                                   Gpe;
+  UINT8                                   Reserved1[3];
+  UINT32                                  GlobalSysInt;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  BaseAddress;
+  UINT32                                  Reserved2;
+  EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE  ConfigAddress;
+  UINT8                                   PciSegNum;
+  UINT8                                   PciBusNum;
+  UINT8                                   PciDevNum;
+  UINT8                                   PciFuncNum;
+} EFI_TCG_SERVER_ACPI_TABLE;
+
+//
+// TCG Platform Type based on TCG ACPI Specification Version 1.00
+//
+#define TCG_PLATFORM_TYPE_CLIENT   0
+#define TCG_PLATFORM_TYPE_SERVER   1
+
+#pragma pack ()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Tls1.h b/MdePkg/Include/IndustryStandard/Tls1.h
new file mode 100644
index 000000000000..019ff617de22
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Tls1.h
@@ -0,0 +1,93 @@
+/** @file
+  Transport Layer Security  -- TLS 1.0/1.1/1.2 Standard definitions, from RFC 2246/4346/5246    
+
+  This file contains common TLS 1.0/1.1/1.2 definitions from RFC 2246/4346/5246 
+
+  Copyright (c) 2016 - 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 __TLS_1_H__
+#define __TLS_1_H__
+
+#pragma pack(1)
+
+///
+/// TLS Cipher Suite, refers to A.5 of rfc-2246, rfc-4346 and rfc-5246.
+///
+#define TLS_RSA_WITH_NULL_MD5                    {0x00, 0x01}
+#define TLS_RSA_WITH_NULL_SHA                    {0x00, 0x02}
+#define TLS_RSA_WITH_RC4_128_MD5                 {0x00, 0x04}
+#define TLS_RSA_WITH_RC4_128_SHA                 {0x00, 0x05}
+#define TLS_RSA_WITH_IDEA_CBC_SHA                {0x00, 0x07}
+#define TLS_RSA_WITH_DES_CBC_SHA                 {0x00, 0x09}
+#define TLS_RSA_WITH_3DES_EDE_CBC_SHA            {0x00, 0x0A}
+#define TLS_DH_DSS_WITH_DES_CBC_SHA              {0x00, 0x0C}
+#define TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA         {0x00, 0x0D}
+#define TLS_DH_RSA_WITH_DES_CBC_SHA              {0x00, 0x0F}
+#define TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA         {0x00, 0x10}
+#define TLS_DHE_DSS_WITH_DES_CBC_SHA             {0x00, 0x12}
+#define TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA        {0x00, 0x13}
+#define TLS_DHE_RSA_WITH_DES_CBC_SHA             {0x00, 0x15}
+#define TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA        {0x00, 0x16}
+#define TLS_RSA_WITH_AES_128_CBC_SHA             {0x00, 0x2F}
+#define TLS_DH_DSS_WITH_AES_128_CBC_SHA          {0x00, 0x30}
+#define TLS_DH_RSA_WITH_AES_128_CBC_SHA          {0x00, 0x31}
+#define TLS_DHE_DSS_WITH_AES_128_CBC_SHA         {0x00, 0x32}
+#define TLS_DHE_RSA_WITH_AES_128_CBC_SHA         {0x00, 0x33}
+#define TLS_RSA_WITH_AES_256_CBC_SHA             {0x00, 0x35}
+#define TLS_DH_DSS_WITH_AES_256_CBC_SHA          {0x00, 0x36}
+#define TLS_DH_RSA_WITH_AES_256_CBC_SHA          {0x00, 0x37}
+#define TLS_DHE_DSS_WITH_AES_256_CBC_SHA         {0x00, 0x38}
+#define TLS_DHE_RSA_WITH_AES_256_CBC_SHA         {0x00, 0x39}
+#define TLS_RSA_WITH_NULL_SHA256                 {0x00, 0x3B}
+#define TLS_RSA_WITH_AES_128_CBC_SHA256          {0x00, 0x3C}
+#define TLS_RSA_WITH_AES_256_CBC_SHA256          {0x00, 0x3D}
+#define TLS_DH_DSS_WITH_AES_128_CBC_SHA256       {0x00, 0x3E}
+#define TLS_DH_RSA_WITH_AES_128_CBC_SHA256       {0x00, 0x3F}
+#define TLS_DHE_DSS_WITH_AES_128_CBC_SHA256      {0x00, 0x40}
+#define TLS_DHE_RSA_WITH_AES_128_CBC_SHA256      {0x00, 0x67}
+#define TLS_DH_DSS_WITH_AES_256_CBC_SHA256       {0x00, 0x68}
+#define TLS_DH_RSA_WITH_AES_256_CBC_SHA256       {0x00, 0x69}
+#define TLS_DHE_DSS_WITH_AES_256_CBC_SHA256      {0x00, 0x6A}
+#define TLS_DHE_RSA_WITH_AES_256_CBC_SHA256      {0x00, 0x6B}
+
+///
+/// TLS Version, refers to A.1 of rfc-2246, rfc-4346 and rfc-5246.
+///
+#define TLS10_PROTOCOL_VERSION_MAJOR  0x03
+#define TLS10_PROTOCOL_VERSION_MINOR  0x01
+#define TLS11_PROTOCOL_VERSION_MAJOR  0x03
+#define TLS11_PROTOCOL_VERSION_MINOR  0x02
+#define TLS12_PROTOCOL_VERSION_MAJOR  0x03
+#define TLS12_PROTOCOL_VERSION_MINOR  0x03
+
+///
+/// TLS Content Type, refers to A.1 of rfc-2246, rfc-4346 and rfc-5246.
+///
+typedef enum {
+  TlsContentTypeChangeCipherSpec = 20,
+  TlsContentTypeAlert            = 21,
+  TlsContentTypeHandshake        = 22,
+  TlsContentTypeApplicationData  = 23,
+} TLS_CONTENT_TYPE;
+
+///
+/// TLS Record Header, refers to A.1 of rfc-2246, rfc-4346 and rfc-5246.
+///
+typedef struct {   
+  UINT8                   ContentType;
+  EFI_TLS_VERSION         Version;
+  UINT16                  Length;
+} TLS_RECORD_HEADER;
+
+#pragma pack()
+
+#endif
+
diff --git a/MdePkg/Include/IndustryStandard/Tpm12.h b/MdePkg/Include/IndustryStandard/Tpm12.h
new file mode 100644
index 000000000000..0736c02a8004
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Tpm12.h
@@ -0,0 +1,2173 @@
+/** @file   
+  TPM Specification data structures (TCG TPM Specification Version 1.2 Revision 103)
+  See http://trustedcomputinggroup.org for latest specification updates
+
+  Copyright (c) 2006 - 2010, 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 _TPM12_H_
+#define _TPM12_H_
+
+///
+/// The start of TPM return codes
+///
+#define TPM_BASE                    0
+
+//
+// All structures MUST be packed on a byte boundary.
+//
+
+#pragma pack (1)
+
+//
+// Part 2, section 2.2.3: Helper redefinitions
+//
+///
+/// Indicates the conditions where it is required that authorization be presented
+///
+typedef UINT8                       TPM_AUTH_DATA_USAGE;
+///
+/// The information as to what the payload is in an encrypted structure
+///
+typedef UINT8                       TPM_PAYLOAD_TYPE;
+///
+/// The version info breakdown
+///
+typedef UINT8                       TPM_VERSION_BYTE;
+///
+/// The state of the dictionary attack mitigation logic
+///
+typedef UINT8                       TPM_DA_STATE;
+///
+/// The request or response authorization type
+///
+typedef UINT16                      TPM_TAG;
+///
+/// The protocol in use
+///
+typedef UINT16                      TPM_PROTOCOL_ID;
+///
+/// Indicates the start state
+///
+typedef UINT16                      TPM_STARTUP_TYPE;
+///
+/// The definition of the encryption scheme
+///
+typedef UINT16                      TPM_ENC_SCHEME;
+///
+/// The definition of the signature scheme
+///
+typedef UINT16                      TPM_SIG_SCHEME;
+///
+/// The definition of the migration scheme
+///
+typedef UINT16                      TPM_MIGRATE_SCHEME;
+///
+/// Sets the state of the physical presence mechanism
+///
+typedef UINT16                      TPM_PHYSICAL_PRESENCE;
+///
+/// Indicates the types of entity that are supported by the TPM
+///
+typedef UINT16                      TPM_ENTITY_TYPE;
+///
+/// Indicates the permitted usage of the key
+///
+typedef UINT16                      TPM_KEY_USAGE;
+///
+/// The type of asymmetric encrypted structure in use by the endorsement key
+///
+typedef UINT16                      TPM_EK_TYPE;
+///
+/// The tag for the structure
+///
+typedef UINT16                      TPM_STRUCTURE_TAG;
+///
+/// The platform specific spec to which the information relates to
+///
+typedef UINT16                      TPM_PLATFORM_SPECIFIC;
+///
+/// The command ordinal
+///
+typedef UINT32                      TPM_COMMAND_CODE;
+///
+/// Identifies a TPM capability area
+///
+typedef UINT32                      TPM_CAPABILITY_AREA;
+///
+/// Indicates information regarding a key
+///
+typedef UINT32                      TPM_KEY_FLAGS;
+///
+/// Indicates the type of algorithm
+///
+typedef UINT32                      TPM_ALGORITHM_ID;
+///
+/// The locality modifier
+///
+typedef UINT32                      TPM_MODIFIER_INDICATOR;
+///
+/// The actual number of a counter
+///
+typedef UINT32                      TPM_ACTUAL_COUNT;
+///
+/// Attributes that define what options are in use for a transport session
+///
+typedef UINT32                      TPM_TRANSPORT_ATTRIBUTES;
+///
+/// Handle to an authorization session
+///
+typedef UINT32                      TPM_AUTHHANDLE;
+///
+/// Index to a DIR register
+///
+typedef UINT32                      TPM_DIRINDEX;
+///
+/// The area where a key is held assigned by the TPM
+///
+typedef UINT32                      TPM_KEY_HANDLE;
+///
+/// Index to a PCR register
+///
+typedef UINT32                      TPM_PCRINDEX;
+///
+/// The return code from a function
+///
+typedef UINT32                      TPM_RESULT;
+///
+/// The types of resources that a TPM may have using internal resources
+///
+typedef UINT32                      TPM_RESOURCE_TYPE;
+///
+/// Allows for controlling of the key when loaded and how to handle TPM_Startup issues
+///
+typedef UINT32                      TPM_KEY_CONTROL;
+///
+/// The index into the NV storage area
+///
+typedef UINT32                      TPM_NV_INDEX;
+///
+/// The family ID. Family IDs are automatically assigned a sequence number by the TPM. 
+/// A trusted process can set the FamilyID value in an individual row to NULL, which 
+/// invalidates that row. The family ID resets to NULL on each change of TPM Owner.
+///
+typedef UINT32                      TPM_FAMILY_ID;
+///
+/// IA value used as a label for the most recent verification of this family. Set to zero when not in use.
+///
+typedef UINT32                      TPM_FAMILY_VERIFICATION;
+///
+/// How the TPM handles var
+///
+typedef UINT32                      TPM_STARTUP_EFFECTS;
+///
+/// The mode of a symmetric encryption
+///
+typedef UINT32                      TPM_SYM_MODE;
+///
+/// The family flags
+///
+typedef UINT32                      TPM_FAMILY_FLAGS;
+///
+/// The index value for the delegate NV table
+///
+typedef UINT32                      TPM_DELEGATE_INDEX;
+///
+/// The restrictions placed on delegation of CMK commands
+///
+typedef UINT32                      TPM_CMK_DELEGATE;
+///
+/// The ID value of a monotonic counter
+///
+typedef UINT32                      TPM_COUNT_ID;
+///
+/// A command to execute
+///
+typedef UINT32                      TPM_REDIT_COMMAND;
+///
+/// A transport session handle
+///
+typedef UINT32                      TPM_TRANSHANDLE;
+///
+/// A generic handle could be key, transport etc
+///
+typedef UINT32                      TPM_HANDLE;
+///
+/// What operation is happening
+///
+typedef UINT32                      TPM_FAMILY_OPERATION;
+
+//
+// Part 2, section 2.2.4: Vendor specific
+// The following defines allow for the quick specification of a
+// vendor specific item.
+//
+#define TPM_Vendor_Specific32       ((UINT32) 0x00000400)
+#define TPM_Vendor_Specific8        ((UINT8) 0x80)
+
+//
+// Part 2, section 3.1: TPM_STRUCTURE_TAG
+//
+#define TPM_TAG_CONTEXTBLOB         ((TPM_STRUCTURE_TAG) 0x0001)
+#define TPM_TAG_CONTEXT_SENSITIVE   ((TPM_STRUCTURE_TAG) 0x0002)
+#define TPM_TAG_CONTEXTPOINTER      ((TPM_STRUCTURE_TAG) 0x0003)
+#define TPM_TAG_CONTEXTLIST         ((TPM_STRUCTURE_TAG) 0x0004)
+#define TPM_TAG_SIGNINFO            ((TPM_STRUCTURE_TAG) 0x0005)
+#define TPM_TAG_PCR_INFO_LONG       ((TPM_STRUCTURE_TAG) 0x0006)
+#define TPM_TAG_PERSISTENT_FLAGS    ((TPM_STRUCTURE_TAG) 0x0007)
+#define TPM_TAG_VOLATILE_FLAGS      ((TPM_STRUCTURE_TAG) 0x0008)
+#define TPM_TAG_PERSISTENT_DATA     ((TPM_STRUCTURE_TAG) 0x0009)
+#define TPM_TAG_VOLATILE_DATA       ((TPM_STRUCTURE_TAG) 0x000A)
+#define TPM_TAG_SV_DATA             ((TPM_STRUCTURE_TAG) 0x000B)
+#define TPM_TAG_EK_BLOB             ((TPM_STRUCTURE_TAG) 0x000C)
+#define TPM_TAG_EK_BLOB_AUTH        ((TPM_STRUCTURE_TAG) 0x000D)
+#define TPM_TAG_COUNTER_VALUE       ((TPM_STRUCTURE_TAG) 0x000E)
+#define TPM_TAG_TRANSPORT_INTERNAL  ((TPM_STRUCTURE_TAG) 0x000F)
+#define TPM_TAG_TRANSPORT_LOG_IN    ((TPM_STRUCTURE_TAG) 0x0010)
+#define TPM_TAG_TRANSPORT_LOG_OUT   ((TPM_STRUCTURE_TAG) 0x0011)
+#define TPM_TAG_AUDIT_EVENT_IN      ((TPM_STRUCTURE_TAG) 0x0012)
+#define TPM_TAG_AUDIT_EVENT_OUT     ((TPM_STRUCTURE_TAG) 0x0013)
+#define TPM_TAG_CURRENT_TICKS       ((TPM_STRUCTURE_TAG) 0x0014)
+#define TPM_TAG_KEY                 ((TPM_STRUCTURE_TAG) 0x0015)
+#define TPM_TAG_STORED_DATA12       ((TPM_STRUCTURE_TAG) 0x0016)
+#define TPM_TAG_NV_ATTRIBUTES       ((TPM_STRUCTURE_TAG) 0x0017)
+#define TPM_TAG_NV_DATA_PUBLIC      ((TPM_STRUCTURE_TAG) 0x0018)
+#define TPM_TAG_NV_DATA_SENSITIVE   ((TPM_STRUCTURE_TAG) 0x0019)
+#define TPM_TAG_DELEGATIONS         ((TPM_STRUCTURE_TAG) 0x001A)
+#define TPM_TAG_DELEGATE_PUBLIC     ((TPM_STRUCTURE_TAG) 0x001B)
+#define TPM_TAG_DELEGATE_TABLE_ROW  ((TPM_STRUCTURE_TAG) 0x001C)
+#define TPM_TAG_TRANSPORT_AUTH      ((TPM_STRUCTURE_TAG) 0x001D)
+#define TPM_TAG_TRANSPORT_PUBLIC    ((TPM_STRUCTURE_TAG) 0x001E)
+#define TPM_TAG_PERMANENT_FLAGS     ((TPM_STRUCTURE_TAG) 0x001F)
+#define TPM_TAG_STCLEAR_FLAGS       ((TPM_STRUCTURE_TAG) 0x0020)
+#define TPM_TAG_STANY_FLAGS         ((TPM_STRUCTURE_TAG) 0x0021)
+#define TPM_TAG_PERMANENT_DATA      ((TPM_STRUCTURE_TAG) 0x0022)
+#define TPM_TAG_STCLEAR_DATA        ((TPM_STRUCTURE_TAG) 0x0023)
+#define TPM_TAG_STANY_DATA          ((TPM_STRUCTURE_TAG) 0x0024)
+#define TPM_TAG_FAMILY_TABLE_ENTRY  ((TPM_STRUCTURE_TAG) 0x0025)
+#define TPM_TAG_DELEGATE_SENSITIVE  ((TPM_STRUCTURE_TAG) 0x0026)
+#define TPM_TAG_DELG_KEY_BLOB       ((TPM_STRUCTURE_TAG) 0x0027)
+#define TPM_TAG_KEY12               ((TPM_STRUCTURE_TAG) 0x0028)
+#define TPM_TAG_CERTIFY_INFO2       ((TPM_STRUCTURE_TAG) 0x0029)
+#define TPM_TAG_DELEGATE_OWNER_BLOB ((TPM_STRUCTURE_TAG) 0x002A)
+#define TPM_TAG_EK_BLOB_ACTIVATE    ((TPM_STRUCTURE_TAG) 0x002B)
+#define TPM_TAG_DAA_BLOB            ((TPM_STRUCTURE_TAG) 0x002C)
+#define TPM_TAG_DAA_CONTEXT         ((TPM_STRUCTURE_TAG) 0x002D)
+#define TPM_TAG_DAA_ENFORCE         ((TPM_STRUCTURE_TAG) 0x002E)
+#define TPM_TAG_DAA_ISSUER          ((TPM_STRUCTURE_TAG) 0x002F)
+#define TPM_TAG_CAP_VERSION_INFO    ((TPM_STRUCTURE_TAG) 0x0030)
+#define TPM_TAG_DAA_SENSITIVE       ((TPM_STRUCTURE_TAG) 0x0031)
+#define TPM_TAG_DAA_TPM             ((TPM_STRUCTURE_TAG) 0x0032)
+#define TPM_TAG_CMK_MIGAUTH         ((TPM_STRUCTURE_TAG) 0x0033)
+#define TPM_TAG_CMK_SIGTICKET       ((TPM_STRUCTURE_TAG) 0x0034)
+#define TPM_TAG_CMK_MA_APPROVAL     ((TPM_STRUCTURE_TAG) 0x0035)
+#define TPM_TAG_QUOTE_INFO2         ((TPM_STRUCTURE_TAG) 0x0036)
+#define TPM_TAG_DA_INFO             ((TPM_STRUCTURE_TAG) 0x0037)
+#define TPM_TAG_DA_LIMITED          ((TPM_STRUCTURE_TAG) 0x0038)
+#define TPM_TAG_DA_ACTION_TYPE      ((TPM_STRUCTURE_TAG) 0x0039)
+
+//
+// Part 2, section 4: TPM Types
+//
+
+//
+// Part 2, section 4.1: TPM_RESOURCE_TYPE
+//
+#define TPM_RT_KEY                  ((TPM_RESOURCE_TYPE) 0x00000001) ///< The handle is a key handle and is the result of a LoadKey type operation
+#define TPM_RT_AUTH                 ((TPM_RESOURCE_TYPE) 0x00000002) ///< The handle is an authorization handle. Auth handles come from TPM_OIAP, TPM_OSAP and TPM_DSAP
+#define TPM_RT_HASH                 ((TPM_RESOURCE_TYPE) 0x00000003) ///< Reserved for hashes
+#define TPM_RT_TRANS                ((TPM_RESOURCE_TYPE) 0x00000004) ///< The handle is for a transport session. Transport handles come from TPM_EstablishTransport
+#define TPM_RT_CONTEXT              ((TPM_RESOURCE_TYPE) 0x00000005) ///< Resource wrapped and held outside the TPM using the context save/restore commands
+#define TPM_RT_COUNTER              ((TPM_RESOURCE_TYPE) 0x00000006) ///< Reserved for counters
+#define TPM_RT_DELEGATE             ((TPM_RESOURCE_TYPE) 0x00000007) ///< The handle is for a delegate row. These are the internal rows held in NV storage by the TPM
+#define TPM_RT_DAA_TPM              ((TPM_RESOURCE_TYPE) 0x00000008) ///< The value is a DAA TPM specific blob
+#define TPM_RT_DAA_V0               ((TPM_RESOURCE_TYPE) 0x00000009) ///< The value is a DAA V0 parameter
+#define TPM_RT_DAA_V1               ((TPM_RESOURCE_TYPE) 0x0000000A) ///< The value is a DAA V1 parameter
+
+//
+// Part 2, section 4.2: TPM_PAYLOAD_TYPE
+//
+#define TPM_PT_ASYM                 ((TPM_PAYLOAD_TYPE) 0x01) ///< The entity is an asymmetric key
+#define TPM_PT_BIND                 ((TPM_PAYLOAD_TYPE) 0x02) ///< The entity is bound data
+#define TPM_PT_MIGRATE              ((TPM_PAYLOAD_TYPE) 0x03) ///< The entity is a migration blob
+#define TPM_PT_MAINT                ((TPM_PAYLOAD_TYPE) 0x04) ///< The entity is a maintenance blob
+#define TPM_PT_SEAL                 ((TPM_PAYLOAD_TYPE) 0x05) ///< The entity is sealed data
+#define TPM_PT_MIGRATE_RESTRICTED   ((TPM_PAYLOAD_TYPE) 0x06) ///< The entity is a restricted-migration asymmetric key
+#define TPM_PT_MIGRATE_EXTERNAL     ((TPM_PAYLOAD_TYPE) 0x07) ///< The entity is a external migratable key
+#define TPM_PT_CMK_MIGRATE          ((TPM_PAYLOAD_TYPE) 0x08) ///< The entity is a CMK migratable blob
+#define TPM_PT_VENDOR_SPECIFIC      ((TPM_PAYLOAD_TYPE) 0x80) ///< 0x80 - 0xFF Vendor specific payloads
+
+//
+// Part 2, section 4.3: TPM_ENTITY_TYPE
+//
+#define TPM_ET_KEYHANDLE            ((UINT16) 0x0001) ///< The entity is a keyHandle or key
+#define TPM_ET_OWNER                ((UINT16) 0x0002) ///< The entity is the TPM Owner
+#define TPM_ET_DATA                 ((UINT16) 0x0003) ///< The entity is some data
+#define TPM_ET_SRK                  ((UINT16) 0x0004) ///< The entity is the SRK
+#define TPM_ET_KEY                  ((UINT16) 0x0005) ///< The entity is a key or keyHandle
+#define TPM_ET_REVOKE               ((UINT16) 0x0006) ///< The entity is the RevokeTrust value
+#define TPM_ET_DEL_OWNER_BLOB       ((UINT16) 0x0007) ///< The entity is a delegate owner blob
+#define TPM_ET_DEL_ROW              ((UINT16) 0x0008) ///< The entity is a delegate row
+#define TPM_ET_DEL_KEY_BLOB         ((UINT16) 0x0009) ///< The entity is a delegate key blob
+#define TPM_ET_COUNTER              ((UINT16) 0x000A) ///< The entity is a counter
+#define TPM_ET_NV                   ((UINT16) 0x000B) ///< The entity is a NV index
+#define TPM_ET_OPERATOR             ((UINT16) 0x000C) ///< The entity is the operator
+#define TPM_ET_RESERVED_HANDLE      ((UINT16) 0x0040) ///< Reserved. This value avoids collisions with the handle MSB setting.
+//
+// TPM_ENTITY_TYPE MSB Values: The MSB is used to indicate the ADIP encryption sheme when applicable
+//
+#define TPM_ET_XOR                  ((UINT16) 0x0000) ///< ADIP encryption scheme: XOR
+#define TPM_ET_AES128               ((UINT16) 0x0006) ///< ADIP encryption scheme: AES 128 bits
+
+//
+// Part 2, section 4.4.1: Reserved Key Handles
+//
+#define TPM_KH_SRK                  ((TPM_KEY_HANDLE) 0x40000000) ///< The handle points to the SRK
+#define TPM_KH_OWNER                ((TPM_KEY_HANDLE) 0x40000001) ///< The handle points to the TPM Owner
+#define TPM_KH_REVOKE               ((TPM_KEY_HANDLE) 0x40000002) ///< The handle points to the RevokeTrust value
+#define TPM_KH_TRANSPORT            ((TPM_KEY_HANDLE) 0x40000003) ///< The handle points to the EstablishTransport static authorization
+#define TPM_KH_OPERATOR             ((TPM_KEY_HANDLE) 0x40000004) ///< The handle points to the Operator auth
+#define TPM_KH_ADMIN                ((TPM_KEY_HANDLE) 0x40000005) ///< The handle points to the delegation administration auth
+#define TPM_KH_EK                   ((TPM_KEY_HANDLE) 0x40000006) ///< The handle points to the PUBEK, only usable with TPM_OwnerReadInternalPub
+
+//
+// Part 2, section 4.5: TPM_STARTUP_TYPE
+//
+#define TPM_ST_CLEAR                ((TPM_STARTUP_TYPE) 0x0001) ///< The TPM is starting up from a clean state
+#define TPM_ST_STATE                ((TPM_STARTUP_TYPE) 0x0002) ///< The TPM is starting up from a saved state
+#define TPM_ST_DEACTIVATED          ((TPM_STARTUP_TYPE) 0x0003) ///< The TPM is to startup and set the deactivated flag to TRUE
+
+//
+// Part 2, section 4.6: TPM_STATUP_EFFECTS
+// The table makeup is still an open issue.
+//
+
+//
+// Part 2, section 4.7: TPM_PROTOCOL_ID
+//
+#define TPM_PID_OIAP                ((TPM_PROTOCOL_ID) 0x0001) ///< The OIAP protocol.
+#define TPM_PID_OSAP                ((TPM_PROTOCOL_ID) 0x0002) ///< The OSAP protocol.
+#define TPM_PID_ADIP                ((TPM_PROTOCOL_ID) 0x0003) ///< The ADIP protocol.
+#define TPM_PID_ADCP                ((TPM_PROTOCOL_ID) 0x0004) ///< The ADCP protocol.
+#define TPM_PID_OWNER               ((TPM_PROTOCOL_ID) 0x0005) ///< The protocol for taking ownership of a TPM.
+#define TPM_PID_DSAP                ((TPM_PROTOCOL_ID) 0x0006) ///< The DSAP protocol
+#define TPM_PID_TRANSPORT           ((TPM_PROTOCOL_ID) 0x0007) ///< The transport protocol
+
+//
+// Part 2, section 4.8: TPM_ALGORITHM_ID
+//   The TPM MUST support the algorithms TPM_ALG_RSA, TPM_ALG_SHA, TPM_ALG_HMAC,
+//   TPM_ALG_MGF1
+//
+#define TPM_ALG_RSA                 ((TPM_ALGORITHM_ID) 0x00000001) ///< The RSA algorithm.
+#define TPM_ALG_DES                 ((TPM_ALGORITHM_ID) 0x00000002) ///< The DES algorithm
+#define TPM_ALG_3DES                ((TPM_ALGORITHM_ID) 0x00000003) ///< The 3DES algorithm in EDE mode
+#define TPM_ALG_SHA                 ((TPM_ALGORITHM_ID) 0x00000004) ///< The SHA1 algorithm
+#define TPM_ALG_HMAC                ((TPM_ALGORITHM_ID) 0x00000005) ///< The RFC 2104 HMAC algorithm
+#define TPM_ALG_AES128              ((TPM_ALGORITHM_ID) 0x00000006) ///< The AES algorithm, key size 128
+#define TPM_ALG_MGF1                ((TPM_ALGORITHM_ID) 0x00000007) ///< The XOR algorithm using MGF1 to create a string the size of the encrypted block
+#define TPM_ALG_AES192              ((TPM_ALGORITHM_ID) 0x00000008) ///< AES, key size 192
+#define TPM_ALG_AES256              ((TPM_ALGORITHM_ID) 0x00000009) ///< AES, key size 256
+#define TPM_ALG_XOR                 ((TPM_ALGORITHM_ID) 0x0000000A) ///< XOR using the rolling nonces
+
+//
+// Part 2, section 4.9: TPM_PHYSICAL_PRESENCE
+//
+#define TPM_PHYSICAL_PRESENCE_HW_DISABLE    ((TPM_PHYSICAL_PRESENCE) 0x0200) ///< Sets the physicalPresenceHWEnable to FALSE
+#define TPM_PHYSICAL_PRESENCE_CMD_DISABLE   ((TPM_PHYSICAL_PRESENCE) 0x0100) ///< Sets the physicalPresenceCMDEnable to FALSE
+#define TPM_PHYSICAL_PRESENCE_LIFETIME_LOCK ((TPM_PHYSICAL_PRESENCE) 0x0080) ///< Sets the physicalPresenceLifetimeLock to TRUE
+#define TPM_PHYSICAL_PRESENCE_HW_ENABLE     ((TPM_PHYSICAL_PRESENCE) 0x0040) ///< Sets the physicalPresenceHWEnable to TRUE
+#define TPM_PHYSICAL_PRESENCE_CMD_ENABLE    ((TPM_PHYSICAL_PRESENCE) 0x0020) ///< Sets the physicalPresenceCMDEnable to TRUE
+#define TPM_PHYSICAL_PRESENCE_NOTPRESENT    ((TPM_PHYSICAL_PRESENCE) 0x0010) ///< Sets PhysicalPresence = FALSE
+#define TPM_PHYSICAL_PRESENCE_PRESENT       ((TPM_PHYSICAL_PRESENCE) 0x0008) ///< Sets PhysicalPresence = TRUE
+#define TPM_PHYSICAL_PRESENCE_LOCK          ((TPM_PHYSICAL_PRESENCE) 0x0004) ///< Sets PhysicalPresenceLock = TRUE
+
+//
+// Part 2, section 4.10: TPM_MIGRATE_SCHEME
+//
+#define TPM_MS_MIGRATE                      ((TPM_MIGRATE_SCHEME) 0x0001) ///< A public key that can be used with all TPM migration commands other than 'ReWrap' mode.
+#define TPM_MS_REWRAP                       ((TPM_MIGRATE_SCHEME) 0x0002) ///< A public key that can be used for the ReWrap mode of TPM_CreateMigrationBlob.
+#define TPM_MS_MAINT                        ((TPM_MIGRATE_SCHEME) 0x0003) ///< A public key that can be used for the Maintenance commands
+#define TPM_MS_RESTRICT_MIGRATE             ((TPM_MIGRATE_SCHEME) 0x0004) ///< The key is to be migrated to a Migration Authority.
+#define TPM_MS_RESTRICT_APPROVE_DOUBLE      ((TPM_MIGRATE_SCHEME) 0x0005) ///< The key is to be migrated to an entity approved by a Migration Authority using double wrapping
+
+//
+// Part 2, section 4.11: TPM_EK_TYPE
+//
+#define TPM_EK_TYPE_ACTIVATE        ((TPM_EK_TYPE) 0x0001) ///< The blob MUST be TPM_EK_BLOB_ACTIVATE
+#define TPM_EK_TYPE_AUTH            ((TPM_EK_TYPE) 0x0002) ///< The blob MUST be TPM_EK_BLOB_AUTH
+
+//
+// Part 2, section 4.12: TPM_PLATFORM_SPECIFIC
+//
+#define TPM_PS_PC_11                ((TPM_PLATFORM_SPECIFIC) 0x0001) ///< PC Specific version 1.1
+#define TPM_PS_PC_12                ((TPM_PLATFORM_SPECIFIC) 0x0002) ///< PC Specific version 1.2
+#define TPM_PS_PDA_12               ((TPM_PLATFORM_SPECIFIC) 0x0003) ///< PDA Specific version 1.2
+#define TPM_PS_Server_12            ((TPM_PLATFORM_SPECIFIC) 0x0004) ///< Server Specific version 1.2
+#define TPM_PS_Mobile_12            ((TPM_PLATFORM_SPECIFIC) 0x0005) ///< Mobil Specific version 1.2
+
+//
+// Part 2, section 5: Basic Structures
+//
+
+///
+/// Part 2, section 5.1: TPM_STRUCT_VER
+///
+typedef struct tdTPM_STRUCT_VER {
+  UINT8                             major;
+  UINT8                             minor;
+  UINT8                             revMajor;
+  UINT8                             revMinor;
+} TPM_STRUCT_VER;
+
+///
+/// Part 2, section 5.3: TPM_VERSION
+///
+typedef struct tdTPM_VERSION {
+  TPM_VERSION_BYTE                  major;
+  TPM_VERSION_BYTE                  minor;
+  UINT8                             revMajor;
+  UINT8                             revMinor;
+} TPM_VERSION;
+
+
+#define TPM_SHA1_160_HASH_LEN       0x14
+#define TPM_SHA1BASED_NONCE_LEN     TPM_SHA1_160_HASH_LEN
+
+///
+/// Part 2, section 5.4: TPM_DIGEST
+///
+typedef struct tdTPM_DIGEST{
+  UINT8                             digest[TPM_SHA1_160_HASH_LEN];
+} TPM_DIGEST;
+
+///
+/// This SHALL be the digest of the chosen identityLabel and privacyCA for a new TPM identity
+///
+typedef TPM_DIGEST                  TPM_CHOSENID_HASH;
+///
+/// This SHALL be the hash of a list of PCR indexes and PCR values that a key or data is bound to
+///
+typedef TPM_DIGEST                  TPM_COMPOSITE_HASH;
+///
+/// This SHALL be the value of a DIR register
+///
+typedef TPM_DIGEST                  TPM_DIRVALUE;
+
+typedef TPM_DIGEST                  TPM_HMAC;
+///
+/// The value inside of the PCR
+///
+typedef TPM_DIGEST                  TPM_PCRVALUE;
+///
+/// This SHALL be the value of the current internal audit state
+///
+typedef TPM_DIGEST                  TPM_AUDITDIGEST;
+
+///
+/// Part 2, section 5.5: TPM_NONCE
+///
+typedef struct tdTPM_NONCE{
+  UINT8                             nonce[20];
+} TPM_NONCE;
+
+///
+/// This SHALL be a random value generated by a TPM immediately after the EK is installed
+/// in that TPM, whenever an EK is installed in that TPM
+///
+typedef TPM_NONCE                  TPM_DAA_TPM_SEED;
+///
+/// This SHALL be a random value
+///
+typedef TPM_NONCE                  TPM_DAA_CONTEXT_SEED;
+
+//
+// Part 2, section 5.6: TPM_AUTHDATA
+//
+///
+/// The AuthData data is the information that is saved or passed to provide proof of ownership
+/// 296 of an entity
+///
+typedef UINT8                       tdTPM_AUTHDATA[20];
+
+typedef tdTPM_AUTHDATA              TPM_AUTHDATA;
+///
+/// A secret plaintext value used in the authorization process
+///
+typedef TPM_AUTHDATA                TPM_SECRET;
+///
+/// A ciphertext (encrypted) version of AuthData data. The encryption mechanism depends on the context
+///
+typedef TPM_AUTHDATA                TPM_ENCAUTH;
+
+///
+/// Part 2, section 5.7: TPM_KEY_HANDLE_LIST
+/// Size of handle is loaded * sizeof(TPM_KEY_HANDLE)
+///
+typedef struct tdTPM_KEY_HANDLE_LIST {
+  UINT16                            loaded;
+  TPM_KEY_HANDLE                    handle[1];
+} TPM_KEY_HANDLE_LIST;
+
+//
+// Part 2, section 5.8: TPM_KEY_USAGE values
+//
+///
+/// TPM_KEY_SIGNING SHALL indicate a signing key. The [private] key SHALL be
+/// used for signing operations, only. This means that it MUST be a leaf of the
+/// Protected Storage key hierarchy.
+///
+#define TPM_KEY_SIGNING             ((UINT16) 0x0010)
+///
+/// TPM_KEY_STORAGE SHALL indicate a storage key. The key SHALL be used to wrap
+/// and unwrap other keys in the Protected Storage hierarchy
+///
+#define TPM_KEY_STORAGE             ((UINT16) 0x0011)
+///
+/// TPM_KEY_IDENTITY SHALL indicate an identity key. The key SHALL be used for
+/// operations that require a TPM identity, only.
+///
+#define TPM_KEY_IDENTITY            ((UINT16) 0x0012)
+///
+/// TPM_KEY_AUTHCHANGE SHALL indicate an ephemeral key that is in use during
+/// the ChangeAuthAsym process, only.
+///
+#define TPM_KEY_AUTHCHANGE          ((UINT16) 0x0013)
+///
+/// TPM_KEY_BIND SHALL indicate a key that can be used for TPM_Bind and
+/// TPM_Unbind operations only.
+///
+#define TPM_KEY_BIND                ((UINT16) 0x0014)
+///
+/// TPM_KEY_LEGACY SHALL indicate a key that can perform signing and binding
+/// operations. The key MAY be used for both signing and binding operations.
+/// The TPM_KEY_LEGACY key type is to allow for use by applications where both
+/// signing and encryption operations occur with the same key. The use of this
+/// key type is not recommended TPM_KEY_MIGRATE 0x0016 This SHALL indicate a
+/// key in use for TPM_MigrateKey
+///
+#define TPM_KEY_LEGACY              ((UINT16) 0x0015)
+///
+/// TPM_KEY_MIGRAGE SHALL indicate a key in use for TPM_MigrateKey
+///
+#define TPM_KEY_MIGRATE             ((UINT16) 0x0016)
+
+//
+// Part 2, section 5.8.1: Mandatory Key Usage Schemes
+//
+
+#define TPM_ES_NONE                 ((TPM_ENC_SCHEME) 0x0001)
+#define TPM_ES_RSAESPKCSv15         ((TPM_ENC_SCHEME) 0x0002)
+#define TPM_ES_RSAESOAEP_SHA1_MGF1  ((TPM_ENC_SCHEME) 0x0003)
+#define TPM_ES_SYM_CNT              ((TPM_ENC_SCHEME) 0x0004)  ///< rev94 defined
+#define TPM_ES_SYM_CTR              ((TPM_ENC_SCHEME) 0x0004)
+#define TPM_ES_SYM_OFB              ((TPM_ENC_SCHEME) 0x0005)
+
+#define TPM_SS_NONE                 ((TPM_SIG_SCHEME) 0x0001)
+#define TPM_SS_RSASSAPKCS1v15_SHA1  ((TPM_SIG_SCHEME) 0x0002)
+#define TPM_SS_RSASSAPKCS1v15_DER   ((TPM_SIG_SCHEME) 0x0003)
+#define TPM_SS_RSASSAPKCS1v15_INFO  ((TPM_SIG_SCHEME) 0x0004)
+
+//
+// Part 2, section 5.9: TPM_AUTH_DATA_USAGE values
+//
+#define TPM_AUTH_NEVER              ((TPM_AUTH_DATA_USAGE) 0x00)
+#define TPM_AUTH_ALWAYS             ((TPM_AUTH_DATA_USAGE) 0x01)
+#define TPM_AUTH_PRIV_USE_ONLY      ((TPM_AUTH_DATA_USAGE) 0x03)
+
+///
+/// Part 2, section 5.10: TPM_KEY_FLAGS
+///
+typedef enum tdTPM_KEY_FLAGS {
+  redirection                       = 0x00000001,
+  migratable                        = 0x00000002,
+  isVolatile                        = 0x00000004,
+  pcrIgnoredOnRead                  = 0x00000008,
+  migrateAuthority                  = 0x00000010
+} TPM_KEY_FLAGS_BITS;
+
+///
+/// Part 2, section 5.11: TPM_CHANGEAUTH_VALIDATE
+///
+typedef struct tdTPM_CHANGEAUTH_VALIDATE {
+  TPM_SECRET                        newAuthSecret;
+  TPM_NONCE                         n1;
+} TPM_CHANGEAUTH_VALIDATE;
+
+///
+/// Part 2, section 5.12: TPM_MIGRATIONKEYAUTH
+///   decalared after section 10 to catch declaration of TPM_PUBKEY
+///
+/// Part 2 section 10.1: TPM_KEY_PARMS
+///   [size_is(parmSize)] BYTE* parms;
+///
+typedef struct tdTPM_KEY_PARMS {
+  TPM_ALGORITHM_ID                  algorithmID;
+  TPM_ENC_SCHEME                    encScheme;
+  TPM_SIG_SCHEME                    sigScheme;
+  UINT32                            parmSize;
+  UINT8                             *parms;
+} TPM_KEY_PARMS;
+
+///
+/// Part 2, section 10.4: TPM_STORE_PUBKEY
+///
+typedef struct tdTPM_STORE_PUBKEY {
+  UINT32                            keyLength;
+  UINT8                             key[1];
+} TPM_STORE_PUBKEY;
+
+///
+/// Part 2, section 10.5: TPM_PUBKEY
+///
+typedef struct tdTPM_PUBKEY{
+  TPM_KEY_PARMS                     algorithmParms;
+  TPM_STORE_PUBKEY                  pubKey;
+} TPM_PUBKEY;
+
+///
+/// Part 2, section 5.12: TPM_MIGRATIONKEYAUTH
+///
+typedef struct tdTPM_MIGRATIONKEYAUTH{
+  TPM_PUBKEY                        migrationKey;
+  TPM_MIGRATE_SCHEME                migrationScheme;
+  TPM_DIGEST                        digest;
+} TPM_MIGRATIONKEYAUTH;
+
+///
+/// Part 2, section 5.13: TPM_COUNTER_VALUE
+///
+typedef struct tdTPM_COUNTER_VALUE{
+  TPM_STRUCTURE_TAG                 tag;
+  UINT8                             label[4];
+  TPM_ACTUAL_COUNT                  counter;
+} TPM_COUNTER_VALUE;
+
+///
+/// Part 2, section 5.14: TPM_SIGN_INFO
+///   Size of data indicated by dataLen
+///
+typedef struct tdTPM_SIGN_INFO {
+  TPM_STRUCTURE_TAG                 tag;
+  UINT8                             fixed[4];
+  TPM_NONCE                         replay;
+  UINT32                            dataLen;
+  UINT8                             *data;
+} TPM_SIGN_INFO;
+
+///
+/// Part 2, section 5.15: TPM_MSA_COMPOSITE
+///   Number of migAuthDigest indicated by MSAlist
+///
+typedef struct tdTPM_MSA_COMPOSITE {
+  UINT32                            MSAlist;
+  TPM_DIGEST                        migAuthDigest[1];
+} TPM_MSA_COMPOSITE;
+
+///
+/// Part 2, section 5.16: TPM_CMK_AUTH
+///
+typedef struct tdTPM_CMK_AUTH{
+  TPM_DIGEST                        migrationAuthorityDigest;
+  TPM_DIGEST                        destinationKeyDigest;
+  TPM_DIGEST                        sourceKeyDigest;
+} TPM_CMK_AUTH;
+
+//
+// Part 2, section 5.17: TPM_CMK_DELEGATE
+//
+#define TPM_CMK_DELEGATE_SIGNING    ((TPM_CMK_DELEGATE) BIT31)
+#define TPM_CMK_DELEGATE_STORAGE    ((TPM_CMK_DELEGATE) BIT30)
+#define TPM_CMK_DELEGATE_BIND       ((TPM_CMK_DELEGATE) BIT29)
+#define TPM_CMK_DELEGATE_LEGACY     ((TPM_CMK_DELEGATE) BIT28)
+#define TPM_CMK_DELEGATE_MIGRATE    ((TPM_CMK_DELEGATE) BIT27)
+
+///
+/// Part 2, section 5.18: TPM_SELECT_SIZE
+///
+typedef struct tdTPM_SELECT_SIZE {
+  UINT8                             major;
+  UINT8                             minor;
+  UINT16                            reqSize;
+} TPM_SELECT_SIZE;
+
+///
+/// Part 2, section 5,19: TPM_CMK_MIGAUTH
+///
+typedef struct tdTPM_CMK_MIGAUTH{
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_DIGEST                        msaDigest;
+  TPM_DIGEST                        pubKeyDigest;
+} TPM_CMK_MIGAUTH;
+
+///
+/// Part 2, section 5.20: TPM_CMK_SIGTICKET
+///
+typedef struct tdTPM_CMK_SIGTICKET{
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_DIGEST                        verKeyDigest;
+  TPM_DIGEST                        signedData;
+} TPM_CMK_SIGTICKET;
+
+///
+/// Part 2, section 5.21: TPM_CMK_MA_APPROVAL
+///
+typedef struct tdTPM_CMK_MA_APPROVAL{
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_DIGEST                        migrationAuthorityDigest;
+} TPM_CMK_MA_APPROVAL;
+
+//
+// Part 2, section 6: Command Tags
+//
+#define TPM_TAG_RQU_COMMAND         ((TPM_STRUCTURE_TAG) 0x00C1)
+#define TPM_TAG_RQU_AUTH1_COMMAND   ((TPM_STRUCTURE_TAG) 0x00C2)
+#define TPM_TAG_RQU_AUTH2_COMMAND   ((TPM_STRUCTURE_TAG) 0x00C3)
+#define TPM_TAG_RSP_COMMAND         ((TPM_STRUCTURE_TAG) 0x00C4)
+#define TPM_TAG_RSP_AUTH1_COMMAND   ((TPM_STRUCTURE_TAG) 0x00C5)
+#define TPM_TAG_RSP_AUTH2_COMMAND   ((TPM_STRUCTURE_TAG) 0x00C6)
+
+///
+/// Part 2, section 7.1: TPM_PERMANENT_FLAGS
+///
+typedef struct tdTPM_PERMANENT_FLAGS{
+  TPM_STRUCTURE_TAG                 tag;
+  BOOLEAN                           disable;
+  BOOLEAN                           ownership;
+  BOOLEAN                           deactivated;
+  BOOLEAN                           readPubek;
+  BOOLEAN                           disableOwnerClear;
+  BOOLEAN                           allowMaintenance;
+  BOOLEAN                           physicalPresenceLifetimeLock;
+  BOOLEAN                           physicalPresenceHWEnable;
+  BOOLEAN                           physicalPresenceCMDEnable;
+  BOOLEAN                           CEKPUsed;
+  BOOLEAN                           TPMpost;
+  BOOLEAN                           TPMpostLock;
+  BOOLEAN                           FIPS;
+  BOOLEAN                           operator;
+  BOOLEAN                           enableRevokeEK;
+  BOOLEAN                           nvLocked;
+  BOOLEAN                           readSRKPub;
+  BOOLEAN                           tpmEstablished;
+  BOOLEAN                           maintenanceDone;
+  BOOLEAN                           disableFullDALogicInfo;
+} TPM_PERMANENT_FLAGS;
+
+//
+// Part 2, section 7.1.1: Flag Restrictions (of TPM_PERMANENT_FLAGS)
+//
+#define TPM_PF_DISABLE                      ((TPM_CAPABILITY_AREA) 1)
+#define TPM_PF_OWNERSHIP                    ((TPM_CAPABILITY_AREA) 2)
+#define TPM_PF_DEACTIVATED                  ((TPM_CAPABILITY_AREA) 3)
+#define TPM_PF_READPUBEK                    ((TPM_CAPABILITY_AREA) 4)
+#define TPM_PF_DISABLEOWNERCLEAR            ((TPM_CAPABILITY_AREA) 5)
+#define TPM_PF_ALLOWMAINTENANCE             ((TPM_CAPABILITY_AREA) 6)
+#define TPM_PF_PHYSICALPRESENCELIFETIMELOCK ((TPM_CAPABILITY_AREA) 7)
+#define TPM_PF_PHYSICALPRESENCEHWENABLE     ((TPM_CAPABILITY_AREA) 8)
+#define TPM_PF_PHYSICALPRESENCECMDENABLE    ((TPM_CAPABILITY_AREA) 9)
+#define TPM_PF_CEKPUSED                     ((TPM_CAPABILITY_AREA) 10)
+#define TPM_PF_TPMPOST                      ((TPM_CAPABILITY_AREA) 11)
+#define TPM_PF_TPMPOSTLOCK                  ((TPM_CAPABILITY_AREA) 12)
+#define TPM_PF_FIPS                         ((TPM_CAPABILITY_AREA) 13)
+#define TPM_PF_OPERATOR                     ((TPM_CAPABILITY_AREA) 14)
+#define TPM_PF_ENABLEREVOKEEK               ((TPM_CAPABILITY_AREA) 15)
+#define TPM_PF_NV_LOCKED                    ((TPM_CAPABILITY_AREA) 16)
+#define TPM_PF_READSRKPUB                   ((TPM_CAPABILITY_AREA) 17)
+#define TPM_PF_TPMESTABLISHED               ((TPM_CAPABILITY_AREA) 18)
+#define TPM_PF_MAINTENANCEDONE              ((TPM_CAPABILITY_AREA) 19)
+#define TPM_PF_DISABLEFULLDALOGICINFO       ((TPM_CAPABILITY_AREA) 20)
+
+///
+/// Part 2, section 7.2: TPM_STCLEAR_FLAGS
+///
+typedef struct tdTPM_STCLEAR_FLAGS{
+  TPM_STRUCTURE_TAG                 tag;
+  BOOLEAN                           deactivated;
+  BOOLEAN                           disableForceClear;
+  BOOLEAN                           physicalPresence;
+  BOOLEAN                           physicalPresenceLock;
+  BOOLEAN                           bGlobalLock;
+} TPM_STCLEAR_FLAGS;
+
+//
+// Part 2, section 7.2.1: Flag Restrictions (of TPM_STCLEAR_FLAGS)
+//
+#define TPM_SF_DEACTIVATED          ((TPM_CAPABILITY_AREA) 1)
+#define TPM_SF_DISABLEFORCECLEAR    ((TPM_CAPABILITY_AREA) 2)
+#define TPM_SF_PHYSICALPRESENCE     ((TPM_CAPABILITY_AREA) 3)
+#define TPM_SF_PHYSICALPRESENCELOCK ((TPM_CAPABILITY_AREA) 4)
+#define TPM_SF_BGLOBALLOCK          ((TPM_CAPABILITY_AREA) 5)
+
+///
+/// Part 2, section 7.3: TPM_STANY_FLAGS
+///
+typedef struct tdTPM_STANY_FLAGS{
+  TPM_STRUCTURE_TAG                 tag;
+  BOOLEAN                           postInitialise;
+  TPM_MODIFIER_INDICATOR            localityModifier;
+  BOOLEAN                           transportExclusive;
+  BOOLEAN                           TOSPresent;
+} TPM_STANY_FLAGS;
+
+//
+// Part 2, section 7.3.1: Flag Restrictions (of TPM_STANY_FLAGS)
+//
+#define TPM_AF_POSTINITIALISE       ((TPM_CAPABILITY_AREA) 1)
+#define TPM_AF_LOCALITYMODIFIER     ((TPM_CAPABILITY_AREA) 2)
+#define TPM_AF_TRANSPORTEXCLUSIVE   ((TPM_CAPABILITY_AREA) 3)
+#define TPM_AF_TOSPRESENT           ((TPM_CAPABILITY_AREA) 4)
+
+//
+// All those structures defined in section 7.4, 7.5, 7.6 are not normative and 
+// thus no definitions here
+//
+// Part 2, section 7.4: TPM_PERMANENT_DATA
+//
+#define TPM_MIN_COUNTERS            4   ///< the minimum number of counters is 4
+#define TPM_DELEGATE_KEY            TPM_KEY
+#define TPM_NUM_PCR                 16
+#define TPM_MAX_NV_WRITE_NOOWNER    64
+
+//
+// Part 2, section 7.4.1: PERMANENT_DATA Subcap for SetCapability
+//
+#define TPM_PD_REVMAJOR               ((TPM_CAPABILITY_AREA) 1)
+#define TPM_PD_REVMINOR               ((TPM_CAPABILITY_AREA) 2)
+#define TPM_PD_TPMPROOF               ((TPM_CAPABILITY_AREA) 3)
+#define TPM_PD_OWNERAUTH              ((TPM_CAPABILITY_AREA) 4)
+#define TPM_PD_OPERATORAUTH           ((TPM_CAPABILITY_AREA) 5)
+#define TPM_PD_MANUMAINTPUB           ((TPM_CAPABILITY_AREA) 6)
+#define TPM_PD_ENDORSEMENTKEY         ((TPM_CAPABILITY_AREA) 7)
+#define TPM_PD_SRK                    ((TPM_CAPABILITY_AREA) 8)
+#define TPM_PD_DELEGATEKEY            ((TPM_CAPABILITY_AREA) 9)
+#define TPM_PD_CONTEXTKEY             ((TPM_CAPABILITY_AREA) 10)
+#define TPM_PD_AUDITMONOTONICCOUNTER  ((TPM_CAPABILITY_AREA) 11)
+#define TPM_PD_MONOTONICCOUNTER       ((TPM_CAPABILITY_AREA) 12)
+#define TPM_PD_PCRATTRIB              ((TPM_CAPABILITY_AREA) 13)
+#define TPM_PD_ORDINALAUDITSTATUS     ((TPM_CAPABILITY_AREA) 14)
+#define TPM_PD_AUTHDIR                ((TPM_CAPABILITY_AREA) 15)
+#define TPM_PD_RNGSTATE               ((TPM_CAPABILITY_AREA) 16)
+#define TPM_PD_FAMILYTABLE            ((TPM_CAPABILITY_AREA) 17)
+#define TPM_DELEGATETABLE             ((TPM_CAPABILITY_AREA) 18)
+#define TPM_PD_EKRESET                ((TPM_CAPABILITY_AREA) 19)
+#define TPM_PD_MAXNVBUFSIZE           ((TPM_CAPABILITY_AREA) 20)
+#define TPM_PD_LASTFAMILYID           ((TPM_CAPABILITY_AREA) 21)
+#define TPM_PD_NOOWNERNVWRITE         ((TPM_CAPABILITY_AREA) 22)
+#define TPM_PD_RESTRICTDELEGATE       ((TPM_CAPABILITY_AREA) 23)
+#define TPM_PD_TPMDAASEED             ((TPM_CAPABILITY_AREA) 24)
+#define TPM_PD_DAAPROOF               ((TPM_CAPABILITY_AREA) 25)
+
+///
+/// Part 2, section 7.5: TPM_STCLEAR_DATA
+///   available inside TPM only
+///
+ typedef struct tdTPM_STCLEAR_DATA{
+   TPM_STRUCTURE_TAG                  tag;
+   TPM_NONCE                          contextNonceKey;
+   TPM_COUNT_ID                       countID;
+   UINT32                             ownerReference;
+   BOOLEAN                            disableResetLock;
+   TPM_PCRVALUE                       PCR[TPM_NUM_PCR];
+   UINT32                             deferredPhysicalPresence;
+ }TPM_STCLEAR_DATA;
+
+//
+// Part 2, section 7.5.1: STCLEAR_DATA Subcap for SetCapability
+//
+#define TPM_SD_CONTEXTNONCEKEY            ((TPM_CAPABILITY_AREA)0x00000001)
+#define TPM_SD_COUNTID                    ((TPM_CAPABILITY_AREA)0x00000002)
+#define TPM_SD_OWNERREFERENCE             ((TPM_CAPABILITY_AREA)0x00000003)
+#define TPM_SD_DISABLERESETLOCK           ((TPM_CAPABILITY_AREA)0x00000004)
+#define TPM_SD_PCR                        ((TPM_CAPABILITY_AREA)0x00000005)
+#define TPM_SD_DEFERREDPHYSICALPRESENCE   ((TPM_CAPABILITY_AREA)0x00000006)
+
+//
+// Part 2, section 7.6.1: STANY_DATA Subcap for SetCapability
+//
+#define TPM_AD_CONTEXTNONCESESSION        ((TPM_CAPABILITY_AREA) 1)
+#define TPM_AD_AUDITDIGEST                ((TPM_CAPABILITY_AREA) 2)
+#define TPM_AD_CURRENTTICKS               ((TPM_CAPABILITY_AREA) 3)
+#define TPM_AD_CONTEXTCOUNT               ((TPM_CAPABILITY_AREA) 4)
+#define TPM_AD_CONTEXTLIST                ((TPM_CAPABILITY_AREA) 5)
+#define TPM_AD_SESSIONS                   ((TPM_CAPABILITY_AREA) 6)
+
+//
+// Part 2, section 8: PCR Structures
+// 
+
+///
+/// Part 2, section 8.1: TPM_PCR_SELECTION
+///   Size of pcrSelect[] indicated by sizeOfSelect
+///
+typedef struct tdTPM_PCR_SELECTION {
+  UINT16                            sizeOfSelect;
+  UINT8                             pcrSelect[1];
+} TPM_PCR_SELECTION;
+
+///
+/// Part 2, section 8.2: TPM_PCR_COMPOSITE
+///   Size of pcrValue[] indicated by valueSize
+///
+typedef struct tdTPM_PCR_COMPOSITE {
+  TPM_PCR_SELECTION                 select;
+  UINT32                            valueSize;
+  TPM_PCRVALUE                      pcrValue[1];
+} TPM_PCR_COMPOSITE;
+
+///
+/// Part 2, section 8.3: TPM_PCR_INFO
+///
+typedef struct tdTPM_PCR_INFO {
+  TPM_PCR_SELECTION                 pcrSelection;
+  TPM_COMPOSITE_HASH                digestAtRelease;
+  TPM_COMPOSITE_HASH                digestAtCreation;
+} TPM_PCR_INFO;
+
+///
+/// Part 2, section 8.6: TPM_LOCALITY_SELECTION
+///
+typedef UINT8                       TPM_LOCALITY_SELECTION;
+
+#define TPM_LOC_FOUR                ((UINT8) 0x10)
+#define TPM_LOC_THREE               ((UINT8) 0x08)
+#define TPM_LOC_TWO                 ((UINT8) 0x04)
+#define TPM_LOC_ONE                 ((UINT8) 0x02)
+#define TPM_LOC_ZERO                ((UINT8) 0x01)
+
+///
+/// Part 2, section 8.4: TPM_PCR_INFO_LONG
+///
+typedef struct tdTPM_PCR_INFO_LONG {
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_LOCALITY_SELECTION            localityAtCreation;
+  TPM_LOCALITY_SELECTION            localityAtRelease;
+  TPM_PCR_SELECTION                 creationPCRSelection;
+  TPM_PCR_SELECTION                 releasePCRSelection;
+  TPM_COMPOSITE_HASH                digestAtCreation;
+  TPM_COMPOSITE_HASH                digestAtRelease;
+} TPM_PCR_INFO_LONG;
+
+///
+/// Part 2, section 8.5: TPM_PCR_INFO_SHORT
+///
+typedef struct tdTPM_PCR_INFO_SHORT{
+  TPM_PCR_SELECTION                 pcrSelection;
+  TPM_LOCALITY_SELECTION            localityAtRelease;
+  TPM_COMPOSITE_HASH                digestAtRelease;
+} TPM_PCR_INFO_SHORT;
+
+///
+/// Part 2, section 8.8: TPM_PCR_ATTRIBUTES
+///
+typedef struct tdTPM_PCR_ATTRIBUTES{
+  BOOLEAN                           pcrReset;
+  TPM_LOCALITY_SELECTION            pcrExtendLocal;
+  TPM_LOCALITY_SELECTION            pcrResetLocal;
+} TPM_PCR_ATTRIBUTES;
+
+//
+// Part 2, section 9: Storage Structures
+//
+
+///
+/// Part 2, section 9.1: TPM_STORED_DATA
+///   [size_is(sealInfoSize)] BYTE* sealInfo;
+///   [size_is(encDataSize)] BYTE* encData;
+///
+typedef struct tdTPM_STORED_DATA {
+  TPM_STRUCT_VER                    ver;
+  UINT32                            sealInfoSize;
+  UINT8                             *sealInfo;
+  UINT32                            encDataSize;
+  UINT8                             *encData;
+} TPM_STORED_DATA;
+
+///
+/// Part 2, section 9.2: TPM_STORED_DATA12
+///   [size_is(sealInfoSize)] BYTE* sealInfo;
+///   [size_is(encDataSize)] BYTE* encData;
+///
+typedef struct tdTPM_STORED_DATA12 {
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_ENTITY_TYPE                   et;
+  UINT32                            sealInfoSize;
+  UINT8                             *sealInfo;
+  UINT32                            encDataSize;
+  UINT8                             *encData;
+} TPM_STORED_DATA12;
+
+///
+/// Part 2, section 9.3: TPM_SEALED_DATA
+///   [size_is(dataSize)] BYTE* data;
+///
+typedef struct tdTPM_SEALED_DATA {
+  TPM_PAYLOAD_TYPE                  payload;
+  TPM_SECRET                        authData;
+  TPM_NONCE                         tpmProof;
+  TPM_DIGEST                        storedDigest;
+  UINT32                            dataSize;
+  UINT8                             *data;
+} TPM_SEALED_DATA;
+
+///
+/// Part 2, section 9.4: TPM_SYMMETRIC_KEY
+///   [size_is(size)] BYTE* data;
+///
+typedef struct tdTPM_SYMMETRIC_KEY {
+  TPM_ALGORITHM_ID                  algId;
+  TPM_ENC_SCHEME                    encScheme;
+  UINT16                            dataSize;
+  UINT8                             *data;
+} TPM_SYMMETRIC_KEY;
+
+///
+/// Part 2, section 9.5: TPM_BOUND_DATA
+///
+typedef struct tdTPM_BOUND_DATA {
+  TPM_STRUCT_VER                    ver;
+  TPM_PAYLOAD_TYPE                  payload;
+  UINT8                             payloadData[1];
+} TPM_BOUND_DATA;
+
+//
+// Part 2 section 10: TPM_KEY complex
+// 
+
+//
+// Section 10.1, 10.4, and 10.5 have been defined previously
+//
+
+///
+/// Part 2, section 10.2: TPM_KEY
+///   [size_is(encDataSize)] BYTE* encData;
+///
+typedef struct tdTPM_KEY{
+  TPM_STRUCT_VER                    ver;
+  TPM_KEY_USAGE                     keyUsage;
+  TPM_KEY_FLAGS                     keyFlags;
+  TPM_AUTH_DATA_USAGE               authDataUsage;
+  TPM_KEY_PARMS                     algorithmParms;
+  UINT32                            PCRInfoSize;
+  UINT8                             *PCRInfo;
+  TPM_STORE_PUBKEY                  pubKey;
+  UINT32                            encDataSize;
+  UINT8                             *encData;
+} TPM_KEY;
+
+///
+/// Part 2, section 10.3: TPM_KEY12
+///   [size_is(encDataSize)] BYTE* encData;
+///
+typedef struct tdTPM_KEY12{
+  TPM_STRUCTURE_TAG                 tag;
+  UINT16                            fill;
+  TPM_KEY_USAGE                     keyUsage;
+  TPM_KEY_FLAGS                     keyFlags;
+  TPM_AUTH_DATA_USAGE               authDataUsage;
+  TPM_KEY_PARMS                     algorithmParms;
+  UINT32                            PCRInfoSize;
+  UINT8                             *PCRInfo;
+  TPM_STORE_PUBKEY                  pubKey;
+  UINT32                            encDataSize;
+  UINT8                             *encData;
+} TPM_KEY12;
+
+///
+/// Part 2, section 10.7: TPM_STORE_PRIVKEY
+///   [size_is(keyLength)] BYTE* key;
+///
+typedef struct tdTPM_STORE_PRIVKEY {
+  UINT32                            keyLength;
+  UINT8                             *key;
+} TPM_STORE_PRIVKEY;
+
+///
+/// Part 2, section 10.6: TPM_STORE_ASYMKEY
+///
+typedef struct tdTPM_STORE_ASYMKEY {                // pos len total
+  TPM_PAYLOAD_TYPE                  payload;        // 0    1   1
+  TPM_SECRET                        usageAuth;      // 1    20  21
+  TPM_SECRET                        migrationAuth;  // 21   20  41
+  TPM_DIGEST                        pubDataDigest;  // 41   20  61
+  TPM_STORE_PRIVKEY                 privKey;        // 61 132-151 193-214
+} TPM_STORE_ASYMKEY;
+
+///
+/// Part 2, section 10.8: TPM_MIGRATE_ASYMKEY
+///   [size_is(partPrivKeyLen)] BYTE* partPrivKey;
+///
+typedef struct tdTPM_MIGRATE_ASYMKEY {              // pos  len  total
+  TPM_PAYLOAD_TYPE                  payload;        //   0    1       1
+  TPM_SECRET                        usageAuth;      //   1   20      21
+  TPM_DIGEST                        pubDataDigest;  //  21   20      41
+  UINT32                            partPrivKeyLen; //  41    4      45
+  UINT8                             *partPrivKey;   //  45 112-127 157-172
+} TPM_MIGRATE_ASYMKEY;
+
+///
+/// Part 2, section 10.9: TPM_KEY_CONTROL
+///
+#define TPM_KEY_CONTROL_OWNER_EVICT ((UINT32) 0x00000001)
+
+//
+// Part 2, section 11: Signed Structures
+//
+
+///
+/// Part 2, section 11.1: TPM_CERTIFY_INFO Structure
+///
+typedef struct tdTPM_CERTIFY_INFO {
+  TPM_STRUCT_VER                  version;
+  TPM_KEY_USAGE                   keyUsage;
+  TPM_KEY_FLAGS                   keyFlags;
+  TPM_AUTH_DATA_USAGE             authDataUsage;
+  TPM_KEY_PARMS                   algorithmParms;
+  TPM_DIGEST                      pubkeyDigest;
+  TPM_NONCE                       data;
+  BOOLEAN                         parentPCRStatus;
+  UINT32                          PCRInfoSize;
+  UINT8                           *PCRInfo;
+} TPM_CERTIFY_INFO;
+
+///
+/// Part 2, section 11.2: TPM_CERTIFY_INFO2 Structure
+///
+typedef struct tdTPM_CERTIFY_INFO2 {
+  TPM_STRUCTURE_TAG               tag;
+  UINT8                           fill;
+  TPM_PAYLOAD_TYPE                payloadType;
+  TPM_KEY_USAGE                   keyUsage;
+  TPM_KEY_FLAGS                   keyFlags;
+  TPM_AUTH_DATA_USAGE             authDataUsage;
+  TPM_KEY_PARMS                   algorithmParms;
+  TPM_DIGEST                      pubkeyDigest;
+  TPM_NONCE                       data;
+  BOOLEAN                         parentPCRStatus;
+  UINT32                          PCRInfoSize;
+  UINT8                           *PCRInfo;
+  UINT32                          migrationAuthoritySize;
+  UINT8                           *migrationAuthority;
+} TPM_CERTIFY_INFO2;
+
+///
+/// Part 2, section 11.3 TPM_QUOTE_INFO Structure
+///
+typedef struct tdTPM_QUOTE_INFO {
+  TPM_STRUCT_VER                  version;
+  UINT8                           fixed[4];
+  TPM_COMPOSITE_HASH              digestValue;
+  TPM_NONCE                       externalData;
+} TPM_QUOTE_INFO;
+
+///
+/// Part 2, section 11.4 TPM_QUOTE_INFO2 Structure
+///
+typedef struct tdTPM_QUOTE_INFO2 {
+  TPM_STRUCTURE_TAG               tag;
+  UINT8                           fixed[4];
+  TPM_NONCE                       externalData;
+  TPM_PCR_INFO_SHORT              infoShort;
+} TPM_QUOTE_INFO2;
+
+//
+// Part 2, section 12: Identity Structures
+//
+
+///
+/// Part 2, section 12.1 TPM_EK_BLOB
+///
+typedef struct tdTPM_EK_BLOB {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_EK_TYPE                     ekType;
+  UINT32                          blobSize;
+  UINT8                           *blob;
+} TPM_EK_BLOB;
+
+///
+/// Part 2, section 12.2 TPM_EK_BLOB_ACTIVATE
+///
+typedef struct tdTPM_EK_BLOB_ACTIVATE {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_SYMMETRIC_KEY               sessionKey;
+  TPM_DIGEST                      idDigest;
+  TPM_PCR_INFO_SHORT              pcrInfo;
+} TPM_EK_BLOB_ACTIVATE;
+
+///
+/// Part 2, section 12.3 TPM_EK_BLOB_AUTH
+///
+typedef struct tdTPM_EK_BLOB_AUTH {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_SECRET                      authValue;
+} TPM_EK_BLOB_AUTH;
+
+
+///
+/// Part 2, section 12.5 TPM_IDENTITY_CONTENTS
+///
+typedef struct tdTPM_IDENTITY_CONTENTS {
+  TPM_STRUCT_VER                  ver;
+  UINT32                          ordinal;
+  TPM_CHOSENID_HASH               labelPrivCADigest;
+  TPM_PUBKEY                      identityPubKey;
+} TPM_IDENTITY_CONTENTS;
+
+///
+/// Part 2, section 12.6 TPM_IDENTITY_REQ
+///
+typedef struct tdTPM_IDENTITY_REQ {
+  UINT32                          asymSize;
+  UINT32                          symSize;
+  TPM_KEY_PARMS                   asymAlgorithm;
+  TPM_KEY_PARMS                   symAlgorithm;
+  UINT8                           *asymBlob;
+  UINT8                           *symBlob;
+} TPM_IDENTITY_REQ;
+
+///
+/// Part 2, section 12.7 TPM_IDENTITY_PROOF
+///
+typedef struct tdTPM_IDENTITY_PROOF {
+  TPM_STRUCT_VER                  ver;
+  UINT32                          labelSize;
+  UINT32                          identityBindingSize;
+  UINT32                          endorsementSize;
+  UINT32                          platformSize;
+  UINT32                          conformanceSize;
+  TPM_PUBKEY                      identityKey;
+  UINT8                           *labelArea;
+  UINT8                           *identityBinding;
+  UINT8                           *endorsementCredential;
+  UINT8                           *platformCredential;
+  UINT8                           *conformanceCredential;
+} TPM_IDENTITY_PROOF;
+
+///
+/// Part 2, section 12.8 TPM_ASYM_CA_CONTENTS
+///
+typedef struct tdTPM_ASYM_CA_CONTENTS {
+  TPM_SYMMETRIC_KEY               sessionKey;
+  TPM_DIGEST                      idDigest;
+} TPM_ASYM_CA_CONTENTS;
+
+///
+/// Part 2, section 12.9 TPM_SYM_CA_ATTESTATION
+///
+typedef struct tdTPM_SYM_CA_ATTESTATION {
+  UINT32                          credSize;
+  TPM_KEY_PARMS                   algorithm;
+  UINT8                           *credential;
+} TPM_SYM_CA_ATTESTATION;
+
+///
+/// Part 2, section 15: Tick Structures
+///   Placed here out of order because definitions are used in section 13.
+///
+typedef struct tdTPM_CURRENT_TICKS {
+  TPM_STRUCTURE_TAG                 tag;
+  UINT64                            currentTicks;
+  UINT16                            tickRate;
+  TPM_NONCE                         tickNonce;
+} TPM_CURRENT_TICKS;
+
+///
+/// Part 2, section 13: Transport structures
+///
+
+///
+/// Part 2, section 13.1: TPM _TRANSPORT_PUBLIC
+///
+typedef struct tdTPM_TRANSPORT_PUBLIC {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_TRANSPORT_ATTRIBUTES        transAttributes;
+  TPM_ALGORITHM_ID                algId;
+  TPM_ENC_SCHEME                  encScheme;
+} TPM_TRANSPORT_PUBLIC;
+
+//
+// Part 2, section 13.1.1 TPM_TRANSPORT_ATTRIBUTES Definitions
+//
+#define TPM_TRANSPORT_ENCRYPT       ((UINT32)BIT0)
+#define TPM_TRANSPORT_LOG           ((UINT32)BIT1)
+#define TPM_TRANSPORT_EXCLUSIVE     ((UINT32)BIT2)
+
+///
+/// Part 2, section 13.2 TPM_TRANSPORT_INTERNAL
+///
+typedef struct tdTPM_TRANSPORT_INTERNAL {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_AUTHDATA                    authData;
+  TPM_TRANSPORT_PUBLIC            transPublic;
+  TPM_TRANSHANDLE                 transHandle;
+  TPM_NONCE                       transNonceEven;
+  TPM_DIGEST                      transDigest;
+} TPM_TRANSPORT_INTERNAL;
+
+///
+/// Part 2, section 13.3 TPM_TRANSPORT_LOG_IN structure
+///
+typedef struct tdTPM_TRANSPORT_LOG_IN {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DIGEST                      parameters;
+  TPM_DIGEST                      pubKeyHash;
+} TPM_TRANSPORT_LOG_IN;
+
+///
+/// Part 2, section 13.4 TPM_TRANSPORT_LOG_OUT structure
+///
+typedef struct tdTPM_TRANSPORT_LOG_OUT {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_CURRENT_TICKS               currentTicks;
+  TPM_DIGEST                      parameters;
+  TPM_MODIFIER_INDICATOR          locality;
+} TPM_TRANSPORT_LOG_OUT;
+
+///
+/// Part 2, section 13.5 TPM_TRANSPORT_AUTH structure
+///
+typedef struct tdTPM_TRANSPORT_AUTH {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_AUTHDATA                    authData;
+} TPM_TRANSPORT_AUTH;
+
+//
+// Part 2, section 14: Audit Structures
+//
+
+///
+/// Part 2, section 14.1 TPM_AUDIT_EVENT_IN structure
+///
+typedef struct tdTPM_AUDIT_EVENT_IN {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DIGEST                      inputParms;
+  TPM_COUNTER_VALUE               auditCount;
+} TPM_AUDIT_EVENT_IN;
+
+///
+/// Part 2, section 14.2 TPM_AUDIT_EVENT_OUT structure
+///
+typedef struct tdTPM_AUDIT_EVENT_OUT {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_COMMAND_CODE                ordinal;
+  TPM_DIGEST                      outputParms;
+  TPM_COUNTER_VALUE               auditCount;
+  TPM_RESULT                      returnCode;
+} TPM_AUDIT_EVENT_OUT;
+
+//
+// Part 2, section 16: Return Codes
+//
+
+#define TPM_VENDOR_ERROR            TPM_Vendor_Specific32
+#define TPM_NON_FATAL               0x00000800
+
+#define TPM_SUCCESS                 ((TPM_RESULT) TPM_BASE)
+#define TPM_AUTHFAIL                ((TPM_RESULT) (TPM_BASE + 1))
+#define TPM_BADINDEX                ((TPM_RESULT) (TPM_BASE + 2))
+#define TPM_BAD_PARAMETER           ((TPM_RESULT) (TPM_BASE + 3))
+#define TPM_AUDITFAILURE            ((TPM_RESULT) (TPM_BASE + 4))
+#define TPM_CLEAR_DISABLED          ((TPM_RESULT) (TPM_BASE + 5))
+#define TPM_DEACTIVATED             ((TPM_RESULT) (TPM_BASE + 6))
+#define TPM_DISABLED                ((TPM_RESULT) (TPM_BASE + 7))
+#define TPM_DISABLED_CMD            ((TPM_RESULT) (TPM_BASE + 8))
+#define TPM_FAIL                    ((TPM_RESULT) (TPM_BASE + 9))
+#define TPM_BAD_ORDINAL             ((TPM_RESULT) (TPM_BASE + 10))
+#define TPM_INSTALL_DISABLED        ((TPM_RESULT) (TPM_BASE + 11))
+#define TPM_INVALID_KEYHANDLE       ((TPM_RESULT) (TPM_BASE + 12))
+#define TPM_KEYNOTFOUND             ((TPM_RESULT) (TPM_BASE + 13))
+#define TPM_INAPPROPRIATE_ENC       ((TPM_RESULT) (TPM_BASE + 14))
+#define TPM_MIGRATEFAIL             ((TPM_RESULT) (TPM_BASE + 15))
+#define TPM_INVALID_PCR_INFO        ((TPM_RESULT) (TPM_BASE + 16))
+#define TPM_NOSPACE                 ((TPM_RESULT) (TPM_BASE + 17))
+#define TPM_NOSRK                   ((TPM_RESULT) (TPM_BASE + 18))
+#define TPM_NOTSEALED_BLOB          ((TPM_RESULT) (TPM_BASE + 19))
+#define TPM_OWNER_SET               ((TPM_RESULT) (TPM_BASE + 20))
+#define TPM_RESOURCES               ((TPM_RESULT) (TPM_BASE + 21))
+#define TPM_SHORTRANDOM             ((TPM_RESULT) (TPM_BASE + 22))
+#define TPM_SIZE                    ((TPM_RESULT) (TPM_BASE + 23))
+#define TPM_WRONGPCRVAL             ((TPM_RESULT) (TPM_BASE + 24))
+#define TPM_BAD_PARAM_SIZE          ((TPM_RESULT) (TPM_BASE + 25))
+#define TPM_SHA_THREAD              ((TPM_RESULT) (TPM_BASE + 26))
+#define TPM_SHA_ERROR               ((TPM_RESULT) (TPM_BASE + 27))
+#define TPM_FAILEDSELFTEST          ((TPM_RESULT) (TPM_BASE + 28))
+#define TPM_AUTH2FAIL               ((TPM_RESULT) (TPM_BASE + 29))
+#define TPM_BADTAG                  ((TPM_RESULT) (TPM_BASE + 30))
+#define TPM_IOERROR                 ((TPM_RESULT) (TPM_BASE + 31))
+#define TPM_ENCRYPT_ERROR           ((TPM_RESULT) (TPM_BASE + 32))
+#define TPM_DECRYPT_ERROR           ((TPM_RESULT) (TPM_BASE + 33))
+#define TPM_INVALID_AUTHHANDLE      ((TPM_RESULT) (TPM_BASE + 34))
+#define TPM_NO_ENDORSEMENT          ((TPM_RESULT) (TPM_BASE + 35))
+#define TPM_INVALID_KEYUSAGE        ((TPM_RESULT) (TPM_BASE + 36))
+#define TPM_WRONG_ENTITYTYPE        ((TPM_RESULT) (TPM_BASE + 37))
+#define TPM_INVALID_POSTINIT        ((TPM_RESULT) (TPM_BASE + 38))
+#define TPM_INAPPROPRIATE_SIG       ((TPM_RESULT) (TPM_BASE + 39))
+#define TPM_BAD_KEY_PROPERTY        ((TPM_RESULT) (TPM_BASE + 40))
+#define TPM_BAD_MIGRATION           ((TPM_RESULT) (TPM_BASE + 41))
+#define TPM_BAD_SCHEME              ((TPM_RESULT) (TPM_BASE + 42))
+#define TPM_BAD_DATASIZE            ((TPM_RESULT) (TPM_BASE + 43))
+#define TPM_BAD_MODE                ((TPM_RESULT) (TPM_BASE + 44))
+#define TPM_BAD_PRESENCE            ((TPM_RESULT) (TPM_BASE + 45))
+#define TPM_BAD_VERSION             ((TPM_RESULT) (TPM_BASE + 46))
+#define TPM_NO_WRAP_TRANSPORT       ((TPM_RESULT) (TPM_BASE + 47))
+#define TPM_AUDITFAIL_UNSUCCESSFUL  ((TPM_RESULT) (TPM_BASE + 48))
+#define TPM_AUDITFAIL_SUCCESSFUL    ((TPM_RESULT) (TPM_BASE + 49))
+#define TPM_NOTRESETABLE            ((TPM_RESULT) (TPM_BASE + 50))
+#define TPM_NOTLOCAL                ((TPM_RESULT) (TPM_BASE + 51))
+#define TPM_BAD_TYPE                ((TPM_RESULT) (TPM_BASE + 52))
+#define TPM_INVALID_RESOURCE        ((TPM_RESULT) (TPM_BASE + 53))
+#define TPM_NOTFIPS                 ((TPM_RESULT) (TPM_BASE + 54))
+#define TPM_INVALID_FAMILY          ((TPM_RESULT) (TPM_BASE + 55))
+#define TPM_NO_NV_PERMISSION        ((TPM_RESULT) (TPM_BASE + 56))
+#define TPM_REQUIRES_SIGN           ((TPM_RESULT) (TPM_BASE + 57))
+#define TPM_KEY_NOTSUPPORTED        ((TPM_RESULT) (TPM_BASE + 58))
+#define TPM_AUTH_CONFLICT           ((TPM_RESULT) (TPM_BASE + 59))
+#define TPM_AREA_LOCKED             ((TPM_RESULT) (TPM_BASE + 60))
+#define TPM_BAD_LOCALITY            ((TPM_RESULT) (TPM_BASE + 61))
+#define TPM_READ_ONLY               ((TPM_RESULT) (TPM_BASE + 62))
+#define TPM_PER_NOWRITE             ((TPM_RESULT) (TPM_BASE + 63))
+#define TPM_FAMILYCOUNT             ((TPM_RESULT) (TPM_BASE + 64))
+#define TPM_WRITE_LOCKED            ((TPM_RESULT) (TPM_BASE + 65))
+#define TPM_BAD_ATTRIBUTES          ((TPM_RESULT) (TPM_BASE + 66))
+#define TPM_INVALID_STRUCTURE       ((TPM_RESULT) (TPM_BASE + 67))
+#define TPM_KEY_OWNER_CONTROL       ((TPM_RESULT) (TPM_BASE + 68))
+#define TPM_BAD_COUNTER             ((TPM_RESULT) (TPM_BASE + 69))
+#define TPM_NOT_FULLWRITE           ((TPM_RESULT) (TPM_BASE + 70))
+#define TPM_CONTEXT_GAP             ((TPM_RESULT) (TPM_BASE + 71))
+#define TPM_MAXNVWRITES             ((TPM_RESULT) (TPM_BASE + 72))
+#define TPM_NOOPERATOR              ((TPM_RESULT) (TPM_BASE + 73))
+#define TPM_RESOURCEMISSING         ((TPM_RESULT) (TPM_BASE + 74))
+#define TPM_DELEGATE_LOCK           ((TPM_RESULT) (TPM_BASE + 75))
+#define TPM_DELEGATE_FAMILY         ((TPM_RESULT) (TPM_BASE + 76))
+#define TPM_DELEGATE_ADMIN          ((TPM_RESULT) (TPM_BASE + 77))
+#define TPM_TRANSPORT_NOTEXCLUSIVE  ((TPM_RESULT) (TPM_BASE + 78))
+#define TPM_OWNER_CONTROL           ((TPM_RESULT) (TPM_BASE + 79))
+#define TPM_DAA_RESOURCES           ((TPM_RESULT) (TPM_BASE + 80))
+#define TPM_DAA_INPUT_DATA0         ((TPM_RESULT) (TPM_BASE + 81))
+#define TPM_DAA_INPUT_DATA1         ((TPM_RESULT) (TPM_BASE + 82))
+#define TPM_DAA_ISSUER_SETTINGS     ((TPM_RESULT) (TPM_BASE + 83))
+#define TPM_DAA_TPM_SETTINGS        ((TPM_RESULT) (TPM_BASE + 84))
+#define TPM_DAA_STAGE               ((TPM_RESULT) (TPM_BASE + 85))
+#define TPM_DAA_ISSUER_VALIDITY     ((TPM_RESULT) (TPM_BASE + 86))
+#define TPM_DAA_WRONG_W             ((TPM_RESULT) (TPM_BASE + 87))
+#define TPM_BAD_HANDLE              ((TPM_RESULT) (TPM_BASE + 88))
+#define TPM_BAD_DELEGATE            ((TPM_RESULT) (TPM_BASE + 89))
+#define TPM_BADCONTEXT              ((TPM_RESULT) (TPM_BASE + 90))
+#define TPM_TOOMANYCONTEXTS         ((TPM_RESULT) (TPM_BASE + 91))
+#define TPM_MA_TICKET_SIGNATURE     ((TPM_RESULT) (TPM_BASE + 92))
+#define TPM_MA_DESTINATION          ((TPM_RESULT) (TPM_BASE + 93))
+#define TPM_MA_SOURCE               ((TPM_RESULT) (TPM_BASE + 94))
+#define TPM_MA_AUTHORITY            ((TPM_RESULT) (TPM_BASE + 95))
+#define TPM_PERMANENTEK             ((TPM_RESULT) (TPM_BASE + 97))
+#define TPM_BAD_SIGNATURE           ((TPM_RESULT) (TPM_BASE + 98))
+#define TPM_NOCONTEXTSPACE          ((TPM_RESULT) (TPM_BASE + 99))
+
+#define TPM_RETRY                   ((TPM_RESULT) (TPM_BASE + TPM_NON_FATAL))
+#define TPM_NEEDS_SELFTEST          ((TPM_RESULT) (TPM_BASE + TPM_NON_FATAL + 1))
+#define TPM_DOING_SELFTEST          ((TPM_RESULT) (TPM_BASE + TPM_NON_FATAL + 2))
+#define TPM_DEFEND_LOCK_RUNNING     ((TPM_RESULT) (TPM_BASE + TPM_NON_FATAL + 3))
+
+//
+// Part 2, section 17: Ordinals
+//
+// Ordinals are 32 bit values. The upper byte contains values that serve as
+// flag indicators, the next byte contains values indicating what committee
+// designated the ordinal, and the final two bytes contain the Command
+// Ordinal Index.
+//      3                   2                   1
+//    1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |P|C|V| Reserved| Purview |     Command Ordinal Index           |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+//  Where:
+//
+//    * P is Protected/Unprotected command. When 0 the command is a Protected
+//      command, when 1 the command is an Unprotected command.
+//
+//    * C is Non-Connection/Connection related command. When 0 this command
+//      passes through to either the protected (TPM) or unprotected (TSS)
+//      components.
+//
+//    * V is TPM/Vendor command. When 0 the command is TPM defined, when 1 the
+//      command is vendor defined.
+//
+//    * All reserved area bits are set to 0.
+//
+
+#define TPM_ORD_ActivateIdentity                  ((TPM_COMMAND_CODE) 0x0000007A)
+#define TPM_ORD_AuthorizeMigrationKey             ((TPM_COMMAND_CODE) 0x0000002B)
+#define TPM_ORD_CertifyKey                        ((TPM_COMMAND_CODE) 0x00000032)
+#define TPM_ORD_CertifyKey2                       ((TPM_COMMAND_CODE) 0x00000033)
+#define TPM_ORD_CertifySelfTest                   ((TPM_COMMAND_CODE) 0x00000052)
+#define TPM_ORD_ChangeAuth                        ((TPM_COMMAND_CODE) 0x0000000C)
+#define TPM_ORD_ChangeAuthAsymFinish              ((TPM_COMMAND_CODE) 0x0000000F)
+#define TPM_ORD_ChangeAuthAsymStart               ((TPM_COMMAND_CODE) 0x0000000E)
+#define TPM_ORD_ChangeAuthOwner                   ((TPM_COMMAND_CODE) 0x00000010)
+#define TPM_ORD_CMK_ApproveMA                     ((TPM_COMMAND_CODE) 0x0000001D)
+#define TPM_ORD_CMK_ConvertMigration              ((TPM_COMMAND_CODE) 0x00000024)
+#define TPM_ORD_CMK_CreateBlob                    ((TPM_COMMAND_CODE) 0x0000001B)
+#define TPM_ORD_CMK_CreateKey                     ((TPM_COMMAND_CODE) 0x00000013)
+#define TPM_ORD_CMK_CreateTicket                  ((TPM_COMMAND_CODE) 0x00000012)
+#define TPM_ORD_CMK_SetRestrictions               ((TPM_COMMAND_CODE) 0x0000001C)
+#define TPM_ORD_ContinueSelfTest                  ((TPM_COMMAND_CODE) 0x00000053)
+#define TPM_ORD_ConvertMigrationBlob              ((TPM_COMMAND_CODE) 0x0000002A)
+#define TPM_ORD_CreateCounter                     ((TPM_COMMAND_CODE) 0x000000DC)
+#define TPM_ORD_CreateEndorsementKeyPair          ((TPM_COMMAND_CODE) 0x00000078)
+#define TPM_ORD_CreateMaintenanceArchive          ((TPM_COMMAND_CODE) 0x0000002C)
+#define TPM_ORD_CreateMigrationBlob               ((TPM_COMMAND_CODE) 0x00000028)
+#define TPM_ORD_CreateRevocableEK                 ((TPM_COMMAND_CODE) 0x0000007F)
+#define TPM_ORD_CreateWrapKey                     ((TPM_COMMAND_CODE) 0x0000001F)
+#define TPM_ORD_DAA_JOIN                          ((TPM_COMMAND_CODE) 0x00000029)
+#define TPM_ORD_DAA_SIGN                          ((TPM_COMMAND_CODE) 0x00000031)
+#define TPM_ORD_Delegate_CreateKeyDelegation      ((TPM_COMMAND_CODE) 0x000000D4)
+#define TPM_ORD_Delegate_CreateOwnerDelegation    ((TPM_COMMAND_CODE) 0x000000D5)
+#define TPM_ORD_Delegate_LoadOwnerDelegation      ((TPM_COMMAND_CODE) 0x000000D8)
+#define TPM_ORD_Delegate_Manage                   ((TPM_COMMAND_CODE) 0x000000D2)
+#define TPM_ORD_Delegate_ReadTable                ((TPM_COMMAND_CODE) 0x000000DB)
+#define TPM_ORD_Delegate_UpdateVerification       ((TPM_COMMAND_CODE) 0x000000D1)
+#define TPM_ORD_Delegate_VerifyDelegation         ((TPM_COMMAND_CODE) 0x000000D6)
+#define TPM_ORD_DirRead                           ((TPM_COMMAND_CODE) 0x0000001A)
+#define TPM_ORD_DirWriteAuth                      ((TPM_COMMAND_CODE) 0x00000019)
+#define TPM_ORD_DisableForceClear                 ((TPM_COMMAND_CODE) 0x0000005E)
+#define TPM_ORD_DisableOwnerClear                 ((TPM_COMMAND_CODE) 0x0000005C)
+#define TPM_ORD_DisablePubekRead                  ((TPM_COMMAND_CODE) 0x0000007E)
+#define TPM_ORD_DSAP                              ((TPM_COMMAND_CODE) 0x00000011)
+#define TPM_ORD_EstablishTransport                ((TPM_COMMAND_CODE) 0x000000E6)
+#define TPM_ORD_EvictKey                          ((TPM_COMMAND_CODE) 0x00000022)
+#define TPM_ORD_ExecuteTransport                  ((TPM_COMMAND_CODE) 0x000000E7)
+#define TPM_ORD_Extend                            ((TPM_COMMAND_CODE) 0x00000014)
+#define TPM_ORD_FieldUpgrade                      ((TPM_COMMAND_CODE) 0x000000AA)
+#define TPM_ORD_FlushSpecific                     ((TPM_COMMAND_CODE) 0x000000BA)
+#define TPM_ORD_ForceClear                        ((TPM_COMMAND_CODE) 0x0000005D)
+#define TPM_ORD_GetAuditDigest                    ((TPM_COMMAND_CODE) 0x00000085)
+#define TPM_ORD_GetAuditDigestSigned              ((TPM_COMMAND_CODE) 0x00000086)
+#define TPM_ORD_GetAuditEvent                     ((TPM_COMMAND_CODE) 0x00000082)
+#define TPM_ORD_GetAuditEventSigned               ((TPM_COMMAND_CODE) 0x00000083)
+#define TPM_ORD_GetCapability                     ((TPM_COMMAND_CODE) 0x00000065)
+#define TPM_ORD_GetCapabilityOwner                ((TPM_COMMAND_CODE) 0x00000066)
+#define TPM_ORD_GetCapabilitySigned               ((TPM_COMMAND_CODE) 0x00000064)
+#define TPM_ORD_GetOrdinalAuditStatus             ((TPM_COMMAND_CODE) 0x0000008C)
+#define TPM_ORD_GetPubKey                         ((TPM_COMMAND_CODE) 0x00000021)
+#define TPM_ORD_GetRandom                         ((TPM_COMMAND_CODE) 0x00000046)
+#define TPM_ORD_GetTestResult                     ((TPM_COMMAND_CODE) 0x00000054)
+#define TPM_ORD_GetTicks                          ((TPM_COMMAND_CODE) 0x000000F1)
+#define TPM_ORD_IncrementCounter                  ((TPM_COMMAND_CODE) 0x000000DD)
+#define TPM_ORD_Init                              ((TPM_COMMAND_CODE) 0x00000097)
+#define TPM_ORD_KeyControlOwner                   ((TPM_COMMAND_CODE) 0x00000023)
+#define TPM_ORD_KillMaintenanceFeature            ((TPM_COMMAND_CODE) 0x0000002E)
+#define TPM_ORD_LoadAuthContext                   ((TPM_COMMAND_CODE) 0x000000B7)
+#define TPM_ORD_LoadContext                       ((TPM_COMMAND_CODE) 0x000000B9)
+#define TPM_ORD_LoadKey                           ((TPM_COMMAND_CODE) 0x00000020)
+#define TPM_ORD_LoadKey2                          ((TPM_COMMAND_CODE) 0x00000041)
+#define TPM_ORD_LoadKeyContext                    ((TPM_COMMAND_CODE) 0x000000B5)
+#define TPM_ORD_LoadMaintenanceArchive            ((TPM_COMMAND_CODE) 0x0000002D)
+#define TPM_ORD_LoadManuMaintPub                  ((TPM_COMMAND_CODE) 0x0000002F)
+#define TPM_ORD_MakeIdentity                      ((TPM_COMMAND_CODE) 0x00000079)
+#define TPM_ORD_MigrateKey                        ((TPM_COMMAND_CODE) 0x00000025)
+#define TPM_ORD_NV_DefineSpace                    ((TPM_COMMAND_CODE) 0x000000CC)
+#define TPM_ORD_NV_ReadValue                      ((TPM_COMMAND_CODE) 0x000000CF)
+#define TPM_ORD_NV_ReadValueAuth                  ((TPM_COMMAND_CODE) 0x000000D0)
+#define TPM_ORD_NV_WriteValue                     ((TPM_COMMAND_CODE) 0x000000CD)
+#define TPM_ORD_NV_WriteValueAuth                 ((TPM_COMMAND_CODE) 0x000000CE)
+#define TPM_ORD_OIAP                              ((TPM_COMMAND_CODE) 0x0000000A)
+#define TPM_ORD_OSAP                              ((TPM_COMMAND_CODE) 0x0000000B)
+#define TPM_ORD_OwnerClear                        ((TPM_COMMAND_CODE) 0x0000005B)
+#define TPM_ORD_OwnerReadInternalPub              ((TPM_COMMAND_CODE) 0x00000081)
+#define TPM_ORD_OwnerReadPubek                    ((TPM_COMMAND_CODE) 0x0000007D)
+#define TPM_ORD_OwnerSetDisable                   ((TPM_COMMAND_CODE) 0x0000006E)
+#define TPM_ORD_PCR_Reset                         ((TPM_COMMAND_CODE) 0x000000C8)
+#define TPM_ORD_PcrRead                           ((TPM_COMMAND_CODE) 0x00000015)
+#define TPM_ORD_PhysicalDisable                   ((TPM_COMMAND_CODE) 0x00000070)
+#define TPM_ORD_PhysicalEnable                    ((TPM_COMMAND_CODE) 0x0000006F)
+#define TPM_ORD_PhysicalSetDeactivated            ((TPM_COMMAND_CODE) 0x00000072)
+#define TPM_ORD_Quote                             ((TPM_COMMAND_CODE) 0x00000016)
+#define TPM_ORD_Quote2                            ((TPM_COMMAND_CODE) 0x0000003E)
+#define TPM_ORD_ReadCounter                       ((TPM_COMMAND_CODE) 0x000000DE)
+#define TPM_ORD_ReadManuMaintPub                  ((TPM_COMMAND_CODE) 0x00000030)
+#define TPM_ORD_ReadPubek                         ((TPM_COMMAND_CODE) 0x0000007C)
+#define TPM_ORD_ReleaseCounter                    ((TPM_COMMAND_CODE) 0x000000DF)
+#define TPM_ORD_ReleaseCounterOwner               ((TPM_COMMAND_CODE) 0x000000E0)
+#define TPM_ORD_ReleaseTransportSigned            ((TPM_COMMAND_CODE) 0x000000E8)
+#define TPM_ORD_Reset                             ((TPM_COMMAND_CODE) 0x0000005A)
+#define TPM_ORD_ResetLockValue                    ((TPM_COMMAND_CODE) 0x00000040)
+#define TPM_ORD_RevokeTrust                       ((TPM_COMMAND_CODE) 0x00000080)
+#define TPM_ORD_SaveAuthContext                   ((TPM_COMMAND_CODE) 0x000000B6)
+#define TPM_ORD_SaveContext                       ((TPM_COMMAND_CODE) 0x000000B8)
+#define TPM_ORD_SaveKeyContext                    ((TPM_COMMAND_CODE) 0x000000B4)
+#define TPM_ORD_SaveState                         ((TPM_COMMAND_CODE) 0x00000098)
+#define TPM_ORD_Seal                              ((TPM_COMMAND_CODE) 0x00000017)
+#define TPM_ORD_Sealx                             ((TPM_COMMAND_CODE) 0x0000003D)
+#define TPM_ORD_SelfTestFull                      ((TPM_COMMAND_CODE) 0x00000050)
+#define TPM_ORD_SetCapability                     ((TPM_COMMAND_CODE) 0x0000003F)
+#define TPM_ORD_SetOperatorAuth                   ((TPM_COMMAND_CODE) 0x00000074)
+#define TPM_ORD_SetOrdinalAuditStatus             ((TPM_COMMAND_CODE) 0x0000008D)
+#define TPM_ORD_SetOwnerInstall                   ((TPM_COMMAND_CODE) 0x00000071)
+#define TPM_ORD_SetOwnerPointer                   ((TPM_COMMAND_CODE) 0x00000075)
+#define TPM_ORD_SetRedirection                    ((TPM_COMMAND_CODE) 0x0000009A)
+#define TPM_ORD_SetTempDeactivated                ((TPM_COMMAND_CODE) 0x00000073)
+#define TPM_ORD_SHA1Complete                      ((TPM_COMMAND_CODE) 0x000000A2)
+#define TPM_ORD_SHA1CompleteExtend                ((TPM_COMMAND_CODE) 0x000000A3)
+#define TPM_ORD_SHA1Start                         ((TPM_COMMAND_CODE) 0x000000A0)
+#define TPM_ORD_SHA1Update                        ((TPM_COMMAND_CODE) 0x000000A1)
+#define TPM_ORD_Sign                              ((TPM_COMMAND_CODE) 0x0000003C)
+#define TPM_ORD_Startup                           ((TPM_COMMAND_CODE) 0x00000099)
+#define TPM_ORD_StirRandom                        ((TPM_COMMAND_CODE) 0x00000047)
+#define TPM_ORD_TakeOwnership                     ((TPM_COMMAND_CODE) 0x0000000D)
+#define TPM_ORD_Terminate_Handle                  ((TPM_COMMAND_CODE) 0x00000096)
+#define TPM_ORD_TickStampBlob                     ((TPM_COMMAND_CODE) 0x000000F2)
+#define TPM_ORD_UnBind                            ((TPM_COMMAND_CODE) 0x0000001E)
+#define TPM_ORD_Unseal                            ((TPM_COMMAND_CODE) 0x00000018)
+#define TSC_ORD_PhysicalPresence                  ((TPM_COMMAND_CODE) 0x4000000A)
+#define TSC_ORD_ResetEstablishmentBit             ((TPM_COMMAND_CODE) 0x4000000B)
+
+//
+// Part 2, section 18: Context structures
+//
+
+///
+/// Part 2, section 18.1: TPM_CONTEXT_BLOB
+///
+typedef struct tdTPM_CONTEXT_BLOB {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_RESOURCE_TYPE               resourceType;
+  TPM_HANDLE                      handle;
+  UINT8                           label[16];
+  UINT32                          contextCount;
+  TPM_DIGEST                      integrityDigest;
+  UINT32                          additionalSize;
+  UINT8                           *additionalData;
+  UINT32                          sensitiveSize;
+  UINT8                           *sensitiveData;
+} TPM_CONTEXT_BLOB;
+
+///
+/// Part 2, section 18.2 TPM_CONTEXT_SENSITIVE
+///
+typedef struct tdTPM_CONTEXT_SENSITIVE {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_NONCE                       contextNonce;
+  UINT32                          internalSize;
+  UINT8                           *internalData;
+} TPM_CONTEXT_SENSITIVE;
+
+//
+// Part 2, section 19: NV Structures
+//
+
+//
+// Part 2, section 19.1.1: Required TPM_NV_INDEX values
+//
+#define TPM_NV_INDEX_LOCK              ((UINT32)0xffffffff)
+#define TPM_NV_INDEX0                  ((UINT32)0x00000000)
+#define TPM_NV_INDEX_DIR               ((UINT32)0x10000001)
+#define TPM_NV_INDEX_EKCert            ((UINT32)0x0000f000)
+#define TPM_NV_INDEX_TPM_CC            ((UINT32)0x0000f001)
+#define TPM_NV_INDEX_PlatformCert      ((UINT32)0x0000f002)
+#define TPM_NV_INDEX_Platform_CC       ((UINT32)0x0000f003)
+//
+// Part 2, section 19.1.2: Reserved Index values
+//
+#define TPM_NV_INDEX_TSS_BASE          ((UINT32)0x00011100)
+#define TPM_NV_INDEX_PC_BASE           ((UINT32)0x00011200)
+#define TPM_NV_INDEX_SERVER_BASE       ((UINT32)0x00011300)
+#define TPM_NV_INDEX_MOBILE_BASE       ((UINT32)0x00011400)
+#define TPM_NV_INDEX_PERIPHERAL_BASE   ((UINT32)0x00011500)
+#define TPM_NV_INDEX_GROUP_RESV_BASE   ((UINT32)0x00010000)
+
+///
+/// Part 2, section 19.2: TPM_NV_ATTRIBUTES
+///
+typedef struct tdTPM_NV_ATTRIBUTES {
+  TPM_STRUCTURE_TAG               tag;
+  UINT32                          attributes;
+} TPM_NV_ATTRIBUTES;
+
+#define TPM_NV_PER_READ_STCLEAR        (BIT31)
+#define TPM_NV_PER_AUTHREAD            (BIT18)
+#define TPM_NV_PER_OWNERREAD           (BIT17)
+#define TPM_NV_PER_PPREAD              (BIT16)
+#define TPM_NV_PER_GLOBALLOCK          (BIT15)
+#define TPM_NV_PER_WRITE_STCLEAR       (BIT14)
+#define TPM_NV_PER_WRITEDEFINE         (BIT13)
+#define TPM_NV_PER_WRITEALL            (BIT12)
+#define TPM_NV_PER_AUTHWRITE           (BIT2)
+#define TPM_NV_PER_OWNERWRITE          (BIT1)
+#define TPM_NV_PER_PPWRITE             (BIT0)
+
+///
+/// Part 2, section 19.3: TPM_NV_DATA_PUBLIC
+///
+typedef struct tdTPM_NV_DATA_PUBLIC {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_NV_INDEX                    nvIndex;
+  TPM_PCR_INFO_SHORT              pcrInfoRead;
+  TPM_PCR_INFO_SHORT              pcrInfoWrite;
+  TPM_NV_ATTRIBUTES               permission;
+  BOOLEAN                         bReadSTClear;
+  BOOLEAN                         bWriteSTClear;
+  BOOLEAN                         bWriteDefine;
+  UINT32                          dataSize;
+} TPM_NV_DATA_PUBLIC;
+
+//
+// Part 2, section 20: Delegate Structures
+//
+
+#define TPM_DEL_OWNER_BITS          ((UINT32)0x00000001)
+#define TPM_DEL_KEY_BITS            ((UINT32)0x00000002)
+///
+/// Part 2, section 20.2: Delegate Definitions
+///
+typedef struct tdTPM_DELEGATIONS {
+  TPM_STRUCTURE_TAG               tag;
+  UINT32                          delegateType;
+  UINT32                          per1;
+  UINT32                          per2;
+} TPM_DELEGATIONS;
+
+//
+// Part 2, section 20.2.1: Owner Permission Settings
+//
+#define TPM_DELEGATE_SetOrdinalAuditStatus          (BIT30)
+#define TPM_DELEGATE_DirWriteAuth                   (BIT29)
+#define TPM_DELEGATE_CMK_ApproveMA                  (BIT28)
+#define TPM_DELEGATE_NV_WriteValue                  (BIT27)
+#define TPM_DELEGATE_CMK_CreateTicket               (BIT26)
+#define TPM_DELEGATE_NV_ReadValue                   (BIT25)
+#define TPM_DELEGATE_Delegate_LoadOwnerDelegation   (BIT24)
+#define TPM_DELEGATE_DAA_Join                       (BIT23)
+#define TPM_DELEGATE_AuthorizeMigrationKey          (BIT22)
+#define TPM_DELEGATE_CreateMaintenanceArchive       (BIT21)
+#define TPM_DELEGATE_LoadMaintenanceArchive         (BIT20)
+#define TPM_DELEGATE_KillMaintenanceFeature         (BIT19)
+#define TPM_DELEGATE_OwnerReadInteralPub            (BIT18)
+#define TPM_DELEGATE_ResetLockValue                 (BIT17)
+#define TPM_DELEGATE_OwnerClear                     (BIT16)
+#define TPM_DELEGATE_DisableOwnerClear              (BIT15)
+#define TPM_DELEGATE_NV_DefineSpace                 (BIT14)
+#define TPM_DELEGATE_OwnerSetDisable                (BIT13)
+#define TPM_DELEGATE_SetCapability                  (BIT12)
+#define TPM_DELEGATE_MakeIdentity                   (BIT11)
+#define TPM_DELEGATE_ActivateIdentity               (BIT10)
+#define TPM_DELEGATE_OwnerReadPubek                 (BIT9)
+#define TPM_DELEGATE_DisablePubekRead               (BIT8)
+#define TPM_DELEGATE_SetRedirection                 (BIT7)
+#define TPM_DELEGATE_FieldUpgrade                   (BIT6)
+#define TPM_DELEGATE_Delegate_UpdateVerification    (BIT5)
+#define TPM_DELEGATE_CreateCounter                  (BIT4)
+#define TPM_DELEGATE_ReleaseCounterOwner            (BIT3)
+#define TPM_DELEGATE_DelegateManage                 (BIT2)
+#define TPM_DELEGATE_Delegate_CreateOwnerDelegation (BIT1)
+#define TPM_DELEGATE_DAA_Sign                       (BIT0)
+
+//
+// Part 2, section 20.2.3: Key Permission settings
+//
+#define TPM_KEY_DELEGATE_CMK_ConvertMigration       (BIT28)
+#define TPM_KEY_DELEGATE_TickStampBlob              (BIT27)
+#define TPM_KEY_DELEGATE_ChangeAuthAsymStart        (BIT26)
+#define TPM_KEY_DELEGATE_ChangeAuthAsymFinish       (BIT25)
+#define TPM_KEY_DELEGATE_CMK_CreateKey              (BIT24)
+#define TPM_KEY_DELEGATE_MigrateKey                 (BIT23)
+#define TPM_KEY_DELEGATE_LoadKey2                   (BIT22)
+#define TPM_KEY_DELEGATE_EstablishTransport         (BIT21)
+#define TPM_KEY_DELEGATE_ReleaseTransportSigned     (BIT20)
+#define TPM_KEY_DELEGATE_Quote2                     (BIT19)
+#define TPM_KEY_DELEGATE_Sealx                      (BIT18)
+#define TPM_KEY_DELEGATE_MakeIdentity               (BIT17)
+#define TPM_KEY_DELEGATE_ActivateIdentity           (BIT16)
+#define TPM_KEY_DELEGATE_GetAuditDigestSigned       (BIT15)
+#define TPM_KEY_DELEGATE_Sign                       (BIT14)
+#define TPM_KEY_DELEGATE_CertifyKey2                (BIT13)
+#define TPM_KEY_DELEGATE_CertifyKey                 (BIT12)
+#define TPM_KEY_DELEGATE_CreateWrapKey              (BIT11)
+#define TPM_KEY_DELEGATE_CMK_CreateBlob             (BIT10)
+#define TPM_KEY_DELEGATE_CreateMigrationBlob        (BIT9)
+#define TPM_KEY_DELEGATE_ConvertMigrationBlob       (BIT8)
+#define TPM_KEY_DELEGATE_CreateKeyDelegation        (BIT7)
+#define TPM_KEY_DELEGATE_ChangeAuth                 (BIT6)
+#define TPM_KEY_DELEGATE_GetPubKey                  (BIT5)
+#define TPM_KEY_DELEGATE_UnBind                     (BIT4)
+#define TPM_KEY_DELEGATE_Quote                      (BIT3)
+#define TPM_KEY_DELEGATE_Unseal                     (BIT2)
+#define TPM_KEY_DELEGATE_Seal                       (BIT1)
+#define TPM_KEY_DELEGATE_LoadKey                    (BIT0)
+
+//
+// Part 2, section 20.3: TPM_FAMILY_FLAGS
+//
+#define TPM_DELEGATE_ADMIN_LOCK           (BIT1)
+#define TPM_FAMFLAG_ENABLE                (BIT0)
+
+///
+/// Part 2, section 20.4: TPM_FAMILY_LABEL
+///
+typedef struct tdTPM_FAMILY_LABEL {
+  UINT8                           label;
+} TPM_FAMILY_LABEL;
+
+///
+/// Part 2, section 20.5: TPM_FAMILY_TABLE_ENTRY
+///
+typedef struct tdTPM_FAMILY_TABLE_ENTRY {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_FAMILY_LABEL                label;
+  TPM_FAMILY_ID                   familyID;
+  TPM_FAMILY_VERIFICATION         verificationCount;
+  TPM_FAMILY_FLAGS                flags;
+} TPM_FAMILY_TABLE_ENTRY;
+
+//
+// Part 2, section 20.6: TPM_FAMILY_TABLE
+//
+#define TPM_NUM_FAMILY_TABLE_ENTRY_MIN 8
+
+typedef struct tdTPM_FAMILY_TABLE{
+  TPM_FAMILY_TABLE_ENTRY famTableRow[TPM_NUM_FAMILY_TABLE_ENTRY_MIN];
+} TPM_FAMILY_TABLE;
+
+///
+/// Part 2, section 20.7: TPM_DELEGATE_LABEL
+///
+typedef struct tdTPM_DELEGATE_LABEL {
+  UINT8                           label;
+} TPM_DELEGATE_LABEL;
+
+///
+/// Part 2, section 20.8: TPM_DELEGATE_PUBLIC
+///
+typedef struct tdTPM_DELEGATE_PUBLIC {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DELEGATE_LABEL              label;
+  TPM_PCR_INFO_SHORT              pcrInfo;
+  TPM_DELEGATIONS                 permissions;
+  TPM_FAMILY_ID                   familyID;
+  TPM_FAMILY_VERIFICATION         verificationCount;
+} TPM_DELEGATE_PUBLIC;
+
+///
+/// Part 2, section 20.9: TPM_DELEGATE_TABLE_ROW
+///
+typedef struct tdTPM_DELEGATE_TABLE_ROW {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DELEGATE_PUBLIC             pub;
+  TPM_SECRET                      authValue;
+} TPM_DELEGATE_TABLE_ROW;
+
+//
+// Part 2, section 20.10: TPM_DELEGATE_TABLE
+//
+#define TPM_NUM_DELEGATE_TABLE_ENTRY_MIN 2
+
+typedef struct tdTPM_DELEGATE_TABLE{
+  TPM_DELEGATE_TABLE_ROW delRow[TPM_NUM_DELEGATE_TABLE_ENTRY_MIN];
+} TPM_DELEGATE_TABLE;
+
+///
+/// Part 2, section 20.11: TPM_DELEGATE_SENSITIVE
+///
+typedef struct tdTPM_DELEGATE_SENSITIVE {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_SECRET                      authValue;
+} TPM_DELEGATE_SENSITIVE;
+
+///
+/// Part 2, section 20.12: TPM_DELEGATE_OWNER_BLOB
+///
+typedef struct tdTPM_DELEGATE_OWNER_BLOB {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DELEGATE_PUBLIC             pub;
+  TPM_DIGEST                      integrityDigest;
+  UINT32                          additionalSize;
+  UINT8                           *additionalArea;
+  UINT32                          sensitiveSize;
+  UINT8                           *sensitiveArea;
+} TPM_DELEGATE_OWNER_BLOB;
+
+///
+/// Part 2, section 20.13: TTPM_DELEGATE_KEY_BLOB
+///
+typedef struct tdTPM_DELEGATE_KEY_BLOB {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DELEGATE_PUBLIC             pub;
+  TPM_DIGEST                      integrityDigest;
+  TPM_DIGEST                      pubKeyDigest;
+  UINT32                          additionalSize;
+  UINT8                           *additionalArea;
+  UINT32                          sensitiveSize;
+  UINT8                           *sensitiveArea;
+} TPM_DELEGATE_KEY_BLOB;
+
+//
+// Part 2, section 20.14: TPM_FAMILY_OPERATION Values
+//
+#define TPM_FAMILY_CREATE                 ((UINT32)0x00000001)
+#define TPM_FAMILY_ENABLE                 ((UINT32)0x00000002)
+#define TPM_FAMILY_ADMIN                  ((UINT32)0x00000003)
+#define TPM_FAMILY_INVALIDATE             ((UINT32)0x00000004)
+
+//
+// Part 2, section 21.1: TPM_CAPABILITY_AREA for GetCapability
+//
+#define TPM_CAP_ORD                     ((TPM_CAPABILITY_AREA) 0x00000001)
+#define TPM_CAP_ALG                     ((TPM_CAPABILITY_AREA) 0x00000002)
+#define TPM_CAP_PID                     ((TPM_CAPABILITY_AREA) 0x00000003)
+#define TPM_CAP_FLAG                    ((TPM_CAPABILITY_AREA) 0x00000004)
+#define TPM_CAP_PROPERTY                ((TPM_CAPABILITY_AREA) 0x00000005)
+#define TPM_CAP_VERSION                 ((TPM_CAPABILITY_AREA) 0x00000006)
+#define TPM_CAP_KEY_HANDLE              ((TPM_CAPABILITY_AREA) 0x00000007)
+#define TPM_CAP_CHECK_LOADED            ((TPM_CAPABILITY_AREA) 0x00000008)
+#define TPM_CAP_SYM_MODE                ((TPM_CAPABILITY_AREA) 0x00000009)
+#define TPM_CAP_KEY_STATUS              ((TPM_CAPABILITY_AREA) 0x0000000C)
+#define TPM_CAP_NV_LIST                 ((TPM_CAPABILITY_AREA) 0x0000000D)
+#define TPM_CAP_MFR                     ((TPM_CAPABILITY_AREA) 0x00000010)
+#define TPM_CAP_NV_INDEX                ((TPM_CAPABILITY_AREA) 0x00000011)
+#define TPM_CAP_TRANS_ALG               ((TPM_CAPABILITY_AREA) 0x00000012)
+#define TPM_CAP_HANDLE                  ((TPM_CAPABILITY_AREA) 0x00000014)
+#define TPM_CAP_TRANS_ES                ((TPM_CAPABILITY_AREA) 0x00000015)
+#define TPM_CAP_AUTH_ENCRYPT            ((TPM_CAPABILITY_AREA) 0x00000017)
+#define TPM_CAP_SELECT_SIZE             ((TPM_CAPABILITY_AREA) 0x00000018)
+#define TPM_CAP_VERSION_VAL             ((TPM_CAPABILITY_AREA) 0x0000001A)
+
+#define TPM_CAP_FLAG_PERMANENT          ((TPM_CAPABILITY_AREA) 0x00000108)
+#define TPM_CAP_FLAG_VOLATILE           ((TPM_CAPABILITY_AREA) 0x00000109)
+
+//
+// Part 2, section 21.2: CAP_PROPERTY Subcap values for GetCapability
+//
+#define TPM_CAP_PROP_PCR                ((TPM_CAPABILITY_AREA) 0x00000101)
+#define TPM_CAP_PROP_DIR                ((TPM_CAPABILITY_AREA) 0x00000102)
+#define TPM_CAP_PROP_MANUFACTURER       ((TPM_CAPABILITY_AREA) 0x00000103)
+#define TPM_CAP_PROP_KEYS               ((TPM_CAPABILITY_AREA) 0x00000104)
+#define TPM_CAP_PROP_MIN_COUNTER        ((TPM_CAPABILITY_AREA) 0x00000107)
+#define TPM_CAP_PROP_AUTHSESS           ((TPM_CAPABILITY_AREA) 0x0000010A)
+#define TPM_CAP_PROP_TRANSESS           ((TPM_CAPABILITY_AREA) 0x0000010B)
+#define TPM_CAP_PROP_COUNTERS           ((TPM_CAPABILITY_AREA) 0x0000010C)
+#define TPM_CAP_PROP_MAX_AUTHSESS       ((TPM_CAPABILITY_AREA) 0x0000010D)
+#define TPM_CAP_PROP_MAX_TRANSESS       ((TPM_CAPABILITY_AREA) 0x0000010E)
+#define TPM_CAP_PROP_MAX_COUNTERS       ((TPM_CAPABILITY_AREA) 0x0000010F)
+#define TPM_CAP_PROP_MAX_KEYS           ((TPM_CAPABILITY_AREA) 0x00000110)
+#define TPM_CAP_PROP_OWNER              ((TPM_CAPABILITY_AREA) 0x00000111)
+#define TPM_CAP_PROP_CONTEXT            ((TPM_CAPABILITY_AREA) 0x00000112)
+#define TPM_CAP_PROP_MAX_CONTEXT        ((TPM_CAPABILITY_AREA) 0x00000113)
+#define TPM_CAP_PROP_FAMILYROWS         ((TPM_CAPABILITY_AREA) 0x00000114)
+#define TPM_CAP_PROP_TIS_TIMEOUT        ((TPM_CAPABILITY_AREA) 0x00000115)
+#define TPM_CAP_PROP_STARTUP_EFFECT     ((TPM_CAPABILITY_AREA) 0x00000116)
+#define TPM_CAP_PROP_DELEGATE_ROW       ((TPM_CAPABILITY_AREA) 0x00000117)
+#define TPM_CAP_PROP_DAA_MAX            ((TPM_CAPABILITY_AREA) 0x00000119)
+#define CAP_PROP_SESSION_DAA            ((TPM_CAPABILITY_AREA) 0x0000011A)
+#define TPM_CAP_PROP_CONTEXT_DIST       ((TPM_CAPABILITY_AREA) 0x0000011B)
+#define TPM_CAP_PROP_DAA_INTERRUPT      ((TPM_CAPABILITY_AREA) 0x0000011C)
+#define TPM_CAP_PROP_SESSIONS           ((TPM_CAPABILITY_AREA) 0x0000011D)
+#define TPM_CAP_PROP_MAX_SESSIONS       ((TPM_CAPABILITY_AREA) 0x0000011E)
+#define TPM_CAP_PROP_CMK_RESTRICTION    ((TPM_CAPABILITY_AREA) 0x0000011F)
+#define TPM_CAP_PROP_DURATION           ((TPM_CAPABILITY_AREA) 0x00000120)
+#define TPM_CAP_PROP_ACTIVE_COUNTER     ((TPM_CAPABILITY_AREA) 0x00000122)
+#define TPM_CAP_PROP_MAX_NV_AVAILABLE   ((TPM_CAPABILITY_AREA) 0x00000123)
+#define TPM_CAP_PROP_INPUT_BUFFER       ((TPM_CAPABILITY_AREA) 0x00000124)
+
+//
+// Part 2, section 21.4: TPM_CAPABILITY_AREA for SetCapability
+//
+#define TPM_SET_PERM_FLAGS              ((TPM_CAPABILITY_AREA) 0x00000001)
+#define TPM_SET_PERM_DATA               ((TPM_CAPABILITY_AREA) 0x00000002)
+#define TPM_SET_STCLEAR_FLAGS           ((TPM_CAPABILITY_AREA) 0x00000003)
+#define TPM_SET_STCLEAR_DATA            ((TPM_CAPABILITY_AREA) 0x00000004)
+#define TPM_SET_STANY_FLAGS             ((TPM_CAPABILITY_AREA) 0x00000005)
+#define TPM_SET_STANY_DATA              ((TPM_CAPABILITY_AREA) 0x00000006)
+
+///
+/// Part 2, section 21.6: TPM_CAP_VERSION_INFO
+///   [size_is(vendorSpecificSize)] BYTE* vendorSpecific;
+///
+typedef struct tdTPM_CAP_VERSION_INFO {
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_VERSION                       version;
+  UINT16                            specLevel;
+  UINT8                             errataRev;
+  UINT8                             tpmVendorID[4];
+  UINT16                            vendorSpecificSize;
+  UINT8                             *vendorSpecific;
+} TPM_CAP_VERSION_INFO;
+
+///
+/// Part 2, section 21.10: TPM_DA_ACTION_TYPE
+///
+typedef struct tdTPM_DA_ACTION_TYPE {
+  TPM_STRUCTURE_TAG                 tag;
+  UINT32                            actions;
+} TPM_DA_ACTION_TYPE;
+
+#define TPM_DA_ACTION_FAILURE_MODE     (((UINT32)1)<<3)
+#define TPM_DA_ACTION_DEACTIVATE       (((UINT32)1)<<2)
+#define TPM_DA_ACTION_DISABLE          (((UINT32)1)<<1)
+#define TPM_DA_ACTION_TIMEOUT          (((UINT32)1)<<0)
+
+///
+/// Part 2, section 21.7: TPM_DA_INFO
+///
+typedef struct tdTPM_DA_INFO {
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_DA_STATE                      state;
+  UINT16                            currentCount;
+  UINT16                            thresholdCount;
+  TPM_DA_ACTION_TYPE                actionAtThreshold;
+  UINT32                            actionDependValue;
+  UINT32                            vendorDataSize;
+  UINT8                             *vendorData;
+} TPM_DA_INFO;
+
+///
+/// Part 2, section 21.8: TPM_DA_INFO_LIMITED
+///
+typedef struct tdTPM_DA_INFO_LIMITED {
+  TPM_STRUCTURE_TAG                 tag;
+  TPM_DA_STATE                      state;
+  TPM_DA_ACTION_TYPE                actionAtThreshold;
+  UINT32                            vendorDataSize;
+  UINT8                             *vendorData;
+} TPM_DA_INFO_LIMITED;
+
+//
+// Part 2, section 21.9: CAP_PROPERTY Subcap values for GetCapability
+//
+#define TPM_DA_STATE_INACTIVE          ((UINT8)0x00)
+#define TPM_DA_STATE_ACTIVE            ((UINT8)0x01)
+
+//
+// Part 2, section 22: DAA Structures
+//
+
+//
+// Part 2, section 22.1: Size definitions
+//
+#define TPM_DAA_SIZE_r0                (43)
+#define TPM_DAA_SIZE_r1                (43)
+#define TPM_DAA_SIZE_r2                (128)
+#define TPM_DAA_SIZE_r3                (168)
+#define TPM_DAA_SIZE_r4                (219)
+#define TPM_DAA_SIZE_NT                (20)
+#define TPM_DAA_SIZE_v0                (128)
+#define TPM_DAA_SIZE_v1                (192)
+#define TPM_DAA_SIZE_NE                (256)
+#define TPM_DAA_SIZE_w                 (256)
+#define TPM_DAA_SIZE_issuerModulus     (256)
+//
+// Part 2, section 22.2: Constant definitions
+//
+#define TPM_DAA_power0                 (104)
+#define TPM_DAA_power1                 (1024)
+
+///
+/// Part 2, section 22.3: TPM_DAA_ISSUER
+///
+typedef struct tdTPM_DAA_ISSUER {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DIGEST                      DAA_digest_R0;
+  TPM_DIGEST                      DAA_digest_R1;
+  TPM_DIGEST                      DAA_digest_S0;
+  TPM_DIGEST                      DAA_digest_S1;
+  TPM_DIGEST                      DAA_digest_n;
+  TPM_DIGEST                      DAA_digest_gamma;
+  UINT8                           DAA_generic_q[26];
+} TPM_DAA_ISSUER;
+
+///
+/// Part 2, section 22.4: TPM_DAA_TPM
+///
+typedef struct tdTPM_DAA_TPM {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DIGEST                      DAA_digestIssuer;
+  TPM_DIGEST                      DAA_digest_v0;
+  TPM_DIGEST                      DAA_digest_v1;
+  TPM_DIGEST                      DAA_rekey;
+  UINT32                          DAA_count;
+} TPM_DAA_TPM;
+
+///
+/// Part 2, section 22.5: TPM_DAA_CONTEXT
+///
+typedef struct tdTPM_DAA_CONTEXT {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_DIGEST                      DAA_digestContext;
+  TPM_DIGEST                      DAA_digest;
+  TPM_DAA_CONTEXT_SEED            DAA_contextSeed;
+  UINT8                           DAA_scratch[256];
+  UINT8                           DAA_stage;
+} TPM_DAA_CONTEXT;
+
+///
+/// Part 2, section 22.6: TPM_DAA_JOINDATA
+///
+typedef struct tdTPM_DAA_JOINDATA {
+  UINT8                           DAA_join_u0[128];
+  UINT8                           DAA_join_u1[138];
+  TPM_DIGEST                      DAA_digest_n0;
+} TPM_DAA_JOINDATA;
+
+///
+/// Part 2, section 22.8: TPM_DAA_BLOB
+///
+typedef struct tdTPM_DAA_BLOB {
+  TPM_STRUCTURE_TAG               tag;
+  TPM_RESOURCE_TYPE               resourceType;
+  UINT8                           label[16];
+  TPM_DIGEST                      blobIntegrity;
+  UINT32                          additionalSize;
+  UINT8                           *additionalData;
+  UINT32                          sensitiveSize;
+  UINT8                           *sensitiveData;
+} TPM_DAA_BLOB;
+
+///
+/// Part 2, section 22.9: TPM_DAA_SENSITIVE
+///
+typedef struct tdTPM_DAA_SENSITIVE {
+  TPM_STRUCTURE_TAG               tag;
+  UINT32                          internalSize;
+  UINT8                           *internalData;
+} TPM_DAA_SENSITIVE;
+
+
+//
+// Part 2, section 23: Redirection
+//
+
+///
+/// Part 2 section 23.1: TPM_REDIR_COMMAND
+/// This section defines exactly one value but does not
+/// give it a name. The definition of TPM_SetRedirection in Part3
+/// refers to exactly one name but does not give its value. We join
+/// them here.
+///
+#define TPM_REDIR_GPIO              (0x00000001)
+
+///
+/// TPM Command Headers defined in Part 3
+///
+typedef struct tdTPM_RQU_COMMAND_HDR {
+  TPM_STRUCTURE_TAG                 tag;
+  UINT32                            paramSize;
+  TPM_COMMAND_CODE                  ordinal;
+} TPM_RQU_COMMAND_HDR;
+
+///
+/// TPM Response Headers defined in Part 3
+///
+typedef struct tdTPM_RSP_COMMAND_HDR {
+  TPM_STRUCTURE_TAG                 tag;
+  UINT32                            paramSize;
+  TPM_RESULT                        returnCode;
+} TPM_RSP_COMMAND_HDR;
+
+#pragma pack ()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Tpm20.h b/MdePkg/Include/IndustryStandard/Tpm20.h
new file mode 100644
index 000000000000..697a2d7be408
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Tpm20.h
@@ -0,0 +1,1820 @@
+/** @file
+  TPM2.0 Specification data structures
+  (Trusted Platform Module Library Specification, Family "2.0", Level 00, Revision 00.96,
+  @http://www.trustedcomputinggroup.org/resources/tpm_library_specification)
+
+  Check http://trustedcomputinggroup.org for latest specification updates.
+
+Copyright (c) 2013 - 2015, 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 _TPM20_H_
+#define _TPM20_H_
+
+#include <IndustryStandard/Tpm12.h>
+
+#pragma pack (1)
+
+// Annex A Algorithm Constants
+
+// Table 205 - Defines for SHA1 Hash Values
+#define SHA1_DIGEST_SIZE 20
+#define SHA1_BLOCK_SIZE  64
+
+// Table 206 - Defines for SHA256 Hash Values
+#define SHA256_DIGEST_SIZE 32
+#define SHA256_BLOCK_SIZE  64
+
+// Table 207 - Defines for SHA384 Hash Values
+#define SHA384_DIGEST_SIZE 48
+#define SHA384_BLOCK_SIZE  128
+
+// Table 208 - Defines for SHA512 Hash Values
+#define SHA512_DIGEST_SIZE 64
+#define SHA512_BLOCK_SIZE  128
+
+// Table 209 - Defines for SM3_256 Hash Values
+#define SM3_256_DIGEST_SIZE 32
+#define SM3_256_BLOCK_SIZE  64
+
+// Table 210 - Defines for Architectural Limits Values
+#define MAX_SESSION_NUMBER 3
+
+// Annex B Implementation Definitions
+
+// Table 211 - Defines for Logic Values
+#define YES   1
+#define NO    0
+#define SET   1
+#define CLEAR 0
+
+// Table 215 - Defines for RSA Algorithm Constants
+#define MAX_RSA_KEY_BITS  2048
+#define MAX_RSA_KEY_BYTES ((MAX_RSA_KEY_BITS + 7) / 8)
+
+// Table 216 - Defines for ECC Algorithm Constants
+#define MAX_ECC_KEY_BITS  256
+#define MAX_ECC_KEY_BYTES ((MAX_ECC_KEY_BITS + 7) / 8)
+
+// Table 217 - Defines for AES Algorithm Constants
+#define MAX_AES_KEY_BITS         128
+#define MAX_AES_BLOCK_SIZE_BYTES 16
+#define MAX_AES_KEY_BYTES        ((MAX_AES_KEY_BITS + 7) / 8)
+
+// Table 218 - Defines for SM4 Algorithm Constants
+#define MAX_SM4_KEY_BITS         128
+#define MAX_SM4_BLOCK_SIZE_BYTES 16
+#define MAX_SM4_KEY_BYTES        ((MAX_SM4_KEY_BITS + 7) / 8)
+
+// Table 219 - Defines for Symmetric Algorithm Constants
+#define MAX_SYM_KEY_BITS   MAX_AES_KEY_BITS
+#define MAX_SYM_KEY_BYTES  MAX_AES_KEY_BYTES
+#define MAX_SYM_BLOCK_SIZE MAX_AES_BLOCK_SIZE_BYTES
+
+// Table 220 - Defines for Implementation Values
+typedef UINT16                        BSIZE;
+#define BUFFER_ALIGNMENT              4
+#define IMPLEMENTATION_PCR            24
+#define PLATFORM_PCR                  24
+#define DRTM_PCR                      17
+#define NUM_LOCALITIES                5
+#define MAX_HANDLE_NUM                3
+#define MAX_ACTIVE_SESSIONS           64
+typedef UINT16                        CONTEXT_SLOT;
+typedef UINT64                        CONTEXT_COUNTER;
+#define MAX_LOADED_SESSIONS           3
+#define MAX_SESSION_NUM               3
+#define MAX_LOADED_OBJECTS            3
+#define MIN_EVICT_OBJECTS             2
+#define PCR_SELECT_MIN                ((PLATFORM_PCR + 7) / 8)
+#define PCR_SELECT_MAX                ((IMPLEMENTATION_PCR + 7) / 8)
+#define NUM_POLICY_PCR_GROUP          1
+#define NUM_AUTHVALUE_PCR_GROUP       1
+#define MAX_CONTEXT_SIZE              4000
+#define MAX_DIGEST_BUFFER             1024
+#define MAX_NV_INDEX_SIZE             1024
+#define MAX_CAP_BUFFER                1024
+#define NV_MEMORY_SIZE                16384
+#define NUM_STATIC_PCR                16
+#define MAX_ALG_LIST_SIZE             64
+#define TIMER_PRESCALE                100000
+#define PRIMARY_SEED_SIZE             32
+#define CONTEXT_ENCRYPT_ALG           TPM_ALG_AES
+#define CONTEXT_ENCRYPT_KEY_BITS      MAX_SYM_KEY_BITS
+#define CONTEXT_ENCRYPT_KEY_BYTES     ((CONTEXT_ENCRYPT_KEY_BITS + 7) / 8)
+#define CONTEXT_INTEGRITY_HASH_ALG    TPM_ALG_SHA256
+#define CONTEXT_INTEGRITY_HASH_SIZE   SHA256_DIGEST_SIZE
+#define PROOF_SIZE                    CONTEXT_INTEGRITY_HASH_SIZE
+#define NV_CLOCK_UPDATE_INTERVAL      12
+#define NUM_POLICY_PCR                1
+#define MAX_COMMAND_SIZE              4096
+#define MAX_RESPONSE_SIZE             4096
+#define ORDERLY_BITS                  8
+#define MAX_ORDERLY_COUNT             ((1 << ORDERLY_BITS) - 1)
+#define ALG_ID_FIRST                  TPM_ALG_FIRST
+#define ALG_ID_LAST                   TPM_ALG_LAST
+#define MAX_SYM_DATA                  128
+#define MAX_RNG_ENTROPY_SIZE          64
+#define RAM_INDEX_SPACE               512
+#define RSA_DEFAULT_PUBLIC_EXPONENT   0x00010001
+#define CRT_FORMAT_RSA                YES
+#define PRIVATE_VENDOR_SPECIFIC_BYTES ((MAX_RSA_KEY_BYTES / 2) * ( 3 + CRT_FORMAT_RSA * 2))
+
+// Capability related MAX_ value
+#define MAX_CAP_DATA       (MAX_CAP_BUFFER - sizeof(TPM_CAP) - sizeof(UINT32))
+#define MAX_CAP_ALGS       (MAX_CAP_DATA / sizeof(TPMS_ALG_PROPERTY))
+#define MAX_CAP_HANDLES    (MAX_CAP_DATA / sizeof(TPM_HANDLE))
+#define MAX_CAP_CC         (MAX_CAP_DATA / sizeof(TPM_CC))
+#define MAX_TPM_PROPERTIES (MAX_CAP_DATA / sizeof(TPMS_TAGGED_PROPERTY))
+#define MAX_PCR_PROPERTIES (MAX_CAP_DATA / sizeof(TPMS_TAGGED_PCR_SELECT))
+#define MAX_ECC_CURVES     (MAX_CAP_DATA / sizeof(TPM_ECC_CURVE))
+
+//
+// Always set 5 here, because we want to support all hash algo in BIOS.
+//
+#define HASH_COUNT 5
+
+// 5 Base Types
+
+// Table 3 - Definition of Base Types
+typedef UINT8 BYTE;
+
+// Table 4 - Definition of Types for Documentation Clarity
+//
+// NOTE: Comment because it has same name as TPM1.2 (value is same, so not runtime issue)
+//
+//typedef UINT32 TPM_ALGORITHM_ID;
+//typedef UINT32 TPM_MODIFIER_INDICATOR;
+typedef UINT32 TPM_AUTHORIZATION_SIZE;
+typedef UINT32 TPM_PARAMETER_SIZE;
+typedef UINT16 TPM_KEY_SIZE;
+typedef UINT16 TPM_KEY_BITS;
+
+// 6 Constants
+
+// Table 6 - TPM_GENERATED Constants
+typedef UINT32 TPM_GENERATED;
+#define TPM_GENERATED_VALUE (TPM_GENERATED)(0xff544347)
+
+// Table 7 - TPM_ALG_ID Constants
+typedef UINT16 TPM_ALG_ID;
+//
+// NOTE: Comment some algo which has same name as TPM1.2 (value is same, so not runtime issue)
+//
+#define TPM_ALG_ERROR          (TPM_ALG_ID)(0x0000)
+#define TPM_ALG_FIRST          (TPM_ALG_ID)(0x0001)
+//#define TPM_ALG_RSA            (TPM_ALG_ID)(0x0001)
+//#define TPM_ALG_SHA            (TPM_ALG_ID)(0x0004)
+#define TPM_ALG_SHA1           (TPM_ALG_ID)(0x0004)
+//#define TPM_ALG_HMAC           (TPM_ALG_ID)(0x0005)
+#define TPM_ALG_AES            (TPM_ALG_ID)(0x0006)
+//#define TPM_ALG_MGF1           (TPM_ALG_ID)(0x0007)
+#define TPM_ALG_KEYEDHASH      (TPM_ALG_ID)(0x0008)
+//#define TPM_ALG_XOR            (TPM_ALG_ID)(0x000A)
+#define TPM_ALG_SHA256         (TPM_ALG_ID)(0x000B)
+#define TPM_ALG_SHA384         (TPM_ALG_ID)(0x000C)
+#define TPM_ALG_SHA512         (TPM_ALG_ID)(0x000D)
+#define TPM_ALG_NULL           (TPM_ALG_ID)(0x0010)
+#define TPM_ALG_SM3_256        (TPM_ALG_ID)(0x0012)
+#define TPM_ALG_SM4            (TPM_ALG_ID)(0x0013)
+#define TPM_ALG_RSASSA         (TPM_ALG_ID)(0x0014)
+#define TPM_ALG_RSAES          (TPM_ALG_ID)(0x0015)
+#define TPM_ALG_RSAPSS         (TPM_ALG_ID)(0x0016)
+#define TPM_ALG_OAEP           (TPM_ALG_ID)(0x0017)
+#define TPM_ALG_ECDSA          (TPM_ALG_ID)(0x0018)
+#define TPM_ALG_ECDH           (TPM_ALG_ID)(0x0019)
+#define TPM_ALG_ECDAA          (TPM_ALG_ID)(0x001A)
+#define TPM_ALG_SM2            (TPM_ALG_ID)(0x001B)
+#define TPM_ALG_ECSCHNORR      (TPM_ALG_ID)(0x001C)
+#define TPM_ALG_ECMQV          (TPM_ALG_ID)(0x001D)
+#define TPM_ALG_KDF1_SP800_56a (TPM_ALG_ID)(0x0020)
+#define TPM_ALG_KDF2           (TPM_ALG_ID)(0x0021)
+#define TPM_ALG_KDF1_SP800_108 (TPM_ALG_ID)(0x0022)
+#define TPM_ALG_ECC            (TPM_ALG_ID)(0x0023)
+#define TPM_ALG_SYMCIPHER      (TPM_ALG_ID)(0x0025)
+#define TPM_ALG_CTR            (TPM_ALG_ID)(0x0040)
+#define TPM_ALG_OFB            (TPM_ALG_ID)(0x0041)
+#define TPM_ALG_CBC            (TPM_ALG_ID)(0x0042)
+#define TPM_ALG_CFB            (TPM_ALG_ID)(0x0043)
+#define TPM_ALG_ECB            (TPM_ALG_ID)(0x0044)
+#define TPM_ALG_LAST           (TPM_ALG_ID)(0x0044)
+
+// Table 8 - TPM_ECC_CURVE Constants
+typedef UINT16 TPM_ECC_CURVE;
+#define TPM_ECC_NONE      (TPM_ECC_CURVE)(0x0000)
+#define TPM_ECC_NIST_P192 (TPM_ECC_CURVE)(0x0001)
+#define TPM_ECC_NIST_P224 (TPM_ECC_CURVE)(0x0002)
+#define TPM_ECC_NIST_P256 (TPM_ECC_CURVE)(0x0003)
+#define TPM_ECC_NIST_P384 (TPM_ECC_CURVE)(0x0004)
+#define TPM_ECC_NIST_P521 (TPM_ECC_CURVE)(0x0005)
+#define TPM_ECC_BN_P256   (TPM_ECC_CURVE)(0x0010)
+#define TPM_ECC_BN_P638   (TPM_ECC_CURVE)(0x0011)
+#define TPM_ECC_SM2_P256  (TPM_ECC_CURVE)(0x0020)
+
+// Table 11 - TPM_CC Constants (Numeric Order)
+typedef UINT32 TPM_CC;
+#define TPM_CC_FIRST                      (TPM_CC)(0x0000011F)
+#define TPM_CC_PP_FIRST                   (TPM_CC)(0x0000011F)
+#define TPM_CC_NV_UndefineSpaceSpecial    (TPM_CC)(0x0000011F)
+#define TPM_CC_EvictControl               (TPM_CC)(0x00000120)
+#define TPM_CC_HierarchyControl           (TPM_CC)(0x00000121)
+#define TPM_CC_NV_UndefineSpace           (TPM_CC)(0x00000122)
+#define TPM_CC_ChangeEPS                  (TPM_CC)(0x00000124)
+#define TPM_CC_ChangePPS                  (TPM_CC)(0x00000125)
+#define TPM_CC_Clear                      (TPM_CC)(0x00000126)
+#define TPM_CC_ClearControl               (TPM_CC)(0x00000127)
+#define TPM_CC_ClockSet                   (TPM_CC)(0x00000128)
+#define TPM_CC_HierarchyChangeAuth        (TPM_CC)(0x00000129)
+#define TPM_CC_NV_DefineSpace             (TPM_CC)(0x0000012A)
+#define TPM_CC_PCR_Allocate               (TPM_CC)(0x0000012B)
+#define TPM_CC_PCR_SetAuthPolicy          (TPM_CC)(0x0000012C)
+#define TPM_CC_PP_Commands                (TPM_CC)(0x0000012D)
+#define TPM_CC_SetPrimaryPolicy           (TPM_CC)(0x0000012E)
+#define TPM_CC_FieldUpgradeStart          (TPM_CC)(0x0000012F)
+#define TPM_CC_ClockRateAdjust            (TPM_CC)(0x00000130)
+#define TPM_CC_CreatePrimary              (TPM_CC)(0x00000131)
+#define TPM_CC_NV_GlobalWriteLock         (TPM_CC)(0x00000132)
+#define TPM_CC_PP_LAST                    (TPM_CC)(0x00000132)
+#define TPM_CC_GetCommandAuditDigest      (TPM_CC)(0x00000133)
+#define TPM_CC_NV_Increment               (TPM_CC)(0x00000134)
+#define TPM_CC_NV_SetBits                 (TPM_CC)(0x00000135)
+#define TPM_CC_NV_Extend                  (TPM_CC)(0x00000136)
+#define TPM_CC_NV_Write                   (TPM_CC)(0x00000137)
+#define TPM_CC_NV_WriteLock               (TPM_CC)(0x00000138)
+#define TPM_CC_DictionaryAttackLockReset  (TPM_CC)(0x00000139)
+#define TPM_CC_DictionaryAttackParameters (TPM_CC)(0x0000013A)
+#define TPM_CC_NV_ChangeAuth              (TPM_CC)(0x0000013B)
+#define TPM_CC_PCR_Event                  (TPM_CC)(0x0000013C)
+#define TPM_CC_PCR_Reset                  (TPM_CC)(0x0000013D)
+#define TPM_CC_SequenceComplete           (TPM_CC)(0x0000013E)
+#define TPM_CC_SetAlgorithmSet            (TPM_CC)(0x0000013F)
+#define TPM_CC_SetCommandCodeAuditStatus  (TPM_CC)(0x00000140)
+#define TPM_CC_FieldUpgradeData           (TPM_CC)(0x00000141)
+#define TPM_CC_IncrementalSelfTest        (TPM_CC)(0x00000142)
+#define TPM_CC_SelfTest                   (TPM_CC)(0x00000143)
+#define TPM_CC_Startup                    (TPM_CC)(0x00000144)
+#define TPM_CC_Shutdown                   (TPM_CC)(0x00000145)
+#define TPM_CC_StirRandom                 (TPM_CC)(0x00000146)
+#define TPM_CC_ActivateCredential         (TPM_CC)(0x00000147)
+#define TPM_CC_Certify                    (TPM_CC)(0x00000148)
+#define TPM_CC_PolicyNV                   (TPM_CC)(0x00000149)
+#define TPM_CC_CertifyCreation            (TPM_CC)(0x0000014A)
+#define TPM_CC_Duplicate                  (TPM_CC)(0x0000014B)
+#define TPM_CC_GetTime                    (TPM_CC)(0x0000014C)
+#define TPM_CC_GetSessionAuditDigest      (TPM_CC)(0x0000014D)
+#define TPM_CC_NV_Read                    (TPM_CC)(0x0000014E)
+#define TPM_CC_NV_ReadLock                (TPM_CC)(0x0000014F)
+#define TPM_CC_ObjectChangeAuth           (TPM_CC)(0x00000150)
+#define TPM_CC_PolicySecret               (TPM_CC)(0x00000151)
+#define TPM_CC_Rewrap                     (TPM_CC)(0x00000152)
+#define TPM_CC_Create                     (TPM_CC)(0x00000153)
+#define TPM_CC_ECDH_ZGen                  (TPM_CC)(0x00000154)
+#define TPM_CC_HMAC                       (TPM_CC)(0x00000155)
+#define TPM_CC_Import                     (TPM_CC)(0x00000156)
+#define TPM_CC_Load                       (TPM_CC)(0x00000157)
+#define TPM_CC_Quote                      (TPM_CC)(0x00000158)
+#define TPM_CC_RSA_Decrypt                (TPM_CC)(0x00000159)
+#define TPM_CC_HMAC_Start                 (TPM_CC)(0x0000015B)
+#define TPM_CC_SequenceUpdate             (TPM_CC)(0x0000015C)
+#define TPM_CC_Sign                       (TPM_CC)(0x0000015D)
+#define TPM_CC_Unseal                     (TPM_CC)(0x0000015E)
+#define TPM_CC_PolicySigned               (TPM_CC)(0x00000160)
+#define TPM_CC_ContextLoad                (TPM_CC)(0x00000161)
+#define TPM_CC_ContextSave                (TPM_CC)(0x00000162)
+#define TPM_CC_ECDH_KeyGen                (TPM_CC)(0x00000163)
+#define TPM_CC_EncryptDecrypt             (TPM_CC)(0x00000164)
+#define TPM_CC_FlushContext               (TPM_CC)(0x00000165)
+#define TPM_CC_LoadExternal               (TPM_CC)(0x00000167)
+#define TPM_CC_MakeCredential             (TPM_CC)(0x00000168)
+#define TPM_CC_NV_ReadPublic              (TPM_CC)(0x00000169)
+#define TPM_CC_PolicyAuthorize            (TPM_CC)(0x0000016A)
+#define TPM_CC_PolicyAuthValue            (TPM_CC)(0x0000016B)
+#define TPM_CC_PolicyCommandCode          (TPM_CC)(0x0000016C)
+#define TPM_CC_PolicyCounterTimer         (TPM_CC)(0x0000016D)
+#define TPM_CC_PolicyCpHash               (TPM_CC)(0x0000016E)
+#define TPM_CC_PolicyLocality             (TPM_CC)(0x0000016F)
+#define TPM_CC_PolicyNameHash             (TPM_CC)(0x00000170)
+#define TPM_CC_PolicyOR                   (TPM_CC)(0x00000171)
+#define TPM_CC_PolicyTicket               (TPM_CC)(0x00000172)
+#define TPM_CC_ReadPublic                 (TPM_CC)(0x00000173)
+#define TPM_CC_RSA_Encrypt                (TPM_CC)(0x00000174)
+#define TPM_CC_StartAuthSession           (TPM_CC)(0x00000176)
+#define TPM_CC_VerifySignature            (TPM_CC)(0x00000177)
+#define TPM_CC_ECC_Parameters             (TPM_CC)(0x00000178)
+#define TPM_CC_FirmwareRead               (TPM_CC)(0x00000179)
+#define TPM_CC_GetCapability              (TPM_CC)(0x0000017A)
+#define TPM_CC_GetRandom                  (TPM_CC)(0x0000017B)
+#define TPM_CC_GetTestResult              (TPM_CC)(0x0000017C)
+#define TPM_CC_Hash                       (TPM_CC)(0x0000017D)
+#define TPM_CC_PCR_Read                   (TPM_CC)(0x0000017E)
+#define TPM_CC_PolicyPCR                  (TPM_CC)(0x0000017F)
+#define TPM_CC_PolicyRestart              (TPM_CC)(0x00000180)
+#define TPM_CC_ReadClock                  (TPM_CC)(0x00000181)
+#define TPM_CC_PCR_Extend                 (TPM_CC)(0x00000182)
+#define TPM_CC_PCR_SetAuthValue           (TPM_CC)(0x00000183)
+#define TPM_CC_NV_Certify                 (TPM_CC)(0x00000184)
+#define TPM_CC_EventSequenceComplete      (TPM_CC)(0x00000185)
+#define TPM_CC_HashSequenceStart          (TPM_CC)(0x00000186)
+#define TPM_CC_PolicyPhysicalPresence     (TPM_CC)(0x00000187)
+#define TPM_CC_PolicyDuplicationSelect    (TPM_CC)(0x00000188)
+#define TPM_CC_PolicyGetDigest            (TPM_CC)(0x00000189)
+#define TPM_CC_TestParms                  (TPM_CC)(0x0000018A)
+#define TPM_CC_Commit                     (TPM_CC)(0x0000018B)
+#define TPM_CC_PolicyPassword             (TPM_CC)(0x0000018C)
+#define TPM_CC_ZGen_2Phase                (TPM_CC)(0x0000018D)
+#define TPM_CC_EC_Ephemeral               (TPM_CC)(0x0000018E)
+#define TPM_CC_LAST                       (TPM_CC)(0x0000018E)
+
+// Table 15 - TPM_RC Constants (Actions)
+typedef UINT32 TPM_RC;
+#define TPM_RC_SUCCESS           (TPM_RC)(0x000)
+#define TPM_RC_BAD_TAG           (TPM_RC)(0x030)
+#define RC_VER1                  (TPM_RC)(0x100)
+#define TPM_RC_INITIALIZE        (TPM_RC)(RC_VER1 + 0x000)
+#define TPM_RC_FAILURE           (TPM_RC)(RC_VER1 + 0x001)
+#define TPM_RC_SEQUENCE          (TPM_RC)(RC_VER1 + 0x003)
+#define TPM_RC_PRIVATE           (TPM_RC)(RC_VER1 + 0x00B)
+#define TPM_RC_HMAC              (TPM_RC)(RC_VER1 + 0x019)
+#define TPM_RC_DISABLED          (TPM_RC)(RC_VER1 + 0x020)
+#define TPM_RC_EXCLUSIVE         (TPM_RC)(RC_VER1 + 0x021)
+#define TPM_RC_AUTH_TYPE         (TPM_RC)(RC_VER1 + 0x024)
+#define TPM_RC_AUTH_MISSING      (TPM_RC)(RC_VER1 + 0x025)
+#define TPM_RC_POLICY            (TPM_RC)(RC_VER1 + 0x026)
+#define TPM_RC_PCR               (TPM_RC)(RC_VER1 + 0x027)
+#define TPM_RC_PCR_CHANGED       (TPM_RC)(RC_VER1 + 0x028)
+#define TPM_RC_UPGRADE           (TPM_RC)(RC_VER1 + 0x02D)
+#define TPM_RC_TOO_MANY_CONTEXTS (TPM_RC)(RC_VER1 + 0x02E)
+#define TPM_RC_AUTH_UNAVAILABLE  (TPM_RC)(RC_VER1 + 0x02F)
+#define TPM_RC_REBOOT            (TPM_RC)(RC_VER1 + 0x030)
+#define TPM_RC_UNBALANCED        (TPM_RC)(RC_VER1 + 0x031)
+#define TPM_RC_COMMAND_SIZE      (TPM_RC)(RC_VER1 + 0x042)
+#define TPM_RC_COMMAND_CODE      (TPM_RC)(RC_VER1 + 0x043)
+#define TPM_RC_AUTHSIZE          (TPM_RC)(RC_VER1 + 0x044)
+#define TPM_RC_AUTH_CONTEXT      (TPM_RC)(RC_VER1 + 0x045)
+#define TPM_RC_NV_RANGE          (TPM_RC)(RC_VER1 + 0x046)
+#define TPM_RC_NV_SIZE           (TPM_RC)(RC_VER1 + 0x047)
+#define TPM_RC_NV_LOCKED         (TPM_RC)(RC_VER1 + 0x048)
+#define TPM_RC_NV_AUTHORIZATION  (TPM_RC)(RC_VER1 + 0x049)
+#define TPM_RC_NV_UNINITIALIZED  (TPM_RC)(RC_VER1 + 0x04A)
+#define TPM_RC_NV_SPACE          (TPM_RC)(RC_VER1 + 0x04B)
+#define TPM_RC_NV_DEFINED        (TPM_RC)(RC_VER1 + 0x04C)
+#define TPM_RC_BAD_CONTEXT       (TPM_RC)(RC_VER1 + 0x050)
+#define TPM_RC_CPHASH            (TPM_RC)(RC_VER1 + 0x051)
+#define TPM_RC_PARENT            (TPM_RC)(RC_VER1 + 0x052)
+#define TPM_RC_NEEDS_TEST        (TPM_RC)(RC_VER1 + 0x053)
+#define TPM_RC_NO_RESULT         (TPM_RC)(RC_VER1 + 0x054)
+#define TPM_RC_SENSITIVE         (TPM_RC)(RC_VER1 + 0x055)
+#define RC_MAX_FM0               (TPM_RC)(RC_VER1 + 0x07F)
+#define RC_FMT1                  (TPM_RC)(0x080)
+#define TPM_RC_ASYMMETRIC        (TPM_RC)(RC_FMT1 + 0x001)
+#define TPM_RC_ATTRIBUTES        (TPM_RC)(RC_FMT1 + 0x002)
+#define TPM_RC_HASH              (TPM_RC)(RC_FMT1 + 0x003)
+#define TPM_RC_VALUE             (TPM_RC)(RC_FMT1 + 0x004)
+#define TPM_RC_HIERARCHY         (TPM_RC)(RC_FMT1 + 0x005)
+#define TPM_RC_KEY_SIZE          (TPM_RC)(RC_FMT1 + 0x007)
+#define TPM_RC_MGF               (TPM_RC)(RC_FMT1 + 0x008)
+#define TPM_RC_MODE              (TPM_RC)(RC_FMT1 + 0x009)
+#define TPM_RC_TYPE              (TPM_RC)(RC_FMT1 + 0x00A)
+#define TPM_RC_HANDLE            (TPM_RC)(RC_FMT1 + 0x00B)
+#define TPM_RC_KDF               (TPM_RC)(RC_FMT1 + 0x00C)
+#define TPM_RC_RANGE             (TPM_RC)(RC_FMT1 + 0x00D)
+#define TPM_RC_AUTH_FAIL         (TPM_RC)(RC_FMT1 + 0x00E)
+#define TPM_RC_NONCE             (TPM_RC)(RC_FMT1 + 0x00F)
+#define TPM_RC_PP                (TPM_RC)(RC_FMT1 + 0x010)
+#define TPM_RC_SCHEME            (TPM_RC)(RC_FMT1 + 0x012)
+#define TPM_RC_SIZE              (TPM_RC)(RC_FMT1 + 0x015)
+#define TPM_RC_SYMMETRIC         (TPM_RC)(RC_FMT1 + 0x016)
+#define TPM_RC_TAG               (TPM_RC)(RC_FMT1 + 0x017)
+#define TPM_RC_SELECTOR          (TPM_RC)(RC_FMT1 + 0x018)
+#define TPM_RC_INSUFFICIENT      (TPM_RC)(RC_FMT1 + 0x01A)
+#define TPM_RC_SIGNATURE         (TPM_RC)(RC_FMT1 + 0x01B)
+#define TPM_RC_KEY               (TPM_RC)(RC_FMT1 + 0x01C)
+#define TPM_RC_POLICY_FAIL       (TPM_RC)(RC_FMT1 + 0x01D)
+#define TPM_RC_INTEGRITY         (TPM_RC)(RC_FMT1 + 0x01F)
+#define TPM_RC_TICKET            (TPM_RC)(RC_FMT1 + 0x020)
+#define TPM_RC_RESERVED_BITS     (TPM_RC)(RC_FMT1 + 0x021)
+#define TPM_RC_BAD_AUTH          (TPM_RC)(RC_FMT1 + 0x022)
+#define TPM_RC_EXPIRED           (TPM_RC)(RC_FMT1 + 0x023)
+#define TPM_RC_POLICY_CC         (TPM_RC)(RC_FMT1 + 0x024 )
+#define TPM_RC_BINDING           (TPM_RC)(RC_FMT1 + 0x025)
+#define TPM_RC_CURVE             (TPM_RC)(RC_FMT1 + 0x026)
+#define TPM_RC_ECC_POINT         (TPM_RC)(RC_FMT1 + 0x027)
+#define RC_WARN                  (TPM_RC)(0x900)
+#define TPM_RC_CONTEXT_GAP       (TPM_RC)(RC_WARN + 0x001)
+#define TPM_RC_OBJECT_MEMORY     (TPM_RC)(RC_WARN + 0x002)
+#define TPM_RC_SESSION_MEMORY    (TPM_RC)(RC_WARN + 0x003)
+#define TPM_RC_MEMORY            (TPM_RC)(RC_WARN + 0x004)
+#define TPM_RC_SESSION_HANDLES   (TPM_RC)(RC_WARN + 0x005)
+#define TPM_RC_OBJECT_HANDLES    (TPM_RC)(RC_WARN + 0x006)
+#define TPM_RC_LOCALITY          (TPM_RC)(RC_WARN + 0x007)
+#define TPM_RC_YIELDED           (TPM_RC)(RC_WARN + 0x008)
+#define TPM_RC_CANCELED          (TPM_RC)(RC_WARN + 0x009)
+#define TPM_RC_TESTING           (TPM_RC)(RC_WARN + 0x00A)
+#define TPM_RC_REFERENCE_H0      (TPM_RC)(RC_WARN + 0x010)
+#define TPM_RC_REFERENCE_H1      (TPM_RC)(RC_WARN + 0x011)
+#define TPM_RC_REFERENCE_H2      (TPM_RC)(RC_WARN + 0x012)
+#define TPM_RC_REFERENCE_H3      (TPM_RC)(RC_WARN + 0x013)
+#define TPM_RC_REFERENCE_H4      (TPM_RC)(RC_WARN + 0x014)
+#define TPM_RC_REFERENCE_H5      (TPM_RC)(RC_WARN + 0x015)
+#define TPM_RC_REFERENCE_H6      (TPM_RC)(RC_WARN + 0x016)
+#define TPM_RC_REFERENCE_S0      (TPM_RC)(RC_WARN + 0x018)
+#define TPM_RC_REFERENCE_S1      (TPM_RC)(RC_WARN + 0x019)
+#define TPM_RC_REFERENCE_S2      (TPM_RC)(RC_WARN + 0x01A)
+#define TPM_RC_REFERENCE_S3      (TPM_RC)(RC_WARN + 0x01B)
+#define TPM_RC_REFERENCE_S4      (TPM_RC)(RC_WARN + 0x01C)
+#define TPM_RC_REFERENCE_S5      (TPM_RC)(RC_WARN + 0x01D)
+#define TPM_RC_REFERENCE_S6      (TPM_RC)(RC_WARN + 0x01E)
+#define TPM_RC_NV_RATE           (TPM_RC)(RC_WARN + 0x020)
+#define TPM_RC_LOCKOUT           (TPM_RC)(RC_WARN + 0x021)
+#define TPM_RC_RETRY             (TPM_RC)(RC_WARN + 0x022)
+#define TPM_RC_NV_UNAVAILABLE    (TPM_RC)(RC_WARN + 0x023)
+#define TPM_RC_NOT_USED          (TPM_RC)(RC_WARN + 0x7F)
+#define TPM_RC_H                 (TPM_RC)(0x000)
+#define TPM_RC_P                 (TPM_RC)(0x040)
+#define TPM_RC_S                 (TPM_RC)(0x800)
+#define TPM_RC_1                 (TPM_RC)(0x100)
+#define TPM_RC_2                 (TPM_RC)(0x200)
+#define TPM_RC_3                 (TPM_RC)(0x300)
+#define TPM_RC_4                 (TPM_RC)(0x400)
+#define TPM_RC_5                 (TPM_RC)(0x500)
+#define TPM_RC_6                 (TPM_RC)(0x600)
+#define TPM_RC_7                 (TPM_RC)(0x700)
+#define TPM_RC_8                 (TPM_RC)(0x800)
+#define TPM_RC_9                 (TPM_RC)(0x900)
+#define TPM_RC_A                 (TPM_RC)(0xA00)
+#define TPM_RC_B                 (TPM_RC)(0xB00)
+#define TPM_RC_C                 (TPM_RC)(0xC00)
+#define TPM_RC_D                 (TPM_RC)(0xD00)
+#define TPM_RC_E                 (TPM_RC)(0xE00)
+#define TPM_RC_F                 (TPM_RC)(0xF00)
+#define TPM_RC_N_MASK            (TPM_RC)(0xF00)
+
+// Table 16 - TPM_CLOCK_ADJUST Constants
+typedef INT8 TPM_CLOCK_ADJUST;
+#define TPM_CLOCK_COARSE_SLOWER (TPM_CLOCK_ADJUST)(-3)
+#define TPM_CLOCK_MEDIUM_SLOWER (TPM_CLOCK_ADJUST)(-2)
+#define TPM_CLOCK_FINE_SLOWER   (TPM_CLOCK_ADJUST)(-1)
+#define TPM_CLOCK_NO_CHANGE     (TPM_CLOCK_ADJUST)(0)
+#define TPM_CLOCK_FINE_FASTER   (TPM_CLOCK_ADJUST)(1)
+#define TPM_CLOCK_MEDIUM_FASTER (TPM_CLOCK_ADJUST)(2)
+#define TPM_CLOCK_COARSE_FASTER (TPM_CLOCK_ADJUST)(3)
+
+// Table 17 - TPM_EO Constants
+typedef UINT16 TPM_EO;
+#define TPM_EO_EQ          (TPM_EO)(0x0000)
+#define TPM_EO_NEQ         (TPM_EO)(0x0001)
+#define TPM_EO_SIGNED_GT   (TPM_EO)(0x0002)
+#define TPM_EO_UNSIGNED_GT (TPM_EO)(0x0003)
+#define TPM_EO_SIGNED_LT   (TPM_EO)(0x0004)
+#define TPM_EO_UNSIGNED_LT (TPM_EO)(0x0005)
+#define TPM_EO_SIGNED_GE   (TPM_EO)(0x0006)
+#define TPM_EO_UNSIGNED_GE (TPM_EO)(0x0007)
+#define TPM_EO_SIGNED_LE   (TPM_EO)(0x0008)
+#define TPM_EO_UNSIGNED_LE (TPM_EO)(0x0009)
+#define TPM_EO_BITSET      (TPM_EO)(0x000A)
+#define TPM_EO_BITCLEAR    (TPM_EO)(0x000B)
+
+// Table 18 - TPM_ST Constants
+typedef UINT16 TPM_ST;
+#define TPM_ST_RSP_COMMAND          (TPM_ST)(0x00C4)
+#define TPM_ST_NULL                 (TPM_ST)(0X8000)
+#define TPM_ST_NO_SESSIONS          (TPM_ST)(0x8001)
+#define TPM_ST_SESSIONS             (TPM_ST)(0x8002)
+#define TPM_ST_ATTEST_NV            (TPM_ST)(0x8014)
+#define TPM_ST_ATTEST_COMMAND_AUDIT (TPM_ST)(0x8015)
+#define TPM_ST_ATTEST_SESSION_AUDIT (TPM_ST)(0x8016)
+#define TPM_ST_ATTEST_CERTIFY       (TPM_ST)(0x8017)
+#define TPM_ST_ATTEST_QUOTE         (TPM_ST)(0x8018)
+#define TPM_ST_ATTEST_TIME          (TPM_ST)(0x8019)
+#define TPM_ST_ATTEST_CREATION      (TPM_ST)(0x801A)
+#define TPM_ST_CREATION             (TPM_ST)(0x8021)
+#define TPM_ST_VERIFIED             (TPM_ST)(0x8022)
+#define TPM_ST_AUTH_SECRET          (TPM_ST)(0x8023)
+#define TPM_ST_HASHCHECK            (TPM_ST)(0x8024)
+#define TPM_ST_AUTH_SIGNED          (TPM_ST)(0x8025)
+#define TPM_ST_FU_MANIFEST          (TPM_ST)(0x8029)
+
+// Table 19 - TPM_SU Constants
+typedef UINT16 TPM_SU;
+#define TPM_SU_CLEAR (TPM_SU)(0x0000)
+#define TPM_SU_STATE (TPM_SU)(0x0001)
+
+// Table 20 - TPM_SE Constants
+typedef UINT8 TPM_SE;
+#define TPM_SE_HMAC   (TPM_SE)(0x00)
+#define TPM_SE_POLICY (TPM_SE)(0x01)
+#define TPM_SE_TRIAL  (TPM_SE)(0x03)
+
+// Table 21 - TPM_CAP Constants
+typedef UINT32 TPM_CAP;
+#define TPM_CAP_FIRST           (TPM_CAP)(0x00000000)
+#define TPM_CAP_ALGS            (TPM_CAP)(0x00000000)
+#define TPM_CAP_HANDLES         (TPM_CAP)(0x00000001)
+#define TPM_CAP_COMMANDS        (TPM_CAP)(0x00000002)
+#define TPM_CAP_PP_COMMANDS     (TPM_CAP)(0x00000003)
+#define TPM_CAP_AUDIT_COMMANDS  (TPM_CAP)(0x00000004)
+#define TPM_CAP_PCRS            (TPM_CAP)(0x00000005)
+#define TPM_CAP_TPM_PROPERTIES  (TPM_CAP)(0x00000006)
+#define TPM_CAP_PCR_PROPERTIES  (TPM_CAP)(0x00000007)
+#define TPM_CAP_ECC_CURVES      (TPM_CAP)(0x00000008)
+#define TPM_CAP_LAST            (TPM_CAP)(0x00000008)
+#define TPM_CAP_VENDOR_PROPERTY (TPM_CAP)(0x00000100)
+
+// Table 22 - TPM_PT Constants
+typedef UINT32 TPM_PT;
+#define TPM_PT_NONE                (TPM_PT)(0x00000000)
+#define PT_GROUP                   (TPM_PT)(0x00000100)
+#define PT_FIXED                   (TPM_PT)(PT_GROUP * 1)
+#define TPM_PT_FAMILY_INDICATOR    (TPM_PT)(PT_FIXED + 0)
+#define TPM_PT_LEVEL               (TPM_PT)(PT_FIXED + 1)
+#define TPM_PT_REVISION            (TPM_PT)(PT_FIXED + 2)
+#define TPM_PT_DAY_OF_YEAR         (TPM_PT)(PT_FIXED + 3)
+#define TPM_PT_YEAR                (TPM_PT)(PT_FIXED + 4)
+#define TPM_PT_MANUFACTURER        (TPM_PT)(PT_FIXED + 5)
+#define TPM_PT_VENDOR_STRING_1     (TPM_PT)(PT_FIXED + 6)
+#define TPM_PT_VENDOR_STRING_2     (TPM_PT)(PT_FIXED + 7)
+#define TPM_PT_VENDOR_STRING_3     (TPM_PT)(PT_FIXED + 8)
+#define TPM_PT_VENDOR_STRING_4     (TPM_PT)(PT_FIXED + 9)
+#define TPM_PT_VENDOR_TPM_TYPE     (TPM_PT)(PT_FIXED + 10)
+#define TPM_PT_FIRMWARE_VERSION_1  (TPM_PT)(PT_FIXED + 11)
+#define TPM_PT_FIRMWARE_VERSION_2  (TPM_PT)(PT_FIXED + 12)
+#define TPM_PT_INPUT_BUFFER        (TPM_PT)(PT_FIXED + 13)
+#define TPM_PT_HR_TRANSIENT_MIN    (TPM_PT)(PT_FIXED + 14)
+#define TPM_PT_HR_PERSISTENT_MIN   (TPM_PT)(PT_FIXED + 15)
+#define TPM_PT_HR_LOADED_MIN       (TPM_PT)(PT_FIXED + 16)
+#define TPM_PT_ACTIVE_SESSIONS_MAX (TPM_PT)(PT_FIXED + 17)
+#define TPM_PT_PCR_COUNT           (TPM_PT)(PT_FIXED + 18)
+#define TPM_PT_PCR_SELECT_MIN      (TPM_PT)(PT_FIXED + 19)
+#define TPM_PT_CONTEXT_GAP_MAX     (TPM_PT)(PT_FIXED + 20)
+#define TPM_PT_NV_COUNTERS_MAX     (TPM_PT)(PT_FIXED + 22)
+#define TPM_PT_NV_INDEX_MAX        (TPM_PT)(PT_FIXED + 23)
+#define TPM_PT_MEMORY              (TPM_PT)(PT_FIXED + 24)
+#define TPM_PT_CLOCK_UPDATE        (TPM_PT)(PT_FIXED + 25)
+#define TPM_PT_CONTEXT_HASH        (TPM_PT)(PT_FIXED + 26)
+#define TPM_PT_CONTEXT_SYM         (TPM_PT)(PT_FIXED + 27)
+#define TPM_PT_CONTEXT_SYM_SIZE    (TPM_PT)(PT_FIXED + 28)
+#define TPM_PT_ORDERLY_COUNT       (TPM_PT)(PT_FIXED + 29)
+#define TPM_PT_MAX_COMMAND_SIZE    (TPM_PT)(PT_FIXED + 30)
+#define TPM_PT_MAX_RESPONSE_SIZE   (TPM_PT)(PT_FIXED + 31)
+#define TPM_PT_MAX_DIGEST          (TPM_PT)(PT_FIXED + 32)
+#define TPM_PT_MAX_OBJECT_CONTEXT  (TPM_PT)(PT_FIXED + 33)
+#define TPM_PT_MAX_SESSION_CONTEXT (TPM_PT)(PT_FIXED + 34)
+#define TPM_PT_PS_FAMILY_INDICATOR (TPM_PT)(PT_FIXED + 35)
+#define TPM_PT_PS_LEVEL            (TPM_PT)(PT_FIXED + 36)
+#define TPM_PT_PS_REVISION         (TPM_PT)(PT_FIXED + 37)
+#define TPM_PT_PS_DAY_OF_YEAR      (TPM_PT)(PT_FIXED + 38)
+#define TPM_PT_PS_YEAR             (TPM_PT)(PT_FIXED + 39)
+#define TPM_PT_SPLIT_MAX           (TPM_PT)(PT_FIXED + 40)
+#define TPM_PT_TOTAL_COMMANDS      (TPM_PT)(PT_FIXED + 41)
+#define TPM_PT_LIBRARY_COMMANDS    (TPM_PT)(PT_FIXED + 42)
+#define TPM_PT_VENDOR_COMMANDS     (TPM_PT)(PT_FIXED + 43)
+#define PT_VAR                     (TPM_PT)(PT_GROUP * 2)
+#define TPM_PT_PERMANENT           (TPM_PT)(PT_VAR + 0)
+#define TPM_PT_STARTUP_CLEAR       (TPM_PT)(PT_VAR + 1)
+#define TPM_PT_HR_NV_INDEX         (TPM_PT)(PT_VAR + 2)
+#define TPM_PT_HR_LOADED           (TPM_PT)(PT_VAR + 3)
+#define TPM_PT_HR_LOADED_AVAIL     (TPM_PT)(PT_VAR + 4)
+#define TPM_PT_HR_ACTIVE           (TPM_PT)(PT_VAR + 5)
+#define TPM_PT_HR_ACTIVE_AVAIL     (TPM_PT)(PT_VAR + 6)
+#define TPM_PT_HR_TRANSIENT_AVAIL  (TPM_PT)(PT_VAR + 7)
+#define TPM_PT_HR_PERSISTENT       (TPM_PT)(PT_VAR + 8)
+#define TPM_PT_HR_PERSISTENT_AVAIL (TPM_PT)(PT_VAR + 9)
+#define TPM_PT_NV_COUNTERS         (TPM_PT)(PT_VAR + 10)
+#define TPM_PT_NV_COUNTERS_AVAIL   (TPM_PT)(PT_VAR + 11)
+#define TPM_PT_ALGORITHM_SET       (TPM_PT)(PT_VAR + 12)
+#define TPM_PT_LOADED_CURVES       (TPM_PT)(PT_VAR + 13)
+#define TPM_PT_LOCKOUT_COUNTER     (TPM_PT)(PT_VAR + 14)
+#define TPM_PT_MAX_AUTH_FAIL       (TPM_PT)(PT_VAR + 15)
+#define TPM_PT_LOCKOUT_INTERVAL    (TPM_PT)(PT_VAR + 16)
+#define TPM_PT_LOCKOUT_RECOVERY    (TPM_PT)(PT_VAR + 17)
+#define TPM_PT_NV_WRITE_RECOVERY   (TPM_PT)(PT_VAR + 18)
+#define TPM_PT_AUDIT_COUNTER_0     (TPM_PT)(PT_VAR + 19)
+#define TPM_PT_AUDIT_COUNTER_1     (TPM_PT)(PT_VAR + 20)
+
+// Table 23 - TPM_PT_PCR Constants
+typedef UINT32 TPM_PT_PCR;
+#define TPM_PT_PCR_FIRST        (TPM_PT_PCR)(0x00000000)
+#define TPM_PT_PCR_SAVE         (TPM_PT_PCR)(0x00000000)
+#define TPM_PT_PCR_EXTEND_L0    (TPM_PT_PCR)(0x00000001)
+#define TPM_PT_PCR_RESET_L0     (TPM_PT_PCR)(0x00000002)
+#define TPM_PT_PCR_EXTEND_L1    (TPM_PT_PCR)(0x00000003)
+#define TPM_PT_PCR_RESET_L1     (TPM_PT_PCR)(0x00000004)
+#define TPM_PT_PCR_EXTEND_L2    (TPM_PT_PCR)(0x00000005)
+#define TPM_PT_PCR_RESET_L2     (TPM_PT_PCR)(0x00000006)
+#define TPM_PT_PCR_EXTEND_L3    (TPM_PT_PCR)(0x00000007)
+#define TPM_PT_PCR_RESET_L3     (TPM_PT_PCR)(0x00000008)
+#define TPM_PT_PCR_EXTEND_L4    (TPM_PT_PCR)(0x00000009)
+#define TPM_PT_PCR_RESET_L4     (TPM_PT_PCR)(0x0000000A)
+#define TPM_PT_PCR_NO_INCREMENT (TPM_PT_PCR)(0x00000011)
+#define TPM_PT_PCR_DRTM_RESET   (TPM_PT_PCR)(0x00000012)
+#define TPM_PT_PCR_POLICY       (TPM_PT_PCR)(0x00000013)
+#define TPM_PT_PCR_AUTH         (TPM_PT_PCR)(0x00000014)
+#define TPM_PT_PCR_LAST         (TPM_PT_PCR)(0x00000014)
+
+// Table 24 - TPM_PS Constants
+typedef UINT32 TPM_PS;
+#define TPM_PS_MAIN           (TPM_PS)(0x00000000)
+#define TPM_PS_PC             (TPM_PS)(0x00000001)
+#define TPM_PS_PDA            (TPM_PS)(0x00000002)
+#define TPM_PS_CELL_PHONE     (TPM_PS)(0x00000003)
+#define TPM_PS_SERVER         (TPM_PS)(0x00000004)
+#define TPM_PS_PERIPHERAL     (TPM_PS)(0x00000005)
+#define TPM_PS_TSS            (TPM_PS)(0x00000006)
+#define TPM_PS_STORAGE        (TPM_PS)(0x00000007)
+#define TPM_PS_AUTHENTICATION (TPM_PS)(0x00000008)
+#define TPM_PS_EMBEDDED       (TPM_PS)(0x00000009)
+#define TPM_PS_HARDCOPY       (TPM_PS)(0x0000000A)
+#define TPM_PS_INFRASTRUCTURE (TPM_PS)(0x0000000B)
+#define TPM_PS_VIRTUALIZATION (TPM_PS)(0x0000000C)
+#define TPM_PS_TNC            (TPM_PS)(0x0000000D)
+#define TPM_PS_MULTI_TENANT   (TPM_PS)(0x0000000E)
+#define TPM_PS_TC             (TPM_PS)(0x0000000F)
+
+// 7 Handles
+
+// Table 25 - Handles Types
+//
+// NOTE: Comment because it has same name as TPM1.2 (value is same, so not runtime issue)
+//
+//typedef UINT32    TPM_HANDLE;
+
+// Table 26 - TPM_HT Constants
+typedef UINT8 TPM_HT;
+#define TPM_HT_PCR            (TPM_HT)(0x00)
+#define TPM_HT_NV_INDEX       (TPM_HT)(0x01)
+#define TPM_HT_HMAC_SESSION   (TPM_HT)(0x02)
+#define TPM_HT_LOADED_SESSION (TPM_HT)(0x02)
+#define TPM_HT_POLICY_SESSION (TPM_HT)(0x03)
+#define TPM_HT_ACTIVE_SESSION (TPM_HT)(0x03)
+#define TPM_HT_PERMANENT      (TPM_HT)(0x40)
+#define TPM_HT_TRANSIENT      (TPM_HT)(0x80)
+#define TPM_HT_PERSISTENT     (TPM_HT)(0x81)
+
+// Table 27 - TPM_RH Constants
+typedef UINT32 TPM_RH;
+#define TPM_RH_FIRST       (TPM_RH)(0x40000000)
+#define TPM_RH_SRK         (TPM_RH)(0x40000000)
+#define TPM_RH_OWNER       (TPM_RH)(0x40000001)
+#define TPM_RH_REVOKE      (TPM_RH)(0x40000002)
+#define TPM_RH_TRANSPORT   (TPM_RH)(0x40000003)
+#define TPM_RH_OPERATOR    (TPM_RH)(0x40000004)
+#define TPM_RH_ADMIN       (TPM_RH)(0x40000005)
+#define TPM_RH_EK          (TPM_RH)(0x40000006)
+#define TPM_RH_NULL        (TPM_RH)(0x40000007)
+#define TPM_RH_UNASSIGNED  (TPM_RH)(0x40000008)
+#define TPM_RS_PW          (TPM_RH)(0x40000009)
+#define TPM_RH_LOCKOUT     (TPM_RH)(0x4000000A)
+#define TPM_RH_ENDORSEMENT (TPM_RH)(0x4000000B)
+#define TPM_RH_PLATFORM    (TPM_RH)(0x4000000C)
+#define TPM_RH_PLATFORM_NV (TPM_RH)(0x4000000D)
+#define TPM_RH_AUTH_00     (TPM_RH)(0x40000010)
+#define TPM_RH_AUTH_FF     (TPM_RH)(0x4000010F)
+#define TPM_RH_LAST        (TPM_RH)(0x4000010F)
+
+// Table 28 - TPM_HC Constants
+typedef TPM_HANDLE TPM_HC;
+#define HR_HANDLE_MASK       (TPM_HC)(0x00FFFFFF)
+#define HR_RANGE_MASK        (TPM_HC)(0xFF000000)
+#define HR_SHIFT             (TPM_HC)(24)
+#define HR_PCR               (TPM_HC)((TPM_HC)TPM_HT_PCR << HR_SHIFT)
+#define HR_HMAC_SESSION      (TPM_HC)((TPM_HC)TPM_HT_HMAC_SESSION << HR_SHIFT)
+#define HR_POLICY_SESSION    (TPM_HC)((TPM_HC)TPM_HT_POLICY_SESSION << HR_SHIFT)
+#define HR_TRANSIENT         (TPM_HC)((TPM_HC)TPM_HT_TRANSIENT << HR_SHIFT)
+#define HR_PERSISTENT        (TPM_HC)((TPM_HC)TPM_HT_PERSISTENT << HR_SHIFT)
+#define HR_NV_INDEX          (TPM_HC)((TPM_HC)TPM_HT_NV_INDEX << HR_SHIFT)
+#define HR_PERMANENT         (TPM_HC)((TPM_HC)TPM_HT_PERMANENT << HR_SHIFT)
+#define PCR_FIRST            (TPM_HC)(HR_PCR + 0)
+#define PCR_LAST             (TPM_HC)(PCR_FIRST + IMPLEMENTATION_PCR - 1)
+#define HMAC_SESSION_FIRST   (TPM_HC)(HR_HMAC_SESSION + 0)
+#define HMAC_SESSION_LAST    (TPM_HC)(HMAC_SESSION_FIRST + MAX_ACTIVE_SESSIONS - 1)
+#define LOADED_SESSION_FIRST (TPM_HC)(HMAC_SESSION_FIRST)
+#define LOADED_SESSION_LAST  (TPM_HC)(HMAC_SESSION_LAST)
+#define POLICY_SESSION_FIRST (TPM_HC)(HR_POLICY_SESSION + 0)
+#define POLICY_SESSION_LAST  (TPM_HC)(POLICY_SESSION_FIRST + MAX_ACTIVE_SESSIONS - 1)
+#define TRANSIENT_FIRST      (TPM_HC)(HR_TRANSIENT + 0)
+#define ACTIVE_SESSION_FIRST (TPM_HC)(POLICY_SESSION_FIRST)
+#define ACTIVE_SESSION_LAST  (TPM_HC)(POLICY_SESSION_LAST)
+#define TRANSIENT_LAST       (TPM_HC)(TRANSIENT_FIRST+MAX_LOADED_OBJECTS - 1)
+#define PERSISTENT_FIRST     (TPM_HC)(HR_PERSISTENT + 0)
+#define PERSISTENT_LAST      (TPM_HC)(PERSISTENT_FIRST + 0x00FFFFFF)
+#define PLATFORM_PERSISTENT  (TPM_HC)(PERSISTENT_FIRST + 0x00800000)
+#define NV_INDEX_FIRST       (TPM_HC)(HR_NV_INDEX + 0)
+#define NV_INDEX_LAST        (TPM_HC)(NV_INDEX_FIRST + 0x00FFFFFF)
+#define PERMANENT_FIRST      (TPM_HC)(TPM_RH_FIRST)
+#define PERMANENT_LAST       (TPM_HC)(TPM_RH_LAST)
+
+// 8 Attribute Structures
+
+// Table 29 - TPMA_ALGORITHM Bits
+typedef struct {
+  UINT32 asymmetric    : 1;
+  UINT32 symmetric     : 1;
+  UINT32 hash          : 1;
+  UINT32 object        : 1;
+  UINT32 reserved4_7   : 4;
+  UINT32 signing       : 1;
+  UINT32 encrypting    : 1;
+  UINT32 method        : 1;
+  UINT32 reserved11_31 : 21;
+} TPMA_ALGORITHM;
+
+// Table 30 - TPMA_OBJECT Bits
+typedef struct {
+  UINT32 reserved1            : 1;
+  UINT32 fixedTPM             : 1;
+  UINT32 stClear              : 1;
+  UINT32 reserved4            : 1;
+  UINT32 fixedParent          : 1;
+  UINT32 sensitiveDataOrigin  : 1;
+  UINT32 userWithAuth         : 1;
+  UINT32 adminWithPolicy      : 1;
+  UINT32 reserved8_9          : 2;
+  UINT32 noDA                 : 1;
+  UINT32 encryptedDuplication : 1;
+  UINT32 reserved12_15        : 4;
+  UINT32 restricted           : 1;
+  UINT32 decrypt              : 1;
+  UINT32 sign                 : 1;
+  UINT32 reserved19_31        : 13;
+} TPMA_OBJECT;
+
+// Table 31 - TPMA_SESSION Bits
+typedef struct {
+  UINT8 continueSession : 1;
+  UINT8 auditExclusive  : 1;
+  UINT8 auditReset      : 1;
+  UINT8 reserved3_4     : 2;
+  UINT8 decrypt         : 1;
+  UINT8 encrypt         : 1;
+  UINT8 audit           : 1;
+} TPMA_SESSION;
+
+// Table 32 - TPMA_LOCALITY Bits
+//
+// NOTE: Use low case here to resolve conflict
+//
+typedef struct {
+  UINT8 locZero  : 1;
+  UINT8 locOne   : 1;
+  UINT8 locTwo   : 1;
+  UINT8 locThree : 1;
+  UINT8 locFour  : 1;
+  UINT8 Extended : 3;
+} TPMA_LOCALITY;
+
+// Table 33 - TPMA_PERMANENT Bits
+typedef struct {
+  UINT32 ownerAuthSet       : 1;
+  UINT32 endorsementAuthSet : 1;
+  UINT32 lockoutAuthSet     : 1;
+  UINT32 reserved3_7        : 5;
+  UINT32 disableClear       : 1;
+  UINT32 inLockout          : 1;
+  UINT32 tpmGeneratedEPS    : 1;
+  UINT32 reserved11_31      : 21;
+} TPMA_PERMANENT;
+
+// Table 34 - TPMA_STARTUP_CLEAR Bits
+typedef struct {
+  UINT32 phEnable     : 1;
+  UINT32 shEnable     : 1;
+  UINT32 ehEnable     : 1;
+  UINT32 reserved3_30 : 28;
+  UINT32 orderly      : 1;
+} TPMA_STARTUP_CLEAR;
+
+// Table 35 - TPMA_MEMORY Bits
+typedef struct {
+  UINT32 sharedRAM         : 1;
+  UINT32 sharedNV          : 1;
+  UINT32 objectCopiedToRam : 1;
+  UINT32 reserved3_31      : 29;
+} TPMA_MEMORY;
+
+// Table 36 - TPMA_CC Bits
+typedef struct {
+  UINT32 commandIndex  : 16;
+  UINT32 reserved16_21 : 6;
+  UINT32 nv            : 1;
+  UINT32 extensive     : 1;
+  UINT32 flushed       : 1;
+  UINT32 cHandles      : 3;
+  UINT32 rHandle       : 1;
+  UINT32 V             : 1;
+  UINT32 Res           : 2;
+} TPMA_CC;
+
+// 9 Interface Types
+
+// Table 37 - TPMI_YES_NO Type
+typedef BYTE TPMI_YES_NO;
+
+// Table 38 - TPMI_DH_OBJECT Type
+typedef TPM_HANDLE TPMI_DH_OBJECT;
+
+// Table 39 - TPMI_DH_PERSISTENT Type
+typedef TPM_HANDLE TPMI_DH_PERSISTENT;
+
+// Table 40 - TPMI_DH_ENTITY Type
+typedef TPM_HANDLE TPMI_DH_ENTITY;
+
+// Table 41 - TPMI_DH_PCR Type
+typedef TPM_HANDLE TPMI_DH_PCR;
+
+// Table 42 - TPMI_SH_AUTH_SESSION Type
+typedef TPM_HANDLE TPMI_SH_AUTH_SESSION;
+
+// Table 43 - TPMI_SH_HMAC Type
+typedef TPM_HANDLE TPMI_SH_HMAC;
+
+// Table 44 - TPMI_SH_POLICY Type
+typedef TPM_HANDLE TPMI_SH_POLICY;
+
+// Table 45 - TPMI_DH_CONTEXT Type
+typedef TPM_HANDLE TPMI_DH_CONTEXT;
+
+// Table 46 - TPMI_RH_HIERARCHY Type
+typedef TPM_HANDLE TPMI_RH_HIERARCHY;
+
+// Table 47 - TPMI_RH_HIERARCHY_AUTH Type
+typedef TPM_HANDLE TPMI_RH_HIERARCHY_AUTH;
+
+// Table 48 - TPMI_RH_PLATFORM Type
+typedef TPM_HANDLE TPMI_RH_PLATFORM;
+
+// Table 49 - TPMI_RH_OWNER Type
+typedef TPM_HANDLE TPMI_RH_OWNER;
+
+// Table 50 - TPMI_RH_ENDORSEMENT Type
+typedef TPM_HANDLE TPMI_RH_ENDORSEMENT;
+
+// Table 51 - TPMI_RH_PROVISION Type
+typedef TPM_HANDLE TPMI_RH_PROVISION;
+
+// Table 52 - TPMI_RH_CLEAR Type
+typedef TPM_HANDLE TPMI_RH_CLEAR;
+
+// Table 53 - TPMI_RH_NV_AUTH Type
+typedef TPM_HANDLE TPMI_RH_NV_AUTH;
+
+// Table 54 - TPMI_RH_LOCKOUT Type
+typedef TPM_HANDLE TPMI_RH_LOCKOUT;
+
+// Table 55 - TPMI_RH_NV_INDEX Type
+typedef TPM_HANDLE TPMI_RH_NV_INDEX;
+
+// Table 56 - TPMI_ALG_HASH Type
+typedef TPM_ALG_ID TPMI_ALG_HASH;
+
+// Table 57 - TPMI_ALG_ASYM Type
+typedef TPM_ALG_ID TPMI_ALG_ASYM;
+
+// Table 58 - TPMI_ALG_SYM Type
+typedef TPM_ALG_ID TPMI_ALG_SYM;
+
+// Table 59 - TPMI_ALG_SYM_OBJECT Type
+typedef TPM_ALG_ID TPMI_ALG_SYM_OBJECT;
+
+// Table 60 - TPMI_ALG_SYM_MODE Type
+typedef TPM_ALG_ID TPMI_ALG_SYM_MODE;
+
+// Table 61 - TPMI_ALG_KDF Type
+typedef TPM_ALG_ID TPMI_ALG_KDF;
+
+// Table 62 - TPMI_ALG_SIG_SCHEME Type
+typedef TPM_ALG_ID TPMI_ALG_SIG_SCHEME;
+
+// Table 63 - TPMI_ECC_KEY_EXCHANGE Type
+typedef TPM_ALG_ID TPMI_ECC_KEY_EXCHANGE;
+
+// Table 64 - TPMI_ST_COMMAND_TAG Type
+typedef TPM_ST TPMI_ST_COMMAND_TAG;
+
+// 10 Structure Definitions
+
+// Table 65 - TPMS_ALGORITHM_DESCRIPTION Structure
+typedef struct {
+  TPM_ALG_ID     alg;
+  TPMA_ALGORITHM attributes;
+} TPMS_ALGORITHM_DESCRIPTION;
+
+// Table 66 - TPMU_HA Union
+typedef union {
+  BYTE sha1[SHA1_DIGEST_SIZE];
+  BYTE sha256[SHA256_DIGEST_SIZE];
+  BYTE sm3_256[SM3_256_DIGEST_SIZE];
+  BYTE sha384[SHA384_DIGEST_SIZE];
+  BYTE sha512[SHA512_DIGEST_SIZE];
+} TPMU_HA;
+
+// Table 67 - TPMT_HA Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+  TPMU_HA       digest;
+} TPMT_HA;
+
+// Table 68 - TPM2B_DIGEST Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(TPMU_HA)];
+} TPM2B_DIGEST;
+
+// Table 69 - TPM2B_DATA Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(TPMT_HA)];
+} TPM2B_DATA;
+
+// Table 70 - TPM2B_NONCE Types
+typedef TPM2B_DIGEST TPM2B_NONCE;
+
+// Table 71 - TPM2B_AUTH Types
+typedef TPM2B_DIGEST TPM2B_AUTH;
+
+// Table 72 - TPM2B_OPERAND Types
+typedef TPM2B_DIGEST TPM2B_OPERAND;
+
+// Table 73 - TPM2B_EVENT Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[1024];
+} TPM2B_EVENT;
+
+// Table 74 - TPM2B_MAX_BUFFER Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_DIGEST_BUFFER];
+} TPM2B_MAX_BUFFER;
+
+// Table 75 - TPM2B_MAX_NV_BUFFER Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_NV_INDEX_SIZE];
+} TPM2B_MAX_NV_BUFFER;
+
+// Table 76 - TPM2B_TIMEOUT Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(UINT64)];
+} TPM2B_TIMEOUT;
+
+// Table 77 -- TPM2B_IV Structure <I/O>
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_SYM_BLOCK_SIZE];
+} TPM2B_IV;
+
+// Table 78 - TPMU_NAME Union
+typedef union {
+  TPMT_HA    digest;
+  TPM_HANDLE handle;
+} TPMU_NAME;
+
+// Table 79 - TPM2B_NAME Structure
+typedef struct {
+  UINT16 size;
+  BYTE   name[sizeof(TPMU_NAME)];
+} TPM2B_NAME;
+
+// Table 80 - TPMS_PCR_SELECT Structure
+typedef struct {
+  UINT8 sizeofSelect;
+  BYTE  pcrSelect[PCR_SELECT_MAX];
+} TPMS_PCR_SELECT;
+
+// Table 81 - TPMS_PCR_SELECTION Structure
+typedef struct {
+  TPMI_ALG_HASH hash;
+  UINT8         sizeofSelect;
+  BYTE          pcrSelect[PCR_SELECT_MAX];
+} TPMS_PCR_SELECTION;
+
+// Table 84 - TPMT_TK_CREATION Structure
+typedef struct {
+  TPM_ST            tag;
+  TPMI_RH_HIERARCHY hierarchy;
+  TPM2B_DIGEST      digest;
+} TPMT_TK_CREATION;
+
+// Table 85 - TPMT_TK_VERIFIED Structure
+typedef struct {
+  TPM_ST            tag;
+  TPMI_RH_HIERARCHY hierarchy;
+  TPM2B_DIGEST      digest;
+} TPMT_TK_VERIFIED;
+
+// Table 86 - TPMT_TK_AUTH Structure
+typedef struct {
+  TPM_ST            tag;
+  TPMI_RH_HIERARCHY hierarchy;
+  TPM2B_DIGEST      digest;
+} TPMT_TK_AUTH;
+
+// Table 87 - TPMT_TK_HASHCHECK Structure
+typedef struct {
+  TPM_ST            tag;
+  TPMI_RH_HIERARCHY hierarchy;
+  TPM2B_DIGEST      digest;
+} TPMT_TK_HASHCHECK;
+
+// Table 88 - TPMS_ALG_PROPERTY Structure
+typedef struct {
+  TPM_ALG_ID     alg;
+  TPMA_ALGORITHM algProperties;
+} TPMS_ALG_PROPERTY;
+
+// Table 89 - TPMS_TAGGED_PROPERTY Structure
+typedef struct {
+  TPM_PT property;
+  UINT32 value;
+} TPMS_TAGGED_PROPERTY;
+
+// Table 90 - TPMS_TAGGED_PCR_SELECT Structure
+typedef struct {
+  TPM_PT tag;
+  UINT8  sizeofSelect;
+  BYTE   pcrSelect[PCR_SELECT_MAX];
+} TPMS_TAGGED_PCR_SELECT;
+
+// Table 91 - TPML_CC Structure
+typedef struct {
+  UINT32 count;
+  TPM_CC commandCodes[MAX_CAP_CC];
+} TPML_CC;
+
+// Table 92 - TPML_CCA Structure
+typedef struct {
+  UINT32  count;
+  TPMA_CC commandAttributes[MAX_CAP_CC];
+} TPML_CCA;
+
+// Table 93 - TPML_ALG Structure
+typedef struct {
+  UINT32     count;
+  TPM_ALG_ID algorithms[MAX_ALG_LIST_SIZE];
+} TPML_ALG;
+
+// Table 94 - TPML_HANDLE Structure
+typedef struct {
+  UINT32     count;
+  TPM_HANDLE handle[MAX_CAP_HANDLES];
+} TPML_HANDLE;
+
+// Table 95 - TPML_DIGEST Structure
+typedef struct {
+  UINT32       count;
+  TPM2B_DIGEST digests[8];
+} TPML_DIGEST;
+
+// Table 96 -- TPML_DIGEST_VALUES Structure <I/O>
+typedef struct {
+  UINT32  count;
+  TPMT_HA digests[HASH_COUNT];
+} TPML_DIGEST_VALUES;
+
+// Table 97 - TPM2B_DIGEST_VALUES Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(TPML_DIGEST_VALUES)];
+} TPM2B_DIGEST_VALUES;
+
+// Table 98 - TPML_PCR_SELECTION Structure
+typedef struct {
+  UINT32             count;
+  TPMS_PCR_SELECTION pcrSelections[HASH_COUNT];
+} TPML_PCR_SELECTION;
+
+// Table 99 - TPML_ALG_PROPERTY Structure
+typedef struct {
+  UINT32            count;
+  TPMS_ALG_PROPERTY algProperties[MAX_CAP_ALGS];
+} TPML_ALG_PROPERTY;
+
+// Table 100 - TPML_TAGGED_TPM_PROPERTY Structure
+typedef struct {
+  UINT32               count;
+  TPMS_TAGGED_PROPERTY tpmProperty[MAX_TPM_PROPERTIES];
+} TPML_TAGGED_TPM_PROPERTY;
+
+// Table 101 - TPML_TAGGED_PCR_PROPERTY Structure
+typedef struct {
+  UINT32                 count;
+  TPMS_TAGGED_PCR_SELECT pcrProperty[MAX_PCR_PROPERTIES];
+} TPML_TAGGED_PCR_PROPERTY;
+
+// Table 102 - TPML_ECC_CURVE Structure
+typedef struct {
+  UINT32        count;
+  TPM_ECC_CURVE eccCurves[MAX_ECC_CURVES];
+} TPML_ECC_CURVE;
+
+// Table 103 - TPMU_CAPABILITIES Union
+typedef union {
+  TPML_ALG_PROPERTY        algorithms;
+  TPML_HANDLE              handles;
+  TPML_CCA                 command;
+  TPML_CC                  ppCommands;
+  TPML_CC                  auditCommands;
+  TPML_PCR_SELECTION       assignedPCR;
+  TPML_TAGGED_TPM_PROPERTY tpmProperties;
+  TPML_TAGGED_PCR_PROPERTY pcrProperties;
+  TPML_ECC_CURVE           eccCurves;
+} TPMU_CAPABILITIES;
+
+// Table 104 - TPMS_CAPABILITY_DATA Structure
+typedef struct {
+  TPM_CAP           capability;
+  TPMU_CAPABILITIES data;
+} TPMS_CAPABILITY_DATA;
+
+// Table 105 - TPMS_CLOCK_INFO Structure
+typedef struct {
+  UINT64      clock;
+  UINT32      resetCount;
+  UINT32      restartCount;
+  TPMI_YES_NO safe;
+} TPMS_CLOCK_INFO;
+
+// Table 106 - TPMS_TIME_INFO Structure
+typedef struct {
+  UINT64          time;
+  TPMS_CLOCK_INFO clockInfo;
+} TPMS_TIME_INFO;
+
+// Table 107 - TPMS_TIME_ATTEST_INFO Structure
+typedef struct {
+  TPMS_TIME_INFO time;
+  UINT64         firmwareVersion;
+} TPMS_TIME_ATTEST_INFO;
+
+// Table 108 - TPMS_CERTIFY_INFO Structure
+typedef struct {
+  TPM2B_NAME name;
+  TPM2B_NAME qualifiedName;
+} TPMS_CERTIFY_INFO;
+
+// Table 109 - TPMS_QUOTE_INFO Structure
+typedef struct {
+  TPML_PCR_SELECTION pcrSelect;
+  TPM2B_DIGEST       pcrDigest;
+} TPMS_QUOTE_INFO;
+
+// Table 110 - TPMS_COMMAND_AUDIT_INFO Structure
+typedef struct {
+  UINT64       auditCounter;
+  TPM_ALG_ID   digestAlg;
+  TPM2B_DIGEST auditDigest;
+  TPM2B_DIGEST commandDigest;
+} TPMS_COMMAND_AUDIT_INFO;
+
+// Table 111 - TPMS_SESSION_AUDIT_INFO Structure
+typedef struct {
+  TPMI_YES_NO  exclusiveSession;
+  TPM2B_DIGEST sessionDigest;
+} TPMS_SESSION_AUDIT_INFO;
+
+// Table 112 - TPMS_CREATION_INFO Structure
+typedef struct {
+  TPM2B_NAME   objectName;
+  TPM2B_DIGEST creationHash;
+} TPMS_CREATION_INFO;
+
+// Table 113 - TPMS_NV_CERTIFY_INFO Structure
+typedef struct {
+  TPM2B_NAME          indexName;
+  UINT16              offset;
+  TPM2B_MAX_NV_BUFFER nvContents;
+} TPMS_NV_CERTIFY_INFO;
+
+// Table 114 - TPMI_ST_ATTEST Type
+typedef TPM_ST TPMI_ST_ATTEST;
+
+// Table 115 - TPMU_ATTEST Union
+typedef union {
+  TPMS_CERTIFY_INFO       certify;
+  TPMS_CREATION_INFO      creation;
+  TPMS_QUOTE_INFO         quote;
+  TPMS_COMMAND_AUDIT_INFO commandAudit;
+  TPMS_SESSION_AUDIT_INFO sessionAudit;
+  TPMS_TIME_ATTEST_INFO   time;
+  TPMS_NV_CERTIFY_INFO    nv;
+} TPMU_ATTEST;
+
+// Table 116 - TPMS_ATTEST Structure
+typedef struct {
+  TPM_GENERATED   magic;
+  TPMI_ST_ATTEST  type;
+  TPM2B_NAME      qualifiedSigner;
+  TPM2B_DATA      extraData;
+  TPMS_CLOCK_INFO clockInfo;
+  UINT64          firmwareVersion;
+  TPMU_ATTEST     attested;
+} TPMS_ATTEST;
+
+// Table 117 - TPM2B_ATTEST Structure
+typedef struct {
+  UINT16 size;
+  BYTE   attestationData[sizeof(TPMS_ATTEST)];
+} TPM2B_ATTEST;
+
+// Table 118 - TPMS_AUTH_COMMAND Structure
+typedef struct {
+  TPMI_SH_AUTH_SESSION sessionHandle;
+  TPM2B_NONCE          nonce;
+  TPMA_SESSION         sessionAttributes;
+  TPM2B_AUTH           hmac;
+} TPMS_AUTH_COMMAND;
+
+// Table 119 - TPMS_AUTH_RESPONSE Structure
+typedef struct {
+  TPM2B_NONCE  nonce;
+  TPMA_SESSION sessionAttributes;
+  TPM2B_AUTH   hmac;
+} TPMS_AUTH_RESPONSE;
+
+// 11 Algorithm Parameters and Structures
+
+// Table 120 - TPMI_AES_KEY_BITS Type
+typedef TPM_KEY_BITS TPMI_AES_KEY_BITS;
+
+// Table 121 - TPMI_SM4_KEY_BITS Type
+typedef TPM_KEY_BITS TPMI_SM4_KEY_BITS;
+
+// Table 122 - TPMU_SYM_KEY_BITS Union
+typedef union {
+  TPMI_AES_KEY_BITS aes;
+  TPMI_SM4_KEY_BITS SM4;
+  TPM_KEY_BITS      sym;
+  TPMI_ALG_HASH     xor;
+} TPMU_SYM_KEY_BITS;
+
+// Table 123 - TPMU_SYM_MODE Union
+typedef union {
+  TPMI_ALG_SYM_MODE aes;
+  TPMI_ALG_SYM_MODE SM4;
+  TPMI_ALG_SYM_MODE sym;
+} TPMU_SYM_MODE;
+
+// Table 125 - TPMT_SYM_DEF Structure
+typedef struct {
+  TPMI_ALG_SYM      algorithm;
+  TPMU_SYM_KEY_BITS keyBits;
+  TPMU_SYM_MODE     mode;
+} TPMT_SYM_DEF;
+
+// Table 126 - TPMT_SYM_DEF_OBJECT Structure
+typedef struct {
+  TPMI_ALG_SYM_OBJECT algorithm;
+  TPMU_SYM_KEY_BITS   keyBits;
+  TPMU_SYM_MODE       mode;
+} TPMT_SYM_DEF_OBJECT;
+
+// Table 127 - TPM2B_SYM_KEY Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_SYM_KEY_BYTES];
+} TPM2B_SYM_KEY;
+
+// Table 128 - TPMS_SYMCIPHER_PARMS Structure
+typedef struct {
+  TPMT_SYM_DEF_OBJECT sym;
+} TPMS_SYMCIPHER_PARMS;
+
+// Table 129 - TPM2B_SENSITIVE_DATA Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_SYM_DATA];
+} TPM2B_SENSITIVE_DATA;
+
+// Table 130 - TPMS_SENSITIVE_CREATE Structure
+typedef struct {
+  TPM2B_AUTH           userAuth;
+  TPM2B_SENSITIVE_DATA data;
+} TPMS_SENSITIVE_CREATE;
+
+// Table 131 - TPM2B_SENSITIVE_CREATE Structure
+typedef struct {
+  UINT16                size;
+  TPMS_SENSITIVE_CREATE sensitive;
+} TPM2B_SENSITIVE_CREATE;
+
+// Table 132 - TPMS_SCHEME_SIGHASH Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_SIGHASH;
+
+// Table 133 - TPMI_ALG_KEYEDHASH_SCHEME Type
+typedef TPM_ALG_ID TPMI_ALG_KEYEDHASH_SCHEME;
+
+// Table 134 - HMAC_SIG_SCHEME Types
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_HMAC;
+
+// Table 135 - TPMS_SCHEME_XOR Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+  TPMI_ALG_KDF  kdf;
+} TPMS_SCHEME_XOR;
+
+// Table 136 - TPMU_SCHEME_KEYEDHASH Union
+typedef union {
+  TPMS_SCHEME_HMAC hmac;
+  TPMS_SCHEME_XOR  xor;
+} TPMU_SCHEME_KEYEDHASH;
+
+// Table 137 - TPMT_KEYEDHASH_SCHEME Structure
+typedef struct {
+  TPMI_ALG_KEYEDHASH_SCHEME scheme;
+  TPMU_SCHEME_KEYEDHASH     details;
+} TPMT_KEYEDHASH_SCHEME;
+
+// Table 138 - RSA_SIG_SCHEMES Types
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_RSASSA;
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_RSAPSS;
+
+// Table 139 - ECC_SIG_SCHEMES Types
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_ECDSA;
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_SM2;
+typedef TPMS_SCHEME_SIGHASH TPMS_SCHEME_ECSCHNORR;
+
+// Table 140 - TPMS_SCHEME_ECDAA Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+  UINT16        count;
+} TPMS_SCHEME_ECDAA;
+
+// Table 141 - TPMU_SIG_SCHEME Union
+typedef union {
+  TPMS_SCHEME_RSASSA    rsassa;
+  TPMS_SCHEME_RSAPSS    rsapss;
+  TPMS_SCHEME_ECDSA     ecdsa;
+  TPMS_SCHEME_ECDAA     ecdaa;
+  TPMS_SCHEME_ECSCHNORR ecSchnorr;
+  TPMS_SCHEME_HMAC      hmac;
+  TPMS_SCHEME_SIGHASH   any;
+} TPMU_SIG_SCHEME;
+
+// Table 142 - TPMT_SIG_SCHEME Structure
+typedef struct {
+  TPMI_ALG_SIG_SCHEME scheme;
+  TPMU_SIG_SCHEME     details;
+} TPMT_SIG_SCHEME;
+
+// Table 143 - TPMS_SCHEME_OAEP Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_OAEP;
+
+// Table 144 - TPMS_SCHEME_ECDH Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_ECDH;
+
+// Table 145 - TPMS_SCHEME_MGF1 Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_MGF1;
+
+// Table 146 - TPMS_SCHEME_KDF1_SP800_56a Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_KDF1_SP800_56a;
+
+// Table 147 - TPMS_SCHEME_KDF2 Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_KDF2;
+
+// Table 148 - TPMS_SCHEME_KDF1_SP800_108 Structure
+typedef struct {
+  TPMI_ALG_HASH hashAlg;
+} TPMS_SCHEME_KDF1_SP800_108;
+
+// Table 149 - TPMU_KDF_SCHEME Union
+typedef union {
+  TPMS_SCHEME_MGF1           mgf1;
+  TPMS_SCHEME_KDF1_SP800_56a kdf1_SP800_56a;
+  TPMS_SCHEME_KDF2           kdf2;
+  TPMS_SCHEME_KDF1_SP800_108 kdf1_sp800_108;
+} TPMU_KDF_SCHEME;
+
+// Table 150 - TPMT_KDF_SCHEME Structure
+typedef struct {
+  TPMI_ALG_KDF    scheme;
+  TPMU_KDF_SCHEME details;
+} TPMT_KDF_SCHEME;
+
+// Table 151 - TPMI_ALG_ASYM_SCHEME Type
+typedef TPM_ALG_ID TPMI_ALG_ASYM_SCHEME;
+
+// Table 152 - TPMU_ASYM_SCHEME Union
+typedef union {
+  TPMS_SCHEME_RSASSA    rsassa;
+  TPMS_SCHEME_RSAPSS    rsapss;
+  TPMS_SCHEME_OAEP      oaep;
+  TPMS_SCHEME_ECDSA     ecdsa;
+  TPMS_SCHEME_ECDAA     ecdaa;
+  TPMS_SCHEME_ECSCHNORR ecSchnorr;
+  TPMS_SCHEME_SIGHASH   anySig;
+} TPMU_ASYM_SCHEME;
+
+// Table 153 - TPMT_ASYM_SCHEME Structure
+typedef struct {
+  TPMI_ALG_ASYM_SCHEME scheme;
+  TPMU_ASYM_SCHEME     details;
+} TPMT_ASYM_SCHEME;
+
+// Table 154 - TPMI_ALG_RSA_SCHEME Type
+typedef TPM_ALG_ID TPMI_ALG_RSA_SCHEME;
+
+// Table 155 - TPMT_RSA_SCHEME Structure
+typedef struct {
+  TPMI_ALG_RSA_SCHEME scheme;
+  TPMU_ASYM_SCHEME    details;
+} TPMT_RSA_SCHEME;
+
+// Table 156 - TPMI_ALG_RSA_DECRYPT Type
+typedef TPM_ALG_ID TPMI_ALG_RSA_DECRYPT;
+
+// Table 157 - TPMT_RSA_DECRYPT Structure
+typedef struct {
+  TPMI_ALG_RSA_DECRYPT scheme;
+  TPMU_ASYM_SCHEME     details;
+} TPMT_RSA_DECRYPT;
+
+// Table 158 - TPM2B_PUBLIC_KEY_RSA Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_RSA_KEY_BYTES];
+} TPM2B_PUBLIC_KEY_RSA;
+
+// Table 159 - TPMI_RSA_KEY_BITS Type
+typedef TPM_KEY_BITS TPMI_RSA_KEY_BITS;
+
+// Table 160 - TPM2B_PRIVATE_KEY_RSA Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_RSA_KEY_BYTES/2];
+} TPM2B_PRIVATE_KEY_RSA;
+
+// Table 161 - TPM2B_ECC_PARAMETER Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_ECC_KEY_BYTES];
+} TPM2B_ECC_PARAMETER;
+
+// Table 162 - TPMS_ECC_POINT Structure
+typedef struct {
+  TPM2B_ECC_PARAMETER x;
+  TPM2B_ECC_PARAMETER y;
+} TPMS_ECC_POINT;
+
+// Table 163 -- TPM2B_ECC_POINT Structure <I/O>
+typedef struct {
+  UINT16         size;
+  TPMS_ECC_POINT point;
+} TPM2B_ECC_POINT;
+
+// Table 164 - TPMI_ALG_ECC_SCHEME Type
+typedef TPM_ALG_ID TPMI_ALG_ECC_SCHEME;
+
+// Table 165 - TPMI_ECC_CURVE Type
+typedef TPM_ECC_CURVE TPMI_ECC_CURVE;
+
+// Table 166 - TPMT_ECC_SCHEME Structure
+typedef struct {
+  TPMI_ALG_ECC_SCHEME scheme;
+  TPMU_SIG_SCHEME     details;
+} TPMT_ECC_SCHEME;
+
+// Table 167 - TPMS_ALGORITHM_DETAIL_ECC Structure
+typedef struct {
+  TPM_ECC_CURVE       curveID;
+  UINT16              keySize;
+  TPMT_KDF_SCHEME     kdf;
+  TPMT_ECC_SCHEME     sign;
+  TPM2B_ECC_PARAMETER p;
+  TPM2B_ECC_PARAMETER a;
+  TPM2B_ECC_PARAMETER b;
+  TPM2B_ECC_PARAMETER gX;
+  TPM2B_ECC_PARAMETER gY;
+  TPM2B_ECC_PARAMETER n;
+  TPM2B_ECC_PARAMETER h;
+} TPMS_ALGORITHM_DETAIL_ECC;
+
+// Table 168 - TPMS_SIGNATURE_RSASSA Structure
+typedef struct {
+  TPMI_ALG_HASH        hash;
+  TPM2B_PUBLIC_KEY_RSA sig;
+} TPMS_SIGNATURE_RSASSA;
+
+// Table 169 - TPMS_SIGNATURE_RSAPSS Structure
+typedef struct {
+  TPMI_ALG_HASH        hash;
+  TPM2B_PUBLIC_KEY_RSA sig;
+} TPMS_SIGNATURE_RSAPSS;
+
+// Table 170 - TPMS_SIGNATURE_ECDSA Structure
+typedef struct {
+  TPMI_ALG_HASH       hash;
+  TPM2B_ECC_PARAMETER signatureR;
+  TPM2B_ECC_PARAMETER signatureS;
+} TPMS_SIGNATURE_ECDSA;
+
+// Table 171 - TPMU_SIGNATURE Union
+typedef union {
+  TPMS_SIGNATURE_RSASSA rsassa;
+  TPMS_SIGNATURE_RSAPSS rsapss;
+  TPMS_SIGNATURE_ECDSA  ecdsa;
+  TPMS_SIGNATURE_ECDSA  sm2;
+  TPMS_SIGNATURE_ECDSA  ecdaa;
+  TPMS_SIGNATURE_ECDSA  ecschnorr;
+  TPMT_HA               hmac;
+  TPMS_SCHEME_SIGHASH   any;
+} TPMU_SIGNATURE;
+
+// Table 172 - TPMT_SIGNATURE Structure
+typedef struct {
+  TPMI_ALG_SIG_SCHEME sigAlg;
+  TPMU_SIGNATURE      signature;
+} TPMT_SIGNATURE;
+
+// Table 173 - TPMU_ENCRYPTED_SECRET Union
+typedef union {
+  BYTE ecc[sizeof(TPMS_ECC_POINT)];
+  BYTE rsa[MAX_RSA_KEY_BYTES];
+  BYTE symmetric[sizeof(TPM2B_DIGEST)];
+  BYTE keyedHash[sizeof(TPM2B_DIGEST)];
+} TPMU_ENCRYPTED_SECRET;
+
+// Table 174 - TPM2B_ENCRYPTED_SECRET Structure
+typedef struct {
+  UINT16 size;
+  BYTE   secret[sizeof(TPMU_ENCRYPTED_SECRET)];
+} TPM2B_ENCRYPTED_SECRET;
+
+// 12 Key/Object Complex
+
+// Table 175 - TPMI_ALG_PUBLIC Type
+typedef TPM_ALG_ID TPMI_ALG_PUBLIC;
+
+// Table 176 - TPMU_PUBLIC_ID Union
+typedef union {
+  TPM2B_DIGEST         keyedHash;
+  TPM2B_DIGEST         sym;
+  TPM2B_PUBLIC_KEY_RSA rsa;
+  TPMS_ECC_POINT       ecc;
+} TPMU_PUBLIC_ID;
+
+// Table 177 - TPMS_KEYEDHASH_PARMS Structure
+typedef struct {
+  TPMT_KEYEDHASH_SCHEME scheme;
+} TPMS_KEYEDHASH_PARMS;
+
+// Table 178 - TPMS_ASYM_PARMS Structure
+typedef struct {
+  TPMT_SYM_DEF_OBJECT symmetric;
+  TPMT_ASYM_SCHEME    scheme;
+} TPMS_ASYM_PARMS;
+
+// Table 179 - TPMS_RSA_PARMS Structure
+typedef struct {
+  TPMT_SYM_DEF_OBJECT symmetric;
+  TPMT_RSA_SCHEME     scheme;
+  TPMI_RSA_KEY_BITS   keyBits;
+  UINT32              exponent;
+} TPMS_RSA_PARMS;
+
+// Table 180 - TPMS_ECC_PARMS Structure
+typedef struct {
+  TPMT_SYM_DEF_OBJECT symmetric;
+  TPMT_ECC_SCHEME     scheme;
+  TPMI_ECC_CURVE      curveID;
+  TPMT_KDF_SCHEME     kdf;
+} TPMS_ECC_PARMS;
+
+// Table 181 - TPMU_PUBLIC_PARMS Union
+typedef union {
+  TPMS_KEYEDHASH_PARMS keyedHashDetail;
+  TPMT_SYM_DEF_OBJECT  symDetail;
+  TPMS_RSA_PARMS       rsaDetail;
+  TPMS_ECC_PARMS       eccDetail;
+  TPMS_ASYM_PARMS      asymDetail;
+} TPMU_PUBLIC_PARMS;
+
+// Table 182 - TPMT_PUBLIC_PARMS Structure
+typedef struct {
+  TPMI_ALG_PUBLIC   type;
+  TPMU_PUBLIC_PARMS parameters;
+} TPMT_PUBLIC_PARMS;
+
+// Table 183 - TPMT_PUBLIC Structure
+typedef struct {
+  TPMI_ALG_PUBLIC   type;
+  TPMI_ALG_HASH     nameAlg;
+  TPMA_OBJECT       objectAttributes;
+  TPM2B_DIGEST      authPolicy;
+  TPMU_PUBLIC_PARMS parameters;
+  TPMU_PUBLIC_ID    unique;
+} TPMT_PUBLIC;
+
+// Table 184 - TPM2B_PUBLIC Structure
+typedef struct {
+  UINT16      size;
+  TPMT_PUBLIC publicArea;
+} TPM2B_PUBLIC;
+
+// Table 185 - TPM2B_PRIVATE_VENDOR_SPECIFIC Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[PRIVATE_VENDOR_SPECIFIC_BYTES];
+} TPM2B_PRIVATE_VENDOR_SPECIFIC;
+
+// Table 186 - TPMU_SENSITIVE_COMPOSITE Union
+typedef union {
+  TPM2B_PRIVATE_KEY_RSA         rsa;
+  TPM2B_ECC_PARAMETER           ecc;
+  TPM2B_SENSITIVE_DATA          bits;
+  TPM2B_SYM_KEY                 sym;
+  TPM2B_PRIVATE_VENDOR_SPECIFIC any;
+} TPMU_SENSITIVE_COMPOSITE;
+
+// Table 187 - TPMT_SENSITIVE Structure
+typedef struct {
+  TPMI_ALG_PUBLIC          sensitiveType;
+  TPM2B_AUTH               authValue;
+  TPM2B_DIGEST             seedValue;
+  TPMU_SENSITIVE_COMPOSITE sensitive;
+} TPMT_SENSITIVE;
+
+// Table 188 - TPM2B_SENSITIVE Structure
+typedef struct {
+  UINT16         size;
+  TPMT_SENSITIVE sensitiveArea;
+} TPM2B_SENSITIVE;
+
+// Table 189 - _PRIVATE Structure
+typedef struct {
+  TPM2B_DIGEST   integrityOuter;
+  TPM2B_DIGEST   integrityInner;
+  TPMT_SENSITIVE sensitive;
+} _PRIVATE;
+
+// Table 190 - TPM2B_PRIVATE Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(_PRIVATE)];
+} TPM2B_PRIVATE;
+
+// Table 191 - _ID_OBJECT Structure
+typedef struct {
+  TPM2B_DIGEST integrityHMAC;
+  TPM2B_DIGEST encIdentity;
+} _ID_OBJECT;
+
+// Table 192 - TPM2B_ID_OBJECT Structure
+typedef struct {
+  UINT16 size;
+  BYTE   credential[sizeof(_ID_OBJECT)];
+} TPM2B_ID_OBJECT;
+
+// 13 NV Storage Structures
+
+// Table 193 - TPM_NV_INDEX Bits
+//
+// NOTE: Comment here to resolve conflict
+//
+//typedef struct {
+//  UINT32 index : 22;
+//  UINT32 space : 2;
+//  UINT32 RH_NV : 8;
+//} TPM_NV_INDEX;
+
+// Table 195 - TPMA_NV Bits
+typedef struct {
+  UINT32 TPMA_NV_PPWRITE        : 1;
+  UINT32 TPMA_NV_OWNERWRITE     : 1;
+  UINT32 TPMA_NV_AUTHWRITE      : 1;
+  UINT32 TPMA_NV_POLICYWRITE    : 1;
+  UINT32 TPMA_NV_COUNTER        : 1;
+  UINT32 TPMA_NV_BITS           : 1;
+  UINT32 TPMA_NV_EXTEND         : 1;
+  UINT32 reserved7_9            : 3;
+  UINT32 TPMA_NV_POLICY_DELETE  : 1;
+  UINT32 TPMA_NV_WRITELOCKED    : 1;
+  UINT32 TPMA_NV_WRITEALL       : 1;
+  UINT32 TPMA_NV_WRITEDEFINE    : 1;
+  UINT32 TPMA_NV_WRITE_STCLEAR  : 1;
+  UINT32 TPMA_NV_GLOBALLOCK     : 1;
+  UINT32 TPMA_NV_PPREAD         : 1;
+  UINT32 TPMA_NV_OWNERREAD      : 1;
+  UINT32 TPMA_NV_AUTHREAD       : 1;
+  UINT32 TPMA_NV_POLICYREAD     : 1;
+  UINT32 reserved20_24          : 5;
+  UINT32 TPMA_NV_NO_DA          : 1;
+  UINT32 TPMA_NV_ORDERLY        : 1;
+  UINT32 TPMA_NV_CLEAR_STCLEAR  : 1;
+  UINT32 TPMA_NV_READLOCKED     : 1;
+  UINT32 TPMA_NV_WRITTEN        : 1;
+  UINT32 TPMA_NV_PLATFORMCREATE : 1;
+  UINT32 TPMA_NV_READ_STCLEAR   : 1;
+} TPMA_NV;
+
+// Table 196 - TPMS_NV_PUBLIC Structure
+typedef struct {
+  TPMI_RH_NV_INDEX nvIndex;
+  TPMI_ALG_HASH    nameAlg;
+  TPMA_NV          attributes;
+  TPM2B_DIGEST     authPolicy;
+  UINT16           dataSize;
+} TPMS_NV_PUBLIC;
+
+// Table 197 - TPM2B_NV_PUBLIC Structure
+typedef struct {
+  UINT16         size;
+  TPMS_NV_PUBLIC nvPublic;
+} TPM2B_NV_PUBLIC;
+
+// 14 Context Data
+
+// Table 198 - TPM2B_CONTEXT_SENSITIVE Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[MAX_CONTEXT_SIZE];
+} TPM2B_CONTEXT_SENSITIVE;
+
+// Table 199 - TPMS_CONTEXT_DATA Structure
+typedef struct {
+  TPM2B_DIGEST            integrity;
+  TPM2B_CONTEXT_SENSITIVE encrypted;
+} TPMS_CONTEXT_DATA;
+
+// Table 200 - TPM2B_CONTEXT_DATA Structure
+typedef struct {
+  UINT16 size;
+  BYTE   buffer[sizeof(TPMS_CONTEXT_DATA)];
+} TPM2B_CONTEXT_DATA;
+
+// Table 201 - TPMS_CONTEXT Structure
+typedef struct {
+  UINT64             sequence;
+  TPMI_DH_CONTEXT    savedHandle;
+  TPMI_RH_HIERARCHY  hierarchy;
+  TPM2B_CONTEXT_DATA contextBlob;
+} TPMS_CONTEXT;
+
+// 15 Creation Data
+
+// Table 203 - TPMS_CREATION_DATA Structure
+typedef struct {
+  TPML_PCR_SELECTION pcrSelect;
+  TPM2B_DIGEST       pcrDigest;
+  TPMA_LOCALITY      locality;
+  TPM_ALG_ID         parentNameAlg;
+  TPM2B_NAME         parentName;
+  TPM2B_NAME         parentQualifiedName;
+  TPM2B_DATA         outsideInfo;
+} TPMS_CREATION_DATA;
+
+// Table 204 - TPM2B_CREATION_DATA Structure
+typedef struct {
+  UINT16             size;
+  TPMS_CREATION_DATA creationData;
+} TPM2B_CREATION_DATA;
+
+
+//
+// Command Header
+//
+typedef struct {
+  TPM_ST tag;
+  UINT32 paramSize;
+  TPM_CC commandCode;
+} TPM2_COMMAND_HEADER;
+
+typedef struct {
+  TPM_ST tag;
+  UINT32 paramSize;
+  TPM_RC responseCode;
+} TPM2_RESPONSE_HEADER;
+
+#pragma pack ()
+
+//
+// TCG Algorithm Registry
+//
+#define HASH_ALG_SHA1    0x00000001
+#define HASH_ALG_SHA256  0x00000002
+#define HASH_ALG_SHA384  0x00000004
+#define HASH_ALG_SHA512  0x00000008
+#define HASH_ALG_SM3_256 0x00000010
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/Tpm2Acpi.h b/MdePkg/Include/IndustryStandard/Tpm2Acpi.h
new file mode 100644
index 000000000000..b5d5e522dd56
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Tpm2Acpi.h
@@ -0,0 +1,56 @@
+/** @file
+  TPM2 ACPI table definition.
+
+Copyright (c) 2013 - 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 _TPM2_ACPI_H_
+#define _TPM2_ACPI_H_
+
+#include <IndustryStandard/Acpi.h>
+
+#pragma pack (1)
+
+#define EFI_TPM2_ACPI_TABLE_REVISION_3  3
+#define EFI_TPM2_ACPI_TABLE_REVISION_4  4
+#define EFI_TPM2_ACPI_TABLE_REVISION    EFI_TPM2_ACPI_TABLE_REVISION_4
+
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  // Flags field is replaced in version 4 and above
+  //    BIT0~15:  PlatformClass      This field is only valid for version 4 and above
+  //    BIT16~31: Reserved
+  UINT32                      Flags;
+  UINT64                      AddressOfControlArea;
+  UINT32                      StartMethod;
+//UINT8                       PlatformSpecificParameters[];
+} EFI_TPM2_ACPI_TABLE;
+
+#define EFI_TPM2_ACPI_TABLE_START_METHOD_ACPI                                          2
+#define EFI_TPM2_ACPI_TABLE_START_METHOD_TIS                                           6
+#define EFI_TPM2_ACPI_TABLE_START_METHOD_COMMAND_RESPONSE_BUFFER_INTERFACE             7
+#define EFI_TPM2_ACPI_TABLE_START_METHOD_COMMAND_RESPONSE_BUFFER_INTERFACE_WITH_ACPI   8
+
+typedef struct {
+  UINT32   Reserved;
+  UINT32   Error;
+  UINT32   Cancel;
+  UINT32   Start;
+  UINT64   InterruptControl;
+  UINT32   CommandSize;
+  UINT64   Command;
+  UINT32   ResponseSize;
+  UINT64   Response;
+} EFI_TPM2_ACPI_CONTROL_AREA;
+
+#pragma pack ()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/TpmPtp.h b/MdePkg/Include/IndustryStandard/TpmPtp.h
new file mode 100644
index 000000000000..f4c6b0676bc6
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TpmPtp.h
@@ -0,0 +1,522 @@
+/** @file
+  Platform TPM Profile Specification definition for TPM2.0.
+  It covers both FIFO and CRB interface.
+
+Copyright (c) 2016, 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 _TPM_PTP_H_
+#define _TPM_PTP_H_
+
+//
+// PTP FIFO definition
+//
+
+//
+// Set structure alignment to 1-byte
+//
+#pragma pack (1)
+
+//
+// Register set map as specified in PTP specification Chapter 5
+//
+typedef struct {
+  ///
+  /// Used to gain ownership for this particular port.
+  ///
+  UINT8                             Access;             // 0
+  UINT8                             Reserved1[7];       // 1
+  ///
+  /// Controls interrupts.
+  ///
+  UINT32                            IntEnable;          // 8
+  ///
+  /// SIRQ vector to be used by the TPM.
+  ///
+  UINT8                             IntVector;          // 0ch
+  UINT8                             Reserved2[3];       // 0dh
+  ///
+  /// What caused interrupt.
+  ///
+  UINT32                            IntSts;             // 10h
+  ///
+  /// Shows which interrupts are supported by that particular TPM.
+  ///
+  UINT32                            InterfaceCapability;// 14h
+  ///
+  /// Status Register. Provides status of the TPM.
+  ///
+  UINT8                             Status;             // 18h
+  ///
+  /// Number of consecutive writes that can be done to the TPM.
+  ///
+  UINT16                            BurstCount;         // 19h
+  ///
+  /// Additional Status Register.
+  ///
+  UINT8                             StatusEx;           // 1Bh
+  UINT8                             Reserved3[8];
+  ///
+  /// Read or write FIFO, depending on transaction.
+  ///
+  UINT32                            DataFifo;           // 24h
+  UINT8                             Reserved4[8];       // 28h
+  ///
+  /// Used to identify the Interface types supported by the TPM.
+  ///
+  UINT32                            InterfaceId;        // 30h
+  UINT8                             Reserved5[0x4c];    // 34h
+  ///
+  /// Extended ReadFIFO or WriteFIFO, depending on the current bus cycle (read or write)
+  ///
+  UINT32                            XDataFifo;          // 80h
+  UINT8                             Reserved6[0xe7c];   // 84h
+  ///
+  /// Vendor ID
+  ///
+  UINT16                            Vid;                // 0f00h
+  ///
+  /// Device ID
+  ///
+  UINT16                            Did;                // 0f02h
+  ///
+  /// Revision ID
+  ///
+  UINT8                             Rid;                // 0f04h
+  UINT8                             Reserved[0xfb];     // 0f05h
+} PTP_FIFO_REGISTERS;
+
+//
+// Restore original structure alignment
+//
+#pragma pack ()
+
+//
+// Define pointer types used to access TIS registers on PC
+//
+typedef PTP_FIFO_REGISTERS  *PTP_FIFO_REGISTERS_PTR;
+
+//
+// Define bits of FIFO Interface Identifier Register
+//
+typedef union {
+  struct {
+    UINT32   InterfaceType:4;
+    UINT32   InterfaceVersion:4;
+    UINT32   CapLocality:1;
+    UINT32   Reserved1:2;
+    UINT32   CapDataXferSizeSupport:2;
+    UINT32   CapFIFO:1;
+    UINT32   CapCRB:1;
+    UINT32   CapIFRes:2;
+    UINT32   InterfaceSelector:2;
+    UINT32   IntfSelLock:1;
+    UINT32   Reserved2:4;
+    UINT32   Reserved3:8;
+  } Bits;
+  UINT32   Uint32;
+} PTP_FIFO_INTERFACE_IDENTIFIER;
+
+//
+// Define bits of FIFO Interface Capability Register
+//
+typedef union {
+  struct {
+    UINT32   DataAvailIntSupport:1;
+    UINT32   StsValidIntSupport:1;
+    UINT32   LocalityChangeIntSupport:1;
+    UINT32   InterruptLevelHigh:1;
+    UINT32   InterruptLevelLow:1;
+    UINT32   InterruptEdgeRising:1;
+    UINT32   InterruptEdgeFalling:1;
+    UINT32   CommandReadyIntSupport:1;
+    UINT32   BurstCountStatic:1;
+    UINT32   DataTransferSizeSupport:2;
+    UINT32   Reserved:17;
+    UINT32   InterfaceVersion:3;
+    UINT32   Reserved2:1;
+  } Bits;
+  UINT32   Uint32;
+} PTP_FIFO_INTERFACE_CAPABILITY;
+
+///
+/// InterfaceVersion
+///
+#define INTERFACE_CAPABILITY_INTERFACE_VERSION_TIS_12  0x0
+#define INTERFACE_CAPABILITY_INTERFACE_VERSION_TIS_13  0x2
+#define INTERFACE_CAPABILITY_INTERFACE_VERSION_PTP     0x3
+
+
+//
+// Define bits of ACCESS and STATUS registers
+//
+
+///
+/// This bit is a 1 to indicate that the other bits in this register are valid.
+///
+#define PTP_FIFO_VALID                BIT7
+///
+/// Indicate that this locality is active.
+///
+#define PTP_FIFO_ACC_ACTIVE           BIT5
+///
+/// Set to 1 to indicate that this locality had the TPM taken away while
+/// this locality had the TIS_PC_ACC_ACTIVE bit set.
+///
+#define PTP_FIFO_ACC_SEIZED           BIT4
+///
+/// Set to 1 to indicate that TPM MUST reset the
+/// TIS_PC_ACC_ACTIVE bit and remove ownership for localities less than the
+/// locality that is writing this bit.
+///
+#define PTP_FIFO_ACC_SEIZE            BIT3
+///
+/// When this bit is 1, another locality is requesting usage of the TPM.
+///
+#define PTP_FIFO_ACC_PENDIND          BIT2
+///
+/// Set to 1 to indicate that this locality is requesting to use TPM.
+///
+#define PTP_FIFO_ACC_RQUUSE           BIT1
+///
+/// A value of 1 indicates that a T/OS has not been established on the platform
+///
+#define PTP_FIFO_ACC_ESTABLISH        BIT0
+
+///
+/// This field indicates that STS_DATA and STS_EXPECT are valid
+///
+#define PTP_FIFO_STS_VALID            BIT7
+///
+/// When this bit is 1, TPM is in the Ready state,
+/// indicating it is ready to receive a new command.
+///
+#define PTP_FIFO_STS_READY            BIT6
+///
+/// Write a 1 to this bit to cause the TPM to execute that command.
+///
+#define PTP_FIFO_STS_GO               BIT5
+///
+/// This bit indicates that the TPM has data available as a response.
+///
+#define PTP_FIFO_STS_DATA             BIT4
+///
+/// The TPM sets this bit to a value of 1 when it expects another byte of data for a command.
+///
+#define PTP_FIFO_STS_EXPECT           BIT3
+///
+/// Indicates that the TPM has completed all self-test actions following a TPM_ContinueSelfTest command.
+///
+#define PTP_FIFO_STS_SELFTEST_DONE    BIT2
+///
+/// Writes a 1 to this bit to force the TPM to re-send the response.
+///
+#define PTP_FIFO_STS_RETRY            BIT1
+
+///
+/// TPM Family Identifier.
+/// 00: TPM 1.2 Family
+/// 01: TPM 2.0 Family
+///
+#define PTP_FIFO_STS_EX_TPM_FAMILY    (BIT2 | BIT3)
+#define PTP_FIFO_STS_EX_TPM_FAMILY_OFFSET    (2)
+#define PTP_FIFO_STS_EX_TPM_FAMILY_TPM12    (0)
+#define PTP_FIFO_STS_EX_TPM_FAMILY_TPM20    (BIT2)
+///
+/// A write of 1 after tpmGo and before dataAvail aborts the currently executing command, resulting in a response of TPM_RC_CANCELLED.
+/// A write of 1 after dataAvail and before tpmGo is ignored by the TPM.
+///
+#define PTP_FIFO_STS_EX_CANCEL        BIT0
+
+
+//
+// PTP CRB definition
+//
+
+//
+// Set structure alignment to 1-byte
+//
+#pragma pack (1)
+
+//
+// Register set map as specified in PTP specification Chapter 5
+//
+typedef struct {
+  ///
+  /// Used to determine current state of Locality of the TPM.
+  ///
+  UINT32                            LocalityState;             // 0
+  UINT8                             Reserved1[4];              // 4
+  ///
+  /// Used to gain control of the TPM by this Locality.
+  ///
+  UINT32                            LocalityControl;           // 8
+  ///
+  /// Used to determine whether Locality has been granted or Seized.
+  ///
+  UINT32                            LocalityStatus;            // 0ch
+  UINT8                             Reserved2[0x20];           // 10h
+  ///
+  /// Used to identify the Interface types supported by the TPM.
+  ///
+  UINT32                            InterfaceId;               // 30h
+  ///
+  /// Vendor ID
+  ///
+  UINT16                            Vid;                       // 34h
+  ///
+  /// Device ID
+  ///
+  UINT16                            Did;                       // 36h
+  ///
+  /// Optional Register used in low memory environments prior to CRB_DATA_BUFFER availability.
+  ///
+  UINT64                            CrbControlExtension;       // 38h
+  ///
+  /// Register used to initiate transactions for the CRB interface.
+  ///
+  UINT32                            CrbControlRequest;         // 40h
+  ///
+  /// Register used by the TPM to provide status of the CRB interface.
+  ///
+  UINT32                            CrbControlStatus;          // 44h
+  ///
+  /// Register used by software to cancel command processing.
+  ///
+  UINT32                            CrbControlCancel;          // 48h
+  ///
+  /// Register used to indicate presence of command or response data in the CRB buffer.
+  ///
+  UINT32                            CrbControlStart;           // 4Ch
+  ///
+  /// Register used to configure and respond to interrupts.
+  ///
+  UINT32                            CrbInterruptEnable;        // 50h
+  UINT32                            CrbInterruptStatus;        // 54h
+  ///
+  /// Size of the Command buffer.
+  ///
+  UINT32                            CrbControlCommandSize;     // 58h
+  ///
+  /// Command buffer start address
+  ///
+  UINT32                            CrbControlCommandAddressLow;   // 5Ch
+  UINT32                            CrbControlCommandAddressHigh;  // 60h
+  ///
+  /// Size of the Response buffer
+  ///
+  UINT32                            CrbControlResponseSize;    // 64h
+  ///
+  /// Address of the start of the Response buffer
+  ///
+  UINT64                            CrbControlResponseAddrss;  // 68h
+  UINT8                             Reserved4[0x10];           // 70h
+  ///
+  /// Command/Response Data may be defined as large as 3968 (0xF80).
+  ///
+  UINT8                             CrbDataBuffer[0xF80];      // 80h
+} PTP_CRB_REGISTERS;
+
+//
+// Define pointer types used to access CRB registers on PTP
+//
+typedef PTP_CRB_REGISTERS  *PTP_CRB_REGISTERS_PTR;
+
+//
+// Define bits of CRB Interface Identifier Register
+//
+typedef union {
+  struct {
+    UINT32   InterfaceType:4;
+    UINT32   InterfaceVersion:4;
+    UINT32   CapLocality:1;
+    UINT32   Reserved1:2;
+    UINT32   CapDataXferSizeSupport:2;
+    UINT32   CapFIFO:1;
+    UINT32   CapCRB:1;
+    UINT32   CapIFRes:2;
+    UINT32   InterfaceSelector:2;
+    UINT32   IntfSelLock:1;
+    UINT32   Reserved2:4;
+    UINT32   Rid:8;
+  } Bits;
+  UINT32   Uint32;
+} PTP_CRB_INTERFACE_IDENTIFIER;
+
+///
+/// InterfaceType
+///
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_FIFO  0x0
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_CRB   0x1
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_TYPE_TIS   0xF
+
+///
+/// InterfaceVersion
+///
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_VERSION_FIFO  0x0
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_VERSION_CRB   0x1
+
+///
+/// InterfaceSelector
+///
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_SELECTOR_FIFO  0x0
+#define PTP_INTERFACE_IDENTIFIER_INTERFACE_SELECTOR_CRB   0x1
+
+//
+// Define bits of Locality State Register
+//
+
+///
+/// This bit indicates whether all other bits of this register contain valid values, if it is a 1.
+///
+#define PTP_CRB_LOCALITY_STATE_TPM_REG_VALID_STATUS       BIT7
+
+///
+/// 000 - Locality 0
+/// 001 - Locality 1
+/// 010 - Locality 2
+/// 011 - Locality 3
+/// 100 - Locality 4
+///
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_MASK       (BIT2 | BIT3 | BIT4)
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_0          (0)
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_1          (BIT2)
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_2          (BIT3)
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_3          (BIT2 | BIT3)
+#define PTP_CRB_LOCALITY_STATE_ACTIVE_LOCALITY_4          (BIT4)
+
+///
+/// A 0 indicates to the host that no locality is assigned.
+/// A 1 indicates a locality has been assigned.
+///
+#define PTP_CRB_LOCALITY_STATE_LOCALITY_ASSIGNED          BIT1
+
+///
+/// The TPM clears this bit to 0 upon receipt of _TPM_Hash_End
+/// The TPM sets this bit to a 1 when the TPM_LOC_CTRL_x.resetEstablishment field is set to 1.
+///
+#define PTP_CRB_LOCALITY_STATE_TPM_ESTABLISHED            BIT0
+
+//
+// Define bits of Locality Control Register
+//
+
+///
+/// Writes (1): Reset TPM_LOC_STATE_x.tpmEstablished bit if the write occurs from Locality 3 or 4.
+///
+#define PTP_CRB_LOCALITY_CONTROL_RESET_ESTABLISHMENT_BIT  BIT3
+
+///
+/// Writes (1): The TPM gives control of the TPM to the locality setting this bit if it is the higher priority locality.
+///
+#define PTP_CRB_LOCALITY_CONTROL_SEIZE                    BIT2
+
+///
+/// Writes (1): The active Locality is done with the TPM.
+///
+#define PTP_CRB_LOCALITY_CONTROL_RELINQUISH               BIT1
+
+///
+/// Writes (1): Interrupt the TPM and generate a locality arbitration algorithm.
+///
+#define PTP_CRB_LOCALITY_CONTROL_REQUEST_ACCESS           BIT0
+
+//
+// Define bits of Locality Status Register
+//
+
+///
+/// 0: A higher locality has not initiated a Seize arbitration process.
+/// 1: A higher locality has Seized the TPM from this locality.
+///
+#define PTP_CRB_LOCALITY_STATUS_BEEN_SEIZED               BIT1
+
+///
+/// 0: Locality has not been granted to the TPM.
+/// 1: Locality has been granted access to the TPM
+///
+#define PTP_CRB_LOCALITY_STATUS_GRANTED                   BIT0
+
+//
+// Define bits of CRB Control Area Request Register
+//
+
+///
+/// Used by Software to indicate transition the TPM to and from the Idle state
+/// 1: Set by Software to indicate response has been read from the response buffer and TPM can transition to Idle
+/// 0: Cleared to 0 by TPM to acknowledge the request when TPM enters Idle state.
+/// TPM SHALL complete this transition within TIMEOUT_C.
+///
+#define PTP_CRB_CONTROL_AREA_REQUEST_GO_IDLE              BIT1
+
+///
+/// Used by Software to request the TPM transition to the Ready State.
+/// 1: Set to 1 by Software to indicate the TPM should be ready to receive a command.
+/// 0: Cleared to 0 by TPM to acknowledge the request.
+/// TPM SHALL complete this transition within TIMEOUT_C.
+///
+#define PTP_CRB_CONTROL_AREA_REQUEST_COMMAND_READY        BIT0
+
+//
+// Define bits of CRB Control Area Status Register
+//
+
+///
+/// Used by TPM to indicate it is in the Idle State
+/// 1: Set by TPM when in the Idle State
+/// 0: Cleared by TPM on receipt of TPM_CRB_CTRL_REQ_x.cmdReady when TPM transitions to the Ready State.
+/// SHALL be cleared by TIMEOUT_C.
+///
+#define PTP_CRB_CONTROL_AREA_STATUS_TPM_IDLE              BIT1
+
+///
+/// Used by the TPM to indicate current status.
+/// 1: Set by TPM to indicate a FATAL Error
+/// 0: Indicates TPM is operational
+///
+#define PTP_CRB_CONTROL_AREA_STATUS_TPM_STATUS            BIT0
+
+//
+// Define bits of CRB Control Cancel Register
+//
+
+///
+/// Used by software to cancel command processing Reads return correct value
+/// Writes (0000 0001h): Cancel a command
+/// Writes (0000 0000h): Clears field when command has been cancelled
+///
+#define PTP_CRB_CONTROL_CANCEL                            BIT0
+
+//
+// Define bits of CRB Control Start Register
+//
+
+///
+/// When set by software, indicates a command is ready for processing.
+/// Writes (0000 0001h): TPM transitions to Command Execution
+/// Writes (0000 0000h): TPM clears this field and transitions to Command Completion
+///
+#define PTP_CRB_CONTROL_START                             BIT0
+
+//
+// Restore original structure alignment
+//
+#pragma pack ()
+
+//
+// Default TimeOut value
+//
+#define PTP_TIMEOUT_A               (750 * 1000)   // 750ms
+#define PTP_TIMEOUT_B               (2000 * 1000)  // 2s
+#define PTP_TIMEOUT_C               (200 * 1000)   // 200ms
+#define PTP_TIMEOUT_D               (30 * 1000)    // 30ms
+
+#endif
\ No newline at end of file
diff --git a/MdePkg/Include/IndustryStandard/TpmTis.h b/MdePkg/Include/IndustryStandard/TpmTis.h
new file mode 100644
index 000000000000..1e1d23725d08
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/TpmTis.h
@@ -0,0 +1,183 @@
+/** @file
+  TPM Interface Specification definition.
+  It covers both TPM1.2 and TPM2.0.
+
+Copyright (c) 2016, 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 _TPM_TIS_H_
+#define _TPM_TIS_H_
+
+//
+// Set structure alignment to 1-byte
+//
+#pragma pack (1)
+
+//
+// Register set map as specified in TIS specification Chapter 10
+//
+typedef struct {
+  ///
+  /// Used to gain ownership for this particular port.
+  ///
+  UINT8                             Access;             // 0
+  UINT8                             Reserved1[7];       // 1
+  ///
+  /// Controls interrupts.
+  ///
+  UINT32                            IntEnable;          // 8
+  ///
+  /// SIRQ vector to be used by the TPM.
+  ///
+  UINT8                             IntVector;          // 0ch
+  UINT8                             Reserved2[3];       // 0dh
+  ///
+  /// What caused interrupt.
+  ///
+  UINT32                            IntSts;             // 10h
+  ///
+  /// Shows which interrupts are supported by that particular TPM.
+  ///
+  UINT32                            IntfCapability;     // 14h
+  ///
+  /// Status Register. Provides status of the TPM.
+  ///
+  UINT8                             Status;             // 18h
+  ///
+  /// Number of consecutive writes that can be done to the TPM.
+  ///
+  UINT16                            BurstCount;         // 19h
+  UINT8                             Reserved3[9];
+  ///
+  /// Read or write FIFO, depending on transaction.
+  ///
+  UINT32                            DataFifo;           // 24h
+  UINT8                             Reserved4[0xed8];   // 28h
+  ///
+  /// Vendor ID
+  ///
+  UINT16                            Vid;                // 0f00h
+  ///
+  /// Device ID
+  ///
+  UINT16                            Did;                // 0f02h
+  ///
+  /// Revision ID
+  ///
+  UINT8                             Rid;                // 0f04h
+  UINT8                             Reserved[0x7b];     // 0f05h
+  ///
+  /// Alias to I/O legacy space.
+  ///
+  UINT32                            LegacyAddress1;     // 0f80h
+  ///
+  /// Additional 8 bits for I/O legacy space extension.
+  ///
+  UINT32                            LegacyAddress1Ex;   // 0f84h
+  ///
+  /// Alias to second I/O legacy space.
+  ///
+  UINT32                            LegacyAddress2;     // 0f88h
+  ///
+  /// Additional 8 bits for second I/O legacy space extension.
+  ///
+  UINT32                            LegacyAddress2Ex;   // 0f8ch
+  ///
+  /// Vendor-defined configuration registers.
+  ///
+  UINT8                             VendorDefined[0x70];// 0f90h
+} TIS_PC_REGISTERS;
+
+//
+// Restore original structure alignment
+//
+#pragma pack ()
+
+//
+// Define pointer types used to access TIS registers on PC
+//
+typedef TIS_PC_REGISTERS  *TIS_PC_REGISTERS_PTR;
+
+//
+// Define bits of ACCESS and STATUS registers
+//
+
+///
+/// This bit is a 1 to indicate that the other bits in this register are valid.
+///
+#define TIS_PC_VALID                BIT7
+///
+/// Indicate that this locality is active.
+///
+#define TIS_PC_ACC_ACTIVE           BIT5
+///
+/// Set to 1 to indicate that this locality had the TPM taken away while
+/// this locality had the TIS_PC_ACC_ACTIVE bit set.
+///
+#define TIS_PC_ACC_SEIZED           BIT4
+///
+/// Set to 1 to indicate that TPM MUST reset the
+/// TIS_PC_ACC_ACTIVE bit and remove ownership for localities less than the
+/// locality that is writing this bit.
+///
+#define TIS_PC_ACC_SEIZE            BIT3
+///
+/// When this bit is 1, another locality is requesting usage of the TPM.
+///
+#define TIS_PC_ACC_PENDIND          BIT2
+///
+/// Set to 1 to indicate that this locality is requesting to use TPM.
+///
+#define TIS_PC_ACC_RQUUSE           BIT1
+///
+/// A value of 1 indicates that a T/OS has not been established on the platform
+///
+#define TIS_PC_ACC_ESTABLISH        BIT0
+
+///
+/// This field indicates that STS_DATA and STS_EXPECT are valid
+///
+#define TIS_PC_STS_VALID            BIT7
+///
+/// When this bit is 1, TPM is in the Ready state,
+/// indicating it is ready to receive a new command.
+///
+#define TIS_PC_STS_READY            BIT6
+///
+/// Write a 1 to this bit to cause the TPM to execute that command.
+///
+#define TIS_PC_STS_GO               BIT5
+///
+/// This bit indicates that the TPM has data available as a response.
+///
+#define TIS_PC_STS_DATA             BIT4
+///
+/// The TPM sets this bit to a value of 1 when it expects another byte of data for a command.
+///
+#define TIS_PC_STS_EXPECT           BIT3
+///
+/// Indicates that the TPM has completed all self-test actions following a TPM_ContinueSelfTest command.
+///
+#define TIS_PC_STS_SELFTEST_DONE    BIT2
+///
+/// Writes a 1 to this bit to force the TPM to re-send the response.
+///
+#define TIS_PC_STS_RETRY            BIT1
+
+//
+// Default TimeOut value
+//
+#define TIS_TIMEOUT_A               (750  * 1000)  // 750ms
+#define TIS_TIMEOUT_B               (2000 * 1000)  // 2s
+#define TIS_TIMEOUT_C               (750  * 1000)  // 750ms
+#define TIS_TIMEOUT_D               (750  * 1000)  // 750ms
+
+#endif
\ No newline at end of file
diff --git a/MdePkg/Include/IndustryStandard/UefiTcgPlatform.h b/MdePkg/Include/IndustryStandard/UefiTcgPlatform.h
new file mode 100644
index 000000000000..0a7469ad4177
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/UefiTcgPlatform.h
@@ -0,0 +1,333 @@
+/** @file
+  TCG EFI Platform Definition in TCG_EFI_Platform_1_20_Final
+
+  Copyright (c) 2006 - 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_TCG_PLATFORM_H__
+#define __UEFI_TCG_PLATFORM_H__
+
+#include <IndustryStandard/Tpm12.h>
+#include <IndustryStandard/Tpm20.h>
+#include <Uefi.h>
+
+//
+// Standard event types
+//
+#define EV_POST_CODE                ((TCG_EVENTTYPE) 0x00000001)
+#define EV_NO_ACTION                ((TCG_EVENTTYPE) 0x00000003)
+#define EV_SEPARATOR                ((TCG_EVENTTYPE) 0x00000004)
+#define EV_S_CRTM_CONTENTS          ((TCG_EVENTTYPE) 0x00000007)
+#define EV_S_CRTM_VERSION           ((TCG_EVENTTYPE) 0x00000008)
+#define EV_CPU_MICROCODE            ((TCG_EVENTTYPE) 0x00000009)
+#define EV_TABLE_OF_DEVICES         ((TCG_EVENTTYPE) 0x0000000B)
+
+//
+// EFI specific event types
+//
+#define EV_EFI_EVENT_BASE                   ((TCG_EVENTTYPE) 0x80000000)
+#define EV_EFI_VARIABLE_DRIVER_CONFIG       (EV_EFI_EVENT_BASE + 1)
+#define EV_EFI_VARIABLE_BOOT                (EV_EFI_EVENT_BASE + 2)
+#define EV_EFI_BOOT_SERVICES_APPLICATION    (EV_EFI_EVENT_BASE + 3)
+#define EV_EFI_BOOT_SERVICES_DRIVER         (EV_EFI_EVENT_BASE + 4)
+#define EV_EFI_RUNTIME_SERVICES_DRIVER      (EV_EFI_EVENT_BASE + 5)
+#define EV_EFI_GPT_EVENT                    (EV_EFI_EVENT_BASE + 6)
+#define EV_EFI_ACTION                       (EV_EFI_EVENT_BASE + 7)
+#define EV_EFI_PLATFORM_FIRMWARE_BLOB       (EV_EFI_EVENT_BASE + 8)
+#define EV_EFI_HANDOFF_TABLES               (EV_EFI_EVENT_BASE + 9)
+#define EV_EFI_VARIABLE_AUTHORITY           (EV_EFI_EVENT_BASE + 0xE0)
+
+#define EFI_CALLING_EFI_APPLICATION         \
+  "Calling EFI Application from Boot Option"
+#define EFI_RETURNING_FROM_EFI_APPLICATOIN  \
+  "Returning from EFI Application from Boot Option"
+#define EFI_EXIT_BOOT_SERVICES_INVOCATION   \
+  "Exit Boot Services Invocation"
+#define EFI_EXIT_BOOT_SERVICES_FAILED       \
+  "Exit Boot Services Returned with Failure"
+#define EFI_EXIT_BOOT_SERVICES_SUCCEEDED    \
+  "Exit Boot Services Returned with Success"
+
+
+#define EV_POSTCODE_INFO_POST_CODE    "POST CODE"
+#define POST_CODE_STR_LEN             (sizeof(EV_POSTCODE_INFO_POST_CODE) - 1)
+
+#define EV_POSTCODE_INFO_SMM_CODE     "SMM CODE"
+#define SMM_CODE_STR_LEN              (sizeof(EV_POSTCODE_INFO_SMM_CODE) - 1)
+
+#define EV_POSTCODE_INFO_ACPI_DATA    "ACPI DATA"
+#define ACPI_DATA_LEN                 (sizeof(EV_POSTCODE_INFO_ACPI_DATA) - 1)
+
+#define EV_POSTCODE_INFO_BIS_CODE     "BIS CODE"
+#define BIS_CODE_LEN                  (sizeof(EV_POSTCODE_INFO_BIS_CODE) - 1)
+
+#define EV_POSTCODE_INFO_UEFI_PI      "UEFI PI"
+#define UEFI_PI_LEN                   (sizeof(EV_POSTCODE_INFO_UEFI_PI) - 1)
+
+#define EV_POSTCODE_INFO_OPROM        "Embedded Option ROM"
+#define OPROM_LEN                     (sizeof(EV_POSTCODE_INFO_OPROM) - 1)
+
+#define FIRMWARE_DEBUGGER_EVENT_STRING      "UEFI Debug Mode"
+#define FIRMWARE_DEBUGGER_EVENT_STRING_LEN  (sizeof(FIRMWARE_DEBUGGER_EVENT_STRING) - 1)
+
+//
+// Set structure alignment to 1-byte
+//
+#pragma pack (1)
+
+typedef UINT32                     TCG_EVENTTYPE;
+typedef TPM_PCRINDEX               TCG_PCRINDEX;
+typedef TPM_DIGEST                 TCG_DIGEST;
+///
+/// Event Log Entry Structure Definition
+///
+typedef struct tdTCG_PCR_EVENT {
+  TCG_PCRINDEX                      PCRIndex;  ///< PCRIndex event extended to
+  TCG_EVENTTYPE                     EventType; ///< TCG EFI event type
+  TCG_DIGEST                        Digest;    ///< Value extended into PCRIndex
+  UINT32                            EventSize; ///< Size of the event data
+  UINT8                             Event[1];  ///< The event data
+} TCG_PCR_EVENT;
+
+#define TSS_EVENT_DATA_MAX_SIZE   256
+
+///
+/// TCG_PCR_EVENT_HDR
+///
+typedef struct tdTCG_PCR_EVENT_HDR {
+  TCG_PCRINDEX                      PCRIndex;
+  TCG_EVENTTYPE                     EventType;
+  TCG_DIGEST                        Digest;
+  UINT32                            EventSize;
+} TCG_PCR_EVENT_HDR;
+
+///
+/// EFI_PLATFORM_FIRMWARE_BLOB
+///
+/// BlobLength should be of type UINTN but we use UINT64 here
+/// because PEI is 32-bit while DXE is 64-bit on x64 platforms
+///
+typedef struct tdEFI_PLATFORM_FIRMWARE_BLOB {
+  EFI_PHYSICAL_ADDRESS              BlobBase;
+  UINT64                            BlobLength;
+} EFI_PLATFORM_FIRMWARE_BLOB;
+
+///
+/// EFI_IMAGE_LOAD_EVENT
+///
+/// This structure is used in EV_EFI_BOOT_SERVICES_APPLICATION,
+/// EV_EFI_BOOT_SERVICES_DRIVER and EV_EFI_RUNTIME_SERVICES_DRIVER
+///
+typedef struct tdEFI_IMAGE_LOAD_EVENT {
+  EFI_PHYSICAL_ADDRESS              ImageLocationInMemory;
+  UINTN                             ImageLengthInMemory;
+  UINTN                             ImageLinkTimeAddress;
+  UINTN                             LengthOfDevicePath;
+  EFI_DEVICE_PATH_PROTOCOL          DevicePath[1];
+} EFI_IMAGE_LOAD_EVENT;
+
+///
+/// EFI_HANDOFF_TABLE_POINTERS
+///
+/// This structure is used in EV_EFI_HANDOFF_TABLES event to facilitate
+/// the measurement of given configuration tables.
+///
+typedef struct tdEFI_HANDOFF_TABLE_POINTERS {
+  UINTN                             NumberOfTables;
+  EFI_CONFIGURATION_TABLE           TableEntry[1];
+} EFI_HANDOFF_TABLE_POINTERS;
+
+///
+/// EFI_VARIABLE_DATA
+///
+/// This structure serves as the header for measuring variables. The name of the
+/// variable (in Unicode format) should immediately follow, then the variable
+/// data.
+/// This is defined in TCG EFI Platform Spec for TPM1.1 or 1.2 V1.22
+///
+typedef struct tdEFI_VARIABLE_DATA {
+  EFI_GUID                          VariableName;
+  UINTN                             UnicodeNameLength;
+  UINTN                             VariableDataLength;
+  CHAR16                            UnicodeName[1];
+  INT8                              VariableData[1];  ///< Driver or platform-specific data
+} EFI_VARIABLE_DATA;
+
+///
+/// UEFI_VARIABLE_DATA
+///
+/// This structure serves as the header for measuring variables. The name of the
+/// variable (in Unicode format) should immediately follow, then the variable
+/// data.
+/// This is defined in TCG PC Client Firmware Profile Spec 00.21
+///
+typedef struct tdUEFI_VARIABLE_DATA {
+  EFI_GUID                          VariableName;
+  UINT64                            UnicodeNameLength;
+  UINT64                            VariableDataLength;
+  CHAR16                            UnicodeName[1];
+  INT8                              VariableData[1];  ///< Driver or platform-specific data
+} UEFI_VARIABLE_DATA;
+
+//
+// For TrEE1.0 compatibility
+//
+typedef struct {
+  EFI_GUID                          VariableName;
+  UINT64                            UnicodeNameLength;   // The TCG Definition used UINTN
+  UINT64                            VariableDataLength;  // The TCG Definition used UINTN
+  CHAR16                            UnicodeName[1];
+  INT8                              VariableData[1];
+} EFI_VARIABLE_DATA_TREE;
+
+typedef struct tdEFI_GPT_DATA {
+  EFI_PARTITION_TABLE_HEADER  EfiPartitionHeader;
+  UINTN                       NumberOfPartitions; 
+  EFI_PARTITION_ENTRY         Partitions[1];
+} EFI_GPT_DATA;
+
+//
+// Crypto Agile Log Entry Format
+//
+typedef struct tdTCG_PCR_EVENT2 {
+  TCG_PCRINDEX        PCRIndex;
+  TCG_EVENTTYPE       EventType;
+  TPML_DIGEST_VALUES  Digest;
+  UINT32              EventSize;
+  UINT8               Event[1];
+} TCG_PCR_EVENT2;
+
+//
+// TCG PCR Event2 Header
+// Follow TCG EFI Protocol Spec 5.2 Crypto Agile Log Entry Format
+//
+typedef struct tdTCG_PCR_EVENT2_HDR{
+  TCG_PCRINDEX        PCRIndex;
+  TCG_EVENTTYPE       EventType;
+  TPML_DIGEST_VALUES  Digests;
+  UINT32              EventSize;
+} TCG_PCR_EVENT2_HDR;
+
+//
+// Log Header Entry Data
+//
+typedef struct {
+  //
+  // TCG defined hashing algorithm ID.
+  //
+  UINT16              algorithmId;
+  //
+  // The size of the digest for the respective hashing algorithm.
+  //
+  UINT16              digestSize;
+} TCG_EfiSpecIdEventAlgorithmSize;
+
+#define TCG_EfiSpecIDEventStruct_SIGNATURE_02 "Spec ID Event02"
+#define TCG_EfiSpecIDEventStruct_SIGNATURE_03 "Spec ID Event03"
+
+#define TCG_EfiSpecIDEventStruct_SPEC_VERSION_MAJOR_TPM12   1
+#define TCG_EfiSpecIDEventStruct_SPEC_VERSION_MINOR_TPM12   2
+#define TCG_EfiSpecIDEventStruct_SPEC_ERRATA_TPM12          2
+
+#define TCG_EfiSpecIDEventStruct_SPEC_VERSION_MAJOR_TPM2   2
+#define TCG_EfiSpecIDEventStruct_SPEC_VERSION_MINOR_TPM2   0
+#define TCG_EfiSpecIDEventStruct_SPEC_ERRATA_TPM2          0
+
+typedef struct {
+  UINT8               signature[16];
+  //
+  // The value for the Platform Class.
+  // The enumeration is defined in the TCG ACPI Specification Client Common Header.
+  //
+  UINT32              platformClass;
+  //
+  // The TCG EFI Platform Specification minor version number this BIOS supports.
+  // Any BIOS supporting version (1.22) MUST set this value to 02h.
+  // Any BIOS supporting version (2.0) SHALL set this value to 0x00.
+  //
+  UINT8               specVersionMinor;
+  //
+  // The TCG EFI Platform Specification major version number this BIOS supports.
+  // Any BIOS supporting version (1.22) MUST set this value to 01h.
+  // Any BIOS supporting version (2.0) SHALL set this value to 0x02.
+  //
+  UINT8               specVersionMajor;
+  //
+  // The TCG EFI Platform Specification errata for this specification this BIOS supports.
+  // Any BIOS supporting version and errata (1.22) MUST set this value to 02h.
+  // Any BIOS supporting version and errata (2.0) SHALL set this value to 0x00.
+  //
+  UINT8               specErrata;
+  //
+  // Specifies the size of the UINTN fields used in various data structures used in this specification.
+  // 0x01 indicates UINT32 and 0x02 indicates UINT64.
+  //
+  UINT8               uintnSize;
+  //
+  // This field is added in "Spec ID Event03".
+  // The number of hashing algorithms used in this event log (except the first event).
+  // All events in this event log use all hashing algorithms defined here.
+  //
+//UINT32              numberOfAlgorithms;
+  //
+  // This field is added in "Spec ID Event03".
+  // An array of size numberOfAlgorithms of value pairs.
+  //
+//TCG_EfiSpecIdEventAlgorithmSize digestSize[numberOfAlgorithms];
+  //
+  // Size in bytes of the VendorInfo field.
+  // Maximum value SHALL be FFh bytes.
+  //
+//UINT8               vendorInfoSize;
+  //
+  // Provided for use by the BIOS implementer.
+  // The value might be used, for example, to provide more detailed information about the specific BIOS such as BIOS revision numbers, etc.
+  // The values within this field are not standardized and are implementer-specific.
+  // Platform-specific or -unique information SHALL NOT be provided in this field.
+  //
+//UINT8               vendorInfo[vendorInfoSize];
+} TCG_EfiSpecIDEventStruct;
+
+
+
+#define TCG_EfiStartupLocalityEvent_SIGNATURE      "StartupLocality"
+
+
+//
+// PC Client PTP spec Table 8 Relationship between Locality and Locality Attribute
+//
+#define LOCALITY_0_INDICATOR        0x01
+#define LOCALITY_1_INDICATOR        0x02
+#define LOCALITY_2_INDICATOR        0x03
+#define LOCALITY_3_INDICATOR        0x04
+#define LOCALITY_4_INDICATOR        0x05
+
+
+//
+// Startup Locality Event
+//
+typedef struct tdTCG_EfiStartupLocalityEvent{
+  UINT8       Signature[16];
+  //
+  // The Locality Indicator which sent the TPM2_Startup command
+  //
+  UINT8       StartupLocality;
+} TCG_EfiStartupLocalityEvent;
+
+
+//
+// Restore original structure alignment
+//
+#pragma pack ()
+
+#endif
+
+
diff --git a/MdePkg/Include/IndustryStandard/Usb.h b/MdePkg/Include/IndustryStandard/Usb.h
new file mode 100644
index 000000000000..38c4d853e5ec
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Usb.h
@@ -0,0 +1,386 @@
+/** @file
+  Support for USB 2.0 standard.
+
+  Copyright (c) 2006 - 2014, 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 __USB_H__
+#define __USB_H__
+
+//
+// Subset of Class and Subclass definitions from USB Specs
+//
+
+//
+// Usb mass storage class code
+//
+#define USB_MASS_STORE_CLASS    0x08
+
+//
+// Usb mass storage subclass code, specify the command set used.
+//
+#define USB_MASS_STORE_RBC      0x01 ///< Reduced Block Commands
+#define USB_MASS_STORE_8020I    0x02 ///< SFF-8020i, typically a CD/DVD device
+#define USB_MASS_STORE_QIC      0x03 ///< Typically a tape device
+#define USB_MASS_STORE_UFI      0x04 ///< Typically a floppy disk driver device
+#define USB_MASS_STORE_8070I    0x05 ///< SFF-8070i, typically a floppy disk driver device.
+#define USB_MASS_STORE_SCSI     0x06 ///< SCSI transparent command set
+
+//
+// Usb mass storage protocol code, specify the transport protocol
+//
+#define USB_MASS_STORE_CBI0     0x00 ///< CBI protocol with command completion interrupt
+#define USB_MASS_STORE_CBI1     0x01 ///< CBI protocol without command completion interrupt
+#define USB_MASS_STORE_BOT      0x50 ///< Bulk-Only Transport
+
+//
+// Standard device request and request type
+// USB 2.0 spec, Section 9.4
+//
+#define USB_DEV_GET_STATUS                  0x00
+#define USB_DEV_GET_STATUS_REQ_TYPE_D       0x80 // Receiver : Device
+#define USB_DEV_GET_STATUS_REQ_TYPE_I       0x81 // Receiver : Interface
+#define USB_DEV_GET_STATUS_REQ_TYPE_E       0x82 // Receiver : Endpoint
+
+#define USB_DEV_CLEAR_FEATURE               0x01
+#define USB_DEV_CLEAR_FEATURE_REQ_TYPE_D    0x00 // Receiver : Device
+#define USB_DEV_CLEAR_FEATURE_REQ_TYPE_I    0x01 // Receiver : Interface
+#define USB_DEV_CLEAR_FEATURE_REQ_TYPE_E    0x02 // Receiver : Endpoint
+
+#define USB_DEV_SET_FEATURE                 0x03
+#define USB_DEV_SET_FEATURE_REQ_TYPE_D      0x00 // Receiver : Device
+#define USB_DEV_SET_FEATURE_REQ_TYPE_I      0x01 // Receiver : Interface
+#define USB_DEV_SET_FEATURE_REQ_TYPE_E      0x02 // Receiver : Endpoint
+
+#define USB_DEV_SET_ADDRESS                 0x05
+#define USB_DEV_SET_ADDRESS_REQ_TYPE        0x00
+
+#define USB_DEV_GET_DESCRIPTOR              0x06
+#define USB_DEV_GET_DESCRIPTOR_REQ_TYPE     0x80
+
+#define USB_DEV_SET_DESCRIPTOR              0x07
+#define USB_DEV_SET_DESCRIPTOR_REQ_TYPE     0x00
+
+#define USB_DEV_GET_CONFIGURATION           0x08
+#define USB_DEV_GET_CONFIGURATION_REQ_TYPE  0x80
+
+#define USB_DEV_SET_CONFIGURATION           0x09
+#define USB_DEV_SET_CONFIGURATION_REQ_TYPE  0x00
+
+#define USB_DEV_GET_INTERFACE               0x0A
+#define USB_DEV_GET_INTERFACE_REQ_TYPE      0x81
+
+#define USB_DEV_SET_INTERFACE               0x0B
+#define USB_DEV_SET_INTERFACE_REQ_TYPE      0x01
+
+#define USB_DEV_SYNCH_FRAME                 0x0C
+#define USB_DEV_SYNCH_FRAME_REQ_TYPE        0x82
+
+
+//
+// USB standard descriptors and reqeust
+//
+#pragma pack(1)
+
+///
+/// Format of Setup Data for USB Device Requests
+/// USB 2.0 spec, Section 9.3
+///
+typedef struct {
+  UINT8           RequestType;
+  UINT8           Request;
+  UINT16          Value;
+  UINT16          Index;
+  UINT16          Length;
+} USB_DEVICE_REQUEST;
+
+///
+/// Standard Device Descriptor
+/// USB 2.0 spec, Section 9.6.1
+///
+typedef struct {
+  UINT8           Length;
+  UINT8           DescriptorType;
+  UINT16          BcdUSB;
+  UINT8           DeviceClass;
+  UINT8           DeviceSubClass;
+  UINT8           DeviceProtocol;
+  UINT8           MaxPacketSize0;
+  UINT16          IdVendor;
+  UINT16          IdProduct;
+  UINT16          BcdDevice;
+  UINT8           StrManufacturer;
+  UINT8           StrProduct;
+  UINT8           StrSerialNumber;
+  UINT8           NumConfigurations;
+} USB_DEVICE_DESCRIPTOR;
+
+///
+/// Standard Configuration Descriptor
+/// USB 2.0 spec, Section 9.6.3
+///
+typedef struct {
+  UINT8           Length;
+  UINT8           DescriptorType;
+  UINT16          TotalLength;
+  UINT8           NumInterfaces;
+  UINT8           ConfigurationValue;
+  UINT8           Configuration;
+  UINT8           Attributes;
+  UINT8           MaxPower;
+} USB_CONFIG_DESCRIPTOR;
+
+///
+/// Standard Interface Descriptor
+/// USB 2.0 spec, Section 9.6.5
+///
+typedef struct {
+  UINT8           Length;
+  UINT8           DescriptorType;
+  UINT8           InterfaceNumber;
+  UINT8           AlternateSetting;
+  UINT8           NumEndpoints;
+  UINT8           InterfaceClass;
+  UINT8           InterfaceSubClass;
+  UINT8           InterfaceProtocol;
+  UINT8           Interface;
+} USB_INTERFACE_DESCRIPTOR;
+
+///
+/// Standard Endpoint Descriptor
+/// USB 2.0 spec, Section 9.6.6
+///
+typedef struct {
+  UINT8           Length;
+  UINT8           DescriptorType;
+  UINT8           EndpointAddress;
+  UINT8           Attributes;
+  UINT16          MaxPacketSize;
+  UINT8           Interval;
+} USB_ENDPOINT_DESCRIPTOR;
+
+///
+/// UNICODE String Descriptor
+/// USB 2.0 spec, Section 9.6.7
+///
+typedef struct {
+  UINT8           Length;
+  UINT8           DescriptorType;
+  CHAR16          String[1];
+} EFI_USB_STRING_DESCRIPTOR;
+
+#pragma pack()
+
+
+typedef enum {
+  //
+  // USB request type
+  //
+  USB_REQ_TYPE_STANDARD   = (0x00 << 5),
+  USB_REQ_TYPE_CLASS      = (0x01 << 5),
+  USB_REQ_TYPE_VENDOR     = (0x02 << 5),
+
+  //
+  // Standard control transfer request type, or the value
+  // to fill in EFI_USB_DEVICE_REQUEST.Request
+  //
+  USB_REQ_GET_STATUS      = 0x00,
+  USB_REQ_CLEAR_FEATURE   = 0x01,
+  USB_REQ_SET_FEATURE     = 0x03,
+  USB_REQ_SET_ADDRESS     = 0x05,
+  USB_REQ_GET_DESCRIPTOR  = 0x06,
+  USB_REQ_SET_DESCRIPTOR  = 0x07,
+  USB_REQ_GET_CONFIG      = 0x08,
+  USB_REQ_SET_CONFIG      = 0x09,
+  USB_REQ_GET_INTERFACE   = 0x0A,
+  USB_REQ_SET_INTERFACE   = 0x0B,
+  USB_REQ_SYNCH_FRAME     = 0x0C,
+
+  //
+  // Usb control transfer target
+  //
+  USB_TARGET_DEVICE       = 0,
+  USB_TARGET_INTERFACE    = 0x01,
+  USB_TARGET_ENDPOINT     = 0x02,
+  USB_TARGET_OTHER        = 0x03,
+
+  //
+  // USB Descriptor types
+  //
+  USB_DESC_TYPE_DEVICE    = 0x01,
+  USB_DESC_TYPE_CONFIG    = 0x02,
+  USB_DESC_TYPE_STRING    = 0x03,
+  USB_DESC_TYPE_INTERFACE = 0x04,
+  USB_DESC_TYPE_ENDPOINT  = 0x05,
+  USB_DESC_TYPE_HID       = 0x21,
+  USB_DESC_TYPE_REPORT    = 0x22,
+
+  //
+  // Features to be cleared by CLEAR_FEATURE requests
+  //
+  USB_FEATURE_ENDPOINT_HALT = 0,
+
+  //
+  // USB endpoint types: 00: control, 01: isochronous, 10: bulk, 11: interrupt
+  //
+  USB_ENDPOINT_CONTROL    = 0x00,
+  USB_ENDPOINT_ISO        = 0x01,
+  USB_ENDPOINT_BULK       = 0x02,
+  USB_ENDPOINT_INTERRUPT  = 0x03,
+
+  USB_ENDPOINT_TYPE_MASK  = 0x03,
+  USB_ENDPOINT_DIR_IN     = 0x80,
+
+  //
+  //Use 200 ms to increase the error handling response time
+  //
+  EFI_USB_INTERRUPT_DELAY = 2000000
+} USB_TYPES_DEFINITION;
+
+
+//
+// HID constants definition, see Device Class Definition
+// for Human Interface Devices (HID) rev1.11
+//
+
+//
+// HID standard GET_DESCRIPTOR request.
+//
+#define USB_HID_GET_DESCRIPTOR_REQ_TYPE  0x81
+
+//
+// HID specific requests.
+//
+#define USB_HID_CLASS_GET_REQ_TYPE       0xa1
+#define USB_HID_CLASS_SET_REQ_TYPE       0x21
+
+//
+// HID report item format
+//
+#define HID_ITEM_FORMAT_SHORT 0
+#define HID_ITEM_FORMAT_LONG  1
+
+//
+// Special tag indicating long items
+//
+#define HID_ITEM_TAG_LONG 15
+
+//
+// HID report descriptor item type (prefix bit 2,3)
+//
+#define HID_ITEM_TYPE_MAIN      0
+#define HID_ITEM_TYPE_GLOBAL    1
+#define HID_ITEM_TYPE_LOCAL     2
+#define HID_ITEM_TYPE_RESERVED  3
+
+//
+// HID report descriptor main item tags
+//
+#define HID_MAIN_ITEM_TAG_INPUT             8
+#define HID_MAIN_ITEM_TAG_OUTPUT            9
+#define HID_MAIN_ITEM_TAG_FEATURE           11
+#define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION  10
+#define HID_MAIN_ITEM_TAG_END_COLLECTION    12
+
+//
+// HID report descriptor main item contents
+//
+#define HID_MAIN_ITEM_CONSTANT      0x001
+#define HID_MAIN_ITEM_VARIABLE      0x002
+#define HID_MAIN_ITEM_RELATIVE      0x004
+#define HID_MAIN_ITEM_WRAP          0x008
+#define HID_MAIN_ITEM_NONLINEAR     0x010
+#define HID_MAIN_ITEM_NO_PREFERRED  0x020
+#define HID_MAIN_ITEM_NULL_STATE    0x040
+#define HID_MAIN_ITEM_VOLATILE      0x080
+#define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
+
+//
+// HID report descriptor collection item types
+//
+#define HID_COLLECTION_PHYSICAL     0
+#define HID_COLLECTION_APPLICATION  1
+#define HID_COLLECTION_LOGICAL      2
+
+//
+// HID report descriptor global item tags
+//
+#define HID_GLOBAL_ITEM_TAG_USAGE_PAGE        0
+#define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM   1
+#define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM   2
+#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM  3
+#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM  4
+#define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT     5
+#define HID_GLOBAL_ITEM_TAG_UNIT              6
+#define HID_GLOBAL_ITEM_TAG_REPORT_SIZE       7
+#define HID_GLOBAL_ITEM_TAG_REPORT_ID         8
+#define HID_GLOBAL_ITEM_TAG_REPORT_COUNT      9
+#define HID_GLOBAL_ITEM_TAG_PUSH              10
+#define HID_GLOBAL_ITEM_TAG_POP               11
+
+//
+// HID report descriptor local item tags
+//
+#define HID_LOCAL_ITEM_TAG_USAGE              0
+#define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM      1
+#define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM      2
+#define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX   3
+#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
+#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
+#define HID_LOCAL_ITEM_TAG_STRING_INDEX       7
+#define HID_LOCAL_ITEM_TAG_STRING_MINIMUM     8
+#define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM     9
+#define HID_LOCAL_ITEM_TAG_DELIMITER          10
+
+//
+// HID report types
+//
+#define HID_INPUT_REPORT    1
+#define HID_OUTPUT_REPORT   2
+#define HID_FEATURE_REPORT  3
+
+//
+// HID class protocol request
+//
+#define EFI_USB_GET_REPORT_REQUEST    0x01
+#define EFI_USB_GET_IDLE_REQUEST      0x02
+#define EFI_USB_GET_PROTOCOL_REQUEST  0x03
+#define EFI_USB_SET_REPORT_REQUEST    0x09
+#define EFI_USB_SET_IDLE_REQUEST      0x0a
+#define EFI_USB_SET_PROTOCOL_REQUEST  0x0b
+
+#pragma pack(1)
+///
+/// Descriptor header for Report/Physical Descriptors
+/// HID 1.1, section 6.2.1
+///
+typedef struct hid_class_descriptor {
+  UINT8   DescriptorType;
+  UINT16  DescriptorLength;
+} EFI_USB_HID_CLASS_DESCRIPTOR;
+
+///
+/// The HID descriptor identifies the length and type
+/// of subordinate descriptors for a device.
+/// HID 1.1, section 6.2.1
+///
+typedef struct hid_descriptor {
+  UINT8                         Length;
+  UINT8                         DescriptorType;
+  UINT16                        BcdHID;
+  UINT8                         CountryCode;
+  UINT8                         NumDescriptors;
+  EFI_USB_HID_CLASS_DESCRIPTOR  HidClassDesc[1];
+} EFI_USB_HID_DESCRIPTOR;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/WatchdogActionTable.h b/MdePkg/Include/IndustryStandard/WatchdogActionTable.h
new file mode 100644
index 000000000000..124a5e77753b
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/WatchdogActionTable.h
@@ -0,0 +1,96 @@
+/** @file   
+  ACPI Watchdog Action Table (WADT) as defined at
+  Microsoft Hardware Watchdog Timers Design Specification.
+
+  Copyright (c) 2008, 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 _WATCHDOG_ACTION_TABLE_H_
+#define _WATCHDOG_ACTION_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+///
+/// Watchdog Action Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  UINT32                                  WatchdogHeaderLength;
+  UINT16                                  PCISegment;
+  UINT8                                   PCIBusNumber;
+  UINT8                                   PCIDeviceNumber;
+  UINT8                                   PCIFunctionNumber;
+  UINT8                                   Reserved_45[3];
+  UINT32                                  TimerPeriod;
+  UINT32                                  MaxCount;
+  UINT32                                  MinCount;
+  UINT8                                   WatchdogFlags;  
+  UINT8                                   Reserved_61[3];  
+  UINT32                                  NumberWatchdogInstructionEntries;
+} EFI_ACPI_WATCHDOG_ACTION_1_0_TABLE;
+
+///
+/// Watchdog Instruction Entries
+///
+typedef struct {
+  UINT8                                   WatchdogAction;
+  UINT8                                   InstructionFlags;
+  UINT8                                   Reserved_2[2];
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  RegisterRegion;
+  UINT32                                  Value;
+  UINT32                                  Mask;
+} EFI_ACPI_WATCHDOG_ACTION_1_0_WATCHDOG_ACTION_INSTRUCTION_ENTRY;
+
+#pragma pack()
+
+///
+/// WDAT Revision (defined in spec)
+///
+#define EFI_ACPI_WATCHDOG_ACTION_1_0_TABLE_REVISION       0x01
+
+//
+// WDAT 1.0 Flags
+//
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ENABLED                0x1
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_STOPPED_IN_SLEEP_STATE 0x80
+
+//
+// WDAT 1.0 Watchdog Actions
+//
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_RESET                          0x1
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_CURRENT_COUNTDOWN_PERIOD 0x4
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_COUNTDOWN_PERIOD         0x5
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_COUNTDOWN_PERIOD           0x6
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_RUNNING_STATE            0x8
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_RUNNING_STATE              0x9
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_STOPPED_STATE            0xA
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_STOPPED_STATE              0xB
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_REBOOT                   0x10
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_REBOOT                     0x11
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_SHUTDOWN                 0x12
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_SHUTDOWN                   0x13
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_QUERY_WATCHDOG_STATUS          0x20
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_ACTION_SET_WATCHDOG_STATUS            0x21
+
+//
+// WDAT 1.0 Watchdog Action Entry Instruction Flags
+//
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_INSTRUCTION_READ_VALUE        0x0
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_INSTRUCTION_READ_COUNTDOWN    0x1
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_INSTRUCTION_WRITE_VALUE       0x2
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_INSTRUCTION_WRITE_COUNTDOWN   0x3
+#define EFI_ACPI_WDAT_1_0_WATCHDOG_INSTRUCTION_PRESERVE_REGISTER 0x80
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/WatchdogResourceTable.h b/MdePkg/Include/IndustryStandard/WatchdogResourceTable.h
new file mode 100644
index 000000000000..a0b0cf2c1830
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/WatchdogResourceTable.h
@@ -0,0 +1,56 @@
+/** @file   
+  ACPI Watchdog Resource Table (WDRT) as defined at
+  Microsoft Windows Hardware Developer Central.
+
+  Copyright (c) 2006 - 2008, 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 _WATCHDOG_RESOURCE_TABLE_H_
+#define _WATCHDOG_RESOURCE_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// Ensure proper structure formats
+//
+#pragma pack(1)
+
+///
+/// Watchdog Resource Table definition.
+///
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER             Header;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  ControlRegisterAddress;
+  EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE  CountRegisterAddress;
+  UINT16                                  PCIDeviceID;
+  UINT16                                  PCIVendorID;
+  UINT8                                   PCIBusNumber;
+  UINT8                                   PCIDeviceNumber;
+  UINT8                                   PCIFunctionNumber;
+  UINT8                                   PCISegment;
+  UINT16                                  MaxCount;
+  UINT8                                   Units;
+} EFI_ACPI_WATCHDOG_RESOURCE_1_0_TABLE;
+
+#pragma pack()
+
+//
+// WDRT Revision (defined in spec)
+//
+#define EFI_ACPI_WATCHDOG_RESOURCE_1_0_TABLE_REVISION  0x01
+
+//
+// WDRT 1.0 Count Unit
+//
+#define EFI_ACPI_WDRT_1_0_COUNT_UNIT_1_SEC_PER_COUNT        1
+#define EFI_ACPI_WDRT_1_0_COUNT_UNIT_100_MILLISEC_PER_COUNT 2
+#define EFI_ACPI_WDRT_1_0_COUNT_UNIT_10_MILLISEC_PER_COUNT  3
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/WindowsSmmSecurityMitigationTable.h b/MdePkg/Include/IndustryStandard/WindowsSmmSecurityMitigationTable.h
new file mode 100644
index 000000000000..390a3c83720b
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/WindowsSmmSecurityMitigationTable.h
@@ -0,0 +1,39 @@
+/** @file
+  Defines Windows SMM Security Mitigation Table
+  @ https://msdn.microsoft.com/windows/hardware/drivers/bringup/acpi-system-description-tables#wsmt
+
+  Copyright (c) 2016, 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 _WINDOWS_SMM_SECURITY_MITIGATION_TABLE_H_
+#define _WINDOWS_SMM_SECURITY_MITIGATION_TABLE_H_
+
+#include <IndustryStandard/Acpi.h>
+
+#define EFI_ACPI_WINDOWS_SMM_SECURITY_MITIGATION_TABLE_SIGNATURE  SIGNATURE_32('W', 'S', 'M', 'T')
+
+#pragma pack(1)
+
+#define EFI_WSMT_TABLE_REVISION  1
+
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER Header;
+  UINT32                      ProtectionFlags;
+} EFI_ACPI_WSMT_TABLE;
+
+#define EFI_WSMT_PROTECTION_FLAGS_FIXED_COMM_BUFFERS                   0x1
+#define EFI_WSMT_PROTECTION_FLAGS_COMM_BUFFER_NESTED_PTR_PROTECTION    0x2
+#define EFI_WSMT_PROTECTION_FLAGS_SYSTEM_RESOURCE_PROTECTION           0x4
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/IndustryStandard/WindowsUxCapsule.h b/MdePkg/Include/IndustryStandard/WindowsUxCapsule.h
new file mode 100644
index 000000000000..611c8f6377cc
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/WindowsUxCapsule.h
@@ -0,0 +1,47 @@
+/** @file
+  Defines Windows UX Capsule GUID and layout defined at Microsoft
+  Windows UEFI Firmware Update Platform specification
+
+  Copyright (c) 2015, 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 _WINDOWS_UX_CAPSULE_GUID_H_
+#define _WINDOWS_UX_CAPSULE_GUID_H_
+
+#pragma pack(1)
+
+typedef struct {
+   UINT8  Version;
+   UINT8  Checksum;
+   UINT8  ImageType;
+   UINT8  Reserved;
+   UINT32 Mode;
+   UINT32 OffsetX;
+   UINT32 OffsetY;
+   //UINT8  Image[];
+} DISPLAY_DISPLAY_PAYLOAD;
+
+typedef struct {
+  EFI_CAPSULE_HEADER       CapsuleHeader;
+  DISPLAY_DISPLAY_PAYLOAD  ImagePayload;
+} EFI_DISPLAY_CAPSULE;
+
+#pragma pack()
+
+#define WINDOWS_UX_CAPSULE_GUID \
+  { \
+    0x3b8c8162, 0x188c, 0x46a4, { 0xae, 0xc9, 0xbe, 0x43, 0xf1, 0xd6, 0x56, 0x97}  \
+  }
+
+extern EFI_GUID gWindowsUxCapsuleGuid;
+
+#endif
diff --git a/MdePkg/Include/Ipf/IpfMacro.i b/MdePkg/Include/Ipf/IpfMacro.i
new file mode 100644
index 000000000000..95cd13442c1a
--- /dev/null
+++ b/MdePkg/Include/Ipf/IpfMacro.i
@@ -0,0 +1,58 @@
+// @file
+// Contains the macros required by calling procedures in Itanium-based assembly code.
+//
+// Copyright (c) 2006 - 2009, 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  __IA64PROC_I__
+#define  __IA64PROC_I__
+
+//
+// Delcare the begin of assembly function entry.
+//
+// @param name Name of function in assembly code.
+//
+#define PROCEDURE_ENTRY(name)   .##text;            \
+                                .##type name, @function;    \
+                                .##proc name;           \
+name::
+
+//
+// End of assembly function.
+//
+// @param name Name of function in assembly code.
+//
+#define PROCEDURE_EXIT(name)    .##endp name
+
+//
+// NESTED_SETUP Requires number of locals (l) >= 3
+//
+#define NESTED_SETUP(i,l,o,r) \
+         alloc loc1=ar##.##pfs,i,l,o,r ;\
+         mov loc0=b0
+
+//
+// End of Nested
+//
+#define NESTED_RETURN \
+         mov b0=loc0 ;\
+         mov ar##.##pfs=loc1 ;;\
+         br##.##ret##.##dpnt  b0;;
+
+//
+// Export assembly function as the global function.
+//
+// @param Function Name of function in assembly code.
+//
+#define GLOBAL_FUNCTION(Function) \
+         .##type   Function, @function; \
+         .##globl Function
+
+#endif
diff --git a/MdePkg/Include/Ipf/ProcessorBind.h b/MdePkg/Include/Ipf/ProcessorBind.h
new file mode 100644
index 000000000000..8ed5c7840178
--- /dev/null
+++ b/MdePkg/Include/Ipf/ProcessorBind.h
@@ -0,0 +1,319 @@
+/** @file
+  Processor or Compiler specific defines and types for Intel Itanium(TM) processors.
+
+Copyright (c) 2006 - 2013, 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+
+///
+/// Define the processor type so other code can make processor-based choices.
+///
+#define MDE_CPU_IPF
+
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#pragma pack()
+
+
+#if defined(__INTEL_COMPILER)
+//
+// Disable ICC's remark #869: "Parameter" was never referenced warning.
+// This is legal ANSI C code so we disable the remark that is turned on with -Wall
+//
+#pragma warning ( disable : 869 )
+
+//
+// Disable ICC's remark #1418: external function definition with no prior declaration.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1418 )
+
+//
+// Disable ICC's remark #1419: external declaration in primary source file
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1419 )
+
+//
+// Disable ICC's remark #593: "Variable" was set but never used.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 593 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+//
+// Disable warning that make it impossible to compile at /W4
+// This only works for Microsoft* tools
+//
+
+//
+// Disabling bitfield type checking warnings.
+//
+#pragma warning ( disable : 4214 )
+
+//
+// Disabling the unreferenced formal parameter warnings.
+//
+#pragma warning ( disable : 4100 )
+
+//
+// Disable slightly different base types warning as CHAR8 * can not be set
+// to a constant string.
+//
+#pragma warning ( disable : 4057 )
+
+//
+// Disable warning on conversion from function pointer to a data pointer
+//
+#pragma warning ( disable : 4054 )
+
+//
+// ASSERT(FALSE) or while (TRUE) are legal constructs so suppress this warning
+//
+#pragma warning ( disable : 4127 )
+
+//
+// Can not cast a function pointer to a data pointer. We need to do this on
+// Itanium processors to get access to the PLABEL.
+//
+#pragma warning ( disable : 4514 )
+
+//
+// This warning is caused by functions defined but not used. For precompiled header only.
+//
+#pragma warning ( disable : 4505 )
+
+//
+// This warning is caused by empty (after preprocessing) source file. For precompiled header only.
+//
+#pragma warning ( disable : 4206 )
+
+#endif
+
+#if defined(_MSC_EXTENSIONS)
+  //
+  // use Microsoft C compiler dependent integer width types
+  //
+
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned __int64    UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef __int64             INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned __int32    UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef __int32             INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character.
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value.
+  ///
+  typedef signed char         INT8;
+#else
+  ///
+  /// 8-byte unsigned value.
+  ///
+  typedef unsigned long long  UINT64;
+  ///
+  /// 8-byte signed value.
+  ///
+  typedef long long           INT64;
+  ///
+  /// 4-byte unsigned value.
+  ///
+  typedef unsigned int        UINT32;
+  ///
+  /// 4-byte signed value.
+  ///
+  typedef int                 INT32;
+  ///
+  /// 2-byte unsigned value.
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value.
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value.
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character.
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value.
+  ///
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef UINT64  UINTN;
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions;
+/// 8 bytes on supported 64-bit processor instructions.)
+///
+typedef INT64   INTN;
+
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x8000000000000000ULL
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC000000000000000ULL
+
+///
+/// The maximum legal Itanium-based address
+///
+#define MAX_ADDRESS   0xFFFFFFFFFFFFFFFFULL
+
+///
+/// Maximum legal Itanium-based INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFFFFFFFFFFULL)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFFFFFFFFFFULL)
+
+///
+/// Per the Itanium Software Conventions and Runtime Architecture Guide,
+/// section 3.3.4, IPF stack must always be 16-byte aligned.
+///
+#define CPU_STACK_ALIGNMENT   16
+
+///
+/// Page allocation granularity for Itanium
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x2000)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#elif defined(_MSC_EXTENSIONS)
+  ///
+  /// Microsoft* compiler-specific method for EFIAPI calling convention.
+  /// 
+  #define EFIAPI __cdecl
+#else
+  #define EFIAPI
+#endif
+
+///
+/// For GNU assembly code, .global or .globl can declare global symbols.
+/// Define this macro to unify the usage.
+///
+#define ASM_GLOBAL .globl
+
+///
+/// A pointer to a function in IPF points to a plabel.
+///
+typedef struct {
+  UINT64  EntryPoint;
+  UINT64  GP;
+} EFI_PLABEL;
+
+///
+/// PAL Call return structure.
+///
+typedef struct {
+  UINT64                    Status;
+  UINT64                    r9;
+  UINT64                    r10;
+  UINT64                    r11;
+} PAL_CALL_RETURN;
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  For Itanium processors, all function calls are made through a PLABEL, so a pointer to a function 
+  is actually a pointer to a PLABEL.  The pointer to the first instruction of the function 
+  is contained within the PLABEL.  This macro may be used to retrieve a pointer to the first 
+  instruction of a function independent of the CPU architecture being used.  This is very 
+  useful when printing function addresses through DEBUG() macros.
+  
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+  
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(((EFI_PLABEL *)(FunctionPointer))->EntryPoint)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#endif
+
diff --git a/MdePkg/Include/Library/BaseLib.h b/MdePkg/Include/Library/BaseLib.h
new file mode 100644
index 000000000000..b41c10b1b661
--- /dev/null
+++ b/MdePkg/Include/Library/BaseLib.h
@@ -0,0 +1,8910 @@
+/** @file
+  Provides string functions, linked list functions, math functions, synchronization
+  functions, file path functions, and CPU architecture-specific functions.
+
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2009, Apple Inc. 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 __BASE_LIB__
+#define __BASE_LIB__
+
+//
+// Definitions for architecture-specific types
+//
+#if   defined (MDE_CPU_IA32)
+///
+/// The IA-32 architecture context buffer used by SetJump() and LongJump().
+///
+typedef struct {
+  UINT32                            Ebx;
+  UINT32                            Esi;
+  UINT32                            Edi;
+  UINT32                            Ebp;
+  UINT32                            Esp;
+  UINT32                            Eip;
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 4
+
+#endif // defined (MDE_CPU_IA32)
+
+#if defined (MDE_CPU_IPF)
+
+///
+/// The Itanium architecture context buffer used by SetJump() and LongJump().
+///
+typedef struct {
+  UINT64                            F2[2];
+  UINT64                            F3[2];
+  UINT64                            F4[2];
+  UINT64                            F5[2];
+  UINT64                            F16[2];
+  UINT64                            F17[2];
+  UINT64                            F18[2];
+  UINT64                            F19[2];
+  UINT64                            F20[2];
+  UINT64                            F21[2];
+  UINT64                            F22[2];
+  UINT64                            F23[2];
+  UINT64                            F24[2];
+  UINT64                            F25[2];
+  UINT64                            F26[2];
+  UINT64                            F27[2];
+  UINT64                            F28[2];
+  UINT64                            F29[2];
+  UINT64                            F30[2];
+  UINT64                            F31[2];
+  UINT64                            R4;
+  UINT64                            R5;
+  UINT64                            R6;
+  UINT64                            R7;
+  UINT64                            SP;
+  UINT64                            BR0;
+  UINT64                            BR1;
+  UINT64                            BR2;
+  UINT64                            BR3;
+  UINT64                            BR4;
+  UINT64                            BR5;
+  UINT64                            InitialUNAT;
+  UINT64                            AfterSpillUNAT;
+  UINT64                            PFS;
+  UINT64                            BSP;
+  UINT64                            Predicates;
+  UINT64                            LoopCount;
+  UINT64                            FPSR;
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 0x10
+
+#endif // defined (MDE_CPU_IPF)
+
+#if defined (MDE_CPU_X64)
+///
+/// The x64 architecture context buffer used by SetJump() and LongJump().
+///
+typedef struct {
+  UINT64                            Rbx;
+  UINT64                            Rsp;
+  UINT64                            Rbp;
+  UINT64                            Rdi;
+  UINT64                            Rsi;
+  UINT64                            R12;
+  UINT64                            R13;
+  UINT64                            R14;
+  UINT64                            R15;
+  UINT64                            Rip;
+  UINT64                            MxCsr;
+  UINT8                             XmmBuffer[160]; ///< XMM6-XMM15.
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8
+
+#endif // defined (MDE_CPU_X64)
+
+#if defined (MDE_CPU_EBC)
+///
+/// The EBC context buffer used by SetJump() and LongJump().
+///
+typedef struct {
+  UINT64                            R0;
+  UINT64                            R1;
+  UINT64                            R2;
+  UINT64                            R3;
+  UINT64                            IP;
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8
+
+#endif // defined (MDE_CPU_EBC)
+
+#if defined (MDE_CPU_ARM)
+
+typedef struct {
+  UINT32    R3;  ///< A copy of R13.
+  UINT32    R4;
+  UINT32    R5;
+  UINT32    R6;
+  UINT32    R7;
+  UINT32    R8;
+  UINT32    R9;
+  UINT32    R10;
+  UINT32    R11;
+  UINT32    R12;
+  UINT32    R14;
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 4
+
+#endif  // defined (MDE_CPU_ARM)
+
+#if defined (MDE_CPU_AARCH64)
+typedef struct {
+  // GP regs
+  UINT64    X19;
+  UINT64    X20;
+  UINT64    X21;
+  UINT64    X22;
+  UINT64    X23;
+  UINT64    X24;
+  UINT64    X25;
+  UINT64    X26;
+  UINT64    X27;
+  UINT64    X28;
+  UINT64    FP;
+  UINT64    LR;
+  UINT64    IP0;
+
+  // FP regs
+  UINT64    D8;
+  UINT64    D9;
+  UINT64    D10;
+  UINT64    D11;
+  UINT64    D12;
+  UINT64    D13;
+  UINT64    D14;
+  UINT64    D15;
+} BASE_LIBRARY_JUMP_BUFFER;
+
+#define BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT 8
+
+#endif  // defined (MDE_CPU_AARCH64)
+
+
+//
+// String Services
+//
+
+
+/**
+  Returns the length of a Null-terminated Unicode string.
+
+  This function is similar as strlen_s defined in C11.
+
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String   A pointer to a Null-terminated Unicode string.
+  @param  MaxSize  The maximum number of Destination Unicode
+                   char, including terminating null char.
+
+  @retval 0        If String is NULL.
+  @retval MaxSize  If there is no null character in the first MaxSize characters of String.
+  @return The number of characters that percede the terminating null character.
+
+**/
+UINTN
+EFIAPI
+StrnLenS (
+  IN CONST CHAR16              *String,
+  IN UINTN                     MaxSize
+  );
+
+/**
+  Returns the size of a Null-terminated Unicode string in bytes, including the
+  Null terminator.
+
+  This function returns the size of the Null-terminated Unicode string
+  specified by String in bytes, including the Null terminator.
+
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String   A pointer to a Null-terminated Unicode string.
+  @param  MaxSize  The maximum number of Destination Unicode
+                   char, including the Null terminator.
+
+  @retval 0  If String is NULL.
+  @retval (sizeof (CHAR16) * (MaxSize + 1))
+             If there is no Null terminator in the first MaxSize characters of
+             String.
+  @return The size of the Null-terminated Unicode string in bytes, including
+          the Null terminator.
+
+**/
+UINTN
+EFIAPI
+StrnSizeS (
+  IN CONST CHAR16              *String,
+  IN UINTN                     MaxSize
+  );
+
+/**
+  Copies the string pointed to by Source (including the terminating null char)
+  to the array pointed to by Destination.
+
+  This function is similar as strcpy_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrCpyS (
+  OUT CHAR16       *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR16 *Source
+  );
+
+/**
+  Copies not more than Length successive char from the string pointed to by
+  Source to the array pointed to by Destination. If no null char is copied from
+  Source, then Destination[Length] is always set to null.
+
+  This function is similar as strncpy_s defined in C11.
+
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+  @param  Length                   The maximum number of Unicode characters to copy.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than 
+                                   MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrnCpyS (
+  OUT CHAR16       *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR16 *Source,
+  IN  UINTN        Length
+  );
+
+/**
+  Appends a copy of the string pointed to by Source (including the terminating
+  null char) to the end of the string pointed to by Destination.
+
+  This function is similar as strcat_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than 
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrCatS (
+  IN OUT CHAR16       *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR16 *Source
+  );
+
+/**
+  Appends not more than Length successive char from the string pointed to by
+  Source to the end of the string pointed to by Destination. If no null char is
+  copied from Source, then Destination[StrLen(Destination) + Length] is always
+  set to null.
+
+  This function is similar as strncat_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+  @param  Length                   The maximum number of Unicode characters to copy.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrnCatS (
+  IN OUT CHAR16       *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR16 *Source,
+  IN     UINTN        Length
+  );
+
+/**
+  Convert a Null-terminated Unicode decimal 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 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 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
+  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 UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrDecimalToUintnS (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  );
+
+/**
+  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
+EFIAPI
+StrDecimalToUint64S (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  );
+
+/**
+  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
+EFIAPI
+StrHexToUintnS (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  );
+
+/**
+  Convert a Null-terminated Unicode hexadecimal 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 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 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
+  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 UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrHexToUint64S (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  );
+
+/**
+  Returns the length of a Null-terminated Ascii string.
+
+  This function is similar as strlen_s defined in C11.
+
+  @param  String   A pointer to a Null-terminated Ascii string.
+  @param  MaxSize  The maximum number of Destination Ascii
+                   char, including terminating null char.
+
+  @retval 0        If String is NULL.
+  @retval MaxSize  If there is no null character in the first MaxSize characters of String.
+  @return The number of characters that percede the terminating null character.
+
+**/
+UINTN
+EFIAPI
+AsciiStrnLenS (
+  IN CONST CHAR8               *String,
+  IN UINTN                     MaxSize
+  );
+
+/**
+  Returns the size of a Null-terminated Ascii string in bytes, including the
+  Null terminator.
+
+  This function returns the size of the Null-terminated Ascii string specified
+  by String in bytes, including the Null terminator.
+
+  @param  String   A pointer to a Null-terminated Ascii string.
+  @param  MaxSize  The maximum number of Destination Ascii
+                   char, including the Null terminator.
+
+  @retval 0  If String is NULL.
+  @retval (sizeof (CHAR8) * (MaxSize + 1))
+             If there is no Null terminator in the first MaxSize characters of
+             String.
+  @return The size of the Null-terminated Ascii string in bytes, including the
+          Null terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiStrnSizeS (
+  IN CONST CHAR8               *String,
+  IN UINTN                     MaxSize
+  );
+
+/**
+  Copies the string pointed to by Source (including the terminating null char)
+  to the array pointed to by Destination.
+
+  This function is similar as strcpy_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrCpyS (
+  OUT CHAR8        *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR8  *Source
+  );
+
+/**
+  Copies not more than Length successive char from the string pointed to by
+  Source to the array pointed to by Destination. If no null char is copied from
+  Source, then Destination[Length] is always set to null.
+
+  This function is similar as strncpy_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+  @param  Length                   The maximum number of Ascii characters to copy.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than 
+                                   MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnCpyS (
+  OUT CHAR8        *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR8  *Source,
+  IN  UINTN        Length
+  );
+
+/**
+  Appends a copy of the string pointed to by Source (including the terminating
+  null char) to the end of the string pointed to by Destination.
+
+  This function is similar as strcat_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than 
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrCatS (
+  IN OUT CHAR8        *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR8  *Source
+  );
+
+/**
+  Appends not more than Length successive char from the string pointed to by
+  Source to the end of the string pointed to by Destination. If no null char is
+  copied from Source, then Destination[StrLen(Destination) + Length] is always
+  set to null.
+
+  This function is similar as strncat_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+  @param  Length                   The maximum number of Ascii characters to copy.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnCatS (
+  IN OUT CHAR8        *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR8  *Source,
+  IN     UINTN        Length
+  );
+
+/**
+  Convert a Null-terminated Ascii decimal string to a value of type UINTN.
+
+  This function outputs a value of type UINTN by interpreting the contents of
+  the Ascii string specified by String as a decimal number. The format of the
+  input Ascii 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 PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 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
+  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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrDecimalToUintnS (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  );
+
+/**
+  Convert a Null-terminated Ascii decimal string to a value of type UINT64.
+
+  This function outputs a value of type UINT64 by interpreting the contents of
+  the Ascii string specified by String as a decimal number. The format of the
+  input Ascii 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 PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrDecimalToUint64S (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  );
+
+/**
+  Convert a Null-terminated Ascii hexadecimal string to a value of type UINTN.
+
+  This function outputs a value of type UINTN by interpreting the contents of
+  the Ascii string specified by String as a hexadecimal number. The format of
+  the input Ascii 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 digits]. The running zero before [x] or
+  [hexadecimal digits] 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-terminator,
+  whichever on comes first.
+
+  If String is NULL, then ASSERT().
+  If Data is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrHexToUintnS (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  );
+
+/**
+  Convert a Null-terminated Ascii hexadecimal string to a value of type UINT64.
+
+  This function outputs a value of type UINT64 by interpreting the contents of
+  the Ascii string specified by String as a hexadecimal number. The format of
+  the input Ascii 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 digits]. The running zero before [x] or
+  [hexadecimal digits] 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-terminator,
+  whichever on comes first.
+
+  If String is NULL, then ASSERT().
+  If Data is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 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
+  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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrHexToUint64S (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  );
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Copies one Null-terminated Unicode string to another Null-terminated Unicode
+  string and returns the new Unicode string.
+
+  This function copies the contents of the Unicode string Source to the Unicode
+  string Destination, and returns Destination. If Source and Destination
+  overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated Unicode string.
+  @param  Source      The pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrCpy (
+  OUT     CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source
+  );
+
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Copies up to a specified length from one Null-terminated Unicode string to 
+  another Null-terminated Unicode string and returns the new Unicode string.
+
+  This function copies the contents of the Unicode string Source to the Unicode
+  string Destination, and returns Destination. At most, Length Unicode
+  characters are copied from Source to Destination. If Length is 0, then
+  Destination is returned unmodified. If Length is greater that the number of
+  Unicode characters in Source, then Destination is padded with Null Unicode
+  characters. If Source and Destination overlap, then the results are
+  undefined.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Length is greater than 
+  PcdMaximumUnicodeStringLength, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated Unicode string.
+  @param  Source      The pointer to a Null-terminated Unicode string.
+  @param  Length      The maximum number of Unicode characters to copy.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrnCpy (
+  OUT     CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length
+  );
+#endif
+
+/**
+  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  Pointer to a Null-terminated Unicode string.
+
+  @return The length of String.
+
+**/
+UINTN
+EFIAPI
+StrLen (
+  IN      CONST CHAR16              *String
+  );
+
+
+/**
+  Returns the size of a Null-terminated Unicode string in bytes, including the
+  Null terminator.
+
+  This function returns the size, in bytes, of 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  The pointer to a Null-terminated Unicode string.
+
+  @return The size of String.
+
+**/
+UINTN
+EFIAPI
+StrSize (
+  IN      CONST CHAR16              *String
+  );
+
+
+/**
+  Compares 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. 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 FirstString is NULL, then ASSERT().
+  If FirstString is not aligned on a 16-bit boundary, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If SecondString is not aligned on a 16-bit boundary, 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   The pointer to a Null-terminated Unicode string.
+  @param  SecondString  The pointer to a Null-terminated Unicode string.
+
+  @retval 0      FirstString is identical to SecondString.
+  @return others FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+StrCmp (
+  IN      CONST CHAR16              *FirstString,
+  IN      CONST CHAR16              *SecondString
+  );
+
+
+/**
+  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   The pointer to a Null-terminated Unicode string.
+  @param  SecondString  The 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
+EFIAPI
+StrnCmp (
+  IN      CONST CHAR16              *FirstString,
+  IN      CONST CHAR16              *SecondString,
+  IN      UINTN                     Length
+  );
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Concatenates one Null-terminated Unicode string to another Null-terminated
+  Unicode string, and returns the concatenated Unicode string.
+
+  This function concatenates two Null-terminated Unicode strings. The contents
+  of Null-terminated Unicode string Source are concatenated to the end of
+  Null-terminated Unicode string Destination. The Null-terminated concatenated
+  Unicode String is returned. If Source and Destination overlap, then the
+  results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
+  than PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
+  and Source results in a Unicode string with more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated Unicode string.
+  @param  Source      The pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrCat (
+  IN OUT  CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source
+  );
+
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Concatenates up to a specified length one Null-terminated Unicode to the end 
+  of another Null-terminated Unicode string, and returns the concatenated 
+  Unicode string.
+
+  This function concatenates two Null-terminated Unicode strings. The contents
+  of Null-terminated Unicode string Source are concatenated to the end of
+  Null-terminated Unicode string Destination, and Destination is returned. At
+  most, Length Unicode characters are concatenated from Source to the end of
+  Destination, and Destination is always Null-terminated. If Length is 0, then
+  Destination is returned unmodified. If Source and Destination overlap, then
+  the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Length is greater than 
+  PcdMaximumUnicodeStringLength, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
+  than PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
+  and Source results in a Unicode string with more than PcdMaximumUnicodeStringLength
+  Unicode characters, not including the Null-terminator, then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated Unicode string.
+  @param  Source      The pointer to a Null-terminated Unicode string.
+  @param  Length      The maximum number of Unicode characters to concatenate from
+                      Source.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrnCat (
+  IN OUT  CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length
+  );
+#endif
+
+/**
+  Returns the first occurrence of a Null-terminated Unicode sub-string
+  in a Null-terminated Unicode string.
+
+  This function scans the contents of the Null-terminated Unicode string
+  specified by String and returns the first occurrence of SearchString.
+  If SearchString is not found in String, then NULL is returned.  If
+  the length of SearchString is zero, then String is returned.
+
+  If String is NULL, then ASSERT().
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+  If SearchString is NULL, then ASSERT().
+  If SearchString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If PcdMaximumUnicodeStringLength is not zero, and SearchString
+  or String contains more than PcdMaximumUnicodeStringLength Unicode
+  characters, not including the Null-terminator, then ASSERT().
+
+  @param  String          The pointer to a Null-terminated Unicode string.
+  @param  SearchString    The pointer to a Null-terminated Unicode string to search for.
+
+  @retval NULL            If the SearchString does not appear in String.
+  @return others          If there is a match.
+
+**/
+CHAR16 *
+EFIAPI
+StrStr (
+  IN      CONST CHAR16              *String,
+  IN      CONST CHAR16              *SearchString
+  );
+
+/**
+  Convert a Null-terminated Unicode decimal string to a value of
+  type UINTN.
+
+  This function returns a value of type UINTN 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits,
+  then 0 is returned.
+  If the number represented by String overflows according
+  to the range defined by UINTN, then MAX_UINTN is returned.
+
+  If PcdMaximumUnicodeStringLength is not zero, and String contains
+  more than PcdMaximumUnicodeStringLength Unicode characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String      The pointer to a Null-terminated Unicode string.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+StrDecimalToUintn (
+  IN      CONST CHAR16              *String
+  );
+
+/**
+  Convert a Null-terminated Unicode decimal string to a value of
+  type UINT64.
+
+  This function returns 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits,
+  then 0 is returned.
+  If the number represented by String overflows according
+  to the range defined by UINT64, then MAX_UINT64 is returned.
+
+  If PcdMaximumUnicodeStringLength is not zero, and String contains
+  more than PcdMaximumUnicodeStringLength Unicode characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String          The pointer to a Null-terminated Unicode string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+StrDecimalToUint64 (
+  IN      CONST CHAR16              *String
+  );
+ 
+
+/**
+  Convert a Null-terminated Unicode hexadecimal string to a value of type UINTN.
+
+  This function returns 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then zero is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
+  then zero is returned.
+  If the number represented by String overflows according to the range defined by
+  UINTN, then MAX_UINTN is returned.
+
+  If PcdMaximumUnicodeStringLength is not zero, and String contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          The pointer to a Null-terminated Unicode string.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+StrHexToUintn (
+  IN      CONST CHAR16              *String
+  );
+
+
+/**
+  Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.
+
+  This function returns a value of type UINT64 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then zero is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
+  then zero is returned.
+  If the number represented by String overflows according to the range defined by
+  UINT64, then MAX_UINT64 is returned.
+
+  If PcdMaximumUnicodeStringLength is not zero, and String contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          The pointer to a Null-terminated Unicode string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+StrHexToUint64 (
+  IN      CONST CHAR16             *String
+  );
+
+/**
+  Convert a Null-terminated Unicode string to IPv6 address and prefix length.
+
+  This function outputs a value of type IPv6_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the Unicode string specified
+  by String. The format of the input Unicode string String is as follows:
+
+                  X:X:X:X:X:X:X:X[/P]
+
+  X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and
+  [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low
+  memory address and high byte is stored in high memory address. P contains decimal
+  digit characters in the range [0-9]. The running zero in the beginning of P will
+  be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid hexadecimal digit character after eight X's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  "::" can be used to compress one or more groups of X when X contains only 0.
+  The "::" can only appear once in the String.
+
+  If String is NULL, then ASSERT().
+
+  If Address 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 EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan 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  Address                  Pointer to the converted IPv6 address.
+  @param  PrefixLength             Pointer to the converted IPv6 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If X contains more than four hexadecimal
+                                    digit characters.
+                                   If String contains "::" and number of X
+                                    is not less than 8.
+                                   If P starts with character that is not a
+                                    valid decimal digit character.
+                                   If the decimal number converted from P
+                                    exceeds 128.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrToIpv6Address (
+  IN  CONST CHAR16       *String,
+  OUT CHAR16             **EndPointer, OPTIONAL
+  OUT IPv6_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  );
+
+/**
+  Convert a Null-terminated Unicode string to IPv4 address and prefix length.
+
+  This function outputs a value of type IPv4_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the Unicode string specified
+  by String. The format of the input Unicode string String is as follows:
+
+                  D.D.D.D[/P]
+
+  D and P are decimal digit characters in the range [0-9]. The running zero in
+  the beginning of D and P will be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid decimal digit character after four D's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  If String is NULL, then ASSERT().
+
+  If Address 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 EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan 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  Address                  Pointer to the converted IPv4 address.
+  @param  PrefixLength             Pointer to the converted IPv4 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If String is not in the correct format.
+                                   If any decimal number converted from D
+                                    exceeds 255.
+                                   If the decimal number converted from P
+                                    exceeds 32.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrToIpv4Address (
+  IN  CONST CHAR16       *String,
+  OUT CHAR16             **EndPointer, OPTIONAL
+  OUT IPv4_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  );
+
+#define GUID_STRING_LENGTH  36
+
+/**
+  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
+EFIAPI
+StrToGuid (
+  IN  CONST CHAR16       *String,
+  OUT GUID               *Guid
+  );
+
+/**
+  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
+EFIAPI
+StrHexToBytes (
+  IN  CONST CHAR16       *String,
+  IN  UINTN              Length,
+  OUT UINT8              *Buffer,
+  IN  UINTN              MaxBufferSize
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Convert a Null-terminated Unicode string to a Null-terminated
+  ASCII string and returns the ASCII string.
+
+  This function converts the content of the Unicode string Source
+  to the ASCII string Destination by copying the lower 8 bits of
+  each Unicode character. It returns Destination.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.
+
+  If any Unicode characters in Source contain non-zero value in
+  the upper 8 bits, then ASSERT().
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains
+  more than PcdMaximumUnicodeStringLength Unicode characters not including
+  the Null-terminator, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more
+  than PcdMaximumAsciiStringLength Unicode characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  Source        The pointer to a Null-terminated Unicode string.
+  @param  Destination   The pointer to a Null-terminated ASCII string.
+
+  @return Destination.
+
+**/
+CHAR8 *
+EFIAPI
+UnicodeStrToAsciiStr (
+  IN      CONST CHAR16              *Source,
+  OUT     CHAR8                     *Destination
+  );
+
+#endif
+
+/**
+  Convert a Null-terminated Unicode string to a Null-terminated
+  ASCII string.
+
+  This function is similar to AsciiStrCpyS.
+
+  This function converts the content of the Unicode string Source
+  to the ASCII string Destination by copying the lower 8 bits of
+  each Unicode character. The function terminates the ASCII string
+  Destination by appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.
+
+  If any Unicode characters in Source contain non-zero value in
+  the upper 8 bits, then ASSERT().
+
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Source        The pointer to a Null-terminated Unicode string.
+  @param  Destination   The pointer to a Null-terminated ASCII string.
+  @param  DestMax       The maximum number of Destination Ascii
+                        char, including terminating null char.
+
+  @retval RETURN_SUCCESS           String is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeStrToAsciiStrS (
+  IN      CONST CHAR16              *Source,
+  OUT     CHAR8                     *Destination,
+  IN      UINTN                     DestMax
+  );
+
+/**
+  Convert not more than Length successive characters from a Null-terminated
+  Unicode string to a Null-terminated Ascii string. If no null char is copied
+  from Source, then Destination[Length] is always set to null.
+
+  This function converts not more than Length successive characters from the
+  Unicode string Source to the Ascii string Destination by copying the lower 8
+  bits of each Unicode character. The function terminates the Ascii string
+  Destination by appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.
+
+  If any Unicode characters in Source contain non-zero value in the upper 8
+  bits, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Source             The pointer to a Null-terminated Unicode string.
+  @param  Length             The maximum number of Unicode characters to
+                             convert.
+  @param  Destination        The pointer to a Null-terminated Ascii string.
+  @param  DestMax            The maximum number of Destination Ascii
+                             char, including terminating null char.
+  @param  DestinationLength  The number of Unicode characters converted.
+
+  @retval RETURN_SUCCESS            String is converted.
+  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.
+                                    If Source is NULL.
+                                    If DestinationLength is NULL.
+                                    If PcdMaximumAsciiStringLength is not zero,
+                                    and Length or DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                    If PcdMaximumUnicodeStringLength is not
+                                    zero, and Length or DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                    If DestMax is 0.
+  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than
+                                    MIN(StrLen(Source), Length).
+  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeStrnToAsciiStrS (
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length,
+  OUT     CHAR8                     *Destination,
+  IN      UINTN                     DestMax,
+  OUT     UINTN                     *DestinationLength
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Copies one Null-terminated ASCII string to another Null-terminated ASCII
+  string and returns the new ASCII string.
+
+  This function copies the contents of the ASCII string Source to the ASCII
+  string Destination, and returns Destination. If Source and Destination
+  overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated ASCII string.
+  @param  Source      The pointer to a Null-terminated ASCII string.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrCpy (
+  OUT     CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source
+  );
+
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Copies up to a specified length one Null-terminated ASCII string to another 
+  Null-terminated ASCII string and returns the new ASCII string.
+
+  This function copies the contents of the ASCII string Source to the ASCII
+  string Destination, and returns Destination. At most, Length ASCII characters
+  are copied from Source to Destination. If Length is 0, then Destination is
+  returned unmodified. If Length is greater that the number of ASCII characters
+  in Source, then Destination is padded with Null ASCII characters. If Source
+  and Destination overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than 
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated ASCII string.
+  @param  Source      The pointer to a Null-terminated ASCII string.
+  @param  Length      The maximum number of ASCII characters to copy.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrnCpy (
+  OUT     CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length
+  );
+#endif
+
+/**
+  Returns the length of a Null-terminated ASCII string.
+
+  This function returns the number of ASCII characters in the Null-terminated
+  ASCII string specified by String.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String  The pointer to a Null-terminated ASCII string.
+
+  @return The length of String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrLen (
+  IN      CONST CHAR8               *String
+  );
+
+
+/**
+  Returns the size of a Null-terminated ASCII string in bytes, including the
+  Null terminator.
+
+  This function returns the size, in bytes, of the Null-terminated ASCII string
+  specified by String.
+
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String  The pointer to a Null-terminated ASCII string.
+
+  @return The size of String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrSize (
+  IN      CONST CHAR8               *String
+  );
+
+
+/**
+  Compares two Null-terminated ASCII strings, and returns the difference
+  between the first mismatched ASCII characters.
+
+  This function compares the Null-terminated ASCII string FirstString to the
+  Null-terminated ASCII string SecondString. If FirstString is identical to
+  SecondString, then 0 is returned. Otherwise, the value returned is the first
+  mismatched ASCII character in SecondString subtracted from the first
+  mismatched ASCII character in FirstString.
+
+  If FirstString is NULL, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and SecondString contains more
+  than PcdMaximumAsciiStringLength ASCII characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  FirstString   The pointer to a Null-terminated ASCII string.
+  @param  SecondString  The pointer to a Null-terminated ASCII string.
+
+  @retval ==0      FirstString is identical to SecondString.
+  @retval !=0      FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+AsciiStrCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString
+  );
+
+
+/**
+  Performs a case insensitive comparison of two Null-terminated ASCII strings,
+  and returns the difference between the first mismatched ASCII characters.
+
+  This function performs a case insensitive comparison of the Null-terminated
+  ASCII string FirstString to the Null-terminated ASCII string SecondString. If
+  FirstString is identical to SecondString, then 0 is returned. Otherwise, the
+  value returned is the first mismatched lower case ASCII character in
+  SecondString subtracted from the first mismatched lower case ASCII character
+  in FirstString.
+
+  If FirstString is NULL, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and SecondString contains more
+  than PcdMaximumAsciiStringLength ASCII characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  FirstString   The pointer to a Null-terminated ASCII string.
+  @param  SecondString  The pointer to a Null-terminated ASCII string.
+
+  @retval ==0    FirstString is identical to SecondString using case insensitive
+                 comparisons.
+  @retval !=0    FirstString is not identical to SecondString using case
+                 insensitive comparisons.
+
+**/
+INTN
+EFIAPI
+AsciiStriCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString
+  );
+
+
+/**
+  Compares two Null-terminated ASCII strings with maximum lengths, and returns
+  the difference between the first mismatched ASCII characters.
+
+  This function compares the Null-terminated ASCII string FirstString to the
+  Null-terminated ASCII  string SecondString. At most, Length ASCII 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 ASCII character in SecondString subtracted from the
+  first mismatched ASCII character in FirstString.
+
+  If Length > 0 and FirstString is NULL, then ASSERT().
+  If Length > 0 and SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than 
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and SecondString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  FirstString   The pointer to a Null-terminated ASCII string.
+  @param  SecondString  The pointer to a Null-terminated ASCII string.
+  @param  Length        The maximum number of ASCII characters for compare.
+  
+  @retval ==0       FirstString is identical to SecondString.
+  @retval !=0       FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+AsciiStrnCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString,
+  IN      UINTN                     Length
+  );
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Concatenates one Null-terminated ASCII string to another Null-terminated
+  ASCII string, and returns the concatenated ASCII string.
+
+  This function concatenates two Null-terminated ASCII strings. The contents of
+  Null-terminated ASCII string Source are concatenated to the end of Null-
+  terminated ASCII string Destination. The Null-terminated concatenated ASCII
+  String is returned.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Destination contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and concatenating Destination and
+  Source results in a ASCII string with more than PcdMaximumAsciiStringLength
+  ASCII characters, then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated ASCII string.
+  @param  Source      The pointer to a Null-terminated ASCII string.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrCat (
+  IN OUT CHAR8    *Destination,
+  IN CONST CHAR8  *Source
+  );
+
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Concatenates up to a specified length one Null-terminated ASCII string to 
+  the end of another Null-terminated ASCII string, and returns the 
+  concatenated ASCII string.
+
+  This function concatenates two Null-terminated ASCII strings. The contents
+  of Null-terminated ASCII string Source are concatenated to the end of Null-
+  terminated ASCII string Destination, and Destination is returned. At most,
+  Length ASCII characters are concatenated from Source to the end of
+  Destination, and Destination is always Null-terminated. If Length is 0, then
+  Destination is returned unmodified. If Source and Destination overlap, then
+  the results are undefined.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Destination contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and concatenating Destination and
+  Source results in a ASCII string with more than PcdMaximumAsciiStringLength
+  ASCII characters, not including the Null-terminator, then ASSERT().
+
+  @param  Destination The pointer to a Null-terminated ASCII string.
+  @param  Source      The pointer to a Null-terminated ASCII string.
+  @param  Length      The maximum number of ASCII characters to concatenate from
+                      Source.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrnCat (
+  IN OUT  CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length
+  );
+#endif
+
+/**
+  Returns the first occurrence of a Null-terminated ASCII sub-string
+  in a Null-terminated ASCII string.
+
+  This function scans the contents of the ASCII string specified by String
+  and returns the first occurrence of SearchString. If SearchString is not
+  found in String, then NULL is returned. If the length of SearchString is zero,
+  then String is returned.
+
+  If String is NULL, then ASSERT().
+  If SearchString is NULL, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero, and SearchString or
+  String contains more than PcdMaximumAsciiStringLength Unicode characters
+  not including the Null-terminator, then ASSERT().
+
+  @param  String          The pointer to a Null-terminated ASCII string.
+  @param  SearchString    The pointer to a Null-terminated ASCII string to search for.
+
+  @retval NULL            If the SearchString does not appear in String.
+  @retval others          If there is a match return the first occurrence of SearchingString.
+                          If the length of SearchString is zero,return String.
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrStr (
+  IN      CONST CHAR8               *String,
+  IN      CONST CHAR8               *SearchString
+  );
+
+
+/**
+  Convert a Null-terminated ASCII decimal string to a value of type
+  UINTN.
+
+  This function returns a value of type UINTN by interpreting the contents
+  of the ASCII string String as a decimal number. The format of the input
+  ASCII 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 the 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
+  Null-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits, then 0 is returned.
+  If the number represented by String overflows according to the range defined by
+  UINTN, then MAX_UINTN is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          The pointer to a Null-terminated ASCII string.
+
+  @retval The value translated from String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrDecimalToUintn (
+  IN      CONST CHAR8               *String
+  );
+
+
+/**
+  Convert a Null-terminated ASCII decimal string to a value of type
+  UINT64.
+
+  This function returns a value of type UINT64 by interpreting the contents
+  of the ASCII string String as a decimal number. The format of the input
+  ASCII 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 the 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
+  Null-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits, then 0 is returned.
+  If the number represented by String overflows according to the range defined by
+  UINT64, then MAX_UINT64 is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          The pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+AsciiStrDecimalToUint64 (
+  IN      CONST CHAR8               *String
+  );
+
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a value of type UINTN.
+
+  This function returns a value of type UINTN by interpreting the contents of
+  the ASCII string String as a hexadecimal number. The format of the input ASCII
+  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 digits]. The running zero before [x] or [hexadecimal digits]
+  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-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then
+  0 is returned.
+
+  If the number represented by String overflows according to the range defined by UINTN,
+  then MAX_UINTN is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero,
+  and String contains more than PcdMaximumAsciiStringLength ASCII characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String          The pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrHexToUintn (
+  IN      CONST CHAR8               *String
+  );
+
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a value of type UINT64.
+
+  This function returns a value of type UINT64 by interpreting the contents of
+  the ASCII string String as a hexadecimal number. The format of the input ASCII
+  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 digits]. The running zero before [x] or [hexadecimal digits]
+  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-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then
+  0 is returned.
+
+  If the number represented by String overflows according to the range defined by UINT64,
+  then MAX_UINT64 is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero,
+  and String contains more than PcdMaximumAsciiStringLength ASCII characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String          The pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+AsciiStrHexToUint64 (
+  IN      CONST CHAR8                *String
+  );
+
+/**
+  Convert a Null-terminated ASCII string to IPv6 address and prefix length.
+
+  This function outputs a value of type IPv6_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the ASCII string specified
+  by String. The format of the input ASCII string String is as follows:
+
+                  X:X:X:X:X:X:X:X[/P]
+
+  X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and
+  [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low
+  memory address and high byte is stored in high memory address. P contains decimal
+  digit characters in the range [0-9]. The running zero in the beginning of P will
+  be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid hexadecimal digit character after eight X's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  "::" can be used to compress one or more groups of X when X contains only 0.
+  The "::" can only appear once in the String.
+
+  If String is NULL, then ASSERT().
+
+  If Address is NULL, then ASSERT().
+
+  If EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan is stored at the location pointed to
+  by EndPointer.
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  EndPointer               Pointer to character that stops scan.
+  @param  Address                  Pointer to the converted IPv6 address.
+  @param  PrefixLength             Pointer to the converted IPv6 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If X contains more than four hexadecimal
+                                    digit characters.
+                                   If String contains "::" and number of X
+                                    is not less than 8.
+                                   If P starts with character that is not a
+                                    valid decimal digit character.
+                                   If the decimal number converted from P
+                                    exceeds 128.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToIpv6Address (
+  IN  CONST CHAR8        *String,
+  OUT CHAR8              **EndPointer, OPTIONAL
+  OUT IPv6_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  );
+
+/**
+  Convert a Null-terminated ASCII string to IPv4 address and prefix length.
+
+  This function outputs a value of type IPv4_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the ASCII string specified
+  by String. The format of the input ASCII string String is as follows:
+
+                  D.D.D.D[/P]
+
+  D and P are decimal digit characters in the range [0-9]. The running zero in
+  the beginning of D and P will be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid decimal digit character after four D's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  If String is NULL, then ASSERT().
+
+  If Address is NULL, then ASSERT().
+
+  If EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan is stored at the location pointed to
+  by EndPointer.
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  EndPointer               Pointer to character that stops scan.
+  @param  Address                  Pointer to the converted IPv4 address.
+  @param  PrefixLength             Pointer to the converted IPv4 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If String is not in the correct format.
+                                   If any decimal number converted from D
+                                    exceeds 255.
+                                   If the decimal number converted from P
+                                    exceeds 32.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToIpv4Address (
+  IN  CONST CHAR8        *String,
+  OUT CHAR8              **EndPointer, OPTIONAL
+  OUT IPv4_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  );
+
+/**
+  Convert a Null-terminated ASCII GUID string to a value of type
+  EFI_GUID.
+
+  This function outputs a GUID value by interpreting the contents of
+  the ASCII string specified by String. The format of the input
+  ASCII 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().
+
+  @param  String                   Pointer to a Null-terminated ASCII 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
+EFIAPI
+AsciiStrToGuid (
+  IN  CONST CHAR8        *String,
+  OUT GUID               *Guid
+  );
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a byte array.
+
+  This function outputs a byte array by interpreting the contents of
+  the ASCII string specified by String in hexadecimal format. The format of
+  the input ASCII 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 NULL, then ASSERT().
+
+  If Buffer is NULL, then ASSERT().
+
+  If Length is not multiple of 2, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero and Length is greater than
+  PcdMaximumAsciiStringLength, then ASSERT().
+
+  If MaxBufferSize is less than (Length / 2), then ASSERT().
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  Length                   The number of ASCII 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 PcdMaximumAsciiStringLength is not zero,
+                                    and Length is greater than
+                                    PcdMaximumAsciiStringLength.
+  @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
+EFIAPI
+AsciiStrHexToBytes (
+  IN  CONST CHAR8        *String,
+  IN  UINTN              Length,
+  OUT UINT8              *Buffer,
+  IN  UINTN              MaxBufferSize
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Convert one Null-terminated ASCII string to a Null-terminated
+  Unicode string and returns the Unicode string.
+
+  This function converts the contents of the ASCII string Source to the Unicode
+  string Destination, and returns Destination.  The function terminates the
+  Unicode string Destination by appending a Null-terminator character at the end.
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength ASCII characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  Source        The pointer to a Null-terminated ASCII string.
+  @param  Destination   The pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+AsciiStrToUnicodeStr (
+  IN      CONST CHAR8               *Source,
+  OUT     CHAR16                    *Destination
+  );
+
+#endif
+
+/**
+  Convert one Null-terminated ASCII string to a Null-terminated
+  Unicode string.
+
+  This function is similar to StrCpyS.
+
+  This function converts the contents of the ASCII string Source to the Unicode
+  string Destination. The function terminates the Unicode string Destination by
+  appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Source        The pointer to a Null-terminated ASCII string.
+  @param  Destination   The pointer to a Null-terminated Unicode string.
+  @param  DestMax       The maximum number of Destination Unicode
+                        char, including terminating null char.
+
+  @retval RETURN_SUCCESS           String is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToUnicodeStrS (
+  IN      CONST CHAR8               *Source,
+  OUT     CHAR16                    *Destination,
+  IN      UINTN                     DestMax
+  );
+
+/**
+  Convert not more than Length successive characters from a Null-terminated
+  Ascii string to a Null-terminated Unicode string. If no null char is copied
+  from Source, then Destination[Length] is always set to null.
+
+  This function converts not more than Length successive characters from the
+  Ascii string Source to the Unicode string Destination. The function
+  terminates the Unicode string Destination by appending a Null-terminator
+  character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with
+  size not smaller than
+  ((MIN(AsciiStrLen(Source), Length) + 1) * sizeof (CHAR8)) in bytes.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then Destination and DestinationLength are
+  unmodified.
+
+  @param  Source             The pointer to a Null-terminated Ascii string.
+  @param  Length             The maximum number of Ascii characters to convert.
+  @param  Destination        The pointer to a Null-terminated Unicode string.
+  @param  DestMax            The maximum number of Destination Unicode char,
+                             including terminating null char.
+  @param  DestinationLength  The number of Ascii characters converted.
+
+  @retval RETURN_SUCCESS            String is converted.
+  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.
+                                    If Source is NULL.
+                                    If DestinationLength is NULL.
+                                    If PcdMaximumUnicodeStringLength is not
+                                    zero, and Length or DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                    If PcdMaximumAsciiStringLength is not zero,
+                                    and Length or DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                    If DestMax is 0.
+  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than
+                                    MIN(AsciiStrLen(Source), Length).
+  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnToUnicodeStrS (
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length,
+  OUT     CHAR16                    *Destination,
+  IN      UINTN                     DestMax,
+  OUT     UINTN                     *DestinationLength
+  );
+
+/**
+  Converts an 8-bit value to an 8-bit BCD value.
+
+  Converts the 8-bit value specified by Value to BCD. The BCD value is
+  returned.
+
+  If Value >= 100, then ASSERT().
+
+  @param  Value The 8-bit value to convert to BCD. Range 0..99.
+
+  @return The BCD value.
+
+**/
+UINT8
+EFIAPI
+DecimalToBcd8 (
+  IN      UINT8                     Value
+  );
+
+
+/**
+  Converts an 8-bit BCD value to an 8-bit value.
+
+  Converts the 8-bit BCD value specified by Value to an 8-bit value. The 8-bit
+  value is returned.
+
+  If Value >= 0xA0, then ASSERT().
+  If (Value & 0x0F) >= 0x0A, then ASSERT().
+
+  @param  Value The 8-bit BCD value to convert to an 8-bit value.
+
+  @return The 8-bit value is returned.
+
+**/
+UINT8
+EFIAPI
+BcdToDecimal8 (
+  IN      UINT8                     Value
+  );
+
+//
+//  File Path Manipulation Functions
+//
+
+/**
+  Removes the last directory or file entry in a path.
+
+  @param[in, out] Path    The pointer to the path to modify.
+
+  @retval FALSE     Nothing was found to remove.
+  @retval TRUE      A directory or file was removed.
+**/
+BOOLEAN
+EFIAPI
+PathRemoveLastItem(
+  IN OUT CHAR16 *Path
+  );
+
+/**
+  Function to clean up paths.
+    - Single periods in the path are removed.
+    - Double periods in the path are removed along with a single parent directory.
+    - Forward slashes L'/' are converted to backward slashes L'\'.
+
+  This will be done inline and the existing buffer may be larger than required
+  upon completion.
+
+  @param[in] Path       The pointer to the string containing the path.
+
+  @return       Returns Path, otherwise returns NULL to indicate that an error has occurred.
+**/
+CHAR16*
+EFIAPI
+PathCleanUpDirectories(
+  IN CHAR16 *Path
+  );
+
+//
+// Linked List Functions and Macros
+//
+
+/**
+  Initializes the head node of a doubly linked list that is declared as a
+  global variable in a module.
+
+  Initializes the forward and backward links of a new linked list. After
+  initializing a linked list with this macro, the other linked list functions
+  may be used to add and remove nodes from the linked list. This macro results
+  in smaller executables by initializing the linked list in the data section,
+  instead if calling the InitializeListHead() function to perform the
+  equivalent operation.
+
+  @param  ListHead  The head note of a list to initialize.
+
+**/
+#define INITIALIZE_LIST_HEAD_VARIABLE(ListHead)  {&(ListHead), &(ListHead)}
+
+
+/**
+  Initializes the head node of a doubly linked list, and returns the pointer to
+  the head node of the doubly linked list.
+
+  Initializes the forward and backward links of a new linked list. After
+  initializing a linked list with this function, the other linked list
+  functions may be used to add and remove nodes from the linked list. It is up
+  to the caller of this function to allocate the memory for ListHead.
+
+  If ListHead is NULL, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a new doubly linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InitializeListHead (
+  IN OUT  LIST_ENTRY                *ListHead
+  );
+
+
+/**
+  Adds a node to the beginning of a doubly linked list, and returns the pointer
+  to the head node of the doubly linked list.
+
+  Adds the node Entry at the beginning of the doubly linked list denoted by
+  ListHead, and returns ListHead.
+
+  If ListHead is NULL, then ASSERT().
+  If Entry is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number
+  of nodes in ListHead, including the ListHead node, is greater than or
+  equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly linked list.
+  @param  Entry     A pointer to a node that is to be inserted at the beginning
+                    of a doubly linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InsertHeadList (
+  IN OUT  LIST_ENTRY                *ListHead,
+  IN OUT  LIST_ENTRY                *Entry
+  );
+
+
+/**
+  Adds a node to the end of a doubly linked list, and returns the pointer to
+  the head node of the doubly linked list.
+
+  Adds the node Entry to the end of the doubly linked list denoted by ListHead,
+  and returns ListHead.
+
+  If ListHead is NULL, then ASSERT().
+  If Entry is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number
+  of nodes in ListHead, including the ListHead node, is greater than or
+  equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly linked list.
+  @param  Entry     A pointer to a node that is to be added at the end of the
+                    doubly linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InsertTailList (
+  IN OUT  LIST_ENTRY                *ListHead,
+  IN OUT  LIST_ENTRY                *Entry
+  );
+
+
+/**
+  Retrieves the first node of a doubly linked list.
+
+  Returns the first node of a doubly linked list.  List must have been 
+  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+  If List is empty, then List is returned.
+
+  If List is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly linked list.
+
+  @return The first node of a doubly linked list.
+  @retval List  The list is empty.
+
+**/
+LIST_ENTRY *
+EFIAPI
+GetFirstNode (
+  IN      CONST LIST_ENTRY          *List
+  );
+
+
+/**
+  Retrieves the next node of a doubly linked list.
+
+  Returns the node of a doubly linked list that follows Node.  
+  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()
+  or InitializeListHead().  If List is empty, then List is returned.
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and List contains more than
+  PcdMaximumLinkedListLength nodes, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly linked list.
+  @param  Node  A pointer to a node in the doubly linked list.
+
+  @return The pointer to the next node if one exists. Otherwise List is returned.
+
+**/
+LIST_ENTRY *
+EFIAPI
+GetNextNode (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  );
+
+  
+/**
+  Retrieves the previous node of a doubly linked list.
+ 
+  Returns the node of a doubly linked list that precedes Node.  
+  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()
+  or InitializeListHead().  If List is empty, then List is returned.
+ 
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and List contains more than
+  PcdMaximumLinkedListLength nodes, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+ 
+  @param  List  A pointer to the head node of a doubly linked list.
+  @param  Node  A pointer to a node in the doubly linked list.
+ 
+  @return The pointer to the previous node if one exists. Otherwise List is returned.
+ 
+**/
+LIST_ENTRY *
+EFIAPI
+GetPreviousNode (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  );
+
+  
+/**
+  Checks to see if a doubly linked list is empty or not.
+
+  Checks to see if the doubly linked list is empty. If the linked list contains
+  zero nodes, this function returns TRUE. Otherwise, it returns FALSE.
+
+  If ListHead is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly linked list.
+
+  @retval TRUE  The linked list is empty.
+  @retval FALSE The linked list is not empty.
+
+**/
+BOOLEAN
+EFIAPI
+IsListEmpty (
+  IN      CONST LIST_ENTRY          *ListHead
+  );
+
+
+/**
+  Determines if a node in a doubly linked list is the head node of a the same
+  doubly linked list.  This function is typically used to terminate a loop that
+  traverses all the nodes in a doubly linked list starting with the head node.
+
+  Returns TRUE if Node is equal to List.  Returns FALSE if Node is one of the
+  nodes in the doubly linked list specified by List.  List must have been
+  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(), 
+  then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List the and Node is not equal 
+  to List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly linked list.
+  @param  Node  A pointer to a node in the doubly linked list.
+
+  @retval TRUE  Node is the head of the doubly-linked list pointed by List.
+  @retval FALSE Node is not the head of the doubly-linked list pointed by List.
+
+**/
+BOOLEAN
+EFIAPI
+IsNull (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  );
+
+
+/**
+  Determines if a node the last node in a doubly linked list.
+
+  Returns TRUE if Node is the last node in the doubly linked list specified by
+  List. Otherwise, FALSE is returned. List must have been initialized with
+  INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly linked list.
+  @param  Node  A pointer to a node in the doubly linked list.
+
+  @retval TRUE  Node is the last node in the linked list.
+  @retval FALSE Node is not the last node in the linked list.
+
+**/
+BOOLEAN
+EFIAPI
+IsNodeAtEnd (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  );
+
+
+/**
+  Swaps the location of two nodes in a doubly linked list, and returns the
+  first node after the swap.
+
+  If FirstEntry is identical to SecondEntry, then SecondEntry is returned.
+  Otherwise, the location of the FirstEntry node is swapped with the location
+  of the SecondEntry node in a doubly linked list. SecondEntry must be in the
+  same double linked list as FirstEntry and that double linked list must have
+  been initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). 
+  SecondEntry is returned after the nodes are swapped.
+
+  If FirstEntry is NULL, then ASSERT().
+  If SecondEntry is NULL, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and SecondEntry and FirstEntry are not in the 
+  same linked list, then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes in the
+  linked list containing the FirstEntry and SecondEntry nodes, including
+  the FirstEntry and SecondEntry nodes, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  FirstEntry  A pointer to a node in a linked list.
+  @param  SecondEntry A pointer to another node in the same linked list.
+  
+  @return SecondEntry.
+
+**/
+LIST_ENTRY *
+EFIAPI
+SwapListEntries (
+  IN OUT  LIST_ENTRY                *FirstEntry,
+  IN OUT  LIST_ENTRY                *SecondEntry
+  );
+
+
+/**
+  Removes a node from a doubly linked list, and returns the node that follows
+  the removed node.
+
+  Removes the node Entry from a doubly linked list. It is up to the caller of
+  this function to release the memory used by this node if that is required. On
+  exit, the node following Entry in the doubly linked list is returned. If
+  Entry is the only node in the linked list, then the head node of the linked
+  list is returned.
+
+  If Entry is NULL, then ASSERT().
+  If Entry is the head node of an empty list, then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes in the
+  linked list containing Entry, including the Entry node, is greater than
+  or equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  Entry A pointer to a node in a linked list.
+
+  @return Entry.
+
+**/
+LIST_ENTRY *
+EFIAPI
+RemoveEntryList (
+  IN      CONST LIST_ENTRY          *Entry
+  );
+
+//
+// Math Services
+//
+
+/**
+  Shifts a 64-bit integer left between 0 and 63 bits. The low bits are filled
+  with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the left by Count bits. The
+  low Count bits are set to zero. The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift left.
+  @param  Count   The number of bits to shift left.
+
+  @return Operand << Count.
+
+**/
+UINT64
+EFIAPI
+LShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. This high bits are
+  filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to zero. The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+RShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits are filled
+  with original integer's bit 63. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to bit 63 of Operand.  The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+ARShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Rotates a 32-bit integer left between 0 and 31 bits, filling the low bits
+  with the high bits that were rotated.
+
+  This function rotates the 32-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 31, then ASSERT().
+
+  @param  Operand The 32-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand << Count
+
+**/
+UINT32
+EFIAPI
+LRotU32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Rotates a 32-bit integer right between 0 and 31 bits, filling the high bits
+  with the low bits that were rotated.
+
+  This function rotates the 32-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 31, then ASSERT().
+
+  @param  Operand The 32-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >> Count
+
+**/
+UINT32
+EFIAPI
+RRotU32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Rotates a 64-bit integer left between 0 and 63 bits, filling the low bits
+  with the high bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand << Count
+
+**/
+UINT64
+EFIAPI
+LRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Rotates a 64-bit integer right between 0 and 63 bits, filling the high bits
+  with the high low bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+RRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+
+/**
+  Returns the bit position of the lowest bit set in a 32-bit value.
+
+  This function computes the bit position of the lowest bit set in the 32-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 31 is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @retval 0..31  The lowest bit set in Operand was found.
+  @retval -1    Operand is zero.
+
+**/
+INTN
+EFIAPI
+LowBitSet32 (
+  IN      UINT32                    Operand
+  );
+
+
+/**
+  Returns the bit position of the lowest bit set in a 64-bit value.
+
+  This function computes the bit position of the lowest bit set in the 64-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 63 is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @retval 0..63  The lowest bit set in Operand was found.
+  @retval -1    Operand is zero.
+
+
+**/
+INTN
+EFIAPI
+LowBitSet64 (
+  IN      UINT64                    Operand
+  );
+
+
+/**
+  Returns the bit position of the highest bit set in a 32-bit value. Equivalent
+  to log2(x).
+
+  This function computes the bit position of the highest bit set in the 32-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 31 is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @retval 0..31  Position of the highest bit set in Operand if found.
+  @retval -1    Operand is zero.
+
+**/
+INTN
+EFIAPI
+HighBitSet32 (
+  IN      UINT32                    Operand
+  );
+
+
+/**
+  Returns the bit position of the highest bit set in a 64-bit value. Equivalent
+  to log2(x).
+
+  This function computes the bit position of the highest bit set in the 64-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 63 is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @retval 0..63   Position of the highest bit set in Operand if found.
+  @retval -1     Operand is zero.
+
+**/
+INTN
+EFIAPI
+HighBitSet64 (
+  IN      UINT64                    Operand
+  );
+
+
+/**
+  Returns the value of the highest bit set in a 32-bit value. Equivalent to
+  1 << log2(x).
+
+  This function computes the value of the highest bit set in the 32-bit value
+  specified by Operand. If Operand is zero, then zero is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @return 1 << HighBitSet32(Operand)
+  @retval 0 Operand is zero.
+
+**/
+UINT32
+EFIAPI
+GetPowerOfTwo32 (
+  IN      UINT32                    Operand
+  );
+
+
+/**
+  Returns the value of the highest bit set in a 64-bit value. Equivalent to
+  1 << log2(x).
+
+  This function computes the value of the highest bit set in the 64-bit value
+  specified by Operand. If Operand is zero, then zero is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @return 1 << HighBitSet64(Operand)
+  @retval 0 Operand is zero.
+
+**/
+UINT64
+EFIAPI
+GetPowerOfTwo64 (
+  IN      UINT64                    Operand
+  );
+
+
+/**
+  Switches the endianness of a 16-bit integer.
+
+  This function swaps the bytes in a 16-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 16-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT16
+EFIAPI
+SwapBytes16 (
+  IN      UINT16                    Value
+  );
+
+
+/**
+  Switches the endianness of a 32-bit integer.
+
+  This function swaps the bytes in a 32-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 32-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT32
+EFIAPI
+SwapBytes32 (
+  IN      UINT32                    Value
+  );
+
+
+/**
+  Switches the endianness of a 64-bit integer.
+
+  This function swaps the bytes in a 64-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 64-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT64
+EFIAPI
+SwapBytes64 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Multiples a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function multiples the 64-bit unsigned value Multiplicand by the 32-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 32-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+MultU64x32 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT32                    Multiplier
+  );
+
+
+/**
+  Multiples a 64-bit unsigned integer by a 64-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function multiples the 64-bit unsigned value Multiplicand by the 64-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 64-bit unsigned value.
+
+  @return Multiplicand * Multiplier.
+
+**/
+UINT64
+EFIAPI
+MultU64x64 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT64                    Multiplier
+  );
+
+
+/**
+  Multiples a 64-bit signed integer by a 64-bit signed integer and generates a
+  64-bit signed result.
+
+  This function multiples the 64-bit signed value Multiplicand by the 64-bit
+  signed value Multiplier and generates a 64-bit signed result. This 64-bit
+  signed result is returned.
+
+  @param  Multiplicand  A 64-bit signed value.
+  @param  Multiplier    A 64-bit signed value.
+
+  @return Multiplicand * Multiplier
+
+**/
+INT64
+EFIAPI
+MultS64x64 (
+  IN      INT64                     Multiplicand,
+  IN      INT64                     Multiplier
+  );
+
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 64-bit unsigned result.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. This
+  function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend / Divisor.
+
+**/
+UINT64
+EFIAPI
+DivU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  );
+
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 32-bit remainder. This function
+  returns the 32-bit unsigned remainder.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend % Divisor.
+
+**/
+UINT32
+EFIAPI
+ModU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  );
+
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 64-bit unsigned result and an optional 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor.
+
+**/
+UINT64
+EFIAPI
+DivU64x32Remainder (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor,
+  OUT     UINT32                    *Remainder  OPTIONAL
+  );
+
+
+/**
+  Divides a 64-bit unsigned integer by a 64-bit unsigned integer and generates
+  a 64-bit unsigned result and an optional 64-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 64-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 64-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 64-bit unsigned value.
+  @param  Remainder A pointer to a 64-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor.
+
+**/
+UINT64
+EFIAPI
+DivU64x64Remainder (
+  IN      UINT64                    Dividend,
+  IN      UINT64                    Divisor,
+  OUT     UINT64                    *Remainder  OPTIONAL
+  );
+
+
+/**
+  Divides a 64-bit signed integer by a 64-bit signed integer and generates a
+  64-bit signed result and a optional 64-bit signed remainder.
+
+  This function divides the 64-bit signed value Dividend by the 64-bit signed
+  value Divisor and generates a 64-bit signed quotient. If Remainder is not
+  NULL, then the 64-bit signed remainder is returned in Remainder. This
+  function returns the 64-bit signed quotient.
+
+  It is the caller's responsibility to not call this function with a Divisor of 0.
+  If Divisor is 0, then the quotient and remainder should be assumed to be 
+  the largest negative integer.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit signed value.
+  @param  Divisor   A 64-bit signed value.
+  @param  Remainder A pointer to a 64-bit signed value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor.
+
+**/
+INT64
+EFIAPI
+DivS64x64Remainder (
+  IN      INT64                     Dividend,
+  IN      INT64                     Divisor,
+  OUT     INT64                     *Remainder  OPTIONAL
+  );
+
+
+/**
+  Reads a 16-bit value from memory that may be unaligned.
+
+  This function returns the 16-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+
+  @return The 16-bit value read from Buffer.
+
+**/
+UINT16
+EFIAPI
+ReadUnaligned16 (
+  IN CONST UINT16              *Buffer
+  );
+
+
+/**
+  Writes a 16-bit value to memory that may be unaligned.
+
+  This function writes the 16-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+  @param  Value   16-bit value to write to Buffer.
+
+  @return The 16-bit value to write to Buffer.
+
+**/
+UINT16
+EFIAPI
+WriteUnaligned16 (
+  OUT UINT16                    *Buffer,
+  IN  UINT16                    Value
+  );
+
+
+/**
+  Reads a 24-bit value from memory that may be unaligned.
+
+  This function returns the 24-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+
+  @return The 24-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned24 (
+  IN CONST UINT32              *Buffer
+  );
+
+
+/**
+  Writes a 24-bit value to memory that may be unaligned.
+
+  This function writes the 24-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+  @param  Value   24-bit value to write to Buffer.
+
+  @return The 24-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned24 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  );
+
+
+/**
+  Reads a 32-bit value from memory that may be unaligned.
+
+  This function returns the 32-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+
+  @return The 32-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned32 (
+  IN CONST UINT32              *Buffer
+  );
+
+
+/**
+  Writes a 32-bit value to memory that may be unaligned.
+
+  This function writes the 32-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+  @param  Value   32-bit value to write to Buffer.
+
+  @return The 32-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned32 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  );
+
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  IN CONST UINT64              *Buffer
+  );
+
+
+/**
+  Writes a 64-bit value to memory that may be unaligned.
+
+  This function writes the 64-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+  @param  Value   64-bit value to write to Buffer.
+
+  @return The 64-bit value to write to Buffer.
+
+**/
+UINT64
+EFIAPI
+WriteUnaligned64 (
+  OUT UINT64                    *Buffer,
+  IN  UINT64                    Value
+  );
+
+
+//
+// Bit Field Functions
+//
+
+/**
+  Returns a bit field from an 8-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The bit field read.
+
+**/
+UINT8
+EFIAPI
+BitFieldRead8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to an 8-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 8-bit value is
+  returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldWrite8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the value
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldOr8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the value.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldAnd8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldAndThenOr8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+
+/**
+  Returns a bit field from a 16-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The bit field read.
+
+**/
+UINT16
+EFIAPI
+BitFieldRead16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to a 16-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 16-bit value is
+  returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldWrite16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the value
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldOr16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the value
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldAnd16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldAndThenOr16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+
+/**
+  Returns a bit field from a 32-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The bit field read.
+
+**/
+UINT32
+EFIAPI
+BitFieldRead32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to a 32-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 32-bit value is
+  returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldWrite32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the value.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldOr32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the value
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldAnd32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldAndThenOr32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Returns a bit field from a 64-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The bit field read.
+
+**/
+UINT64
+EFIAPI
+BitFieldRead64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to a 64-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 64-bit value is
+  returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldWrite64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the value
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldOr64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  );
+
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the value
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldAnd64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  );
+
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldAndThenOr64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+//
+// Base Library Checksum Functions
+//
+
+/**
+  Returns the sum of all elements in a buffer in unit of UINT8.
+  During calculation, the carry bits are dropped.
+
+  This function calculates the sum of all elements in a buffer
+  in unit of UINT8. The carry bits in result of addition are dropped.
+  The result is returned as UINT8. If Length is Zero, then Zero is
+  returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT8
+EFIAPI
+CalculateSum8 (
+  IN      CONST UINT8              *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer
+  of 8-bit values.
+
+  This function first calculates the sum of the 8-bit values in the
+  buffer specified by Buffer and Length.  The carry bits in the result
+  of addition are dropped. Then, the two's complement of the sum is
+  returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The two's complement checksum of Buffer.
+
+**/
+UINT8
+EFIAPI
+CalculateCheckSum8 (
+  IN      CONST UINT8              *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the sum of all elements in a buffer of 16-bit values.  During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 16-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 16-bit result is returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT16
+EFIAPI
+CalculateSum16 (
+  IN      CONST UINT16             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  16-bit values.
+
+  This function first calculates the sum of the 16-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The two's complement checksum of Buffer.
+
+**/
+UINT16
+EFIAPI
+CalculateCheckSum16 (
+  IN      CONST UINT16             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the sum of all elements in a buffer of 32-bit values. During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 32-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 32-bit result is returned. If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT32
+EFIAPI
+CalculateSum32 (
+  IN      CONST UINT32             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  32-bit values.
+
+  This function first calculates the sum of the 32-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The two's complement checksum of Buffer.
+
+**/
+UINT32
+EFIAPI
+CalculateCheckSum32 (
+  IN      CONST UINT32             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the sum of all elements in a buffer of 64-bit values.  During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 64-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 64-bit result is returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT64
+EFIAPI
+CalculateSum64 (
+  IN      CONST UINT64             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  64-bit values.
+
+  This function first calculates the sum of the 64-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The two's complement checksum of Buffer.
+
+**/
+UINT64
+EFIAPI
+CalculateCheckSum64 (
+  IN      CONST UINT64             *Buffer,
+  IN      UINTN                     Length
+  );
+
+
+//
+// Base Library CPU Functions
+//
+
+/**
+  Function entry point used when a stack switch is requested with SwitchStack()
+
+  @param  Context1        Context1 parameter passed into SwitchStack().
+  @param  Context2        Context2 parameter passed into SwitchStack().
+
+**/
+typedef
+VOID
+(EFIAPI *SWITCH_STACK_ENTRY_POINT)(
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2   OPTIONAL
+  );
+
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  );
+
+
+/**
+  Saves the current CPU context that can be restored with a call to LongJump()
+  and returns 0.
+
+  Saves the current CPU context in the buffer specified by JumpBuffer and
+  returns 0. The initial call to SetJump() must always return 0. Subsequent
+  calls to LongJump() cause a non-zero value to be returned by SetJump().
+
+  If JumpBuffer is NULL, then ASSERT().
+  For Itanium processors, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+  
+  NOTE: The structure BASE_LIBRARY_JUMP_BUFFER is CPU architecture specific.
+  The same structure must never be used for more than one CPU architecture context.
+  For example, a BASE_LIBRARY_JUMP_BUFFER allocated by an IA-32 module must never be used from an x64 module. 
+  SetJump()/LongJump() is not currently supported for the EBC processor type.   
+
+  @param  JumpBuffer  A pointer to CPU context buffer.
+
+  @retval 0 Indicates a return from SetJump().
+
+**/
+UINTN
+EFIAPI
+SetJump (
+  OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  );
+
+
+/**
+  Restores the CPU context that was saved with SetJump().
+
+  Restores the CPU context from the buffer specified by JumpBuffer. This
+  function never returns to the caller. Instead is resumes execution based on
+  the state of JumpBuffer.
+
+  If JumpBuffer is NULL, then ASSERT().
+  For Itanium processors, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+  If Value is 0, then ASSERT().
+
+  @param  JumpBuffer  A pointer to CPU context buffer.
+  @param  Value       The value to return when the SetJump() context is
+                      restored and must be non-zero.
+
+**/
+VOID
+EFIAPI
+LongJump (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+  IN      UINTN                     Value
+  );
+
+
+/**
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  );
+
+
+/**
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  );
+
+
+/**
+  Disables CPU interrupts and returns the interrupt state prior to the disable
+  operation.
+
+  @retval TRUE  CPU interrupts were enabled on entry to this call.
+  @retval FALSE CPU interrupts were disabled on entry to this call.
+
+**/
+BOOLEAN
+EFIAPI
+SaveAndDisableInterrupts (
+  VOID
+  );
+
+
+/**
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+**/
+VOID
+EFIAPI
+EnableDisableInterrupts (
+  VOID
+  );
+
+
+/**
+  Retrieves the current CPU interrupt state.
+
+  Returns TRUE if interrupts are currently enabled. Otherwise
+  returns FALSE.
+
+  @retval TRUE  CPU interrupts are enabled.
+  @retval FALSE CPU interrupts are disabled.
+
+**/
+BOOLEAN
+EFIAPI
+GetInterruptState (
+  VOID
+  );
+
+
+/**
+  Set the current CPU interrupt state.
+
+  Sets the current CPU interrupt state to the state specified by
+  InterruptState. If InterruptState is TRUE, then interrupts are enabled. If
+  InterruptState is FALSE, then interrupts are disabled. InterruptState is
+  returned.
+
+  @param  InterruptState  TRUE if interrupts should enabled. FALSE if
+                          interrupts should be disabled.
+
+  @return InterruptState
+
+**/
+BOOLEAN
+EFIAPI
+SetInterruptState (
+  IN      BOOLEAN                   InterruptState
+  );
+
+
+/**
+  Requests CPU to pause for a short period of time.
+
+  Requests CPU to pause for a short period of time. Typically used in MP
+  systems to prevent memory starvation while waiting for a spin lock.
+
+**/
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  );
+
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.  This function
+  supports a variable number of arguments following the NewStack parameter.
+  These additional arguments are ignored on IA-32, x64, and EBC architectures.
+  Itanium processors expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  ...         This variable argument list is ignored for IA-32, x64, and 
+                      EBC architectures.  For Itanium processors, this variable 
+                      argument list is expected to contain a single parameter of 
+                      type VOID * that specifies the new backing store pointer.
+
+
+**/
+VOID
+EFIAPI
+SwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack,
+  ...
+  );
+
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  );
+
+
+/**
+  Executes an infinite loop.
+
+  Forces the CPU to execute an infinite loop. A debugger may be used to skip
+  past the loop and the code that follows the loop must execute properly. This
+  implies that the infinite loop must not cause the code that follow it to be
+  optimized away.
+
+**/
+VOID
+EFIAPI
+CpuDeadLoop (
+  VOID
+  );
+ 
+#if defined (MDE_CPU_IPF)
+
+/**
+  Flush a range of  cache lines in the cache coherency domain of the calling
+  CPU.
+
+  Flushes the cache lines specified by Address and Length.  If Address is not aligned 
+  on a cache line boundary, then entire cache line containing Address is flushed.  
+  If Address + Length is not aligned on a cache line boundary, then the entire cache 
+  line containing Address + Length - 1 is flushed.  This function may choose to flush 
+  the entire cache if that is more efficient than flushing the specified range.  If 
+  Length is 0, the no cache lines are flushed.  Address is returned.   
+  This function is only available on Itanium processors.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+AsmFlushCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+
+/**
+  Executes an FC instruction.
+  Executes an FC instruction on the cache line specified by Address.
+  The cache line size affected is at least 32-bytes (aligned on a 32-byte boundary).
+  An implementation may flush a larger region.  This function is only available on Itanium processors.
+
+  @param Address    The Address of cache line to be flushed.
+
+  @return The address of FC instruction executed.
+
+**/
+UINT64
+EFIAPI
+AsmFc (
+  IN  UINT64  Address
+  );
+
+
+/**
+  Executes an FC.I instruction.
+  Executes an FC.I instruction on the cache line specified by Address.
+  The cache line size affected is at least 32-bytes (aligned on a 32-byte boundary).
+  An implementation may flush a larger region.  This function is only available on Itanium processors.
+
+  @param Address    The Address of cache line to be flushed.
+
+  @return The address of the FC.I instruction executed.
+
+**/
+UINT64
+EFIAPI
+AsmFci (
+  IN  UINT64  Address
+  );
+
+
+/**
+  Reads the current value of a Processor Identifier Register (CPUID).
+  
+  Reads and returns the current value of Processor Identifier Register specified by Index. 
+  The Index of largest implemented CPUID (One less than the number of implemented CPUID
+  registers) is determined by CPUID [3] bits {7:0}.
+  No parameter checking is performed on Index.  If the Index value is beyond the
+  implemented CPUID register range, a Reserved Register/Field fault may occur.  The caller
+  must either guarantee that Index is valid, or the caller must set up fault handlers to
+  catch the faults.  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Processor Identifier Register index to read.
+
+  @return The current value of Processor Identifier Register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadCpuid (
+  IN  UINT8   Index
+  );
+
+
+/**
+  Reads the current value of 64-bit Processor Status Register (PSR).
+  This function is only available on Itanium processors.
+
+  @return The current value of PSR.
+
+**/
+UINT64
+EFIAPI
+AsmReadPsr (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit Processor Status Register (PSR).
+
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of PSR must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults. This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to PSR.
+
+  @return The 64-bit value written to the PSR.
+
+**/
+UINT64
+EFIAPI
+AsmWritePsr (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #0 (KR0).
+  
+  Reads and returns the current value of KR0. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR0.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #1 (KR1).
+
+  Reads and returns the current value of KR1. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR1.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr1 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #2 (KR2).
+
+  Reads and returns the current value of KR2. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR2.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr2 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #3 (KR3).
+
+  Reads and returns the current value of KR3. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR3.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr3 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #4 (KR4).
+
+  Reads and returns the current value of KR4. 
+  This function is only available on Itanium processors.
+  
+  @return The current value of KR4.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr4 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #5 (KR5).
+
+  Reads and returns the current value of KR5. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR5.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr5 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #6 (KR6).
+
+  Reads and returns the current value of KR6. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR6.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr6 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit Kernel Register #7 (KR7).
+
+  Reads and returns the current value of KR7. 
+  This function is only available on Itanium processors.
+
+  @return The current value of KR7.
+
+**/
+UINT64
+EFIAPI
+AsmReadKr7 (
+  VOID
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #0 (KR0).
+  
+  Writes the current value of KR0.  The 64-bit value written to 
+  the KR0 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR0.
+
+  @return The 64-bit value written to the KR0.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr0 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #1 (KR1).
+
+  Writes the current value of KR1.  The 64-bit value written to 
+  the KR1 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR1.
+
+  @return The 64-bit value written to the KR1.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr1 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #2 (KR2).
+
+  Writes the current value of KR2.  The 64-bit value written to 
+  the KR2 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR2.
+
+  @return The 64-bit value written to the KR2.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr2 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #3 (KR3).
+
+  Writes the current value of KR3.  The 64-bit value written to 
+  the KR3 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR3.
+
+  @return The 64-bit value written to the KR3.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr3 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #4 (KR4).
+
+  Writes the current value of KR4.  The 64-bit value written to 
+  the KR4 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR4.
+
+  @return The 64-bit value written to the KR4.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr4 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #5 (KR5).
+
+  Writes the current value of KR5.  The 64-bit value written to 
+  the KR5 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR5.
+
+  @return The 64-bit value written to the KR5.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr5 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #6 (KR6).
+
+  Writes the current value of KR6.  The 64-bit value written to 
+  the KR6 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR6.
+
+  @return The 64-bit value written to the KR6.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr6 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Write the current value of 64-bit Kernel Register #7 (KR7).
+
+  Writes the current value of KR7.  The 64-bit value written to 
+  the KR7 is returned. This function is only available on Itanium processors.
+
+  @param  Value   The 64-bit value to write to KR7.
+
+  @return The 64-bit value written to the KR7.
+
+**/
+UINT64
+EFIAPI
+AsmWriteKr7 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of Interval Timer Counter Register (ITC).
+  
+  Reads and returns the current value of ITC.
+  This function is only available on Itanium processors.
+
+  @return The current value of ITC.
+
+**/
+UINT64
+EFIAPI
+AsmReadItc (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Interval Timer Vector Register (ITV).
+  
+  Reads and returns the current value of ITV. 
+  This function is only available on Itanium processors.
+
+  @return The current value of ITV.
+
+**/
+UINT64
+EFIAPI
+AsmReadItv (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Interval Timer Match Register (ITM).
+  
+  Reads and returns the current value of ITM.
+  This function is only available on Itanium processors.
+
+  @return The current value of ITM.
+**/
+UINT64
+EFIAPI
+AsmReadItm (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit Interval Timer Counter Register (ITC).
+  
+  Writes the current value of ITC.  The 64-bit value written to the ITC is returned. 
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to ITC.
+
+  @return The 64-bit value written to the ITC.
+
+**/
+UINT64
+EFIAPI
+AsmWriteItc (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Interval Timer Match Register (ITM).
+  
+  Writes the current value of ITM.  The 64-bit value written to the ITM is returned. 
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to ITM.
+
+  @return The 64-bit value written to the ITM.
+
+**/
+UINT64
+EFIAPI
+AsmWriteItm (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Interval Timer Vector Register (ITV).
+  
+  Writes the current value of ITV.  The 64-bit value written to the ITV is returned.  
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of ITV must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to ITV.
+
+  @return The 64-bit value written to the ITV.
+
+**/
+UINT64
+EFIAPI
+AsmWriteItv (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of Default Control Register (DCR).
+  
+  Reads and returns the current value of DCR.  This function is only available on Itanium processors.
+
+  @return The current value of DCR.
+
+**/
+UINT64
+EFIAPI
+AsmReadDcr (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Interruption Vector Address Register (IVA).
+  
+  Reads and returns the current value of IVA.  This function is only available on Itanium processors.
+
+  @return The current value of IVA.
+**/
+UINT64
+EFIAPI
+AsmReadIva (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Page Table Address Register (PTA).
+  
+  Reads and returns the current value of PTA.  This function is only available on Itanium processors.
+
+  @return The current value of PTA.
+
+**/
+UINT64
+EFIAPI
+AsmReadPta (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit Default Control Register (DCR).
+  
+  Writes the current value of DCR.  The 64-bit value written to the DCR is returned. 
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of DCR must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to DCR.
+
+  @return The 64-bit value written to the DCR.
+
+**/
+UINT64
+EFIAPI
+AsmWriteDcr (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Interruption Vector Address Register (IVA).
+  
+  Writes the current value of IVA.  The 64-bit value written to the IVA is returned.  
+  The size of vector table is 32 K bytes and is 32 K bytes aligned
+  the low 15 bits of Value is ignored when written.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to IVA.
+
+  @return The 64-bit value written to the IVA.
+
+**/
+UINT64
+EFIAPI
+AsmWriteIva (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Page Table Address Register (PTA).
+  
+  Writes the current value of PTA.  The 64-bit value written to the PTA is returned. 
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of DCR must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to PTA.
+
+  @return The 64-bit value written to the PTA.
+**/
+UINT64
+EFIAPI
+AsmWritePta (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of Local Interrupt ID Register (LID).
+  
+  Reads and returns the current value of LID.  This function is only available on Itanium processors.
+
+  @return The current value of LID.
+
+**/
+UINT64
+EFIAPI
+AsmReadLid (
+  VOID
+  );
+
+
+/**
+  Reads the current value of External Interrupt Vector Register (IVR).
+  
+  Reads and returns the current value of IVR.  This function is only available on Itanium processors. 
+
+  @return The current value of IVR.
+
+**/
+UINT64
+EFIAPI
+AsmReadIvr (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Task Priority Register (TPR).
+  
+  Reads and returns the current value of TPR.  This function is only available on Itanium processors. 
+
+  @return The current value of TPR.
+
+**/
+UINT64
+EFIAPI
+AsmReadTpr (
+  VOID
+  );
+
+
+/**
+  Reads the current value of External Interrupt Request Register #0 (IRR0).
+  
+  Reads and returns the current value of IRR0.  This function is only available on Itanium processors.  
+
+  @return The current value of IRR0.
+
+**/
+UINT64
+EFIAPI
+AsmReadIrr0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of External Interrupt Request Register #1 (IRR1).
+  
+  Reads and returns the current value of IRR1.  This function is only available on Itanium processors. 
+
+  @return The current value of IRR1.
+
+**/
+UINT64
+EFIAPI
+AsmReadIrr1 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of External Interrupt Request Register #2 (IRR2).
+  
+  Reads and returns the current value of IRR2.  This function is only available on Itanium processors.
+
+  @return The current value of IRR2.
+
+**/
+UINT64
+EFIAPI
+AsmReadIrr2 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of External Interrupt Request Register #3 (IRR3).
+  
+  Reads and returns the current value of IRR3.  This function is only available on Itanium processors.  
+
+  @return The current value of IRR3.
+
+**/
+UINT64
+EFIAPI
+AsmReadIrr3 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Performance Monitor Vector Register (PMV).
+  
+  Reads and returns the current value of PMV.  This function is only available on Itanium processors. 
+
+  @return The current value of PMV.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmv (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Corrected Machine Check Vector Register (CMCV).
+  
+  Reads and returns the current value of CMCV.  This function is only available on Itanium processors.
+
+  @return The current value of CMCV.
+
+**/
+UINT64
+EFIAPI
+AsmReadCmcv (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Local Redirection Register #0 (LRR0).
+  
+  Reads and returns the current value of LRR0.  This function is only available on Itanium processors. 
+
+  @return The current value of LRR0.
+
+**/
+UINT64
+EFIAPI
+AsmReadLrr0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Local Redirection Register #1 (LRR1).
+  
+  Reads and returns the current value of LRR1.  This function is only available on Itanium processors.
+
+  @return The current value of LRR1.
+
+**/
+UINT64
+EFIAPI
+AsmReadLrr1 (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit Page Local Interrupt ID Register (LID).
+  
+  Writes the current value of LID.  The 64-bit value written to the LID is returned.  
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of LID must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to LID.
+
+  @return The 64-bit value written to the LID.
+
+**/
+UINT64
+EFIAPI
+AsmWriteLid (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Task Priority Register (TPR).
+  
+  Writes the current value of TPR.  The 64-bit value written to the TPR is returned. 
+  No parameter checking is performed on Value.  All bits of Value corresponding to
+  reserved fields of TPR must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to TPR.
+
+  @return The 64-bit value written to the TPR.
+
+**/
+UINT64
+EFIAPI
+AsmWriteTpr (
+  IN UINT64  Value
+  );
+
+
+/**
+  Performs a write operation on End OF External Interrupt Register (EOI).
+  
+  Writes a value of 0 to the EOI Register.  This function is only available on Itanium processors.
+
+**/
+VOID
+EFIAPI
+AsmWriteEoi (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit Performance Monitor Vector Register (PMV).
+  
+  Writes the current value of PMV.  The 64-bit value written to the PMV is returned.  
+  No parameter checking is performed on Value.  All bits of Value corresponding
+  to reserved fields of PMV must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to PMV.
+
+  @return The 64-bit value written to the PMV.
+
+**/
+UINT64
+EFIAPI
+AsmWritePmv (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Corrected Machine Check Vector Register (CMCV).
+  
+  Writes the current value of CMCV.  The 64-bit value written to the CMCV is returned. 
+  No parameter checking is performed on Value.  All bits of Value corresponding
+  to reserved fields of CMCV must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to CMCV.
+
+  @return The 64-bit value written to the CMCV.
+
+**/
+UINT64
+EFIAPI
+AsmWriteCmcv (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Local Redirection Register #0 (LRR0).
+  
+  Writes the current value of LRR0.  The 64-bit value written to the LRR0 is returned.  
+  No parameter checking is performed on Value.  All bits of Value corresponding
+  to reserved fields of LRR0 must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to LRR0.
+
+  @return The 64-bit value written to the LRR0.
+
+**/
+UINT64
+EFIAPI
+AsmWriteLrr0 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Local Redirection Register #1 (LRR1).
+  
+  Writes the current value of LRR1.  The 64-bit value written to the LRR1 is returned. 
+  No parameter checking is performed on Value.  All bits of Value corresponding
+  to reserved fields of LRR1 must be 0 or a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Value is valid, or the caller must
+  set up fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Value    The 64-bit value to write to LRR1.
+
+  @return The 64-bit value written to the LRR1.
+
+**/
+UINT64
+EFIAPI
+AsmWriteLrr1 (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of Instruction Breakpoint Register (IBR).
+  
+  The Instruction Breakpoint Registers are used in pairs.  The even numbered
+  registers contain breakpoint addresses, and the odd numbered registers contain
+  breakpoint mask conditions.  At least four instruction registers pairs are implemented
+  on all processor models.   Implemented registers are contiguous starting with
+  register 0.  No parameter checking is performed on Index, and if the Index value
+  is beyond the implemented IBR register range, a Reserved Register/Field fault may
+  occur.  The caller must either guarantee that Index is valid, or the caller must
+  set up fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Instruction Breakpoint Register index to read.
+
+  @return The current value of Instruction Breakpoint Register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadIbr (
+  IN  UINT8   Index
+  );
+
+
+/**
+  Reads the current value of Data Breakpoint Register (DBR).
+
+  The Data Breakpoint Registers are used in pairs.  The even numbered registers
+  contain breakpoint addresses, and odd numbered registers contain breakpoint
+  mask conditions.  At least four data registers pairs are implemented on all processor
+  models.  Implemented registers are contiguous starting with register 0.
+  No parameter checking is performed on Index.  If the Index value is beyond
+  the implemented DBR register range, a Reserved Register/Field fault may occur.
+  The caller must either guarantee that Index is valid, or the caller must set up
+  fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Data Breakpoint Register index to read.
+
+  @return The current value of Data Breakpoint Register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadDbr (
+  IN  UINT8   Index
+  );
+
+
+/**
+  Reads the current value of Performance Monitor Configuration Register (PMC).
+
+  All processor implementations provide at least four performance counters
+  (PMC/PMD [4]...PMC/PMD [7] pairs), and four performance monitor counter overflow
+  status registers (PMC [0]... PMC [3]).  Processor implementations may provide
+  additional implementation-dependent PMC and PMD to increase the number of
+  'generic' performance counters (PMC/PMD pairs).  The remainder of PMC and PMD
+  register set is implementation dependent.  No parameter checking is performed
+  on Index.  If the Index value is beyond the implemented PMC register range,
+  zero value will be returned.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Performance Monitor Configuration Register index to read.
+
+  @return   The current value of Performance Monitor Configuration Register
+            specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmc (
+  IN  UINT8   Index
+  );
+
+
+/**
+  Reads the current value of Performance Monitor Data Register (PMD).
+
+  All processor implementations provide at least 4 performance counters
+  (PMC/PMD [4]...PMC/PMD [7] pairs), and 4 performance monitor counter
+  overflow status registers (PMC [0]... PMC [3]).  Processor implementations may
+  provide additional implementation-dependent PMC and PMD to increase the number
+  of 'generic' performance counters (PMC/PMD pairs).  The remainder of PMC and PMD
+  register set is implementation dependent.  No parameter checking is performed
+  on Index.  If the Index value is beyond the implemented PMD register range,
+  zero value will be returned.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Performance Monitor Data Register index to read.
+
+  @return The current value of Performance Monitor Data Register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmd (
+  IN  UINT8   Index
+  );
+
+
+/**
+  Writes the current value of 64-bit Instruction Breakpoint Register (IBR).
+
+  Writes current value of Instruction Breakpoint Register specified by Index.
+  The Instruction Breakpoint Registers are used in pairs.  The even numbered
+  registers contain breakpoint addresses, and odd numbered registers contain
+  breakpoint mask conditions.  At least four instruction registers pairs are implemented
+  on all processor models.  Implemented registers are contiguous starting with
+  register 0.  No parameter checking is performed on Index.  If the Index value
+  is beyond the implemented IBR register range, a Reserved Register/Field fault may
+  occur.  The caller must either guarantee that Index is valid, or the caller must
+  set up fault handlers to catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Instruction Breakpoint Register index to write.
+  @param Value    The 64-bit value to write to IBR.
+
+  @return The 64-bit value written to the IBR.
+
+**/
+UINT64
+EFIAPI
+AsmWriteIbr (
+  IN UINT8   Index,
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Data Breakpoint Register (DBR).
+
+  Writes current value of Data Breakpoint Register specified by Index.
+  The Data Breakpoint Registers are used in pairs.  The even numbered registers
+  contain breakpoint addresses, and odd numbered registers contain breakpoint
+  mask conditions.  At least four data registers pairs are implemented on all processor
+  models.  Implemented registers are contiguous starting with register 0.  No parameter
+  checking is performed on Index.  If the Index value is beyond the implemented
+  DBR register range, a Reserved Register/Field fault may occur.  The caller must
+  either guarantee that Index is valid, or the caller must set up fault handlers to
+  catch the faults.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Data Breakpoint Register index to write.
+  @param Value    The 64-bit value to write to DBR.
+
+  @return The 64-bit value written to the DBR.
+
+**/
+UINT64
+EFIAPI
+AsmWriteDbr (
+  IN UINT8   Index,
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Performance Monitor Configuration Register (PMC).
+
+  Writes current value of Performance Monitor Configuration Register specified by Index.
+  All processor implementations provide at least four performance counters
+  (PMC/PMD [4]...PMC/PMD [7] pairs), and four performance monitor counter overflow status
+  registers (PMC [0]... PMC [3]).  Processor implementations may provide additional
+  implementation-dependent PMC and PMD to increase the number of 'generic' performance
+  counters (PMC/PMD pairs).  The remainder of PMC and PMD register set is implementation
+  dependent.  No parameter checking is performed on Index.  If the Index value is
+  beyond the implemented PMC register range, the write is ignored.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Performance Monitor Configuration Register index to write.
+  @param Value    The 64-bit value to write to PMC.
+
+  @return The 64-bit value written to the PMC.
+
+**/
+UINT64
+EFIAPI
+AsmWritePmc (
+  IN UINT8   Index,
+  IN UINT64  Value
+  );
+
+
+/**
+  Writes the current value of 64-bit Performance Monitor Data Register (PMD).
+
+  Writes current value of Performance Monitor Data Register specified by Index.
+  All processor implementations provide at least four performance counters
+  (PMC/PMD [4]...PMC/PMD [7] pairs), and four performance monitor counter overflow
+  status registers (PMC [0]... PMC [3]).  Processor implementations may provide
+  additional implementation-dependent PMC and PMD to increase the number of 'generic'
+  performance counters (PMC/PMD pairs).  The remainder of PMC and PMD register set
+  is implementation dependent.  No parameter checking is performed on Index.  If the
+  Index value is beyond the implemented PMD register range, the write is ignored.
+  This function is only available on Itanium processors.
+
+  @param Index    The 8-bit Performance Monitor Data Register index to write.
+  @param Value    The 64-bit value to write to PMD.
+
+  @return The 64-bit value written to the PMD.
+
+**/
+UINT64
+EFIAPI
+AsmWritePmd (
+  IN UINT8   Index,
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of 64-bit Global Pointer (GP).
+
+  Reads and returns the current value of GP.
+  This function is only available on Itanium processors.
+
+  @return The current value of GP.
+
+**/
+UINT64
+EFIAPI
+AsmReadGp (
+  VOID
+  );
+
+
+/**
+  Write the current value of 64-bit Global Pointer (GP).
+
+  Writes the current value of GP. The 64-bit value written to the GP is returned.
+  No parameter checking is performed on Value.
+  This function is only available on Itanium processors.
+
+  @param Value  The 64-bit value to write to GP.
+
+  @return The 64-bit value written to the GP.
+
+**/
+UINT64
+EFIAPI
+AsmWriteGp (
+  IN UINT64  Value
+  );
+
+
+/**
+  Reads the current value of 64-bit Stack Pointer (SP).
+
+  Reads and returns the current value of SP.
+  This function is only available on Itanium processors.
+
+  @return The current value of SP.
+
+**/
+UINT64
+EFIAPI
+AsmReadSp (
+  VOID
+  );
+
+
+///
+/// Valid Index value for AsmReadControlRegister().
+///
+#define IPF_CONTROL_REGISTER_DCR   0
+#define IPF_CONTROL_REGISTER_ITM   1
+#define IPF_CONTROL_REGISTER_IVA   2
+#define IPF_CONTROL_REGISTER_PTA   8
+#define IPF_CONTROL_REGISTER_IPSR  16
+#define IPF_CONTROL_REGISTER_ISR   17
+#define IPF_CONTROL_REGISTER_IIP   19
+#define IPF_CONTROL_REGISTER_IFA   20
+#define IPF_CONTROL_REGISTER_ITIR  21
+#define IPF_CONTROL_REGISTER_IIPA  22
+#define IPF_CONTROL_REGISTER_IFS   23
+#define IPF_CONTROL_REGISTER_IIM   24
+#define IPF_CONTROL_REGISTER_IHA   25
+#define IPF_CONTROL_REGISTER_LID   64
+#define IPF_CONTROL_REGISTER_IVR   65
+#define IPF_CONTROL_REGISTER_TPR   66
+#define IPF_CONTROL_REGISTER_EOI   67
+#define IPF_CONTROL_REGISTER_IRR0  68
+#define IPF_CONTROL_REGISTER_IRR1  69
+#define IPF_CONTROL_REGISTER_IRR2  70
+#define IPF_CONTROL_REGISTER_IRR3  71
+#define IPF_CONTROL_REGISTER_ITV   72
+#define IPF_CONTROL_REGISTER_PMV   73
+#define IPF_CONTROL_REGISTER_CMCV  74
+#define IPF_CONTROL_REGISTER_LRR0  80
+#define IPF_CONTROL_REGISTER_LRR1  81
+
+/**
+  Reads a 64-bit control register.
+
+  Reads and returns the control register specified by Index. The valid Index valued 
+  are defined above in "Related Definitions".
+  If Index is invalid then 0xFFFFFFFFFFFFFFFF is returned.  This function is only 
+  available on Itanium processors.
+
+  @param  Index                     The index of the control register to read.
+
+  @return The control register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegister (
+  IN UINT64  Index
+  );
+
+
+///
+/// Valid Index value for AsmReadApplicationRegister().
+///
+#define IPF_APPLICATION_REGISTER_K0        0
+#define IPF_APPLICATION_REGISTER_K1        1
+#define IPF_APPLICATION_REGISTER_K2        2
+#define IPF_APPLICATION_REGISTER_K3        3
+#define IPF_APPLICATION_REGISTER_K4        4
+#define IPF_APPLICATION_REGISTER_K5        5
+#define IPF_APPLICATION_REGISTER_K6        6
+#define IPF_APPLICATION_REGISTER_K7        7
+#define IPF_APPLICATION_REGISTER_RSC       16
+#define IPF_APPLICATION_REGISTER_BSP       17
+#define IPF_APPLICATION_REGISTER_BSPSTORE  18
+#define IPF_APPLICATION_REGISTER_RNAT      19
+#define IPF_APPLICATION_REGISTER_FCR       21
+#define IPF_APPLICATION_REGISTER_EFLAG     24
+#define IPF_APPLICATION_REGISTER_CSD       25
+#define IPF_APPLICATION_REGISTER_SSD       26
+#define IPF_APPLICATION_REGISTER_CFLG      27
+#define IPF_APPLICATION_REGISTER_FSR       28
+#define IPF_APPLICATION_REGISTER_FIR       29
+#define IPF_APPLICATION_REGISTER_FDR       30
+#define IPF_APPLICATION_REGISTER_CCV       32
+#define IPF_APPLICATION_REGISTER_UNAT      36
+#define IPF_APPLICATION_REGISTER_FPSR      40
+#define IPF_APPLICATION_REGISTER_ITC       44
+#define IPF_APPLICATION_REGISTER_PFS       64
+#define IPF_APPLICATION_REGISTER_LC        65
+#define IPF_APPLICATION_REGISTER_EC        66
+
+/**
+  Reads a 64-bit application register.
+
+  Reads and returns the application register specified by Index. The valid Index 
+  valued are defined above in "Related Definitions".
+  If Index is invalid then 0xFFFFFFFFFFFFFFFF is returned.  This function is only 
+  available on Itanium processors.
+
+  @param  Index                     The index of the application register to read.
+
+  @return The application register specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegister (
+  IN UINT64  Index
+  );
+
+
+/**
+  Reads the current value of a Machine Specific Register (MSR).
+
+  Reads and returns the current value of the Machine Specific Register specified by Index.  No
+  parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+  register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+  Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+  only available on Itanium processors.
+
+  @param  Index                     The 8-bit Machine Specific Register index to read.
+
+  @return The current value of the Machine Specific Register specified by Index.  
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr (
+  IN UINT8   Index  
+  );
+
+
+/**
+  Writes the current value of a Machine Specific Register (MSR).
+
+  Writes Value to the Machine Specific Register specified by Index.  Value is returned.  No
+  parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+  register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+  Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+  only available on Itanium processors.
+
+  @param  Index                     The 8-bit Machine Specific Register index to write.
+  @param  Value                     The 64-bit value to write to the Machine Specific Register.
+
+  @return The 64-bit value to write to the Machine Specific Register.  
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr (
+  IN UINT8   Index, 
+  IN UINT64  Value  
+  );
+
+
+/**
+  Determines if the CPU is currently executing in virtual, physical, or mixed mode.
+
+  Determines the current execution mode of the CPU.
+  If the CPU is in virtual mode(PSR.RT=1, PSR.DT=1, PSR.IT=1), then 1 is returned.
+  If the CPU is in physical mode(PSR.RT=0, PSR.DT=0, PSR.IT=0), then 0 is returned.
+  If the CPU is not in physical mode or virtual mode, then it is in mixed mode,
+  and -1 is returned.
+  This function is only available on Itanium processors.
+
+  @retval  1  The CPU is in virtual mode.
+  @retval  0  The CPU is in physical mode.
+  @retval -1  The CPU is in mixed mode.
+
+**/
+INT64
+EFIAPI
+AsmCpuVirtual (
+  VOID
+  );
+
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index
+  value this API will make static or stacked PAL call.  The following table
+  describes the usage of PAL Procedure Index Assignment. Architected procedures
+  may be designated as required or optional.  If a PAL procedure is specified
+  as optional, a unique return code of 0xFFFFFFFFFFFFFFFF is returned in the
+  Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.
+  It is the caller's responsibility to check for this return code after calling
+  any optional PAL procedure.
+  No parameter checking is performed on the 5 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any
+  address passed to PAL as buffers for return parameters must be 8-byte aligned.
+  Unaligned addresses may cause undefined results.  For those parameters defined
+  as reserved or some fields defined as reserved must be zero filled or the invalid
+  argument return value may be returned or undefined result may occur during the
+  execution of the procedure.  If the PalEntryPoint  does not point to a valid
+  PAL entry point then the system behavior is undefined.  This function is only
+  available on Itanium processors.
+
+  @param PalEntryPoint  The PAL procedure calls entry point.
+  @param Index          The PAL procedure Index number.
+  @param Arg2           The 2nd parameter for PAL procedure calls.
+  @param Arg3           The 3rd parameter for PAL procedure calls.
+  @param Arg4           The 4th parameter for PAL procedure calls.
+
+  @return structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+AsmPalCall (
+  IN UINT64  PalEntryPoint,
+  IN UINT64  Index,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4
+  );
+#endif
+
+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
+///
+/// IA32 and x64 Specific Functions.
+/// Byte packed structure for 16-bit Real Mode EFLAGS.
+///
+typedef union {
+  struct {
+    UINT32  CF:1;           ///< Carry Flag.
+    UINT32  Reserved_0:1;   ///< Reserved.
+    UINT32  PF:1;           ///< Parity Flag.
+    UINT32  Reserved_1:1;   ///< Reserved.
+    UINT32  AF:1;           ///< Auxiliary Carry Flag.
+    UINT32  Reserved_2:1;   ///< Reserved.
+    UINT32  ZF:1;           ///< Zero Flag.
+    UINT32  SF:1;           ///< Sign Flag.
+    UINT32  TF:1;           ///< Trap Flag.
+    UINT32  IF:1;           ///< Interrupt Enable Flag.
+    UINT32  DF:1;           ///< Direction Flag.
+    UINT32  OF:1;           ///< Overflow Flag.
+    UINT32  IOPL:2;         ///< I/O Privilege Level.
+    UINT32  NT:1;           ///< Nested Task.
+    UINT32  Reserved_3:1;   ///< Reserved.
+  } Bits;
+  UINT16    Uint16;
+} IA32_FLAGS16;
+
+///
+/// Byte packed structure for EFLAGS/RFLAGS.
+/// 32-bits on IA-32.
+/// 64-bits on x64.  The upper 32-bits on x64 are reserved.
+///
+typedef union {
+  struct {
+    UINT32  CF:1;           ///< Carry Flag.
+    UINT32  Reserved_0:1;   ///< Reserved.
+    UINT32  PF:1;           ///< Parity Flag.
+    UINT32  Reserved_1:1;   ///< Reserved.
+    UINT32  AF:1;           ///< Auxiliary Carry Flag.
+    UINT32  Reserved_2:1;   ///< Reserved.
+    UINT32  ZF:1;           ///< Zero Flag.
+    UINT32  SF:1;           ///< Sign Flag.
+    UINT32  TF:1;           ///< Trap Flag.
+    UINT32  IF:1;           ///< Interrupt Enable Flag.
+    UINT32  DF:1;           ///< Direction Flag.
+    UINT32  OF:1;           ///< Overflow Flag.
+    UINT32  IOPL:2;         ///< I/O Privilege Level.
+    UINT32  NT:1;           ///< Nested Task.
+    UINT32  Reserved_3:1;   ///< Reserved.
+    UINT32  RF:1;           ///< Resume Flag.
+    UINT32  VM:1;           ///< Virtual 8086 Mode.
+    UINT32  AC:1;           ///< Alignment Check.
+    UINT32  VIF:1;          ///< Virtual Interrupt Flag.
+    UINT32  VIP:1;          ///< Virtual Interrupt Pending.
+    UINT32  ID:1;           ///< ID Flag.
+    UINT32  Reserved_4:10;  ///< Reserved.
+  } Bits;
+  UINTN     UintN;
+} IA32_EFLAGS32;
+
+///
+/// Byte packed structure for Control Register 0 (CR0).
+/// 32-bits on IA-32.
+/// 64-bits on x64.  The upper 32-bits on x64 are reserved.
+///
+typedef union {
+  struct {
+    UINT32  PE:1;           ///< Protection Enable.
+    UINT32  MP:1;           ///< Monitor Coprocessor.
+    UINT32  EM:1;           ///< Emulation.
+    UINT32  TS:1;           ///< Task Switched.
+    UINT32  ET:1;           ///< Extension Type.
+    UINT32  NE:1;           ///< Numeric Error.
+    UINT32  Reserved_0:10;  ///< Reserved.
+    UINT32  WP:1;           ///< Write Protect.
+    UINT32  Reserved_1:1;   ///< Reserved.
+    UINT32  AM:1;           ///< Alignment Mask.
+    UINT32  Reserved_2:10;  ///< Reserved.
+    UINT32  NW:1;           ///< Mot Write-through.
+    UINT32  CD:1;           ///< Cache Disable.
+    UINT32  PG:1;           ///< Paging.
+  } Bits;
+  UINTN     UintN;
+} IA32_CR0;
+
+///
+/// Byte packed structure for Control Register 4 (CR4).
+/// 32-bits on IA-32.
+/// 64-bits on x64.  The upper 32-bits on x64 are reserved.
+///
+typedef union {
+  struct {
+    UINT32  VME:1;          ///< Virtual-8086 Mode Extensions.
+    UINT32  PVI:1;          ///< Protected-Mode Virtual Interrupts.
+    UINT32  TSD:1;          ///< Time Stamp Disable.
+    UINT32  DE:1;           ///< Debugging Extensions.
+    UINT32  PSE:1;          ///< Page Size Extensions.
+    UINT32  PAE:1;          ///< Physical Address Extension.
+    UINT32  MCE:1;          ///< Machine Check Enable.
+    UINT32  PGE:1;          ///< Page Global Enable.
+    UINT32  PCE:1;          ///< Performance Monitoring Counter
+                            ///< Enable.
+    UINT32  OSFXSR:1;       ///< Operating System Support for
+                            ///< FXSAVE and FXRSTOR instructions
+    UINT32  OSXMMEXCPT:1;   ///< Operating System Support for
+                            ///< Unmasked SIMD Floating Point
+                            ///< Exceptions.
+    UINT32  Reserved_0:2;   ///< Reserved.
+    UINT32  VMXE:1;         ///< VMX Enable
+    UINT32  Reserved_1:18;  ///< Reserved.
+  } Bits;
+  UINTN     UintN;
+} IA32_CR4;
+
+///
+/// Byte packed structure for a segment descriptor in a GDT/LDT.
+///
+typedef union {
+  struct {
+    UINT32  LimitLow:16;
+    UINT32  BaseLow:16;
+    UINT32  BaseMid:8;
+    UINT32  Type:4;
+    UINT32  S:1;
+    UINT32  DPL:2;
+    UINT32  P:1;
+    UINT32  LimitHigh:4;
+    UINT32  AVL:1;
+    UINT32  L:1;
+    UINT32  DB:1;
+    UINT32  G:1;
+    UINT32  BaseHigh:8;
+  } Bits;
+  UINT64  Uint64;
+} IA32_SEGMENT_DESCRIPTOR;
+
+///
+/// Byte packed structure for an IDTR, GDTR, LDTR descriptor.
+///
+#pragma pack (1)
+typedef struct {
+  UINT16  Limit;
+  UINTN   Base;
+} IA32_DESCRIPTOR;
+#pragma pack ()
+
+#define IA32_IDT_GATE_TYPE_TASK          0x85
+#define IA32_IDT_GATE_TYPE_INTERRUPT_16  0x86
+#define IA32_IDT_GATE_TYPE_TRAP_16       0x87
+#define IA32_IDT_GATE_TYPE_INTERRUPT_32  0x8E
+#define IA32_IDT_GATE_TYPE_TRAP_32       0x8F
+
+
+#if defined (MDE_CPU_IA32)
+///
+/// Byte packed structure for an IA-32 Interrupt Gate Descriptor.
+///
+typedef union {
+  struct {
+    UINT32  OffsetLow:16;   ///< Offset bits 15..0.
+    UINT32  Selector:16;    ///< Selector.
+    UINT32  Reserved_0:8;   ///< Reserved.
+    UINT32  GateType:8;     ///< Gate Type.  See #defines above.
+    UINT32  OffsetHigh:16;  ///< Offset bits 31..16.
+  } Bits;
+  UINT64  Uint64;
+} IA32_IDT_GATE_DESCRIPTOR;
+
+#endif
+
+#if defined (MDE_CPU_X64)
+///
+/// Byte packed structure for an x64 Interrupt Gate Descriptor.
+///
+typedef union {
+  struct {
+    UINT32  OffsetLow:16;   ///< Offset bits 15..0.
+    UINT32  Selector:16;    ///< Selector.
+    UINT32  Reserved_0:8;   ///< Reserved.
+    UINT32  GateType:8;     ///< Gate Type.  See #defines above.
+    UINT32  OffsetHigh:16;  ///< Offset bits 31..16.
+    UINT32  OffsetUpper:32; ///< Offset bits 63..32.
+    UINT32  Reserved_1:32;  ///< Reserved.
+  } Bits;
+  struct {
+    UINT64  Uint64;
+    UINT64  Uint64_1;
+  } Uint128;   
+} IA32_IDT_GATE_DESCRIPTOR;
+
+#endif
+
+///
+/// Byte packed structure for an FP/SSE/SSE2 context.
+///
+typedef struct {
+  UINT8  Buffer[512];
+} IA32_FX_BUFFER;
+
+///
+/// Structures for the 16-bit real mode thunks.
+///
+typedef struct {
+  UINT32                            Reserved1;
+  UINT32                            Reserved2;
+  UINT32                            Reserved3;
+  UINT32                            Reserved4;
+  UINT8                             BL;
+  UINT8                             BH;
+  UINT16                            Reserved5;
+  UINT8                             DL;
+  UINT8                             DH;
+  UINT16                            Reserved6;
+  UINT8                             CL;
+  UINT8                             CH;
+  UINT16                            Reserved7;
+  UINT8                             AL;
+  UINT8                             AH;
+  UINT16                            Reserved8;
+} IA32_BYTE_REGS;
+
+typedef struct {
+  UINT16                            DI;
+  UINT16                            Reserved1;
+  UINT16                            SI;
+  UINT16                            Reserved2;
+  UINT16                            BP;
+  UINT16                            Reserved3;
+  UINT16                            SP;
+  UINT16                            Reserved4;
+  UINT16                            BX;
+  UINT16                            Reserved5;
+  UINT16                            DX;
+  UINT16                            Reserved6;
+  UINT16                            CX;
+  UINT16                            Reserved7;
+  UINT16                            AX;
+  UINT16                            Reserved8;
+} IA32_WORD_REGS;
+
+typedef struct {
+  UINT32                            EDI;
+  UINT32                            ESI;
+  UINT32                            EBP;
+  UINT32                            ESP;
+  UINT32                            EBX;
+  UINT32                            EDX;
+  UINT32                            ECX;
+  UINT32                            EAX;
+  UINT16                            DS;
+  UINT16                            ES;
+  UINT16                            FS;
+  UINT16                            GS;
+  IA32_EFLAGS32                     EFLAGS;
+  UINT32                            Eip;
+  UINT16                            CS;
+  UINT16                            SS;
+} IA32_DWORD_REGS;
+
+typedef union {
+  IA32_DWORD_REGS                   E;
+  IA32_WORD_REGS                    X;
+  IA32_BYTE_REGS                    H;
+} IA32_REGISTER_SET;
+
+///
+/// Byte packed structure for an 16-bit real mode thunks.
+///
+typedef struct {
+  IA32_REGISTER_SET                 *RealModeState;
+  VOID                              *RealModeBuffer;
+  UINT32                            RealModeBufferSize;
+  UINT32                            ThunkAttributes;
+} THUNK_CONTEXT;
+
+#define THUNK_ATTRIBUTE_BIG_REAL_MODE             0x00000001
+#define THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15   0x00000002
+#define THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL 0x00000004
+
+/**
+  Retrieves CPUID information.
+
+  Executes the CPUID instruction with EAX set to the value specified by Index.
+  This function always returns Index.
+  If Eax is not NULL, then the value of EAX after CPUID is returned in Eax.
+  If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx.
+  If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx.
+  If Edx is not NULL, then the value of EDX after CPUID is returned in Edx.
+  This function is only available on IA-32 and x64.
+
+  @param  Index The 32-bit value to load into EAX prior to invoking the CPUID
+                instruction.
+  @param  Eax   The pointer to the 32-bit EAX value returned by the CPUID
+                instruction. This is an optional parameter that may be NULL.
+  @param  Ebx   The pointer to the 32-bit EBX value returned by the CPUID
+                instruction. This is an optional parameter that may be NULL.
+  @param  Ecx   The pointer to the 32-bit ECX value returned by the CPUID
+                instruction. This is an optional parameter that may be NULL.
+  @param  Edx   The pointer to the 32-bit EDX value returned by the CPUID
+                instruction. This is an optional parameter that may be NULL.
+
+  @return Index.
+
+**/
+UINT32
+EFIAPI
+AsmCpuid (
+  IN      UINT32                    Index,
+  OUT     UINT32                    *Eax,  OPTIONAL
+  OUT     UINT32                    *Ebx,  OPTIONAL
+  OUT     UINT32                    *Ecx,  OPTIONAL
+  OUT     UINT32                    *Edx   OPTIONAL
+  );
+
+
+/**
+  Retrieves CPUID information using an extended leaf identifier.
+
+  Executes the CPUID instruction with EAX set to the value specified by Index
+  and ECX set to the value specified by SubIndex. This function always returns
+  Index. This function is only available on IA-32 and x64.
+
+  If Eax is not NULL, then the value of EAX after CPUID is returned in Eax.
+  If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx.
+  If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx.
+  If Edx is not NULL, then the value of EDX after CPUID is returned in Edx.
+
+  @param  Index     The 32-bit value to load into EAX prior to invoking the
+                    CPUID instruction.
+  @param  SubIndex  The 32-bit value to load into ECX prior to invoking the
+                    CPUID instruction.
+  @param  Eax       The pointer to the 32-bit EAX value returned by the CPUID
+                    instruction. This is an optional parameter that may be
+                    NULL.
+  @param  Ebx       The pointer to the 32-bit EBX value returned by the CPUID
+                    instruction. This is an optional parameter that may be
+                    NULL.
+  @param  Ecx       The pointer to the 32-bit ECX value returned by the CPUID
+                    instruction. This is an optional parameter that may be
+                    NULL.
+  @param  Edx       The pointer to the 32-bit EDX value returned by the CPUID
+                    instruction. This is an optional parameter that may be
+                    NULL.
+
+  @return Index.
+
+**/
+UINT32
+EFIAPI
+AsmCpuidEx (
+  IN      UINT32                    Index,
+  IN      UINT32                    SubIndex,
+  OUT     UINT32                    *Eax,  OPTIONAL
+  OUT     UINT32                    *Ebx,  OPTIONAL
+  OUT     UINT32                    *Ecx,  OPTIONAL
+  OUT     UINT32                    *Edx   OPTIONAL
+  );
+
+
+/**
+  Set CD bit and clear NW bit of CR0 followed by a WBINVD.
+
+  Disables the caches by setting the CD bit of CR0 to 1, clearing the NW bit of CR0 to 0,
+  and executing a WBINVD instruction.  This function is only available on IA-32 and x64.
+
+**/
+VOID
+EFIAPI
+AsmDisableCache (
+  VOID
+  );
+
+
+/**
+  Perform a WBINVD and clear both the CD and NW bits of CR0.
+
+  Enables the caches by executing a WBINVD instruction and then clear both the CD and NW
+  bits of CR0 to 0.  This function is only available on IA-32 and x64.
+
+**/
+VOID
+EFIAPI
+AsmEnableCache (
+  VOID
+  );
+
+
+/**
+  Returns the lower 32-bits of a Machine Specific Register(MSR).
+
+  Reads and returns the lower 32-bits of the MSR specified by Index.
+  No parameter checking is performed on Index, and some Index values may cause
+  CPU exceptions. The caller must either guarantee that Index is valid, or the
+  caller must set up exception handlers to catch the exceptions. This function
+  is only available on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The lower 32 bits of the MSR identified by Index.
+
+**/
+UINT32
+EFIAPI
+AsmReadMsr32 (
+  IN      UINT32                    Index
+  );
+
+
+/**
+  Writes a 32-bit value to a Machine Specific Register(MSR), and returns the value.
+  The upper 32-bits of the MSR are set to zero.
+
+  Writes the 32-bit value specified by Value to the MSR specified by Index. The
+  upper 32-bits of the MSR write are set to zero. The 32-bit value written to
+  the MSR is returned. No parameter checking is performed on Index or Value,
+  and some of these may cause CPU exceptions. The caller must either guarantee
+  that Index and Value are valid, or the caller must establish proper exception
+  handlers. This function is only available on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 32-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT32
+EFIAPI
+AsmWriteMsr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    Value
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise OR on the lower 32-bits, and
+  writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the lower 32-bits of the read result and the value specified by
+  OrData, and writes the result to the 64-bit MSR specified by Index. The lower
+  32-bits of the value written to the MSR is returned. No parameter checking is
+  performed on Index or OrData, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and OrData are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  OrData  The value to OR with the read value from the MSR.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrOr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND on the lower 32-bits, and writes
+  the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  lower 32-bits of the read result and the value specified by AndData, and
+  writes the result to the 64-bit MSR specified by Index. The lower 32-bits of
+  the value written to the MSR is returned. No parameter checking is performed
+  on Index or AndData, and some of these may cause CPU exceptions. The caller
+  must either guarantee that Index and AndData are valid, or the caller must
+  establish proper exception handlers. This function is only available on IA-32
+  and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrAnd32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    AndData
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise OR
+  on the lower 32-bits, and writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  lower 32-bits of the read result and the value specified by AndData
+  preserving the upper 32-bits, performs a bitwise OR between the
+  result of the AND operation and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Address. The lower 32-bits of the value
+  written to the MSR is returned. No parameter checking is performed on Index,
+  AndData, or OrData, and some of these may cause CPU exceptions. The caller
+  must either guarantee that Index, AndData, and OrData are valid, or the
+  caller must establish proper exception handlers. This function is only
+  available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrAndThenOr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Reads a bit field of an MSR.
+
+  Reads the bit field in the lower 32-bits of a 64-bit MSR. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned. The caller must either guarantee that Index is valid, or the caller
+  must set up exception handlers to catch the exceptions. This function is only
+  available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The bit field read from the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldRead32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to an MSR.
+
+  Writes Value to a bit field in the lower 32-bits of a 64-bit MSR. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination MSR are preserved. The lower 32-bits of the MSR written is
+  returned. The caller must either guarantee that Index and the data written 
+  is valid, or the caller must set up exception handlers to catch the exceptions. 
+  This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldWrite32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The lower 32-bits of the value
+  written to the MSR are returned. Extra left bits in OrData are stripped. The
+  caller must either guarantee that Index and the data written is valid, or
+  the caller must set up exception handlers to catch the exceptions. This
+  function is only available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the MSR.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldOr32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by AndData, and writes the result to the
+  64-bit MSR specified by Index. The lower 32-bits of the value written to the
+  MSR are returned. Extra left bits in AndData are stripped. The caller must
+  either guarantee that Index and the data written is valid, or the caller must
+  set up exception handlers to catch the exceptions. This function is only
+  available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the MSR.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldAnd32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by a
+  bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit MSR specified by Index. The
+  lower 32-bits of the value written to the MSR are returned. Extra left bits
+  in both AndData and OrData are stripped. The caller must either guarantee
+  that Index and the data written is valid, or the caller must set up exception
+  handlers to catch the exceptions. This function is only available on IA-32
+  and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the MSR.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldAndThenOr32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+
+/**
+  Returns a 64-bit Machine Specific Register(MSR).
+
+  Reads and returns the 64-bit MSR specified by Index. No parameter checking is
+  performed on Index, and some Index values may cause CPU exceptions. The
+  caller must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The value of the MSR identified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr64 (
+  IN      UINT32                    Index
+  );
+
+
+/**
+  Writes a 64-bit value to a Machine Specific Register(MSR), and returns the
+  value.
+
+  Writes the 64-bit value specified by Value to the MSR specified by Index. The
+  64-bit value written to the MSR is returned. No parameter checking is
+  performed on Index or Value, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and Value are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 64-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise OR, and writes the result
+  back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The value written to the MSR is
+  returned. No parameter checking is performed on Index or OrData, and some of
+  these may cause CPU exceptions. The caller must either guarantee that Index
+  and OrData are valid, or the caller must establish proper exception handlers.
+  This function is only available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  OrData  The value to OR with the read value from the MSR.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrOr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    OrData
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND, and writes the result back to the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by OrData, and writes the result to the
+  64-bit MSR specified by Index. The value written to the MSR is returned. No
+  parameter checking is performed on Index or OrData, and some of these may
+  cause CPU exceptions. The caller must either guarantee that Index and OrData
+  are valid, or the caller must establish proper exception handlers. This
+  function is only available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrAnd64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    AndData
+  );
+
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between read
+  result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit MSR specified by Index. The value written
+  to the MSR is returned. No parameter checking is performed on Index, AndData,
+  or OrData, and some of these may cause CPU exceptions. The caller must either
+  guarantee that Index, AndData, and OrData are valid, or the caller must
+  establish proper exception handlers. This function is only available on IA-32
+  and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrAndThenOr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+
+/**
+  Reads a bit field of an MSR.
+
+  Reads the bit field in the 64-bit MSR. The bit field is specified by the
+  StartBit and the EndBit. The value of the bit field is returned. The caller
+  must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read from the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldRead64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Writes a bit field to an MSR.
+
+  Writes Value to a bit field in a 64-bit MSR. The bit field is specified by
+  the StartBit and the EndBit. All other bits in the destination MSR are
+  preserved. The MSR written is returned. The caller must either guarantee 
+  that Index and the data written is valid, or the caller must set up exception 
+  handlers to catch the exceptions. This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldWrite64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The value written to the MSR is
+  returned. Extra left bits in OrData are stripped. The caller must either
+  guarantee that Index and the data written is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldOr64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by AndData, and writes the result to the
+  64-bit MSR specified by Index. The value written to the MSR is returned.
+  Extra left bits in AndData are stripped. The caller must either guarantee
+  that Index and the data written is valid, or the caller must set up exception
+  handlers to catch the exceptions. This function is only available on IA-32
+  and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldAnd64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  );
+
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by
+  a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit MSR specified by Index. The
+  value written to the MSR is returned. Extra left bits in both AndData and
+  OrData are stripped. The caller must either guarantee that Index and the data
+  written is valid, or the caller must set up exception handlers to catch the
+  exceptions. This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the bit field.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldAndThenOr64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+
+/**
+  Reads the current value of the EFLAGS register.
+
+  Reads and returns the current value of the EFLAGS register. This function is
+  only available on IA-32 and x64. This returns a 32-bit value on IA-32 and a
+  64-bit value on x64.
+
+  @return EFLAGS on IA-32 or RFLAGS on x64.
+
+**/
+UINTN
+EFIAPI
+AsmReadEflags (
+  VOID
+  );
+
+
+/**
+  Reads the current value of the Control Register 0 (CR0).
+
+  Reads and returns the current value of CR0. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 0 (CR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of the Control Register 2 (CR2).
+
+  Reads and returns the current value of CR2. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 2 (CR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr2 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of the Control Register 3 (CR3).
+
+  Reads and returns the current value of CR3. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 3 (CR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr3 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of the Control Register 4 (CR4).
+
+  Reads and returns the current value of CR4. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 4 (CR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr4 (
+  VOID
+  );
+
+
+/**
+  Writes a value to Control Register 0 (CR0).
+
+  Writes and returns a new value to CR0. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Cr0 The value to write to CR0.
+
+  @return The value written to CR0.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr0 (
+  UINTN  Cr0
+  );
+
+
+/**
+  Writes a value to Control Register 2 (CR2).
+
+  Writes and returns a new value to CR2. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Cr2 The value to write to CR2.
+
+  @return The value written to CR2.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr2 (
+  UINTN  Cr2
+  );
+
+
+/**
+  Writes a value to Control Register 3 (CR3).
+
+  Writes and returns a new value to CR3. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Cr3 The value to write to CR3.
+
+  @return The value written to CR3.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr3 (
+  UINTN  Cr3
+  );
+
+
+/**
+  Writes a value to Control Register 4 (CR4).
+
+  Writes and returns a new value to CR4. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Cr4 The value to write to CR4.
+
+  @return The value written to CR4.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr4 (
+  UINTN  Cr4
+  );
+
+
+/**
+  Reads the current value of Debug Register 0 (DR0).
+
+  Reads and returns the current value of DR0. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 1 (DR1).
+
+  Reads and returns the current value of DR1. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr1 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 2 (DR2).
+
+  Reads and returns the current value of DR2. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr2 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 3 (DR3).
+
+  Reads and returns the current value of DR3. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr3 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 4 (DR4).
+
+  Reads and returns the current value of DR4. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr4 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 5 (DR5).
+
+  Reads and returns the current value of DR5. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr5 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 6 (DR6).
+
+  Reads and returns the current value of DR6. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr6 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Debug Register 7 (DR7).
+
+  Reads and returns the current value of DR7. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr7 (
+  VOID
+  );
+
+
+/**
+  Writes a value to Debug Register 0 (DR0).
+
+  Writes and returns a new value to DR0. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr0 The value to write to Dr0.
+
+  @return The value written to Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr0 (
+  UINTN  Dr0
+  );
+
+
+/**
+  Writes a value to Debug Register 1 (DR1).
+
+  Writes and returns a new value to DR1. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr1 The value to write to Dr1.
+
+  @return The value written to Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr1 (
+  UINTN  Dr1
+  );
+
+
+/**
+  Writes a value to Debug Register 2 (DR2).
+
+  Writes and returns a new value to DR2. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr2 The value to write to Dr2.
+
+  @return The value written to Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr2 (
+  UINTN  Dr2
+  );
+
+
+/**
+  Writes a value to Debug Register 3 (DR3).
+
+  Writes and returns a new value to DR3. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr3 The value to write to Dr3.
+
+  @return The value written to Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr3 (
+  UINTN  Dr3
+  );
+
+
+/**
+  Writes a value to Debug Register 4 (DR4).
+
+  Writes and returns a new value to DR4. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr4 The value to write to Dr4.
+
+  @return The value written to Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr4 (
+  UINTN  Dr4
+  );
+
+
+/**
+  Writes a value to Debug Register 5 (DR5).
+
+  Writes and returns a new value to DR5. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr5 The value to write to Dr5.
+
+  @return The value written to Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr5 (
+  UINTN  Dr5
+  );
+
+
+/**
+  Writes a value to Debug Register 6 (DR6).
+
+  Writes and returns a new value to DR6. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr6 The value to write to Dr6.
+
+  @return The value written to Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr6 (
+  UINTN  Dr6
+  );
+
+
+/**
+  Writes a value to Debug Register 7 (DR7).
+
+  Writes and returns a new value to DR7. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Dr7 The value to write to Dr7.
+
+  @return The value written to Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr7 (
+  UINTN  Dr7
+  );
+
+
+/**
+  Reads the current value of Code Segment Register (CS).
+
+  Reads and returns the current value of CS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of CS.
+
+**/
+UINT16
+EFIAPI
+AsmReadCs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Data Segment Register (DS).
+
+  Reads and returns the current value of DS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of DS.
+
+**/
+UINT16
+EFIAPI
+AsmReadDs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Extra Segment Register (ES).
+
+  Reads and returns the current value of ES. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of ES.
+
+**/
+UINT16
+EFIAPI
+AsmReadEs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of FS Data Segment Register (FS).
+
+  Reads and returns the current value of FS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of FS.
+
+**/
+UINT16
+EFIAPI
+AsmReadFs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of GS Data Segment Register (GS).
+
+  Reads and returns the current value of GS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of GS.
+
+**/
+UINT16
+EFIAPI
+AsmReadGs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Stack Segment Register (SS).
+
+  Reads and returns the current value of SS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of SS.
+
+**/
+UINT16
+EFIAPI
+AsmReadSs (
+  VOID
+  );
+
+
+/**
+  Reads the current value of Task Register (TR).
+
+  Reads and returns the current value of TR. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of TR.
+
+**/
+UINT16
+EFIAPI
+AsmReadTr (
+  VOID
+  );
+
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and x64.
+
+  If Gdtr is NULL, then ASSERT().
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmReadGdtr (
+  OUT     IA32_DESCRIPTOR           *Gdtr
+  );
+
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and x64.
+
+  If Gdtr is NULL, then ASSERT().
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmWriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  );
+
+
+/**
+  Reads the current Interrupt Descriptor Table Register(IDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and x64.
+
+  If Idtr is NULL, then ASSERT().
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  );
+
+
+/**
+  Writes the current Interrupt Descriptor Table Register(IDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and x64.
+
+  If Idtr is NULL, then ASSERT().
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmWriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  );
+
+
+/**
+  Reads the current Local Descriptor Table Register(LDTR) selector.
+
+  Reads and returns the current 16-bit LDTR descriptor value. This function is
+  only available on IA-32 and x64.
+
+  @return The current selector of LDT.
+
+**/
+UINT16
+EFIAPI
+AsmReadLdtr (
+  VOID
+  );
+
+
+/**
+  Writes the current Local Descriptor Table Register (LDTR) selector.
+
+  Writes and the current LDTR descriptor specified by Ldtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Ldtr  16-bit LDTR selector value.
+
+**/
+VOID
+EFIAPI
+AsmWriteLdtr (
+  IN      UINT16                    Ldtr
+  );
+
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and x64.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+AsmFxSave (
+  OUT     IA32_FX_BUFFER            *Buffer
+  );
+
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and x64.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-byte boundary, then ASSERT().
+  If Buffer was not saved with AsmFxSave(), then ASSERT().
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+AsmFxRestore (
+  IN      CONST IA32_FX_BUFFER      *Buffer
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #0 (MM0).
+
+  Reads and returns the current value of MM0. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM0.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm0 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #1 (MM1).
+
+  Reads and returns the current value of MM1. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM1.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm1 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #2 (MM2).
+
+  Reads and returns the current value of MM2. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM2.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm2 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #3 (MM3).
+
+  Reads and returns the current value of MM3. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM3.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm3 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #4 (MM4).
+
+  Reads and returns the current value of MM4. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM4.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm4 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #5 (MM5).
+
+  Reads and returns the current value of MM5. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM5.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm5 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #6 (MM6).
+
+  Reads and returns the current value of MM6. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM6.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm6 (
+  VOID
+  );
+
+
+/**
+  Reads the current value of 64-bit MMX Register #7 (MM7).
+
+  Reads and returns the current value of MM7. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM7.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm7 (
+  VOID
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #0 (MM0).
+
+  Writes the current value of MM0. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM0.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm0 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #1 (MM1).
+
+  Writes the current value of MM1. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM1.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm1 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #2 (MM2).
+
+  Writes the current value of MM2. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM2.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm2 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #3 (MM3).
+
+  Writes the current value of MM3. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM3.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm3 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #4 (MM4).
+
+  Writes the current value of MM4. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM4.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm4 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #5 (MM5).
+
+  Writes the current value of MM5. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM5.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm5 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #6 (MM6).
+
+  Writes the current value of MM6. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM6.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm6 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Writes the current value of 64-bit MMX Register #7 (MM7).
+
+  Writes the current value of MM7. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM7.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm7 (
+  IN      UINT64                    Value
+  );
+
+
+/**
+  Reads the current value of Time Stamp Counter (TSC).
+
+  Reads and returns the current value of TSC. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of TSC
+
+**/
+UINT64
+EFIAPI
+AsmReadTsc (
+  VOID
+  );
+
+
+/**
+  Reads the current value of a Performance Counter (PMC).
+
+  Reads and returns the current value of performance counter specified by
+  Index. This function is only available on IA-32 and x64.
+
+  @param  Index The 32-bit Performance Counter index to read.
+
+  @return The value of the PMC specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmc (
+  IN      UINT32                    Index
+  );
+
+
+/**
+  Sets up a monitor buffer that is used by AsmMwait().
+
+  Executes a MONITOR instruction with the register state specified by Eax, Ecx
+  and Edx. Returns Eax. This function is only available on IA-32 and x64.
+
+  @param  Eax The value to load into EAX or RAX before executing the MONITOR
+              instruction.
+  @param  Ecx The value to load into ECX or RCX before executing the MONITOR
+              instruction.
+  @param  Edx The value to load into EDX or RDX before executing the MONITOR
+              instruction.
+
+  @return Eax
+
+**/
+UINTN
+EFIAPI
+AsmMonitor (
+  IN      UINTN                     Eax,
+  IN      UINTN                     Ecx,
+  IN      UINTN                     Edx
+  );
+
+
+/**
+  Executes an MWAIT instruction.
+
+  Executes an MWAIT instruction with the register state specified by Eax and
+  Ecx. Returns Eax. This function is only available on IA-32 and x64.
+
+  @param  Eax The value to load into EAX or RAX before executing the MONITOR
+              instruction.
+  @param  Ecx The value to load into ECX or RCX before executing the MONITOR
+              instruction.
+
+  @return Eax
+
+**/
+UINTN
+EFIAPI
+AsmMwait (
+  IN      UINTN                     Eax,
+  IN      UINTN                     Ecx
+  );
+
+
+/**
+  Executes a WBINVD instruction.
+
+  Executes a WBINVD instruction. This function is only available on IA-32 and
+  x64.
+
+**/
+VOID
+EFIAPI
+AsmWbinvd (
+  VOID
+  );
+
+
+/**
+  Executes a INVD instruction.
+
+  Executes a INVD instruction. This function is only available on IA-32 and
+  x64.
+
+**/
+VOID
+EFIAPI
+AsmInvd (
+  VOID
+  );
+
+
+/**
+  Flushes a cache line from all the instruction and data caches within the
+  coherency domain of the CPU.
+
+  Flushed the cache line specified by LinearAddress, and returns LinearAddress.
+  This function is only available on IA-32 and x64.
+
+  @param  LinearAddress The address of the cache line to flush. If the CPU is
+                        in a physical addressing mode, then LinearAddress is a
+                        physical address. If the CPU is in a virtual
+                        addressing mode, then LinearAddress is a virtual
+                        address.
+
+  @return LinearAddress.
+**/
+VOID *
+EFIAPI
+AsmFlushCacheLine (
+  IN      VOID                      *LinearAddress
+  );
+
+
+/**
+  Enables the 32-bit paging mode on the CPU.
+
+  Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode. This function is
+  only available on IA-32. After the 32-bit paging mode is enabled, control is
+  transferred to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  If the current execution mode is not 32-bit protected mode, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit protected mode with flat descriptors. This
+      means all descriptors must have a base of 0 and a limit of 4GB.
+  3)  CR0 and CR4 must be compatible with 32-bit protected mode with flat
+      descriptors.
+  4)  CR3 must point to valid page tables that will be used once the transition
+      is complete, and those page tables must guarantee that the pages for this
+      function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is enabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is enabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is enabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+AsmEnablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+
+/**
+  Disables the 32-bit paging mode on the CPU.
+
+  Disables the 32-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 32-paged protected
+  mode. This function is only available on IA-32. After the 32-bit paging mode
+  is disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be NULL. The function EntryPoint must never return.
+
+  If the current execution mode is not 32-bit paged mode, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit paged mode.
+  3)  CR0, CR3, and CR4 must be compatible with 32-bit paged mode.
+  4)  CR3 must point to valid page tables that guarantee that the pages for
+      this function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is disabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is disabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is
+                      disabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+AsmDisablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+
+/**
+  Enables the 64-bit paging mode on the CPU.
+
+  Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode with flat
+  descriptors. This function is only available on IA-32. After the 64-bit
+  paging mode is enabled, control is transferred to the function specified by
+  EntryPoint using the new stack specified by NewStack and passing in the
+  parameters specified by Context1 and Context2. Context1 and Context2 are
+  optional and may be 0. The function EntryPoint must never return.
+
+  If the current execution mode is not 32-bit protected mode with flat
+  descriptors, then ASSERT().
+  If EntryPoint is 0, then ASSERT().
+  If NewStack is 0, then ASSERT().
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for long mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is enabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is enabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is enabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+AsmEnablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT64                    EntryPoint,
+  IN      UINT64                    Context1,  OPTIONAL
+  IN      UINT64                    Context2,  OPTIONAL
+  IN      UINT64                    NewStack
+  );
+
+
+/**
+  Disables the 64-bit paging mode on the CPU.
+
+  Disables the 64-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 64-paging mode.
+  This function is only available on x64. After the 64-bit paging mode is
+  disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be 0. The function EntryPoint must never return.
+
+  If the current execution mode is not 64-bit paged mode, then ASSERT().
+  If EntryPoint is 0, then ASSERT().
+  If NewStack is 0, then ASSERT().
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for 32-bit protected mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is disabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is disabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is disabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+AsmDisablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT32                    EntryPoint,
+  IN      UINT32                    Context1,  OPTIONAL
+  IN      UINT32                    Context2,  OPTIONAL
+  IN      UINT32                    NewStack
+  );
+
+
+//
+// 16-bit thunking services
+//
+
+/**
+  Retrieves the properties for 16-bit thunk functions.
+
+  Computes the size of the buffer and stack below 1MB required to use the
+  AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
+  buffer size is returned in RealModeBufferSize, and the stack size is returned
+  in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
+  then the actual minimum stack size is ExtraStackSize plus the maximum number
+  of bytes that need to be passed to the 16-bit real mode code.
+  
+  If RealModeBufferSize is NULL, then ASSERT().
+  If ExtraStackSize is NULL, then ASSERT().
+
+  @param  RealModeBufferSize  A pointer to the size of the buffer below 1MB
+                              required to use the 16-bit thunk functions.
+  @param  ExtraStackSize      A pointer to the extra size of stack below 1MB
+                              that the 16-bit thunk functions require for
+                              temporary storage in the transition to and from
+                              16-bit real mode.
+
+**/
+VOID
+EFIAPI
+AsmGetThunk16Properties (
+  OUT     UINT32                    *RealModeBufferSize,
+  OUT     UINT32                    *ExtraStackSize
+  );
+
+
+/**
+  Prepares all structures a code required to use AsmThunk16().
+
+  Prepares all structures and code required to use AsmThunk16().
+  
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1.
+
+  If ThunkContext is NULL, then ASSERT().
+
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmPrepareThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  );
+
+
+/**
+  Transfers control to a 16-bit real mode entry point and returns the results.
+
+  Transfers control to a 16-bit real mode entry point and returns the results.
+  AsmPrepareThunk16() must be called with ThunkContext before this function is used.
+  This function must be called with interrupts disabled.
+
+  The register state from the RealModeState field of ThunkContext is restored just prior 
+  to calling the 16-bit real mode entry point.  This includes the EFLAGS field of RealModeState, 
+  which is used to set the interrupt state when a 16-bit real mode entry point is called.
+  Control is transferred to the 16-bit real mode entry point specified by the CS and Eip fields of RealModeState.
+  The stack is initialized to the SS and ESP fields of RealModeState.  Any parameters passed to 
+  the 16-bit real mode code must be populated by the caller at SS:ESP prior to calling this function.  
+  The 16-bit real mode entry point is invoked with a 16-bit CALL FAR instruction,
+  so when accessing stack contents, the 16-bit real mode code must account for the 16-bit segment 
+  and 16-bit offset of the return address that were pushed onto the stack. The 16-bit real mode entry 
+  point must exit with a RETF instruction. The register state is captured into RealModeState immediately 
+  after the RETF instruction is executed.
+  
+  If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, 
+  or any of the 16-bit real mode code makes a SW interrupt, then the caller is responsible for making sure 
+  the IDT at address 0 is initialized to handle any HW or SW interrupts that may occur while in 16-bit real mode. 
+  
+  If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, 
+  then the caller is responsible for making sure the 8259 PIC is in a state compatible with 16-bit real mode.  
+  This includes the base vectors, the interrupt masks, and the edge/level trigger mode.
+  
+  If THUNK_ATTRIBUTE_BIG_REAL_MODE is set in the ThunkAttributes field of ThunkContext, then the user code 
+  is invoked in big real mode.  Otherwise, the user code is invoked in 16-bit real mode with 64KB segment limits.
+  
+  If neither THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 nor THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in 
+  ThunkAttributes, then it is assumed that the user code did not enable the A20 mask, and no attempt is made to 
+  disable the A20 mask.
+  
+  If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is set and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is clear in 
+  ThunkAttributes, then attempt to use the INT 15 service to disable the A20 mask.  If this INT 15 call fails, 
+  then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports.
+  
+  If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is clear and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is set in 
+  ThunkAttributes, then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports.
+    
+  If ThunkContext is NULL, then ASSERT().
+  If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
+  If both THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in 
+  ThunkAttributes, then ASSERT().
+
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer are mapped 1:1.
+
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  );
+
+
+/**
+  Prepares all structures and code for a 16-bit real mode thunk, transfers
+  control to a 16-bit real mode entry point, and returns the results.
+
+  Prepares all structures and code for a 16-bit real mode thunk, transfers
+  control to a 16-bit real mode entry point, and returns the results. If the
+  caller only need to perform a single 16-bit real mode thunk, then this
+  service should be used. If the caller intends to make more than one 16-bit
+  real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
+  once and AsmThunk16() can be called for each 16-bit real mode thunk.
+
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1.
+
+  See AsmPrepareThunk16() and AsmThunk16() for the detailed description and ASSERT() conditions.
+
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmPrepareAndThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  );
+
+/**
+  Generates a 16-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+ **/
+BOOLEAN
+EFIAPI
+AsmRdRand16 (
+  OUT     UINT16                    *Rand
+  );
+
+/**
+  Generates a 32-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+AsmRdRand32 (
+  OUT     UINT32                    *Rand
+  );
+
+/**
+  Generates a 64-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+AsmRdRand64  (
+  OUT     UINT64                    *Rand
+  );
+
+#endif
+#endif
+
+
diff --git a/MdePkg/Include/Library/BaseMemoryLib.h b/MdePkg/Include/Library/BaseMemoryLib.h
new file mode 100644
index 000000000000..31a403c56ab9
--- /dev/null
+++ b/MdePkg/Include/Library/BaseMemoryLib.h
@@ -0,0 +1,489 @@
+/** @file
+  Provides copy memory, fill memory, zero memory, and GUID functions.
+   
+  The Base Memory Library provides optimized implementations for common memory-based operations. 
+  These functions should be used in place of coding your own loops to do equivalent common functions. 
+  This allows optimized library implementations to help increase performance. 
+
+Copyright (c) 2006 - 2016, 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 __BASE_MEMORY_LIB__
+#define __BASE_MEMORY_LIB__
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  );
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  );
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  );
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  );
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  );
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  );
+  
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  );
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  );
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches target the buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer, otherwise NULL.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  );
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  );
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/CacheMaintenanceLib.h b/MdePkg/Include/Library/CacheMaintenanceLib.h
new file mode 100644
index 000000000000..b2c6258a32a4
--- /dev/null
+++ b/MdePkg/Include/Library/CacheMaintenanceLib.h
@@ -0,0 +1,212 @@
+/** @file
+  Provides services to maintain instruction and data caches.
+  
+  The Cache Maintenance Library provides abstractions for basic processor cache operations.
+  It removes the need to use assembly in C code.
+    
+Copyright (c) 2006 - 2008, 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 __CACHE_MAINTENANCE_LIB__
+#define __CACHE_MAINTENANCE_LIB__
+
+/**
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+**/
+VOID
+EFIAPI
+InvalidateInstructionCache (
+  VOID
+  );
+
+/**
+  Invalidates a range of instruction cache lines in the cache coherency domain
+  of the calling CPU.
+
+  Invalidates the instruction cache lines specified by Address and Length. If
+  Address is not aligned on a cache line boundary, then entire instruction
+  cache line containing Address is invalidated. If Address + Length is not
+  aligned on a cache line boundary, then the entire instruction cache line
+  containing Address + Length -1 is invalidated. This function may choose to
+  invalidate the entire instruction cache if that is more efficient than
+  invalidating the specified range. If Length is 0, then no instruction cache
+  lines are invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateInstructionCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+/**
+  Writes Back and Invalidates the entire data cache in cache coherency domain
+  of the calling CPU.
+
+  Writes Back and Invalidates the entire data cache in cache coherency domain
+  of the calling CPU. This function guarantees that all dirty cache lines are
+  written back to system memory, and also invalidates all the data cache lines
+  in the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackInvalidateDataCache (
+  VOID
+  );
+
+/**
+  Writes Back and Invalidates a range of data cache lines in the cache
+  coherency domain of the calling CPU.
+
+  Writes Back and Invalidate the data cache lines specified by Address and
+  Length. If Address is not aligned on a cache line boundary, then entire data
+  cache line containing Address is written back and invalidated. If Address +
+  Length is not aligned on a cache line boundary, then the entire data cache
+  line containing Address + Length -1 is written back and invalidated. This
+  function may choose to write back and invalidate the entire data cache if
+  that is more efficient than writing back and invalidating the specified
+  range. If Length is 0, then no data cache lines are written back and
+  invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back and
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back and invalidate from the
+                  data cache.
+
+  @return Address of cache invalidation.
+
+**/
+VOID *
+EFIAPI
+WriteBackInvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+/**
+  Writes Back the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Writes Back the entire data cache in cache coherency domain of the calling
+  CPU. This function guarantees that all dirty cache lines are written back to
+  system memory. This function may also invalidate all the data cache lines in
+  the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackDataCache (
+  VOID
+  );
+
+/**
+  Writes Back a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Writes Back the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is written back. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is written back. This function may choose to write back the entire
+  data cache if that is more efficient than writing back the specified range.
+  If Length is 0, then no data cache lines are written back. This function may
+  also invalidate all the data cache lines in the specified range of the cache
+  coherency domain of the calling CPU. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing
+                  mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back from the data cache.
+
+  @return Address of cache written in main memory.
+
+**/
+VOID *
+EFIAPI
+WriteBackDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+/**
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU. This function must be used with care because dirty cache lines are not
+  written back to system memory. It is typically used for cache diagnostics. If
+  the CPU does not support invalidation of the entire data cache, then a write
+  back and invalidate operation should be performed on the entire data cache.
+
+**/
+VOID
+EFIAPI
+InvalidateDataCache (
+  VOID
+  );
+
+/**
+  Invalidates a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Invalidates the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is invalidated. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is invalidated. This function must never invalidate any cache lines
+  outside the specified range. If Length is 0, the no data cache lines are
+  invalidated. Address is returned. This function must be used with care
+  because dirty cache lines are not written back to system memory. It is
+  typically used for cache diagnostics. If the CPU does not support
+  invalidation of a data cache range, then a write back and invalidate
+  operation should be performed on the data cache range.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+  @param  Length  The number of bytes to invalidate from the data cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/CpuLib.h b/MdePkg/Include/Library/CpuLib.h
new file mode 100644
index 000000000000..662e4d9ce69c
--- /dev/null
+++ b/MdePkg/Include/Library/CpuLib.h
@@ -0,0 +1,51 @@
+/** @file
+  Provides CPU architecture specific functions that can not be defined
+  in the Base Library due to dependencies on the PAL Library
+  
+  The CPU Library provides services to flush CPU TLBs and place the CPU in a sleep state.
+  The implementation of these services on Itanium processors requires the use of PAL Calls.
+  PAL Calls require PEI and DXE specific mechanisms to look up PAL Entry Point.
+  As a result, these services could not be defined in the Base Library.
+
+Copyright (c) 2006 - 2008, 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 __CPU_LIB_H__
+#define __CPU_LIB_H__
+
+/**
+  Places the CPU in a sleep state until an interrupt is received.
+
+  Places the CPU in a sleep state until an interrupt is received. If interrupts
+  are disabled prior to calling this function, then the CPU will be placed in a
+  sleep state indefinitely.
+
+**/
+VOID
+EFIAPI
+CpuSleep (
+  VOID
+  );
+
+/**
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+**/
+VOID
+EFIAPI
+CpuFlushTlb (
+  VOID
+  );
+
+
+#endif
diff --git a/MdePkg/Include/Library/DebugLib.h b/MdePkg/Include/Library/DebugLib.h
new file mode 100644
index 000000000000..a26b635a22f1
--- /dev/null
+++ b/MdePkg/Include/Library/DebugLib.h
@@ -0,0 +1,529 @@
+/** @file
+  Provides services to print debug and assert messages to a debug output device.
+  
+  The Debug library supports debug print and asserts based on a combination of macros and code.
+  The debug library can be turned on and off so that the debug code does not increase the size of an image.
+
+  Note that a reserved macro named MDEPKG_NDEBUG is introduced for the intention
+  of size reduction when compiler optimization is disabled. If MDEPKG_NDEBUG is
+  defined, then debug and assert related macros wrapped by it are the NULL implementations.
+
+Copyright (c) 2006 - 2016, 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 __DEBUG_LIB_H__
+#define __DEBUG_LIB_H__
+
+//
+// Declare bits for PcdDebugPropertyMask
+//
+#define DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED       0x01
+#define DEBUG_PROPERTY_DEBUG_PRINT_ENABLED        0x02
+#define DEBUG_PROPERTY_DEBUG_CODE_ENABLED         0x04
+#define DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED       0x08
+#define DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED  0x10
+#define DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED    0x20
+
+//
+// Declare bits for PcdDebugPrintErrorLevel and the ErrorLevel parameter of DebugPrint()
+//
+#define DEBUG_INIT      0x00000001  // Initialization
+#define DEBUG_WARN      0x00000002  // Warnings
+#define DEBUG_LOAD      0x00000004  // Load events
+#define DEBUG_FS        0x00000008  // EFI File system
+#define DEBUG_POOL      0x00000010  // Alloc & Free (pool)
+#define DEBUG_PAGE      0x00000020  // Alloc & Free (page)
+#define DEBUG_INFO      0x00000040  // Informational debug messages
+#define DEBUG_DISPATCH  0x00000080  // PEI/DXE/SMM Dispatchers
+#define DEBUG_VARIABLE  0x00000100  // Variable
+#define DEBUG_BM        0x00000400  // Boot Manager
+#define DEBUG_BLKIO     0x00001000  // BlkIo Driver
+#define DEBUG_NET       0x00004000  // Network Io Driver
+#define DEBUG_UNDI      0x00010000  // UNDI Driver
+#define DEBUG_LOADFILE  0x00020000  // LoadFile
+#define DEBUG_EVENT     0x00080000  // Event messages
+#define DEBUG_GCD       0x00100000  // Global Coherency Database changes
+#define DEBUG_CACHE     0x00200000  // Memory range cachability changes
+#define DEBUG_VERBOSE   0x00400000  // Detailed debug messages that may
+                                    // significantly impact boot performance
+#define DEBUG_ERROR     0x80000000  // Error
+
+//
+// Aliases of debug message mask bits
+//
+#define EFI_D_INIT      DEBUG_INIT
+#define EFI_D_WARN      DEBUG_WARN
+#define EFI_D_LOAD      DEBUG_LOAD
+#define EFI_D_FS        DEBUG_FS
+#define EFI_D_POOL      DEBUG_POOL
+#define EFI_D_PAGE      DEBUG_PAGE
+#define EFI_D_INFO      DEBUG_INFO
+#define EFI_D_DISPATCH  DEBUG_DISPATCH
+#define EFI_D_VARIABLE  DEBUG_VARIABLE
+#define EFI_D_BM        DEBUG_BM
+#define EFI_D_BLKIO     DEBUG_BLKIO
+#define EFI_D_NET       DEBUG_NET
+#define EFI_D_UNDI      DEBUG_UNDI
+#define EFI_D_LOADFILE  DEBUG_LOADFILE
+#define EFI_D_EVENT     DEBUG_EVENT
+#define EFI_D_VERBOSE   DEBUG_VERBOSE
+#define EFI_D_ERROR     DEBUG_ERROR
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      The format string for the debug message to print.
+  @param  ...         The variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  );
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated the assert condition.
+  @param  LineNumber   The line number in the source file that generated the assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  );
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  );
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise, FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  );
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise, FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  );
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise, FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  );
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise, FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  );
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  );
+
+/**  
+  Internal worker macro that calls DebugAssert().
+
+  This macro calls DebugAssert(), passing in the filename, line number, and an
+  expression that evaluated to FALSE.
+
+  @param  Expression  Boolean expression that evaluated to FALSE
+
+**/
+#define _ASSERT(Expression)  DebugAssert (__FILE__, __LINE__, #Expression)
+
+
+/**  
+  Internal worker macro that calls DebugPrint().
+
+  This macro calls DebugPrint() passing in the debug error level, a format 
+  string, and a variable argument list.
+  __VA_ARGS__ is not supported by EBC compiler, Microsoft Visual Studio .NET 2003
+  and Microsoft Windows Server 2003 Driver Development Kit (Microsoft WINDDK) version 3790.1830.
+
+  @param  Expression  Expression containing an error level, a format string, 
+                      and a variable argument list based on the format string.
+
+**/
+
+#if !defined(MDE_CPU_EBC) && (!defined (_MSC_VER) || _MSC_VER > 1400)
+  #define _DEBUG_PRINT(PrintLevel, ...)              \
+    do {                                             \
+      if (DebugPrintLevelEnabled (PrintLevel)) {     \
+        DebugPrint (PrintLevel, ##__VA_ARGS__);      \
+      }                                              \
+    } while (FALSE)
+  #define _DEBUG(Expression)   _DEBUG_PRINT Expression
+#else
+#define _DEBUG(Expression)   DebugPrint Expression
+#endif
+
+/**  
+  Macro that calls DebugAssert() if an expression evaluates to FALSE.
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED 
+  bit of PcdDebugProperyMask is set, then this macro evaluates the Boolean 
+  expression specified by Expression.  If Expression evaluates to FALSE, then 
+  DebugAssert() is called passing in the source filename, source line number, 
+  and Expression.
+
+  @param  Expression  Boolean expression.
+
+**/
+#if !defined(MDEPKG_NDEBUG)       
+  #define ASSERT(Expression)        \
+    do {                            \
+      if (DebugAssertEnabled ()) {  \
+        if (!(Expression)) {        \
+          _ASSERT (Expression);     \
+          ANALYZER_UNREACHABLE ();  \
+        }                           \
+      }                             \
+    } while (FALSE)
+#else
+  #define ASSERT(Expression)
+#endif
+
+/**  
+  Macro that calls DebugPrint().
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED 
+  bit of PcdDebugProperyMask is set, then this macro passes Expression to 
+  DebugPrint().
+
+  @param  Expression  Expression containing an error level, a format string, 
+                      and a variable argument list based on the format string.
+  
+
+**/
+#if !defined(MDEPKG_NDEBUG)      
+  #define DEBUG(Expression)        \
+    do {                           \
+      if (DebugPrintEnabled ()) {  \
+        _DEBUG (Expression);       \
+      }                            \
+    } while (FALSE)
+#else
+  #define DEBUG(Expression)
+#endif
+
+/**  
+  Macro that calls DebugAssert() if an EFI_STATUS evaluates to an error code.
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED 
+  bit of PcdDebugProperyMask is set, then this macro evaluates the EFI_STATUS 
+  value specified by StatusParameter.  If StatusParameter is an error code, 
+  then DebugAssert() is called passing in the source filename, source line 
+  number, and StatusParameter.
+
+  @param  StatusParameter  EFI_STATUS value to evaluate.
+
+**/
+#if !defined(MDEPKG_NDEBUG)
+  #define ASSERT_EFI_ERROR(StatusParameter)                                              \
+    do {                                                                                 \
+      if (DebugAssertEnabled ()) {                                                       \
+        if (EFI_ERROR (StatusParameter)) {                                               \
+          DEBUG ((EFI_D_ERROR, "\nASSERT_EFI_ERROR (Status = %r)\n", StatusParameter));  \
+          _ASSERT (!EFI_ERROR (StatusParameter));                                        \
+        }                                                                                \
+      }                                                                                  \
+    } while (FALSE)
+#else
+  #define ASSERT_EFI_ERROR(StatusParameter)
+#endif
+
+/**
+  Macro that calls DebugAssert() if a RETURN_STATUS evaluates to an error code.
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED
+  bit of PcdDebugProperyMask is set, then this macro evaluates the
+  RETURN_STATUS value specified by StatusParameter.  If StatusParameter is an
+  error code, then DebugAssert() is called passing in the source filename,
+  source line number, and StatusParameter.
+
+  @param  StatusParameter  RETURN_STATUS value to evaluate.
+
+**/
+#if !defined(MDEPKG_NDEBUG)
+  #define ASSERT_RETURN_ERROR(StatusParameter)                          \
+    do {                                                                \
+      if (DebugAssertEnabled ()) {                                      \
+        if (RETURN_ERROR (StatusParameter)) {                           \
+          DEBUG ((DEBUG_ERROR, "\nASSERT_RETURN_ERROR (Status = %r)\n", \
+            StatusParameter));                                          \
+          _ASSERT (!RETURN_ERROR (StatusParameter));                    \
+        }                                                               \
+      }                                                                 \
+    } while (FALSE)
+#else
+  #define ASSERT_RETURN_ERROR(StatusParameter)
+#endif
+
+/**  
+  Macro that calls DebugAssert() if a protocol is already installed in the 
+  handle database.
+
+  If MDEPKG_NDEBUG is defined or the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit 
+  of PcdDebugProperyMask is clear, then return.
+
+  If Handle is NULL, then a check is made to see if the protocol specified by Guid 
+  is present on any handle in the handle database.  If Handle is not NULL, then 
+  a check is made to see if the protocol specified by Guid is present on the 
+  handle specified by Handle.  If the check finds the protocol, then DebugAssert() 
+  is called passing in the source filename, source line number, and Guid.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Handle  The handle to check for the protocol.  This is an optional 
+                  parameter that may be NULL.  If it is NULL, then the entire 
+                  handle database is searched.
+
+  @param  Guid    The pointer to a protocol GUID.
+
+**/
+#if !defined(MDEPKG_NDEBUG)
+  #define ASSERT_PROTOCOL_ALREADY_INSTALLED(Handle, Guid)                               \
+    do {                                                                                \
+      if (DebugAssertEnabled ()) {                                                      \
+        VOID  *Instance;                                                                \
+        ASSERT (Guid != NULL);                                                          \
+        if (Handle == NULL) {                                                           \
+          if (!EFI_ERROR (gBS->LocateProtocol ((EFI_GUID *)Guid, NULL, &Instance))) {   \
+            _ASSERT (Guid already installed in database);                               \
+          }                                                                             \
+        } else {                                                                        \
+          if (!EFI_ERROR (gBS->HandleProtocol (Handle, (EFI_GUID *)Guid, &Instance))) { \
+            _ASSERT (Guid already installed on Handle);                                 \
+          }                                                                             \
+        }                                                                               \
+      }                                                                                 \
+    } while (FALSE)
+#else
+  #define ASSERT_PROTOCOL_ALREADY_INSTALLED(Handle, Guid)
+#endif
+
+/**
+  Macro that marks the beginning of debug source code.
+
+  If the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set, 
+  then this macro marks the beginning of source code that is included in a module.
+  Otherwise, the source lines between DEBUG_CODE_BEGIN() and DEBUG_CODE_END() 
+  are not included in a module.
+
+**/
+#define DEBUG_CODE_BEGIN()  do { if (DebugCodeEnabled ()) { UINT8  __DebugCodeLocal
+
+
+/**  
+  The macro that marks the end of debug source code.
+
+  If the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set, 
+  then this macro marks the end of source code that is included in a module.  
+  Otherwise, the source lines between DEBUG_CODE_BEGIN() and DEBUG_CODE_END() 
+  are not included in a module.
+
+**/
+#define DEBUG_CODE_END()    __DebugCodeLocal = 0; __DebugCodeLocal++; } } while (FALSE)
+
+
+/**  
+  The macro that declares a section of debug source code.
+
+  If the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set, 
+  then the source code specified by Expression is included in a module.  
+  Otherwise, the source specified by Expression is not included in a module.
+
+**/
+#define DEBUG_CODE(Expression)  \
+  DEBUG_CODE_BEGIN ();          \
+  Expression                    \
+  DEBUG_CODE_END ()
+
+
+/**  
+  The macro that calls DebugClearMemory() to clear a buffer to a default value.
+
+  If the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set, 
+  then this macro calls DebugClearMemory() passing in Address and Length.
+
+  @param  Address  The pointer to a buffer.
+  @param  Length   The number of bytes in the buffer to set.
+
+**/
+#define DEBUG_CLEAR_MEMORY(Address, Length)  \
+  do {                                       \
+    if (DebugClearMemoryEnabled ()) {        \
+      DebugClearMemory (Address, Length);    \
+    }                                        \
+  } while (FALSE)
+
+
+/**
+  Macro that calls DebugAssert() if the containing record does not have a 
+  matching signature.  If the signatures matches, then a pointer to the data 
+  structure that contains a specified field of that data structure is returned.  
+  This is a lightweight method hide information by placing a public data 
+  structure inside a larger private data structure and using a pointer to the 
+  public data structure to retrieve a pointer to the private data structure.
+
+  If MDEPKG_NDEBUG is defined or the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit 
+  of PcdDebugProperyMask is clear, then this macro computes the offset, in bytes,
+  of the field specified by Field from the beginning of the data structure specified 
+  by TYPE.  This offset is subtracted from Record, and is used to return a pointer 
+  to a data structure of the type specified by TYPE.
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit
+  of PcdDebugProperyMask is set, then this macro computes the offset, in bytes, 
+  of field specified by Field from the beginning of the data structure specified 
+  by TYPE.  This offset is subtracted from Record, and is used to compute a pointer
+  to a data structure of the type specified by TYPE.  The Signature field of the 
+  data structure specified by TYPE is compared to TestSignature.  If the signatures 
+  match, then a pointer to the pointer to a data structure of the type specified by 
+  TYPE is returned.  If the signatures do not match, then DebugAssert() is called 
+  with a description of "CR has a bad signature" and Record is returned.  
+
+  If the data type specified by TYPE does not contain the field specified by Field, 
+  then the module will not compile.
+
+  If TYPE does not contain a field called Signature, then the module will not 
+  compile.
+
+  @param  Record         The pointer to the field specified by Field within a data 
+                         structure of type TYPE.
+
+  @param  TYPE           The name of the data structure type to return  This 
+                         data structure must contain the field specified by Field. 
+
+  @param  Field          The name of the field in the data structure specified 
+                         by TYPE to which Record points.
+
+  @param  TestSignature  The 32-bit signature value to match.
+
+**/
+#if !defined(MDEPKG_NDEBUG)
+  #define CR(Record, TYPE, Field, TestSignature)                                              \
+    (DebugAssertEnabled () && (BASE_CR (Record, TYPE, Field)->Signature != TestSignature)) ?  \
+    (TYPE *) (_ASSERT (CR has Bad Signature), Record) :                                       \
+    BASE_CR (Record, TYPE, Field)
+#else
+  #define CR(Record, TYPE, Field, TestSignature)                                              \
+    BASE_CR (Record, TYPE, Field)
+#endif
+    
+#endif
diff --git a/MdePkg/Include/Library/DebugPrintErrorLevelLib.h b/MdePkg/Include/Library/DebugPrintErrorLevelLib.h
new file mode 100644
index 000000000000..496f07b54d17
--- /dev/null
+++ b/MdePkg/Include/Library/DebugPrintErrorLevelLib.h
@@ -0,0 +1,43 @@
+/** @file
+  Debug Print Error Level Library class
+
+  Copyright (c) 2011, 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 _DEBUG_PRINT_ERROR_LEVEL_LIB_H_
+#define _DEBUG_PRINT_ERROR_LEVEL_LIB_H_
+
+/**
+  Returns the debug print error level mask for the current module.
+
+  @return  Debug print error level mask for the current module.
+
+**/
+UINT32
+EFIAPI
+GetDebugPrintErrorLevel (
+  VOID
+  );
+
+/**
+  Sets the global debug print error level mask fpr the entire platform.
+  
+  @param   ErrorLevel     Global debug print error level
+  
+  @retval  TRUE           The debug print error level mask was successfully set.
+  @retval  FALSE          The debug print error level mask could not be set.
+
+**/
+BOOLEAN
+EFIAPI
+SetDebugPrintErrorLevel (
+  UINT32  ErrorLevel
+  );
+#endif
diff --git a/MdePkg/Include/Library/DevicePathLib.h b/MdePkg/Include/Library/DevicePathLib.h
new file mode 100644
index 000000000000..61fa19ce690d
--- /dev/null
+++ b/MdePkg/Include/Library/DevicePathLib.h
@@ -0,0 +1,566 @@
+/** @file
+  Provides library functions to construct and parse UEFI Device Paths.
+
+  This library provides defines, macros, and functions to help create and parse 
+  EFI_DEVICE_PATH_PROTOCOL structures.
+
+Copyright (c) 2006 - 2013, 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 __DEVICE_PATH_LIB_H__
+#define __DEVICE_PATH_LIB_H__
+
+#define END_DEVICE_PATH_LENGTH               (sizeof (EFI_DEVICE_PATH_PROTOCOL))
+
+/**
+  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
+EFIAPI
+IsDevicePathValid (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN       UINTN                    MaxSize
+  );
+
+/**
+  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
+EFIAPI
+DevicePathType (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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
+EFIAPI
+DevicePathSubType (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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
+EFIAPI
+DevicePathNodeLength (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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 *
+EFIAPI
+NextDevicePathNode (
+  IN CONST VOID  *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
+EFIAPI
+IsDevicePathEndType (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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
+EFIAPI
+IsDevicePathEnd (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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
+EFIAPI
+IsDevicePathEndInstance (
+  IN CONST VOID  *Node
+  );
+
+/**
+  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 >= 0x10000, 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
+EFIAPI
+SetDevicePathNodeLength (
+  IN OUT VOID  *Node,
+  IN UINTN     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
+EFIAPI
+SetDevicePathEndNode (
+  OUT VOID  *Node
+  );
+
+/**
+  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
+EFIAPI
+GetDevicePathSize (
+  IN 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 *
+EFIAPI
+DuplicateDevicePath (
+  IN 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 *
+EFIAPI
+AppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN 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      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 *
+EFIAPI
+AppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN 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 secified 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 *
+EFIAPI
+AppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN 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 *
+EFIAPI
+GetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT 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 *
+EFIAPI
+CreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN 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
+EFIAPI
+IsDevicePathMultiInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  );
+
+/**
+  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 *
+EFIAPI
+DevicePathFromHandle (
+  IN EFI_HANDLE                      Handle
+  );
+
+/**
+  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 *
+EFIAPI
+FileDevicePath (
+  IN EFI_HANDLE                      Device,     OPTIONAL
+  IN CONST CHAR16                    *FileName
+  );
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  );
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  );
+
+/**
+  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 *
+EFIAPI
+ConvertTextToDeviceNode (
+  IN 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 *
+EFIAPI
+ConvertTextToDevicePath (
+  IN CONST CHAR16 *TextDevicePath
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/DxeCoreEntryPoint.h b/MdePkg/Include/Library/DxeCoreEntryPoint.h
new file mode 100644
index 000000000000..b0de4ee9ff3e
--- /dev/null
+++ b/MdePkg/Include/Library/DxeCoreEntryPoint.h
@@ -0,0 +1,99 @@
+/** @file
+  Module entry point library for DXE core.
+
+Copyright (c) 2006 - 2008, 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 __MODULE_ENTRY_POINT_H__
+#define __MODULE_ENTRY_POINT_H__
+
+///
+/// Global variable that contains a pointer to the Hob List passed into the DXE Core entry point. 
+/// 
+extern VOID  *gHobList;
+
+
+/**
+  The entry point of PE/COFF Image for the DXE Core. 
+
+  This function is the entry point for the DXE Core. This function is required to call
+  ProcessModuleEntryPointList() and ProcessModuleEntryPointList() is never expected to return.
+  The DXE Core is responsible for calling ProcessLibraryConstructorList() as soon as the EFI
+  System Table and the image handle for the DXE Core itself have been established.
+  If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system.
+
+  @param  HobStart  Pointer to the beginning of the HOB List passed in from the PEI Phase. 
+
+**/
+VOID
+EFIAPI
+_ModuleEntryPoint (
+  IN VOID  *HobStart
+  );
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+
+  This function is required to call _ModuleEntryPoint() passing in HobStart.
+
+  @param  HobStart  Pointer to the beginning of the HOB List passed in from the PEI Phase. 
+
+**/
+VOID
+EFIAPI
+EfiMain (
+  IN VOID  *HobStart
+  );
+
+
+/**
+  Autogenerated function that calls the library constructors for all of the module's dependent libraries.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of library constructors for the set of library instances
+  that a module depends on.  This includes library instances that a module depends on
+  directly and library instances that a module depends on indirectly through other
+  libraries. This function is autogenerated by build tools and those build tools are
+  responsible for collecting the set of library instances, determine which ones have
+  constructors, and calling the library constructors in the proper order based upon
+  each of the library instances own dependencies.
+
+  @param  ImageHandle  The image handle of the DXE Core.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryConstructorList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Autogenerated function that calls a set of module entry points.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of module entry points.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the module entry points and calling them in a specified order.
+
+  @param  HobStart  Pointer to the beginning of the HOB List passed in from the PEI Phase. 
+ 
+**/
+VOID
+EFIAPI
+ProcessModuleEntryPointList (
+  IN VOID  *HobStart
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/DxeServicesLib.h b/MdePkg/Include/Library/DxeServicesLib.h
new file mode 100644
index 000000000000..48cb70339850
--- /dev/null
+++ b/MdePkg/Include/Library/DxeServicesLib.h
@@ -0,0 +1,309 @@
+/** @file
+  MDE DXE Services Library provides functions that simplify the development of DXE Drivers.  
+  These functions help access data from sections of FFS files or from file path.
+
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+(C) Copyright 2015 Hewlett Packard Enterprise Development LP<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 __DXE_SERVICES_LIB_H__
+#define __DXE_SERVICES_LIB_H__
+
+/**
+  Searches all the available firmware volumes and returns the first matching FFS section. 
+
+  This function searches all the firmware volumes for FFS files with FV file type specified by FileType
+  The order that the firmware volumes is searched is not deterministic. For each available FV a search 
+  is made for FFS file of type FileType. If the FV contains more than one FFS file with the same FileType, 
+  the FileInstance instance will be the matched FFS file. For each FFS file found a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances 
+  of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. 
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer.  
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections 
+  are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+  @param  FileType             Indicates the FV file type to search for within all available FVs.
+  @param  FileInstance         Indicates which file instance within all available FVs specified by FileType.
+                               FileInstance starts from zero.
+  @param  SectionType          Indicates the FFS section type to search for within the FFS file 
+                               specified by FileType with FileInstance.
+  @param  SectionInstance      Indicates which section instance within the FFS file 
+                               specified by FileType with FileInstance to retrieve. SectionInstance starts from zero.
+  @param  Buffer               On output, a pointer to a callee allocated buffer containing the FFS file section that was found.
+                               Is it the caller's responsibility to free this buffer using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the firmware volume that 
+                                contains the matching FFS section does not allow reads.
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromAnyFvByFileType  (
+  IN  EFI_FV_FILETYPE               FileType,
+  IN  UINTN                         FileInstance,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  );
+
+/**
+  Searches all the available firmware volumes and returns the first matching FFS section. 
+
+  This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid.  
+  The order in which the firmware volumes are searched is not deterministic. For each FFS file found, a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances 
+  of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. 
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer.  
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections 
+  are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If NameGuid is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+
+  @param  NameGuid             A pointer to to the FFS filename GUID to search for  
+                               within any of the firmware volumes in the platform. 
+  @param  SectionType          Indicates the FFS section type to search for within 
+                               the FFS file specified by NameGuid.
+  @param  SectionInstance      Indicates which section instance within the FFS file 
+                               specified by NameGuid to retrieve.
+  @param  Buffer               On output, a pointer to a callee-allocated buffer 
+                               containing the FFS file section that was found.  
+                               It is the caller's responsibility to free this 
+                               buffer using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that contains the matching FFS 
+                                section does not allow reads.
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromAnyFv  (
+  IN  CONST EFI_GUID                *NameGuid,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  );
+
+/**
+  Searches the firmware volume that the currently executing module was loaded from and returns the first matching FFS section. 
+
+  This function searches the firmware volume that the currently executing module was loaded 
+  from for an FFS file with an FFS filename specified by NameGuid. If the FFS file is found, a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance 
+  instances of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer.
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer. 
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections are retrieved from 
+  an FFS file based on SectionType and SectionInstance.
+
+  If the currently executing module was not loaded from a firmware volume, then EFI_NOT_FOUND is returned.
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  
+  This function must be called with a TPL <= TPL_NOTIFY.
+  If NameGuid is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+  @param  NameGuid             A pointer to to the FFS filename GUID to search for  
+                               within the firmware volumes that the currently 
+                               executing module was loaded from.
+  @param  SectionType          Indicates the FFS section type to search for within 
+                               the FFS file specified by NameGuid.
+  @param  SectionInstance      Indicates which section instance within the FFS 
+                               file specified by NameGuid to retrieve.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.  
+                               It is the caller's responsibility to free this buffer 
+                               using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that contains the matching FFS 
+                                section does not allow reads.  
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromFv (
+  IN  CONST EFI_GUID                *NameGuid,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  );
+
+
+/**
+  Searches the FFS file the the currently executing module was loaded from and returns the first matching FFS section.
+
+  This function searches the FFS file that the currently executing module was loaded from for a FFS sections of type SectionType.
+  If the FFS file contains at least SectionInstance instances of the FFS section specified by SectionType, 
+  then the SectionInstance instance is returned in Buffer. Buffer is allocated using AllocatePool(), 
+  and the size of the allocated buffer is returned in Size. It is the caller's responsibility 
+  to use FreePool() to free the allocated buffer. See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for 
+  details on how sections are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If the currently executing module was not loaded from an FFS file, then EFI_NOT_FOUND is returned.
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+  
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+
+  @param  SectionType          Indicates the FFS section type to search for within  
+                               the FFS file that the currently executing module 
+                               was loaded from.
+  @param  SectionInstance      Indicates which section instance to retrieve within 
+                               the FFS file that the currently executing module 
+                               was loaded from.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.  
+                               It is the caller's responsibility to free this buffer 
+                               using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that contains the matching FFS 
+                                section does not allow reads.  
+  
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromFfs (
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  );
+
+
+/**
+  Get the image file buffer data and buffer size by its device path. 
+  
+  Access the file either from a firmware volume, from a file system interface, 
+  or from the load file interface.
+  
+  Allocate memory to store the found image. The caller is responsible to free memory.
+
+  If FilePath is NULL, then NULL is returned.
+  If FileSize is NULL, then NULL is returned.
+  If AuthenticationStatus is NULL, then NULL is returned.
+
+  @param[in]       BootPolicy           The policy for Open Image File.If TRUE, 
+                                        indicates that the request originates from 
+                                        the boot manager, and that the boot manager is
+                                        attempting to load FilePath as a boot selection. 
+                                        If FALSE, then FilePath must match an exact 
+                                        file to be loaded.
+  @param[in]       FilePath             Pointer to the device path of the file that is abstracted to
+                                        the file buffer.
+  @param[out]      FileSize             Pointer to the size of the abstracted file buffer.
+  @param[out]      AuthenticationStatus Pointer to the authentication status.
+
+  @retval NULL   FilePath is NULL, or FileSize is NULL, or AuthenticationStatus is NULL, or the file can't be found.
+  @retval other  The abstracted file buffer. The caller is responsible to free memory.
+**/
+VOID *
+EFIAPI
+GetFileBufferByFilePath (
+  IN BOOLEAN                           BootPolicy,
+  IN CONST EFI_DEVICE_PATH_PROTOCOL    *FilePath,
+  OUT      UINTN                       *FileSize,
+  OUT UINT32                           *AuthenticationStatus
+  );
+
+/**
+  Searches all the available firmware volumes and returns the file device path of first matching
+  FFS section.
+
+  This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid.
+  The order that the firmware volumes is searched is not deterministic. For each FFS file found a search
+  is made for FFS sections of type SectionType.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails,
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If NameGuid is NULL, then ASSERT().
+
+   @param  NameGuid             A pointer to to the FFS filename GUID to search for
+                                within any of the firmware volumes in the platform.
+   @param  SectionType          Indicates the FFS section type to search for within
+                                the FFS file specified by NameGuid.
+   @param  SectionInstance      Indicates which section instance within the FFS file
+                                specified by NameGuid to retrieve.
+   @param  FvFileDevicePath     Device path for the target FFS
+                                file.
+
+   @retval  EFI_SUCCESS           The specified file device path of FFS section was returned.
+   @retval  EFI_NOT_FOUND         The specified file device path of FFS section could not be found.
+   @retval  EFI_DEVICE_ERROR      The FFS section could not be retrieves due to a
+                                  device error.
+   @retval  EFI_ACCESS_DENIED     The FFS section could not be retrieves because the
+                                  firmware volume that contains the matching FFS section does not
+                                  allow reads.
+   @retval  EFI_INVALID_PARAMETER FvFileDevicePath is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+GetFileDevicePathFromAnyFv (
+  IN CONST  EFI_GUID                  *NameGuid,
+  IN        EFI_SECTION_TYPE          SectionType,
+  IN        UINTN                     SectionInstance,
+  OUT       EFI_DEVICE_PATH_PROTOCOL  **FvFileDevicePath
+  );
+
+#endif
+
diff --git a/MdePkg/Include/Library/DxeServicesTableLib.h b/MdePkg/Include/Library/DxeServicesTableLib.h
new file mode 100644
index 000000000000..0038715530fb
--- /dev/null
+++ b/MdePkg/Include/Library/DxeServicesTableLib.h
@@ -0,0 +1,34 @@
+/** @file
+  Provides a service to retrieve a pointer to the DXE Services Table.
+  Only available to DXE module types.
+  
+  This library does not contain any functions or macros.  It simply exports a global 
+  pointer to the DXE Services Table as defined in the Platform Initialization Driver 
+  Execution Environment Core Interface Specification.  The library constructor must 
+  initialize this global pointer to the DX Services Table, so it is available at the
+  module's entry point.  Since there is overhead in looking up the pointer to the DXE 
+  Services Table, only those modules that actually require access to the DXE Services 
+  Table should use this library.  This will typically be DXE Drivers that require GCD 
+  or Dispatcher services.
+   
+Copyright (c) 2006 - 2008, 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 __DXE_SERVICES_TABLE_LIB_H__
+#define __DXE_SERVICES_TABLE_LIB_H__
+
+///
+/// Cache copy of the DXE Services Table
+///
+extern EFI_DXE_SERVICES  *gDS;
+
+#endif
+
diff --git a/MdePkg/Include/Library/ExtendedSalLib.h b/MdePkg/Include/Library/ExtendedSalLib.h
new file mode 100644
index 000000000000..710675ff8eeb
--- /dev/null
+++ b/MdePkg/Include/Library/ExtendedSalLib.h
@@ -0,0 +1,494 @@
+/** @file
+  Library class definition of Extended SAL Library.
+
+Copyright (c) 2007 - 2011, 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 _EXTENDED_SAL_LIB_H__
+#define _EXTENDED_SAL_LIB_H__
+
+#include <IndustryStandard/Sal.h>
+
+/**
+  Register ESAL Class and its associated global.
+  
+  This function Registers one or more Extended SAL services in a given
+  class along with the associated global context.
+  This function is only available prior to ExitBootServices().
+
+  @param  ClassGuidLo          GUID of function class, lower 64-bits
+  @param  ClassGuidHi          GUID of function class, upper 64-bits
+  @param  ModuleGlobal         Module global for Function.
+  @param  ...                  List of Function/FunctionId pairs, ended by NULL
+
+  @retval EFI_SUCCESS          The Extended SAL services were registered.
+  @retval EFI_UNSUPPORTED      This function was called after ExitBootServices().
+  @retval EFI_OUT_OF_RESOURCES There are not enough resources available to register one or more of the specified services.
+  @retval Other                ClassGuid could not be installed onto a new handle.  
+
+**/
+EFI_STATUS
+EFIAPI
+RegisterEsalClass (
+  IN  CONST UINT64    ClassGuidLo,
+  IN  CONST UINT64    ClassGuidHi,
+  IN  VOID            *ModuleGlobal,  OPTIONAL
+  ...
+  );
+
+/**
+  Calls an Extended SAL Class service that was previously registered with RegisterEsalClass().
+  
+  This function calls an Extended SAL Class service that was previously registered with RegisterEsalClass().
+
+  @param  ClassGuidLo    GUID of function, lower 64-bits
+  @param  ClassGuidHi    GUID of function, upper 64-bits
+  @param  FunctionId     Function in ClassGuid to call
+  @param  Arg2           Argument 2 ClassGuid/FunctionId defined
+  @param  Arg3           Argument 3 ClassGuid/FunctionId defined
+  @param  Arg4           Argument 4 ClassGuid/FunctionId defined
+  @param  Arg5           Argument 5 ClassGuid/FunctionId defined
+  @param  Arg6           Argument 6 ClassGuid/FunctionId defined
+  @param  Arg7           Argument 7 ClassGuid/FunctionId defined
+  @param  Arg8           Argument 8 ClassGuid/FunctionId defined
+  
+  @retval EFI_SAL_ERROR  The address of ExtendedSalProc() can not be determined
+                         for the current CPU execution mode.
+  @retval Other          See the return status from ExtendedSalProc() in the
+                         EXTENDED_SAL_BOOT_SERVICE_PROTOCOL.  
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalCall (
+  IN UINT64  ClassGuidLo,
+  IN UINT64  ClassGuidHi,
+  IN UINT64  FunctionId,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  );
+
+/**
+  Wrapper for the EsalStallFunctionId service of Extended SAL Stall Services Class.
+  
+  This function is a wrapper for the EsalStallFunctionId service of Extended SAL
+  Stall Services Class. See EsalStallFunctionId of Extended SAL Specification.
+
+  @param  Microseconds                  The number of microseconds to delay.
+
+  @retval EFI_SAL_SUCCESS               Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT      Invalid argument.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR Virtual address not registered
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalStall (
+  IN UINTN  Microseconds
+  );
+
+/**
+  Wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalSetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress                If TRUE, then PalEntryPoint is a physical address.
+                                         If FALSE, then PalEntryPoint is a virtual address.
+  @param  PalEntryPoint                  The PAL Entry Point being set.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was set.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress,
+  IN UINT64   PalEntryPoint
+  );
+
+/**
+  Wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalGetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress                If TRUE, then PalEntryPoint is a physical address.
+                                         If FALSE, then PalEntryPoint is a virtual address.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was retrieved and returned in
+                                         SAL_RETURN_REGS.r9.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+  @return r9                             PAL entry point retrieved.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress
+  );
+
+/**
+  Wrapper for the EsalGetStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalGetStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalGetStateBufferFunctionId of Extended SAL Specification.
+
+  @param  McaType               See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+  @param  McaBuffer             A pointer to the base address of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r9.
+  @param  BufferSize            A pointer to the size, in bytes, of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r10.
+
+  @retval EFI_SAL_SUCCESS       The memory buffer to store error records was returned in r9 and r10.
+  @retval EFI_OUT_OF_RESOURCES  A memory buffer for string error records in not available
+  @return r9                    Base address of the returned buffer
+  @return r10                   Size of the returned buffer in bytes
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetStateBuffer (
+  IN  UINT64  McaType,
+  OUT UINT8   **McaBuffer,
+  OUT UINTN   *BufferSize
+  );
+
+/**
+  Wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalSaveStateBufferFunctionId of Extended SAL Specification.
+
+  @param  McaType      See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+
+  @retval EFI_SUCCESS  The memory buffer containing the error record was written to nonvolatile storage.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSaveStateBuffer (
+  IN  UINT64  McaType
+  );
+
+/**
+  Wrapper for the EsalGetVectorsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetVectorsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetVectorsFunctionId of Extended SAL Specification.
+
+  @param  VectorType               The vector type to retrieve.
+                                   0 - MCA, 1 - BSP INIT, 2 - BOOT_RENDEZ, 3 - AP INIT.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_SET_VECTORS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetVectors (
+  IN  UINT64  VectorType
+  );
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+
+  @param  ParamInfoType            The parameter type to retrieve.
+                                   1 - rendezvous interrupt
+                                   2 - wake up
+                                   3 - Corrected Platform Error Vector.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetParams (
+  IN  UINT64  ParamInfoType
+  );
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetMcParams (
+  VOID
+  );
+
+/**
+  Wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetMcCheckinFlagsFunctionId of Extended SAL Specification.
+
+  @param  CpuIndex         The index of the CPU of set of enabled CPUs to check.
+
+  @retval EFI_SAL_SUCCESS  The checkin status of the requested CPU was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMcCheckinFlags (
+  IN  UINT64  CpuIndex
+  );
+
+/**
+  Wrapper for the EsalAddCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalAddCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalAddCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId                 The Global ID for the CPU being added.
+  @param  Enabled                     The enable flag for the CPU being added.
+                                      TRUE means the CPU is enabled.
+                                      FALSE means the CPU is disabled.
+  @param  PalCompatibility            The PAL Compatibility value for the CPU being added.
+
+  @retval EFI_SAL_SUCCESS             The CPU was added to the database.
+  @retval EFI_SAL_NOT_ENOUGH_SCRATCH  There are not enough resource available to add the CPU.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalAddCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  );
+
+/**
+  Wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalRemoveCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being removed.
+
+  @retval EFI_SAL_SUCCESS         The CPU was removed from the database.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalRemoveCpuData (
+  IN UINT64  CpuGlobalId
+  );
+
+/**
+  Wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalModifyCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being modified.
+  @param  Enabled                 The enable flag for the CPU being modified.
+                                  TRUE means the CPU is enabled.
+                                  FALSE means the CPU is disabled.
+  @param  PalCompatibility        The PAL Compatibility value for the CPU being modified.
+
+  @retval EFI_SAL_SUCCESS         The CPU database was updated.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalModifyCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  );
+
+/**
+  Wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIdFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being looked up.
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataById (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  IndexByEnabledCpu
+  );
+
+/**
+  Wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIndexFunctionId of Extended SAL Specification.
+
+  @param  Index                   The Global ID for the CPU being modified.
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataByIndex (
+  IN UINT64   Index,
+  IN BOOLEAN  IndexByEnabledCpu
+  );
+
+/**
+  Wrapper for the EsalWhoAmIFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalWhoAmIFunctionId service of Extended SAL
+  MP Services Class. See EsalWhoAmIFunctionId of Extended SAL Specification.
+
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The Global ID for the calling CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The calling CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalWhoAmI (
+  IN BOOLEAN  IndexByEnabledCpu
+  );
+
+/**
+  Wrapper for the EsalNumProcessors service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalNumProcessors service of Extended SAL
+  MP Services Class. See EsalNumProcessors of Extended SAL Specification.
+
+  @retval EFI_SAL_SUCCESS    The information on the number of CPUs in the platform
+                             was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalNumProcessors (
+  VOID
+  );
+
+/**
+  Wrapper for the EsalSetMinStateFnctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalSetMinStateFnctionId service of Extended SAL
+  MP Services Class. See EsalSetMinStateFnctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId              The Global ID for the CPU whose MINSTATE pointer is being set.
+  @param  MinStatePointer          The physical address of the MINSTATE buffer for the CPU
+                                   specified by CpuGlobalId.
+
+  @retval EFI_SAL_SUCCESS          The MINSTATE pointer was set for the specified CPU.
+  @retval EFI_SAL_NO_INFORMATION   The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetMinState (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  MinStatePointer
+  );
+
+/**
+  Wrapper for the EsalGetMinStateFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetMinStateFunctionId service of Extended SAL
+  MP Services Class. See EsalGetMinStateFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId            The Global ID for the CPU whose MINSTATE pointer is being retrieved.
+
+  @retval EFI_SAL_SUCCESS        The MINSTATE pointer for the specified CPU was retrieved.
+  @retval EFI_SAL_NO_INFORMATION The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMinState (
+  IN UINT64  CpuGlobalId
+  );
+
+/**
+  Wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcsGetStateInfoFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId               The Global ID for the CPU whose MCA state buffer is being retrieved.
+  @param  StateBufferPointer        A pointer to the returned MCA state buffer.
+  @param  RequiredStateBufferSize   A pointer to the size, in bytes, of the returned MCA state buffer.
+
+  @retval EFI_SUCCESS               MINSTATE successfully got and size calculated.
+  @retval EFI_SAL_NO_INFORMATION    Fail to get MINSTATE.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaGetStateInfo (
+  IN  UINT64                CpuGlobalId,
+  OUT EFI_PHYSICAL_ADDRESS  *StateBufferPointer,
+  OUT UINT64                *RequiredStateBufferSize
+  );
+
+/**
+  Wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcaRegisterCpuFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId              The Global ID for the CPU whose MCA state buffer is being set.
+  @param  StateBufferPointer       A pointer to the MCA state buffer.
+
+  @retval EFI_SAL_NO_INFORMATION   Cannot get the processor info with the CpuId
+  @retval EFI_SUCCESS              Save the processor's state info successfully
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaRegisterCpu (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  StateBufferPointer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/ExtractGuidedSectionLib.h b/MdePkg/Include/Library/ExtractGuidedSectionLib.h
new file mode 100644
index 000000000000..73dfed2e292f
--- /dev/null
+++ b/MdePkg/Include/Library/ExtractGuidedSectionLib.h
@@ -0,0 +1,284 @@
+/** @file
+  This library provides common functions to process the different guided section data. 
+  
+  This library provides functions to process GUIDed sections of FFS files.  Handlers may 
+  be registered to decode GUIDed sections of FFS files.  Services are provided to determine 
+  the set of supported section GUIDs, collection information about a specific GUIDed section, 
+  and decode a specific GUIDed section. 
+  
+  A library instance that produces this library class may be used to produce a 
+  EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI or a EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL 
+  providing a simple method to extend the number of GUIDed sections types a platform supports.
+
+Copyright (c) 2006 - 2010, 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 __EXTRACT_GUIDED_SECTION_H__
+#define __EXTRACT_GUIDED_SECTION_H__
+
+/**
+  Examines a GUIDed section and returns the size of the decoded buffer and the
+  size of an optional scratch buffer required to actually decode the data in a GUIDed section.
+
+  Examines a GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match the GUID that this handler supports,
+  then RETURN_UNSUPPORTED is returned.  
+  If the required information can not be retrieved from InputSection,
+  then RETURN_INVALID_PARAMETER is returned.
+  If the GUID of InputSection does match the GUID that this handler supports,
+  then the size required to hold the decoded buffer is returned in OututBufferSize,
+  the size of an optional scratch buffer is returned in ScratchSize, and the Attributes field
+  from EFI_GUID_DEFINED_SECTION header of InputSection is returned in SectionAttribute.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBufferSize is NULL, then ASSERT().
+  If ScratchBufferSize is NULL, then ASSERT().
+  If SectionAttribute is NULL, then ASSERT().
+
+
+  @param[in]  InputSection       A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBufferSize   A pointer to the size, in bytes, of an output buffer required
+                                 if the buffer specified by InputSection were decoded.
+  @param[out] ScratchBufferSize  A pointer to the size, in bytes, required as scratch space
+                                 if the buffer specified by InputSection were decoded.
+  @param[out] SectionAttribute   A pointer to the attributes of the GUIDed section. See the Attributes
+                                 field of EFI_GUID_DEFINED_SECTION in the PI Specification.
+
+  @retval  RETURN_SUCCESS            The information about InputSection was returned.
+  @retval  RETURN_UNSUPPORTED        The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER  The information can not be retrieved from the section specified by InputSection.
+
+**/
+typedef
+RETURN_STATUS
+(EFIAPI *EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER)(
+  IN CONST  VOID    *InputSection,
+  OUT       UINT32  *OutputBufferSize,
+  OUT       UINT32  *ScratchBufferSize,
+  OUT       UINT16  *SectionAttribute
+  );
+
+/**
+  Decodes a GUIDed section into a caller allocated output buffer.
+  
+  Decodes the GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match the GUID that this handler supports, then RETURN_UNSUPPORTED is returned.  
+  If the data in InputSection can not be decoded, then RETURN_INVALID_PARAMETER is returned.
+  If the GUID of InputSection does match the GUID that this handler supports, then InputSection
+  is decoded into the buffer specified by OutputBuffer and the authentication status of this
+  decode operation is returned in AuthenticationStatus.  If the decoded buffer is identical to the
+  data in InputSection, then OutputBuffer is set to point at the data in InputSection.  Otherwise,
+  the decoded data will be placed in caller allocated buffer specified by OutputBuffer.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBuffer is NULL, then ASSERT().
+  If ScratchBuffer is NULL and this decode operation requires a scratch buffer, then ASSERT().
+  If AuthenticationStatus is NULL, then ASSERT().
+
+
+  @param[in]  InputSection  A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBuffer  A pointer to a buffer that contains the result of a decode operation. 
+  @param[out] ScratchBuffer A caller allocated buffer that may be required by this function
+                            as a scratch buffer to perform the decode operation. 
+  @param[out] AuthenticationStatus 
+                            A pointer to the authentication status of the decoded output buffer.
+                            See the definition of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
+                            section of the PI Specification. EFI_AUTH_STATUS_PLATFORM_OVERRIDE must
+                            never be set by this handler.
+
+  @retval  RETURN_SUCCESS            The buffer specified by InputSection was decoded.
+  @retval  RETURN_UNSUPPORTED        The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER  The section specified by InputSection can not be decoded.
+
+**/
+typedef
+RETURN_STATUS
+(EFIAPI *EXTRACT_GUIDED_SECTION_DECODE_HANDLER)(
+  IN CONST  VOID    *InputSection,
+  OUT       VOID    **OutputBuffer,
+  IN        VOID    *ScratchBuffer,        OPTIONAL
+  OUT       UINT32  *AuthenticationStatus
+  );
+
+/**
+  Registers handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and EXTRACT_GUIDED_SECTION_DECODE_HANDLER
+  for a specific GUID section type.
+
+  Registers the handlers specified by GetInfoHandler and DecodeHandler with the GUID specified by SectionGuid.
+  If the GUID value specified by SectionGuid has already been registered, then return RETURN_ALREADY_STARTED.
+  If there are not enough resources available to register the handlers  then RETURN_OUT_OF_RESOURCES is returned.
+  
+  If SectionGuid is NULL, then ASSERT().
+  If GetInfoHandler is NULL, then ASSERT().
+  If DecodeHandler is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the the handlers
+                             of the GUIDed section type being registered.
+  @param[in]  GetInfoHandler Pointer to a function that examines a GUIDed section and returns the
+                             size of the decoded buffer and the size of an optional scratch buffer
+                             required to actually decode the data in a GUIDed section.
+  @param[in]  DecodeHandler  Pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. 
+
+  @retval  RETURN_SUCCESS           The handlers were registered.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to register the handlers.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionRegisterHandlers (
+  IN CONST  GUID                                     *SectionGuid,
+  IN        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  GetInfoHandler,
+  IN        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    DecodeHandler
+  );
+
+/**
+  Retrieve the list GUIDs that have been registered through ExtractGuidedSectionRegisterHandlers().
+
+  Sets ExtractHandlerGuidTable so it points at a callee allocated array of registered GUIDs.
+  The total number of GUIDs in the array are returned. Since the array of GUIDs is callee allocated
+  and caller must treat this array of GUIDs as read-only data. 
+  If ExtractHandlerGuidTable is NULL, then ASSERT().
+
+  @param[out]  ExtractHandlerGuidTable  A pointer to the array of GUIDs that have been registered through
+                                        ExtractGuidedSectionRegisterHandlers().
+
+  @return the number of the supported extract guided Handler.
+
+**/
+UINTN
+EFIAPI
+ExtractGuidedSectionGetGuidList (
+  OUT  GUID  **ExtractHandlerGuidTable
+  );
+
+/**
+  Retrieves a GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to retrieve and return the size of the decoded buffer and the size of an
+  optional scratch buffer required to actually decode the data in a GUIDed section.
+
+  Examines a GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler 
+  of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to retrieve the OututBufferSize, ScratchSize, and Attributes values. The return status from the handler of
+  type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER is returned.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBufferSize is NULL, then ASSERT().
+  If ScratchBufferSize is NULL, then ASSERT().
+  If SectionAttribute is NULL, then ASSERT().
+
+  @param[in]  InputSection       A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBufferSize   A pointer to the size, in bytes, of an output buffer required if the buffer
+                                 specified by InputSection were decoded.
+  @param[out] ScratchBufferSize  A pointer to the size, in bytes, required as scratch space if the buffer specified by
+                                 InputSection were decoded.
+  @param[out] SectionAttribute   A pointer to the attributes of the GUIDed section.  See the Attributes field of
+                                 EFI_GUID_DEFINED_SECTION in the PI Specification.
+
+  @retval  RETURN_SUCCESS      Get the required information successfully.
+  @retval  RETURN_UNSUPPORTED  The GUID from the section specified by InputSection does not match any of
+                               the GUIDs registered with ExtractGuidedSectionRegisterHandlers().
+  @retval  Others              The return status from the handler associated with the GUID retrieved from
+                               the section specified by InputSection.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetInfo (
+  IN  CONST VOID    *InputSection,
+  OUT       UINT32  *OutputBufferSize,
+  OUT       UINT32  *ScratchBufferSize,
+  OUT       UINT16  *SectionAttribute   
+  );
+
+/**
+  Retrieves the GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to decode the data in a GUIDed section and return the result in a caller
+  allocated output buffer.
+
+  Decodes the GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler
+  of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to decode InputSection into the buffer specified by OutputBuffer and the authentication status of this
+  decode operation is returned in AuthenticationStatus.  If the decoded buffer is identical to the data in InputSection,
+  then OutputBuffer is set to point at the data in InputSection.  Otherwise, the decoded data will be placed in caller
+  allocated buffer specified by OutputBuffer.    This function is responsible for computing the  EFI_AUTH_STATUS_PLATFORM_OVERRIDE
+  bit of in AuthenticationStatus.  The return status from the handler of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER is returned. 
+   
+  If InputSection is NULL, then ASSERT().
+  If OutputBuffer is NULL, then ASSERT().
+  If ScratchBuffer is NULL and this decode operation requires a scratch buffer, then ASSERT().
+  If AuthenticationStatus is NULL, then ASSERT().  
+
+  @param[in]  InputSection   A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBuffer   A pointer to a buffer that contains the result of a decode operation. 
+  @param[in]  ScratchBuffer  A caller allocated buffer that may be required by this function as a scratch buffer to perform the decode operation. 
+  @param[out] AuthenticationStatus 
+                             A pointer to the authentication status of the decoded output buffer. See the definition
+                             of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI section of the PI
+                             Specification.
+
+  @retval  RETURN_SUCCESS           The buffer specified by InputSection was decoded.
+  @retval  RETURN_UNSUPPORTED       The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER The section specified by InputSection can not be decoded.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionDecode (
+  IN  CONST VOID    *InputSection,
+  OUT       VOID    **OutputBuffer,
+  IN        VOID    *ScratchBuffer,        OPTIONAL
+  OUT       UINT32  *AuthenticationStatus  
+  );
+
+/**
+  Retrieves handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and 
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER for a specific GUID section type.
+  
+  Retrieves the handlers associated with SectionGuid and returns them in 
+  GetInfoHandler and DecodeHandler.
+
+  If the GUID value specified by SectionGuid has not been registered, then 
+  return RETURN_NOT_FOUND.
+  
+  If SectionGuid is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the handlersof the GUIDed 
+                             section type being retrieved.
+  @param[out] GetInfoHandler Pointer to a function that examines a GUIDed section and returns 
+                             the size of the decoded buffer and the size of an optional scratch 
+                             buffer required to actually decode the data in a GUIDed section.  
+                             This is an optional parameter that may be NULL. If it is NULL, then 
+                             the previously registered handler is not returned.
+  @param[out] DecodeHandler  Pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. This is an optional parameter that may be NULL.
+                             If it is NULL, then the previously registered handler is not returned.
+
+  @retval  RETURN_SUCCESS     The handlers were retrieved.
+  @retval  RETURN_NOT_FOUND   No handlers have been registered with the specified GUID.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetHandlers (
+  IN CONST   GUID                                     *SectionGuid,
+  OUT        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  *GetInfoHandler,  OPTIONAL
+  OUT        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    *DecodeHandler    OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/FileHandleLib.h b/MdePkg/Include/Library/FileHandleLib.h
new file mode 100644
index 000000000000..cbafa4aca82c
--- /dev/null
+++ b/MdePkg/Include/Library/FileHandleLib.h
@@ -0,0 +1,507 @@
+/** @file
+  Provides interface to EFI_FILE_HANDLE functionality.
+
+  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
+
+  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 _FILE_HANDLE_LIBRARY_HEADER_
+#define _FILE_HANDLE_LIBRARY_HEADER_
+
+#include <Protocol/SimpleFileSystem.h>
+#include <Guid/FileInfo.h>
+
+/// The tag for use in identifying UNICODE files.
+/// If the file is UNICODE, the first 16 bits of the file will equal this value.
+extern CONST UINT16 gUnicodeFileTag;
+
+/**
+  This function retrieves information about the file for the handle
+  specified and stores it in the allocated pool memory.
+
+  This function allocates a buffer to store the file's information. It is the
+  caller's responsibility to free the buffer.
+
+  @param[in] FileHandle         The file handle of the file for which information is
+                                being requested.
+
+  @retval NULL                  Information could not be retrieved.
+  @retval !NULL                 The information about the file.
+**/
+EFI_FILE_INFO*
+EFIAPI
+FileHandleGetInfo (
+  IN EFI_FILE_HANDLE            FileHandle
+  );
+
+/**
+  This function sets the information about the file for the opened handle
+  specified.
+
+  @param[in]  FileHandle        The file handle of the file for which information
+                                is being set.
+
+  @param[in]  FileInfo          The information to set.
+
+  @retval EFI_SUCCESS           The information was set.
+  @retval EFI_INVALID_PARAMETER A parameter was out of range or invalid.
+  @retval EFI_UNSUPPORTED       The FileHandle does not support FileInfo.
+  @retval EFI_NO_MEDIA          The device has no medium.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED     The file was opened read only.
+  @retval EFI_VOLUME_FULL       The volume is full.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetInfo (
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN CONST EFI_FILE_INFO        *FileInfo
+  );
+
+/**
+  This function reads information from an opened file.
+
+  If FileHandle is not a directory, the function reads the requested number of
+  bytes from the file at the file's current position and returns them in Buffer.
+  If the read goes beyond the end of the file, the read length is truncated to the
+  end of the file. The file's current position is increased by the number of bytes
+  returned.  If FileHandle is a directory, the function reads the directory entry
+  at the file's current position and returns the entry in Buffer. If the Buffer
+  is not large enough to hold the current directory entry, then
+  EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated.
+  BufferSize is set to be the size of the buffer needed to read the entry. On
+  success, the current position is updated to the next directory entry. If there
+  are no more directory entries, the read returns a zero-length buffer.
+  EFI_FILE_INFO is the structure returned as the directory entry.
+
+  @param[in] FileHandle          The opened file handle.
+  @param[in, out] BufferSize     On input, the size of buffer in bytes.  On return,
+                                 the number of bytes written.
+  @param[out] Buffer             The buffer to put read data into.
+
+  @retval EFI_SUCCESS         Data was read.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR  The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_BUFFER_TO_SMALL Buffer is too small. ReadSize contains required
+                                size.
+
+**/
+EFI_STATUS
+EFIAPI
+FileHandleRead(
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer
+  );
+
+/**
+  Write data to a file.
+
+  This function writes the specified number of bytes to the file at the current
+  file position. The current file position is advanced the actual number of bytes
+  written, which is returned in BufferSize. Partial writes only occur when there
+  has been a data error during the write attempt (such as "volume space full").
+  The file is automatically grown to hold the data if required. Direct writes to
+  opened directories are not supported.
+
+  @param[in] FileHandle          The opened file for writing.
+  @param[in, out] BufferSize     On input, the number of bytes in Buffer.  On output,
+                                 the number of bytes written.
+  @param[in] Buffer              The buffer containing data to write is stored.
+
+  @retval EFI_SUCCESS         Data was written.
+  @retval EFI_UNSUPPORTED       Writes to an open directory are not supported.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR  The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED The device is write-protected.
+  @retval EFI_ACCESS_DENIED The file was opened for read only.
+  @retval EFI_VOLUME_FULL The volume is full.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleWrite(
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer
+  );
+
+/**
+  Close an open file handle.
+
+  This function closes a specified file handle. All "dirty" cached file data is
+  flushed to the device, and the file is closed. In all cases the handle is
+  closed.
+
+  @param[in] FileHandle           The file handle to close.
+
+  @retval EFI_SUCCESS             The file handle was closed successfully.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleClose (
+  IN EFI_FILE_HANDLE            FileHandle
+  );
+
+/**
+  Delete a file and close the handle.
+
+  This function closes and deletes a file. In all cases the file handle is closed.
+  If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is
+  returned, but the handle is still closed.
+
+  @param[in] FileHandle             The file handle to delete.
+
+  @retval EFI_SUCCESS               The file was closed successfully.
+  @retval EFI_WARN_DELETE_FAILURE   The handle was closed, but the file was not
+                                    deleted.
+  @retval INVALID_PARAMETER         One of the parameters has an invalid value.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleDelete (
+  IN EFI_FILE_HANDLE    FileHandle
+  );
+
+/**
+  Set the current position in a file.
+
+  This function sets the current file position for the handle to the position
+  supplied. With the exception of moving to position 0xFFFFFFFFFFFFFFFF, only
+  absolute positioning is supported, and moving past the end of the file is
+  allowed (a subsequent write would grow the file). Moving to position
+  0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
+  If FileHandle is a directory, the only position that may be set is zero. This
+  has the effect of starting the read process of the directory entries over again.
+
+  @param[in] FileHandle         The file handle on which the position is being set.
+  @param[in] Position           The byte position from the beginning of the file.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_UNSUPPORTED       The request for non-zero is not valid on
+                                directories.
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetPosition (
+  IN EFI_FILE_HANDLE    FileHandle,
+  IN UINT64             Position
+  );
+
+/**
+  Gets a file's current position.
+
+  This function retrieves the current file position for the file handle. For
+  directories, the current file position has no meaning outside of the file
+  system driver. As such, the operation is not supported. An error is returned
+  if FileHandle is a directory.
+
+  @param[in] FileHandle         The open file handle on which to get the position.
+  @param[out] Position          The byte position from beginning of file.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.
+  @retval EFI_UNSUPPORTED       The request is not valid on directories.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetPosition (
+  IN EFI_FILE_HANDLE            FileHandle,
+  OUT UINT64                    *Position
+  );
+/**
+  Flushes data on a file.
+
+  This function flushes all modified data associated with a file to a device.
+
+  @param[in] FileHandle         The file handle on which to flush data.
+
+  @retval EFI_SUCCESS           The data was flushed.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED     The file was opened for read only.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFlush (
+  IN EFI_FILE_HANDLE            FileHandle
+  );
+
+/**
+  Function to determine if a given handle is a directory handle.
+
+  Open the file information on the DirHandle and verify that the Attribute
+  includes EFI_FILE_DIRECTORY bit set.
+
+  @param[in] DirHandle          Handle to open file.
+
+  @retval EFI_SUCCESS           DirHandle is a directory.
+  @retval EFI_INVALID_PARAMETER DirHandle is NULL. 
+                                The file information returns from FileHandleGetInfo is NULL. 
+  @retval EFI_NOT_FOUND         DirHandle is not a directory.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleIsDirectory (
+  IN EFI_FILE_HANDLE            DirHandle
+  );
+
+/** Retrieve first entry from a directory.
+
+  This function takes an open directory handle and gets information from the
+  first entry in the directory.  A buffer is allocated to contain
+  the information and a pointer to the buffer is returned in *Buffer.  The
+  caller can use FileHandleFindNextFile() to get subsequent directory entries.
+
+  The buffer will be freed by FileHandleFindNextFile() when the last directory
+  entry is read.  Otherwise, the caller must free the buffer, using FreePool,
+  when finished with it.
+
+  @param[in]  DirHandle         The file handle of the directory to search.
+  @param[out] Buffer            The pointer to pointer to buffer for file's information.
+
+  @retval EFI_SUCCESS           Found the first file.
+  @retval EFI_NOT_FOUND         Cannot find the directory.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @return Others                The status of FileHandleGetInfo, FileHandleSetPosition,
+                                or FileHandleRead.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFindFirstFile (
+  IN EFI_FILE_HANDLE            DirHandle,
+  OUT EFI_FILE_INFO             **Buffer
+  );
+
+/** Retrieve next entries from a directory.
+
+  To use this function, the caller must first call the FileHandleFindFirstFile()
+  function to get the first directory entry.  Subsequent directory entries are
+  retrieved by using the FileHandleFindNextFile() function.  This function can
+  be called several times to get each entry from the directory.  If the call of
+  FileHandleFindNextFile() retrieved the last directory entry, the next call of
+  this function will set *NoFile to TRUE and free the buffer.
+
+  @param[in]  DirHandle         The file handle of the directory.
+  @param[out] Buffer            The pointer to buffer for file's information.
+  @param[out] NoFile            The pointer to boolean when last file is found.
+
+  @retval EFI_SUCCESS           Found the next file, or reached last file.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFindNextFile(
+  IN EFI_FILE_HANDLE             DirHandle,
+  OUT EFI_FILE_INFO              *Buffer,
+  OUT BOOLEAN                    *NoFile
+  );
+
+/**
+  Retrieve the size of a file.
+
+  This function extracts the file size info from the FileHandle's EFI_FILE_INFO
+  data.
+
+  @param[in] FileHandle         The file handle from which size is retrieved.
+  @param[out] Size              The pointer to size.
+
+  @retval EFI_SUCCESS           Operation was completed successfully.
+  @retval EFI_DEVICE_ERROR      Cannot access the file.
+  @retval EFI_INVALID_PARAMETER FileHandle is NULL.
+                                Size is NULL.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetSize (
+  IN EFI_FILE_HANDLE            FileHandle,
+  OUT UINT64                    *Size
+  );
+
+/**
+  Set the size of a file.
+
+  This function changes the file size info from the FileHandle's EFI_FILE_INFO
+  data.
+
+  @param[in] FileHandle         The file handle whose size is to be changed.
+  @param[in] Size               The new size.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_DEVICE_ERROR      Cannot access the file.
+  @retval EFI_INVALID_PARAMETER FileHandle is NULL.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetSize (
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN UINT64                     Size
+  );
+
+/**
+  Function to get a full filename given a EFI_FILE_HANDLE somewhere lower on the
+  directory 'stack'. If the file is a directory, then append the '\' char at the 
+  end of name string. If it's not a directory, then the last '\' should not be 
+  added.
+
+  @param[in] Handle             Handle to the Directory or File to create path to.
+  @param[out] FullFileName      Pointer to pointer to generated full file name.  It
+                                is the responsibility of the caller to free this memory
+                                with a call to FreePool().
+  @retval EFI_SUCCESS           The operation was successful and FullFileName is valid.
+  @retval EFI_INVALID_PARAMETER Handle was NULL.
+  @retval EFI_INVALID_PARAMETER FullFileName was NULL.
+  @retval EFI_OUT_OF_MEMORY     A memory allocation failed.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetFileName (
+  IN CONST EFI_FILE_HANDLE      Handle,
+  OUT CHAR16                    **FullFileName
+  );
+
+/**
+  Function to read a single line (up to but not including the \n) from a file.
+
+  If the position upon start is 0, then the Ascii Boolean will be set.  This should be
+  maintained and not changed for all operations with the same file.
+  The function will not return the \r and \n character in buffer. When an empty line is
+  read a CHAR_NULL character will be returned in buffer.
+
+  @param[in]       Handle        FileHandle to read from.
+  @param[in, out]  Buffer        The pointer to buffer to read into.
+  @param[in, out]  Size          The pointer to number of bytes in Buffer.
+  @param[in]       Truncate      If the buffer is large enough, this has no effect.
+                                 If the buffer is is too small and Truncate is TRUE,
+                                 the line will be truncated.
+                                 If the buffer is is too small and Truncate is FALSE,
+                                 then no read will occur.
+
+  @param[in, out]  Ascii         Boolean value for indicating whether the file is
+                                 Ascii (TRUE) or UCS2 (FALSE).
+
+  @retval EFI_SUCCESS           The operation was successful.  The line is stored in
+                                Buffer.
+  @retval EFI_INVALID_PARAMETER Handle was NULL.
+  @retval EFI_INVALID_PARAMETER Size was NULL.
+  @retval EFI_BUFFER_TOO_SMALL  Size was not large enough to store the line.
+                                Size was updated to the minimum space required.
+  @sa FileHandleRead
+**/
+EFI_STATUS
+EFIAPI
+FileHandleReadLine(
+  IN EFI_FILE_HANDLE            Handle,
+  IN OUT CHAR16                 *Buffer,
+  IN OUT UINTN                  *Size,
+  IN BOOLEAN                    Truncate,
+  IN OUT BOOLEAN                *Ascii
+  );
+
+/**
+  Function to read a single line from a file. The \n is not included in the returned
+  buffer.  The returned buffer must be callee freed.
+
+  If the position upon start is 0, then the Ascii Boolean will be set.  This should be
+  maintained and not changed for all operations with the same file.
+
+  @param[in]       Handle        FileHandle to read from.
+  @param[in, out]  Ascii         Boolean value for indicating whether the file is
+                                 Ascii (TRUE) or UCS2 (FALSE).
+
+  @return                       The line of text from the file.
+
+  @sa FileHandleReadLine
+**/
+CHAR16*
+EFIAPI
+FileHandleReturnLine(
+  IN EFI_FILE_HANDLE            Handle,
+  IN OUT BOOLEAN                *Ascii
+  );
+
+/**
+  Function to write a line of text to a file.
+  
+  If the file is a Unicode file (with UNICODE file tag) then write the unicode 
+  text.
+  If the file is an ASCII file then write the ASCII text.
+  If the size of file is zero (without file tag at the beginning) then write 
+  ASCII text as default.
+
+  @param[in]     Handle         FileHandle to write to.
+  @param[in]     Buffer         Buffer to write, if NULL the function will
+                                take no action and return EFI_SUCCESS.
+
+  @retval  EFI_SUCCESS            The data was written.
+                                  Buffer is NULL.
+  @retval  EFI_INVALID_PARAMETER  Handle is NULL.
+  @retval  EFI_OUT_OF_RESOURCES   Unable to allocate temporary space for ASCII 
+                                  string due to out of resources.
+
+  @sa FileHandleWrite
+**/
+EFI_STATUS
+EFIAPI
+FileHandleWriteLine(
+  IN EFI_FILE_HANDLE Handle,
+  IN CHAR16          *Buffer
+  );
+
+/**
+  Function to take a formatted argument and print it to a file.
+
+  @param[in] Handle   The file handle for the file to write to.
+  @param[in] Format   The format argument (see printlib for the format specifier).
+  @param[in] ...      The variable arguments for the format.
+
+  @retval EFI_SUCCESS The operation was successful.
+  @retval other       A return value from FileHandleWriteLine.
+
+  @sa FileHandleWriteLine
+**/
+EFI_STATUS
+EFIAPI
+FileHandlePrintLine(
+  IN EFI_FILE_HANDLE  Handle,
+  IN CONST CHAR16     *Format,
+  ...
+  );
+
+/**
+  Function to determine if a FILE_HANDLE is at the end of the file.
+
+  This will NOT work on directories.
+
+  If Handle is NULL, then ASSERT().
+
+  @param[in] Handle     The file handle.
+
+  @retval TRUE          The position is at the end of the file.
+  @retval FALSE         The position is not at the end of the file.
+**/
+BOOLEAN
+EFIAPI
+FileHandleEof(
+  IN EFI_FILE_HANDLE Handle
+  );
+
+#endif //_FILE_HANDLE_LIBRARY_HEADER_
+
diff --git a/MdePkg/Include/Library/HobLib.h b/MdePkg/Include/Library/HobLib.h
new file mode 100644
index 000000000000..292321cd3d72
--- /dev/null
+++ b/MdePkg/Include/Library/HobLib.h
@@ -0,0 +1,534 @@
+/** @file
+  Provides services to create and parse HOBs. Only available for PEI
+  and DXE module types.
+
+  The HOB Library supports the efficient creation and searching of HOBs
+  defined in the PI Specification.
+  A HOB is a Hand-Off Block, defined in the Framework architecture, that
+  allows the PEI phase to pass information to the DXE phase. HOBs are position
+  independent and can be relocated easily to different memory memory locations.
+
+Copyright (c) 2006 - 2016, 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 __HOB_LIB_H__
+#define __HOB_LIB_H__
+
+/**
+  Returns the pointer to the HOB list.
+
+  This function returns the pointer to first HOB in the list.
+  For PEI phase, the PEI service GetHobList() can be used to retrieve the pointer
+  to the HOB list.  For the DXE phase, the HOB list pointer can be retrieved through
+  the EFI System Table by looking up theHOB list GUID in the System Configuration Table.
+  Since the System Configuration Table does not exist that the time the DXE Core is
+  launched, the DXE Core uses a global variable from the DXE Core Entry Point Library
+  to manage the pointer to the HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @return The pointer to the HOB list.
+
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  );
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+
+  This function searches the first instance of a HOB type from the starting HOB pointer.
+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+
+  If HobStart is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+  @param  HobStart      The starting HOB pointer to search from.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  IN UINT16                 Type,
+  IN CONST VOID             *HobStart
+  );
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+
+  This function searches the first instance of a HOB type among the whole HOB list.
+  If there does not exist such HOB type in the HOB list, it will return NULL.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  IN UINT16                 Type
+  );
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+
+  This function searches the first instance of a HOB from the starting HOB pointer.
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size info respectively.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+
+  If Guid is NULL, then ASSERT().
+  If HobStart is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+  @param  HobStart      A pointer to a Guid.
+
+  @return The next instance of the matched GUID HOB from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  IN CONST EFI_GUID         *Guid,
+  IN CONST VOID             *HobStart
+  );
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+
+  This function searches the first instance of a HOB among the whole HOB list.
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size info respectively.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+
+  @return The first instance of the matched GUID HOB among the whole HOB list.
+
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  IN CONST EFI_GUID         *Guid
+  );
+
+/**
+  Get the system boot mode from the HOB list.
+
+  This function returns the system boot mode information from the
+  PHIT HOB in HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  VOID
+
+  @return The Boot Mode.
+
+**/
+EFI_BOOT_MODE
+EFIAPI
+GetBootModeHob (
+  VOID
+  );
+
+/**
+  Builds a HOB for a loaded PE32 module.
+
+  This function builds a HOB for a loaded PE32 module.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If ModuleName is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ModuleName              The GUID File Name of the module.
+  @param  MemoryAllocationModule  The 64 bit physical address of the module.
+  @param  ModuleLength            The length of the module in bytes.
+  @param  EntryPoint              The 64 bit physical address of the module entry point.
+
+**/
+VOID
+EFIAPI
+BuildModuleHob (
+  IN CONST EFI_GUID         *ModuleName,
+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
+  IN UINT64                 ModuleLength,
+  IN EFI_PHYSICAL_ADDRESS   EntryPoint
+  );
+
+/**
+  Builds a HOB that describes a chunk of system memory with Owner GUID.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+  @param  OwnerGUID           GUID for the owner of this resource.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorWithOwnerHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes,
+  IN EFI_GUID                     *OwnerGUID
+  );
+
+/**
+  Builds a HOB that describes a chunk of system memory.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes
+  );
+
+/**
+  Builds a customized HOB tagged with a GUID for identification and returns
+  the start address of GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification
+  and returns the start address of GUID HOB data so that caller can fill the customized data.
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If Guid is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidHob (
+  IN CONST EFI_GUID              *Guid,
+  IN UINTN                       DataLength
+  );
+
+/**
+  Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB
+  data field, and returns the start address of the GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification and copies the input
+  data to the HOB data field and returns the start address of the GUID HOB data.  It can only be
+  invoked during PEI phase; for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If Guid is NULL, then ASSERT().
+  If Data is NULL and DataLength > 0, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  Data          The data to be copied into the data field of the GUID HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidDataHob (
+  IN CONST EFI_GUID              *Guid,
+  IN VOID                        *Data,
+  IN UINTN                       DataLength
+  );
+
+/**
+  Builds a Firmware Volume HOB.
+
+  This function builds a Firmware Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildFvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  );
+
+/**
+  Builds a EFI_HOB_TYPE_FV2 HOB.
+
+  This function builds a EFI_HOB_TYPE_FV2 HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+  @param  FvName        The name of the Firmware Volume.
+  @param  FileName      The name of the file.
+
+**/
+VOID
+EFIAPI
+BuildFv2Hob (
+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN          UINT64                      Length,
+  IN CONST    EFI_GUID                    *FvName,
+  IN CONST    EFI_GUID                    *FileName
+  );
+
+/**
+  Builds a Capsule Volume HOB.
+
+  This function builds a Capsule Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If the platform does not support Capsule Volume HOBs, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The base address of the Capsule Volume.
+  @param  Length        The size of the Capsule Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildCvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  );
+
+/**
+  Builds a HOB for the CPU.
+
+  This function builds a HOB for the CPU.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
+
+**/
+VOID
+EFIAPI
+BuildCpuHob (
+  IN UINT8                       SizeOfMemorySpace,
+  IN UINT8                       SizeOfIoSpace
+  );
+
+/**
+  Builds a HOB for the Stack.
+
+  This function builds a HOB for the stack.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the Stack.
+  @param  Length        The length of the stack in bytes.
+
+**/
+VOID
+EFIAPI
+BuildStackHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  );
+
+/**
+  Builds a HOB for the BSP store.
+
+  This function builds a HOB for BSP store.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the BSP.
+  @param  Length        The length of the BSP store in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildBspStoreHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  );
+
+/**
+  Builds a HOB for the memory allocation.
+
+  This function builds a HOB for the memory allocation.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the memory.
+  @param  Length        The length of the memory allocation in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildMemoryAllocationHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  );
+
+/**
+  Returns the type of a HOB.
+
+  This macro returns the HobType field from the HOB header for the
+  HOB specified by HobStart.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return HobType.
+
+**/
+#define GET_HOB_TYPE(HobStart) \
+  ((*(EFI_HOB_GENERIC_HEADER **)&(HobStart))->HobType)
+
+/**
+  Returns the length, in bytes, of a HOB.
+
+  This macro returns the HobLength field from the HOB header for the
+  HOB specified by HobStart.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return HobLength.
+
+**/
+#define GET_HOB_LENGTH(HobStart) \
+  ((*(EFI_HOB_GENERIC_HEADER **)&(HobStart))->HobLength)
+
+/**
+  Returns a pointer to the next HOB in the HOB list.
+
+  This macro returns a pointer to HOB that follows the
+  HOB specified by HobStart in the HOB List.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return A pointer to the next HOB in the HOB list.
+
+**/
+#define GET_NEXT_HOB(HobStart) \
+  (VOID *)(*(UINT8 **)&(HobStart) + GET_HOB_LENGTH (HobStart))
+
+/**
+  Determines if a HOB is the last HOB in the HOB list.
+
+  This macro determine if the HOB specified by HobStart is the
+  last HOB in the HOB list.  If HobStart is last HOB in the HOB list,
+  then TRUE is returned.  Otherwise, FALSE is returned.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @retval TRUE       The HOB specified by HobStart is the last HOB in the HOB list.
+  @retval FALSE      The HOB specified by HobStart is not the last HOB in the HOB list.
+
+**/
+#define END_OF_HOB_LIST(HobStart)  (GET_HOB_TYPE (HobStart) == (UINT16)EFI_HOB_TYPE_END_OF_HOB_LIST)
+
+/**
+  Returns a pointer to data buffer from a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  This macro returns a pointer to the data buffer in a HOB specified by HobStart.
+  HobStart is assumed to be a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  @param   GuidHob   A pointer to a HOB.
+
+  @return  A pointer to the data buffer in a HOB.
+
+**/
+#define GET_GUID_HOB_DATA(HobStart) \
+  (VOID *)(*(UINT8 **)&(HobStart) + sizeof (EFI_HOB_GUID_TYPE))
+
+/**
+  Returns the size of the data buffer from a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  This macro returns the size, in bytes, of the data buffer in a HOB specified by HobStart.
+  HobStart is assumed to be a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  @param   GuidHob   A pointer to a HOB.
+
+  @return  The size of the data buffer.
+**/
+#define GET_GUID_HOB_DATA_SIZE(HobStart) \
+  (UINT16)(GET_HOB_LENGTH (HobStart) - sizeof (EFI_HOB_GUID_TYPE))
+
+#endif
diff --git a/MdePkg/Include/Library/HstiLib.h b/MdePkg/Include/Library/HstiLib.h
new file mode 100644
index 000000000000..2ae87f67d19e
--- /dev/null
+++ b/MdePkg/Include/Library/HstiLib.h
@@ -0,0 +1,158 @@
+/** @file
+  Provides services to create, get and update HSTI table in AIP protocol.
+
+  Copyright (c) 2015, 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 __HSTI_LIB_H__
+#define __HSTI_LIB_H__
+
+/**
+  Publish HSTI table in AIP protocol.
+
+  One system should have only one PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE.
+
+  If the Role is NOT PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE,
+  SecurityFeaturesRequired field will be ignored.
+
+  @param Hsti      HSTI data
+  @param HstiSize  HSTI size
+
+  @retval EFI_SUCCESS          The HSTI data is published in AIP protocol.
+  @retval EFI_ALREADY_STARTED  There is already HSTI table with Role and ImplementationID published in system.
+  @retval EFI_VOLUME_CORRUPTED The input HSTI data does not follow HSTI specification.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to publish HSTI data in AIP protocol.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetTable (
+  IN VOID                     *Hsti,
+  IN UINTN                    HstiSize
+  );
+
+/**
+  Search HSTI table in AIP protocol, and return the data.
+  This API will return the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param Hsti             HSTI data. This buffer is allocated by callee, and it
+                          is the responsibility of the caller to free it after
+                          using it.
+  @param HstiSize         HSTI size
+
+  @retval EFI_SUCCESS          The HSTI data in AIP protocol is returned.
+  @retval EFI_NOT_FOUND        There is not HSTI table with the Role and ImplementationID published in system.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibGetTable (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID OPTIONAL,
+  OUT VOID                    **Hsti,
+  OUT UINTN                   *HstiSize
+  );
+
+/**
+  Set FeaturesVerified in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ByteIndex        Byte index of FeaturesVerified of HSTI data.
+  @param BitMask          Bit mask of FeaturesVerified of HSTI data.
+
+  @retval EFI_SUCCESS          The FeaturesVerified of HSTI data updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_UNSUPPORTED      The ByteIndex is invalid.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetFeaturesVerified (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN UINT32                   ByteIndex,
+  IN UINT8                    BitMask
+  );
+
+/**
+  Clear FeaturesVerified in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ByteIndex        Byte index of FeaturesVerified of HSTI data.
+  @param BitMask          Bit mask of FeaturesVerified of HSTI data.
+
+  @retval EFI_SUCCESS          The FeaturesVerified of HSTI data updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_UNSUPPORTED      The ByteIndex is invalid.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibClearFeaturesVerified (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN UINT32                   ByteIndex,
+  IN UINT8                    BitMask
+  );
+
+/**
+  Append ErrorString in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ErrorString      ErrorString of HSTI data.
+
+  @retval EFI_SUCCESS          The ErrorString of HSTI data is updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to update ErrorString.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibAppendErrorString (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN CHAR16                   *ErrorString
+  );
+
+/**
+  Set a new ErrorString in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ErrorString      ErrorString of HSTI data.
+
+  @retval EFI_SUCCESS          The ErrorString of HSTI data is updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to update ErrorString.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetErrorString (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN CHAR16                   *ErrorString
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/IoLib.h b/MdePkg/Include/Library/IoLib.h
new file mode 100644
index 000000000000..7c27f1cf6531
--- /dev/null
+++ b/MdePkg/Include/Library/IoLib.h
@@ -0,0 +1,2815 @@
+/** @file
+  Provide services to access I/O Ports and MMIO registers.
+
+Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2017, AMD Incorporated. 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 __IO_LIB_H__
+#define __IO_LIB_H__
+
+/**
+  Macro that converts PCI Segment and I/O Port to an address that can be
+  passed to the I/O Library functions.
+  
+  Computes an address that is compatible with the I/O Library functions.  
+  The unused upper bits of Segment, and Port are stripped prior to the 
+  generation of the address.
+  
+  @param  Segment   PCI Segment number.  Range 0..65535.
+  @param  Port      I/O Port number.  Range 0..65535.
+  
+  @return An address that the I/o Library functions need.
+
+**/
+
+#define IO_LIB_ADDRESS(Segment,Port) \
+  ( ((Port) & 0xffff) | (((Segment) & 0xffff) << 16) )
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  );
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. 
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  );
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  );
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  );
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  );
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  );
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  );
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  );
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  );
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  );
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  );
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  );
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  );
+
+
+#endif
+
diff --git a/MdePkg/Include/Library/MemoryAllocationLib.h b/MdePkg/Include/Library/MemoryAllocationLib.h
new file mode 100644
index 000000000000..204a8b51235f
--- /dev/null
+++ b/MdePkg/Include/Library/MemoryAllocationLib.h
@@ -0,0 +1,493 @@
+/** @file
+  Provides services to allocate and free memory buffers of various memory types and alignments.
+  
+  The Memory Allocation Library abstracts various common memory allocation operations. This library 
+  allows code to be written in a phase-independent manner because the allocation of memory in PEI, DXE, 
+  and SMM (for example) is done via a different mechanism. Using a common library interface makes it 
+  much easier to port algorithms from phase to phase. 
+  
+Copyright (c) 2006 - 2013, 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 __MEMORY_ALLOCATION_LIB_H__
+#define __MEMORY_ALLOCATION_LIB_H__
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData.
+
+  Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePages (
+  IN UINTN  Pages
+  );
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
+
+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePages (
+  IN UINTN  Pages
+  );
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType.
+
+  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPages (
+  IN UINTN  Pages
+  );
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the page allocation
+  functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will
+  perform no actions.
+  
+  If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
+  then ASSERT().
+  If Pages is zero, then ASSERT().
+ 
+  @param  Buffer                Pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreePages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  );
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  );
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedRuntimePages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  );
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedReservedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  );
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the aligned page
+  allocation functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the aligned page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will 
+  perform no actions.
+  
+  If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
+  Library, then ASSERT().
+  If Pages is zero, then ASSERT().
+  
+  @param  Buffer                Pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreeAlignedPages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  );
+
+/**
+  Allocates a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Allocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Allocates a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Allocates and zeros a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateZeroPool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Allocates and zeros a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeZeroPool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Allocates and zeros a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedZeroPool (
+  IN UINTN  AllocationSize
+  );
+
+/**
+  Copies a buffer to an allocated buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  );
+
+/**
+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  );
+
+/**
+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  );
+
+/**
+  Reallocates a buffer of type EfiBootServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocatePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  );
+
+/**
+  Reallocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateRuntimePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  );
+
+/**
+  Reallocates a buffer of type EfiReservedMemoryType.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateReservedPool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  );
+
+/**
+  Frees a buffer that was previously allocated with one of the pool allocation functions in the
+  Memory Allocation Library.
+
+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
+  pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
+  resources, then this function will perform no actions.
+  
+  If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
+  then ASSERT().
+
+  @param  Buffer                Pointer to the buffer to free.
+
+**/
+VOID
+EFIAPI
+FreePool (
+  IN VOID   *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/OrderedCollectionLib.h b/MdePkg/Include/Library/OrderedCollectionLib.h
new file mode 100644
index 000000000000..e4191b82026f
--- /dev/null
+++ b/MdePkg/Include/Library/OrderedCollectionLib.h
@@ -0,0 +1,425 @@
+/** @file
+  An ordered collection library interface.
+
+  The library class provides a set of APIs to manage an ordered collection of
+  items.
+
+  Copyright (C) 2014, Red Hat, Inc.
+
+  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 __ORDERED_COLLECTION_LIB__
+#define __ORDERED_COLLECTION_LIB__
+
+#include <Base.h>
+
+//
+// Opaque structure for a collection.
+//
+typedef struct ORDERED_COLLECTION ORDERED_COLLECTION;
+
+//
+// Opaque structure for collection entries.
+//
+// Collection entries do not take ownership of the associated user structures,
+// they only link them. This makes it easy to link the same user structure into
+// several collections. If reference counting is required, the caller is
+// responsible for implementing it, as part of the user structure.
+//
+// A pointer-to-ORDERED_COLLECTION_ENTRY is considered an "iterator". Multiple,
+// simultaneous iterations are supported.
+//
+typedef struct ORDERED_COLLECTION_ENTRY ORDERED_COLLECTION_ENTRY;
+
+//
+// Altering the key field of an in-collection user structure (ie. the portion
+// of the user structure that ORDERED_COLLECTION_USER_COMPARE and
+// ORDERED_COLLECTION_KEY_COMPARE, below, read) is not allowed in-place. The
+// caller is responsible for bracketing the key change with the deletion and
+// the reinsertion of the user structure, so that the changed key value is
+// reflected in the collection.
+//
+
+/**
+  Comparator function type for two user structures.
+
+  @param[in] UserStruct1  Pointer to the first user structure.
+
+  @param[in] UserStruct2  Pointer to the second user structure.
+
+  @retval <0  If UserStruct1 compares less than UserStruct2.
+
+  @retval  0  If UserStruct1 compares equal to UserStruct2.
+
+  @retval >0  If UserStruct1 compares greater than UserStruct2.
+**/
+typedef
+INTN
+(EFIAPI *ORDERED_COLLECTION_USER_COMPARE)(
+  IN CONST VOID *UserStruct1,
+  IN CONST VOID *UserStruct2
+  );
+
+/**
+  Compare a standalone key against a user structure containing an embedded key.
+
+  @param[in] StandaloneKey  Pointer to the bare key.
+
+  @param[in] UserStruct     Pointer to the user structure with the embedded
+                            key.
+
+  @retval <0  If StandaloneKey compares less than UserStruct's key.
+
+  @retval  0  If StandaloneKey compares equal to UserStruct's key.
+
+  @retval >0  If StandaloneKey compares greater than UserStruct's key.
+**/
+typedef
+INTN
+(EFIAPI *ORDERED_COLLECTION_KEY_COMPARE)(
+  IN CONST VOID *StandaloneKey,
+  IN CONST VOID *UserStruct
+  );
+
+
+//
+// Some functions below are read-only, while others are read-write. If any
+// write operation is expected to run concurrently with any other operation on
+// the same collection, then the caller is responsible for implementing locking
+// for the whole collection.
+//
+
+/**
+  Retrieve the user structure linked by the specified collection entry.
+
+  Read-only operation.
+
+  @param[in] Entry  Pointer to the collection entry whose associated user
+                    structure we want to retrieve. The caller is responsible
+                    for passing a non-NULL argument.
+
+  @return  Pointer to user structure linked by Entry.
+**/
+VOID *
+EFIAPI
+OrderedCollectionUserStruct (
+  IN CONST ORDERED_COLLECTION_ENTRY *Entry
+  );
+
+
+/**
+  Allocate and initialize the ORDERED_COLLECTION structure.
+
+  @param[in]  UserStructCompare  This caller-provided function will be used to
+                                 order two user structures linked into the
+                                 collection, during the insertion procedure.
+
+  @param[in]  KeyCompare         This caller-provided function will be used to
+                                 order the standalone search key against user
+                                 structures linked into the collection, during
+                                 the lookup procedure.
+
+  @retval NULL  If allocation failed.
+
+  @return       Pointer to the allocated, initialized ORDERED_COLLECTION
+                structure, otherwise.
+**/
+ORDERED_COLLECTION *
+EFIAPI
+OrderedCollectionInit (
+  IN ORDERED_COLLECTION_USER_COMPARE UserStructCompare,
+  IN ORDERED_COLLECTION_KEY_COMPARE  KeyCompare
+  );
+
+
+/**
+  Check whether the collection is empty (has no entries).
+
+  Read-only operation.
+
+  @param[in] Collection  The collection to check for emptiness.
+
+  @retval TRUE   The collection is empty.
+
+  @retval FALSE  The collection is not empty.
+**/
+BOOLEAN
+EFIAPI
+OrderedCollectionIsEmpty (
+  IN CONST ORDERED_COLLECTION *Collection
+  );
+
+
+/**
+  Uninitialize and release an empty ORDERED_COLLECTION structure.
+
+  Read-write operation.
+
+  It is the caller's responsibility to delete all entries from the collection
+  before calling this function.
+
+  @param[in] Collection  The empty collection to uninitialize and release.
+**/
+VOID
+EFIAPI
+OrderedCollectionUninit (
+  IN ORDERED_COLLECTION *Collection
+  );
+
+
+/**
+  Look up the collection entry that links the user structure that matches the
+  specified standalone key.
+
+  Read-only operation.
+
+  @param[in] Collection     The collection to search for StandaloneKey.
+
+  @param[in] StandaloneKey  The key to locate among the user structures linked
+                            into Collection. StandaloneKey will be passed to
+                            ORDERED_COLLECTION_KEY_COMPARE.
+
+  @retval NULL  StandaloneKey could not be found.
+
+  @return       The collection entry that links to the user structure matching
+                StandaloneKey, otherwise.
+**/
+ORDERED_COLLECTION_ENTRY *
+EFIAPI
+OrderedCollectionFind (
+  IN CONST ORDERED_COLLECTION *Collection,
+  IN CONST VOID               *StandaloneKey
+  );
+
+
+/**
+  Find the collection entry of the minimum user structure stored in the
+  collection.
+
+  Read-only operation.
+
+  @param[in] Collection  The collection to return the minimum entry of. The
+                         user structure linked by the minimum entry compares
+                         less than all other user structures in the collection.
+
+  @retval NULL  If Collection is empty.
+
+  @return       The collection entry that links the minimum user structure,
+                otherwise.
+**/
+ORDERED_COLLECTION_ENTRY *
+EFIAPI
+OrderedCollectionMin (
+  IN CONST ORDERED_COLLECTION *Collection
+  );
+
+
+/**
+  Find the collection entry of the maximum user structure stored in the
+  collection.
+
+  Read-only operation.
+
+  @param[in] Collection  The collection to return the maximum entry of. The
+                         user structure linked by the maximum entry compares
+                         greater than all other user structures in the
+                         collection.
+
+  @retval NULL  If Collection is empty.
+
+  @return       The collection entry that links the maximum user structure,
+                otherwise.
+**/
+ORDERED_COLLECTION_ENTRY *
+EFIAPI
+OrderedCollectionMax (
+  IN CONST ORDERED_COLLECTION *Collection
+  );
+
+
+/**
+  Get the collection entry of the least user structure that is greater than the
+  one linked by Entry.
+
+  Read-only operation.
+
+  @param[in] Entry  The entry to get the successor entry of.
+
+  @retval NULL  If Entry is NULL, or Entry is the maximum entry of its
+                containing collection (ie. Entry has no successor entry).
+
+  @return       The collection entry linking the least user structure that is
+                greater than the one linked by Entry, otherwise.
+**/
+ORDERED_COLLECTION_ENTRY *
+EFIAPI
+OrderedCollectionNext (
+  IN CONST ORDERED_COLLECTION_ENTRY *Entry
+  );
+
+
+/**
+  Get the collection entry of the greatest user structure that is less than the
+  one linked by Entry.
+
+  Read-only operation.
+
+  @param[in] Entry  The entry to get the predecessor entry of.
+
+  @retval NULL  If Entry is NULL, or Entry is the minimum entry of its
+                containing collection (ie. Entry has no predecessor entry).
+
+  @return       The collection entry linking the greatest user structure that
+                is less than the one linked by Entry, otherwise.
+**/
+ORDERED_COLLECTION_ENTRY *
+EFIAPI
+OrderedCollectionPrev (
+  IN CONST ORDERED_COLLECTION_ENTRY *Entry
+  );
+
+
+/**
+  Insert (link) a user structure into the collection, allocating a new
+  collection entry.
+
+  Read-write operation.
+
+  @param[in,out] Collection  The collection to insert UserStruct into.
+
+  @param[out]    Entry       The meaning of this optional, output-only
+                             parameter depends on the return value of the
+                             function.
+
+                             When insertion is successful (RETURN_SUCCESS),
+                             Entry is set on output to the new collection entry
+                             that now links UserStruct.
+
+                             When insertion fails due to lack of memory
+                             (RETURN_OUT_OF_RESOURCES), Entry is not changed.
+
+                             When insertion fails due to key collision (ie.
+                             another user structure is already in the
+                             collection that compares equal to UserStruct),
+                             with return value RETURN_ALREADY_STARTED, then
+                             Entry is set on output to the entry that links the
+                             colliding user structure. This enables
+                             "find-or-insert" in one function call, or helps
+                             with later removal of the colliding element.
+
+  @param[in]     UserStruct  The user structure to link into the collection.
+                             UserStruct is ordered against in-collection user
+                             structures with the
+                             ORDERED_COLLECTION_USER_COMPARE function.
+
+  @retval RETURN_SUCCESS           Insertion successful. A new collection entry
+                                   has been allocated, linking UserStruct. The
+                                   new collection entry is reported back in
+                                   Entry (if the caller requested it).
+
+                                   Existing ORDERED_COLLECTION_ENTRY pointers
+                                   into Collection remain valid. For example,
+                                   on-going iterations in the caller can
+                                   continue with OrderedCollectionNext() /
+                                   OrderedCollectionPrev(), and they will
+                                   return the new entry at some point if user
+                                   structure order dictates it.
+
+  @retval RETURN_OUT_OF_RESOURCES  The function failed to allocate memory for
+                                   the new collection entry. The collection has
+                                   not been changed. Existing
+                                   ORDERED_COLLECTION_ENTRY pointers into
+                                   Collection remain valid.
+
+  @retval RETURN_ALREADY_STARTED   A user structure has been found in the
+                                   collection that compares equal to
+                                   UserStruct. The entry linking the colliding
+                                   user structure is reported back in Entry (if
+                                   the caller requested it). The collection has
+                                   not been changed. Existing
+                                   ORDERED_COLLECTION_ENTRY pointers into
+                                   Collection remain valid.
+**/
+RETURN_STATUS
+EFIAPI
+OrderedCollectionInsert (
+  IN OUT ORDERED_COLLECTION       *Collection,
+  OUT    ORDERED_COLLECTION_ENTRY **Entry      OPTIONAL,
+  IN     VOID                     *UserStruct
+  );
+
+
+/**
+  Delete an entry from the collection, unlinking the associated user structure.
+
+  Read-write operation.
+
+  @param[in,out] Collection  The collection to delete Entry from.
+
+  @param[in]     Entry       The collection entry to delete from Collection.
+                             The caller is responsible for ensuring that Entry
+                             belongs to Collection, and that Entry is non-NULL
+                             and valid. Entry is typically an earlier return
+                             value, or output parameter, of:
+
+                             - OrderedCollectionFind(), for deleting an entry
+                               by user structure key,
+
+                             - OrderedCollectionMin() / OrderedCollectionMax(),
+                               for deleting the minimum / maximum entry,
+
+                             - OrderedCollectionNext() /
+                               OrderedCollectionPrev(), for deleting an entry
+                               found during an iteration,
+
+                             - OrderedCollectionInsert() with return value
+                               RETURN_ALREADY_STARTED, for deleting an entry
+                               whose linked user structure caused collision
+                               during insertion.
+
+                             Existing ORDERED_COLLECTION_ENTRY pointers (ie.
+                             iterators) *different* from Entry remain valid.
+                             For example:
+
+                             - OrderedCollectionNext() /
+                               OrderedCollectionPrev() iterations in the caller
+                               can be continued from Entry, if
+                               OrderedCollectionNext() or
+                               OrderedCollectionPrev() is called on Entry
+                               *before* OrderedCollectionDelete() is. That is,
+                               fetch the successor / predecessor entry first,
+                               then delete Entry.
+
+                             - On-going iterations in the caller that would
+                               have otherwise returned Entry at some point, as
+                               dictated by user structure order, will correctly
+                               reflect the absence of Entry after
+                               OrderedCollectionDelete() is called
+                               mid-iteration.
+
+  @param[out]    UserStruct  If the caller provides this optional output-only
+                             parameter, then on output it is set to the user
+                             structure originally linked by Entry (which is now
+                             freed).
+
+                             This is a convenience that may save the caller a
+                             OrderedCollectionUserStruct() invocation before
+                             calling OrderedCollectionDelete(), in order to
+                             retrieve the user structure being unlinked.
+**/
+VOID
+EFIAPI
+OrderedCollectionDelete (
+  IN OUT ORDERED_COLLECTION       *Collection,
+  IN     ORDERED_COLLECTION_ENTRY *Entry,
+  OUT    VOID                     **UserStruct OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PalLib.h b/MdePkg/Include/Library/PalLib.h
new file mode 100644
index 000000000000..e5c3473c61d4
--- /dev/null
+++ b/MdePkg/Include/Library/PalLib.h
@@ -0,0 +1,63 @@
+/** @file
+  Provides library services to make PAL Calls.
+  
+  The PAL Library provides a service to make a PAL CALL.  This service is identical
+  in functionality to AsmPalCall() in the functions of the Base Library specific to Intel Itanium architecture.
+  The only difference is that the PAL Entry Point is not passed in.  Implementations
+  of this library class must manage PAL Entry Point on their own.  For example, a PEI
+  implementation can use a PPI to lookup the PAL Entry Point, and a DXE implementation
+  can contain a constructor to look up the PAL Entry Point from a HOB.  This library class 
+  is only available on Intel Itanium-based platforms.
+  
+Copyright (c) 2006 - 2008, 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 __PAL_CALL_LIB_H__
+#define __PAL_CALL_LIB_H__
+
+#include <IndustryStandard/Pal.h>
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on Intel Itanium-based platforms.
+
+  @param Index  The PAL procedure Index number.
+  @param Arg2   The 2nd parameter for PAL procedure calls.
+  @param Arg3   The 3rd parameter for PAL procedure calls.
+  @param Arg4   The 4th parameter for PAL procedure calls.
+
+  @return Structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  );
+
+#endif
+
diff --git a/MdePkg/Include/Library/PcdLib.h b/MdePkg/Include/Library/PcdLib.h
new file mode 100644
index 000000000000..fdb2df87aa0f
--- /dev/null
+++ b/MdePkg/Include/Library/PcdLib.h
@@ -0,0 +1,2260 @@
+/** @file
+  Provides library services to get and set Platform Configuration Database entries.
+
+  PCD Library Class provides a PCD usage macro interface for all PCD types.
+  It should be included in any module that uses PCD. If a module uses dynamic/dynamicex
+  PCD, module should be linked to a PEIM/DXE library instance to access that PCD.
+  If a module uses PatchableInModule type PCD, it also needs the library instance to produce
+  LibPatchPcdSetPtr() interface. For FeatureFlag/Fixed PCD, the macro interface is
+  translated to a variable or macro that is auto-generated by build tool in
+  module's autogen.h/autogen.c.
+  The PcdGetXX(), PcdSetXX(), PcdToken(), and PcdGetNextTokenSpace() operations are 
+  only available prior to ExitBootServices().  If access to PCD values are required 
+  at runtime, then their values must be collected prior to ExitBootServices().
+  There are no restrictions on the use of FeaturePcd(), FixedPcdGetXX(),
+  PatchPcdGetXX(), and PatchPcdSetXX().
+
+Copyright (c) 2006 - 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 __PCD_LIB_H__
+#define __PCD_LIB_H__
+
+
+/**
+  Retrieves a token number based on a token name.
+
+  Returns the token number associated with the PCD token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve the token number for.
+
+  @return  The token number associated with the PCD.
+
+**/
+#define PcdToken(TokenName)                 _PCD_TOKEN_##TokenName
+
+
+/**
+  Retrieves a Boolean PCD feature flag based on a token name.
+
+  Returns the Boolean value for the PCD feature flag specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a feature flag PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  Boolean value for the PCD feature flag.
+
+**/
+#define FeaturePcdGet(TokenName)            _PCD_GET_MODE_BOOL_##TokenName
+
+
+/**
+  Retrieves an 8-bit fixed PCD token value based on a token name.
+
+  Returns the 8-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  8-bit value for the token specified by TokenName.
+
+**/
+#define FixedPcdGet8(TokenName)             _PCD_VALUE_##TokenName
+
+
+/**
+  Retrieves a 16-bit fixed PCD token value based on a token name.
+
+  Returns the 16-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  16-bit value for the token specified by TokenName.
+
+**/
+#define FixedPcdGet16(TokenName)            _PCD_VALUE_##TokenName
+
+
+/**
+  Retrieves a 32-bit fixed PCD token value based on a token name.
+
+  Returns the 32-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  32-bit value for the token specified by TokenName.
+
+**/
+#define FixedPcdGet32(TokenName)            _PCD_VALUE_##TokenName
+
+
+/**
+  Retrieves a 64-bit fixed PCD token value based on a token name.
+
+  Returns the 64-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  64-bit value for the token specified by TokenName.
+
+**/
+#define FixedPcdGet64(TokenName)            _PCD_VALUE_##TokenName
+
+
+/**
+  Retrieves a Boolean fixed PCD token value based on a token name.
+
+  Returns the Boolean value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  The Boolean value for the token. 
+
+**/
+#define FixedPcdGetBool(TokenName)          _PCD_VALUE_##TokenName
+
+
+/**
+  Retrieves a pointer to a fixed PCD token buffer based on a token name.
+
+  Returns a pointer to the buffer for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a fixed at build PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A pointer to the buffer. 
+
+**/
+#define FixedPcdGetPtr(TokenName)           ((VOID *)_PCD_VALUE_##TokenName)
+
+
+/**
+  Retrieves an 8-bit binary patchable PCD token value based on a token name.
+
+  Returns the 8-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  An 8-bit binary patchable PCD token value.
+
+**/
+#define PatchPcdGet8(TokenName)             _gPcd_BinaryPatch_##TokenName
+
+/**
+  Retrieves a 16-bit binary patchable PCD token value based on a token name.
+
+  Returns the 16-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A 16-bit binary patchable PCD token value.
+
+**/
+#define PatchPcdGet16(TokenName)            _gPcd_BinaryPatch_##TokenName
+
+
+/**
+  Retrieves a 32-bit binary patchable PCD token value based on a token name.
+
+  Returns the 32-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A 32-bit binary patchable PCD token value.
+
+**/
+#define PatchPcdGet32(TokenName)            _gPcd_BinaryPatch_##TokenName
+
+
+/**
+  Retrieves a 64-bit binary patchable PCD token value based on a token name.
+
+  Returns the 64-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A 64-bit binary patchable PCD token value.
+
+**/
+#define PatchPcdGet64(TokenName)            _gPcd_BinaryPatch_##TokenName
+
+
+/**
+  Retrieves a Boolean binary patchable PCD token value based on a token name.
+
+  Returns the Boolean value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  The Boolean value for the token.
+
+**/
+#define PatchPcdGetBool(TokenName)          _gPcd_BinaryPatch_##TokenName
+
+
+/**
+  Retrieves a pointer to a binary patchable PCD token buffer based on a token name.
+
+  Returns a pointer to the buffer for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A pointer to the buffer for the token.
+
+**/
+#define PatchPcdGetPtr(TokenName)           ((VOID *)_gPcd_BinaryPatch_##TokenName)
+
+
+/**
+  Sets an 8-bit binary patchable PCD token value based on a token name.
+
+  Sets the 8-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the binary patchable PCD token to set the current value for.
+  @param   Value      The 8-bit value to set.
+  
+  @return Return the Value that was set.
+
+**/
+#define PatchPcdSet8(TokenName, Value)      (_gPcd_BinaryPatch_##TokenName = (Value))
+
+
+/**
+  Sets a 16-bit binary patchable PCD token value based on a token name.
+
+  Sets the 16-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the binary patchable PCD token to set the current value for.
+  @param   Value      The 16-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PatchPcdSet16(TokenName, Value)     (_gPcd_BinaryPatch_##TokenName = (Value))
+
+
+/**
+  Sets a 32-bit binary patchable PCD token value based on a token name.
+
+  Sets the 32-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the binary patchable PCD token to set the current value for.
+  @param   Value      The 32-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PatchPcdSet32(TokenName, Value)     (_gPcd_BinaryPatch_##TokenName = (Value))
+
+
+/**
+  Sets a 64-bit binary patchable PCD token value based on a token name.
+
+  Sets the 64-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the binary patchable PCD token to set the current value for.
+  @param   Value      The 64-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PatchPcdSet64(TokenName, Value)     (_gPcd_BinaryPatch_##TokenName = (Value))
+
+
+/**
+  Sets a Boolean binary patchable PCD token value based on a token name.
+
+  Sets the Boolean value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+
+  @param   TokenName  The name of the binary patchable PCD token to set the current value for.
+  @param   Value      The boolean value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PatchPcdSetBool(TokenName, Value)   (_gPcd_BinaryPatch_##TokenName = (Value))
+
+
+/**
+  Sets a pointer to a binary patchable PCD token buffer based on a token name.
+
+  Sets the buffer for the token specified by TokenName.  Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size supported by TokenName, then set SizeOfBuffer
+  to the maximum size supported by TokenName and return NULL to indicate that the set operation 
+  was not actually performed.  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be 
+  set to the maximum size supported by TokenName and NULL must be returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  If TokenName is not a patchable in module PCD, then the module will not build.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param   TokenName      The name of the binary patchable PCD token to set the current value for.
+  @param   SizeOfBuffer   A pointer to the size, in bytes, of Buffer.
+  @param   Buffer         Pointer to the value to set.
+
+  @return Return the pointer to the Buffer that was set.
+
+**/
+#define PatchPcdSetPtr(TokenName, Size, Buffer) \
+                                            LibPatchPcdSetPtrAndSize (                 \
+                                              (VOID *)_gPcd_BinaryPatch_##TokenName,   \
+                                              &_gPcd_BinaryPatch_Size_##TokenName,     \
+                                              (UINTN)_PCD_PATCHABLE_##TokenName##_SIZE, \
+                                              (Size),                                  \
+                                              (Buffer)                                 \
+                                              )
+/**
+  Retrieves an 8-bit PCD token value based on a token name.
+  
+  Returns the 8-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  8-bit value for the token specified by TokenName.
+
+**/
+#define PcdGet8(TokenName)                  _PCD_GET_MODE_8_##TokenName
+
+
+/**
+  Retrieves a 16-bit PCD token value based on a token name.
+
+  Returns the 16-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  16-bit value for the token specified by TokenName.
+
+**/
+#define PcdGet16(TokenName)                 _PCD_GET_MODE_16_##TokenName
+
+
+/**
+  Retrieves a 32-bit PCD token value based on a token name.
+
+  Returns the 32-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  32-bit value for the token specified by TokenName.
+
+**/
+#define PcdGet32(TokenName)                 _PCD_GET_MODE_32_##TokenName
+
+
+/**
+  Retrieves a 64-bit PCD token value based on a token name.
+
+  Returns the 64-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  64-bit value for the token specified by TokenName.
+
+**/
+#define PcdGet64(TokenName)                 _PCD_GET_MODE_64_##TokenName
+
+
+/**
+  Retrieves a pointer to a PCD token buffer based on a token name.
+
+  Returns a pointer to the buffer for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A pointer to the buffer.
+
+**/
+#define PcdGetPtr(TokenName)                _PCD_GET_MODE_PTR_##TokenName
+
+
+/**
+  Retrieves a Boolean PCD token value based on a token name.
+
+  Returns the Boolean value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+
+  @return  A Boolean PCD token value.
+
+**/
+#define PcdGetBool(TokenName)               _PCD_GET_MODE_BOOL_##TokenName
+
+
+/**
+  Retrieves the size of a fixed PCD token based on a token name.
+
+  Returns the size of the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param[in]  TokenName  The name of the PCD token to retrieve a current value size for.
+
+  @return     Return the size
+
+**/
+#define FixedPcdGetSize(TokenName)    _PCD_SIZE_##TokenName
+
+
+/**
+  Retrieves the size of a binary patchable PCD token based on a token name.
+
+  Returns the size of the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param[in]  TokenName  The name of the PCD token to retrieve a current value size for.
+
+  @return     Return the size
+
+**/
+#define PatchPcdGetSize(TokenName)    _gPcd_BinaryPatch_Size_##TokenName
+
+
+/**
+  Retrieves the size of the PCD token based on a token name.
+  
+  Returns the size of the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  
+  @param[in]   TokenName  The name of the PCD token to retrieve a current value size for.
+
+  @return      Return the size
+
+**/
+#define PcdGetSize(TokenName)         _PCD_GET_MODE_SIZE_##TokenName
+
+
+/**
+  Retrieve the size of a given PCD token.
+  
+  Returns the size of the token specified by TokenNumber and Guid. 
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value size for.
+
+  @return     Return the size.
+
+**/
+#define PcdGetExSize(Guid, TokenName) LibPcdGetExSize ((Guid), PcdTokenEx(Guid,TokenName))
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  Sets an 8-bit PCD token value based on a token name.
+
+  Sets the 8-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+  @param   Value      The 8-bit value to set.
+  
+  @return Return the Value that was set.
+
+**/
+#define PcdSet8(TokenName, Value)           _PCD_SET_MODE_8_##TokenName     ((Value))
+
+
+/**
+  Sets a 16-bit PCD token value based on a token name.
+
+  Sets the 16-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+  @param   Value      The 16-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSet16(TokenName, Value)          _PCD_SET_MODE_16_##TokenName    ((Value))
+
+
+/**
+  Sets a 32-bit PCD token value based on a token name.
+
+  Sets the 32-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+  @param   Value      The 32-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSet32(TokenName, Value)          _PCD_SET_MODE_32_##TokenName    ((Value))
+
+
+/**
+  Sets a 64-bit PCD token value based on a token name.
+
+  Sets the 64-bit value for the token specified by TokenName. Value is returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName  The name of the PCD token to retrieve a current value for.
+  @param   Value      The 64-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSet64(TokenName, Value)          _PCD_SET_MODE_64_##TokenName    ((Value))
+
+
+/**
+  Sets a pointer to a PCD token buffer based on a token name.
+
+  Sets the buffer for the token specified by TokenName. Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size supported by TokenName, 
+  then set SizeOfBuffer to the maximum size supported by TokenName and return NULL 
+  to indicate that the set operation was not actually performed.  If SizeOfBuffer 
+  is set to MAX_ADDRESS, then SizeOfBuffer must be set to the maximum size supported 
+  by TokenName and NULL must be returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param   TokenName      The name of the PCD token to set the current value for.
+  @param   SizeOfBuffer   A pointer to the size, in bytes, of Buffer.
+  @param   Buffer         A pointer to the buffer to set.
+
+  @return Return the pointer to the Buffer that was set.
+
+**/
+#define PcdSetPtr(TokenName, SizeOfBuffer, Buffer) \
+                                            _PCD_SET_MODE_PTR_##TokenName   ((SizeOfBuffer), (Buffer))
+                                            
+/**
+  Sets a Boolean PCD token value based on a token name.
+
+  Sets the Boolean value for the token specified by TokenName. Value is returned. 
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   TokenName      The name of the PCD token to set the current value for.
+  @param   Buffer         The Boolean value to set.
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSetBool(TokenName, Value)        _PCD_SET_MODE_BOOL_##TokenName  ((Value))
+#endif
+
+/**
+  Sets a 8-bit PCD token value based on a token name.
+
+  Sets the 8-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param TokenName  The name of the PCD token to retrieve a current value for.
+  @param Value      The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSet8S(TokenName, Value)          _PCD_SET_MODE_8_S_##TokenName    ((Value))
+
+/**
+  Sets a 16-bit PCD token value based on a token name.
+
+  Sets the 16-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param TokenName  The name of the PCD token to retrieve a current value for.
+  @param Value      The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSet16S(TokenName, Value)         _PCD_SET_MODE_16_S_##TokenName    ((Value))
+
+/**
+  Sets a 32-bit PCD token value based on a token name.
+
+  Sets the 32-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param TokenName  The name of the PCD token to retrieve a current value for.
+  @param Value      The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSet32S(TokenName, Value)         _PCD_SET_MODE_32_S_##TokenName    ((Value))
+
+/**
+  Sets a 64-bit PCD token value based on a token name.
+
+  Sets the 64-bit value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param TokenName  The name of the PCD token to retrieve a current value for.
+  @param Value      The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSet64S(TokenName, Value)         _PCD_SET_MODE_64_S_##TokenName    ((Value))
+
+/**
+  Sets a pointer to a PCD token buffer based on a token name.
+
+  Sets the buffer for the token specified by TokenName.
+  If SizeOfBuffer is greater than the maximum size supported by TokenName,
+  then set SizeOfBuffer to the maximum size supported by TokenName and return
+  RETURN_INVALID_PARAMETER to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the maximum size
+  supported by TokenName and RETURN_INVALID_PARAMETER must be returned.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param TokenName      The name of the PCD token to set the current value for.
+  @param SizeOfBuffer   A pointer to the size, in bytes, of Buffer.
+  @param Buffer         A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetPtrS(TokenName, SizeOfBuffer, Buffer) \
+                                            _PCD_SET_MODE_PTR_S_##TokenName   ((SizeOfBuffer), (Buffer))
+
+
+
+/**
+  Sets a boolean PCD token value based on a token name.
+
+  Sets the boolean value for the token specified by TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param TokenName  The name of the PCD token to retrieve a current value for.
+  @param Value      The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetBoolS(TokenName, Value)       _PCD_SET_MODE_BOOL_S_##TokenName    ((Value))
+
+/**
+  Retrieves a token number based on a GUID and a token name.
+
+  Returns the token number for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space, then the module will not build.
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  Return the token number.
+
+**/
+#define PcdTokenEx(Guid,TokenName)  _PCD_TOKEN_EX_##TokenName(Guid)
+
+/**
+  Retrieves an 8-bit PCD token value based on a GUID and a token name.
+
+  Returns the 8-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+  
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  An 8-bit PCD token value.
+
+**/
+#define PcdGetEx8(Guid, TokenName)          LibPcdGetEx8 ((Guid), PcdTokenEx(Guid,TokenName))
+
+/**
+  Retrieves a 16-bit PCD token value based on a GUID and a token name.
+
+  Returns the 16-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  A 16-bit PCD token value.
+
+**/
+#define PcdGetEx16(Guid, TokenName)         LibPcdGetEx16 ((Guid), PcdTokenEx(Guid,TokenName))
+
+
+/**
+  Retrieves a 32-bit PCD token value based on a GUID and a token name.
+
+  Returns the 32-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  A 32-bit PCD token value.
+
+**/
+#define PcdGetEx32(Guid, TokenName)         LibPcdGetEx32 ((Guid), PcdTokenEx(Guid,TokenName))
+
+
+/**
+  Retrieves a 64-bit PCD token value based on a GUID and a token name.
+
+  Returns the 64-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  A 64-bit PCD token value.
+
+**/
+#define PcdGetEx64(Guid, TokenName)         LibPcdGetEx64 ((Guid), PcdTokenEx(Guid,TokenName))
+
+
+/**
+  Retrieves a pointer to a PCD token buffer based on a GUID and a token name.
+
+  Returns a pointer to the buffer for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  A pointer to a PCD token buffer.
+
+**/
+#define PcdGetExPtr(Guid, TokenName)        LibPcdGetExPtr ((Guid), PcdTokenEx(Guid,TokenName))
+
+
+/**
+  Retrieves a Boolean PCD token value based on a GUID and a token name.
+
+  Returns the Boolean value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to retrieve a current value for.                 
+
+  @return  A Boolean PCD token value.
+
+**/
+#define PcdGetExBool(Guid, TokenName)       LibPcdGetExBool  ((Guid), PcdTokenEx(Guid,TokenName))
+
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  Sets an 8-bit PCD token value based on a GUID and a token name.
+
+  Sets the 8-bit value for the token specified by Guid and TokenName. Value is returned.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to set the current value for.
+  @param   Value       The 8-bit value to set.                   
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSetEx8(Guid, TokenName, Value)   LibPcdSetEx8   ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+
+/**
+  Sets a 16-bit PCD token value based on a GUID and a token name.
+
+  Sets the 16-bit value for the token specified by Guid and TokenName. Value is returned.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to set the current value for.
+  @param   Value       The 16-bit value to set.                   
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSetEx16(Guid, TokenName, Value)  LibPcdSetEx16  ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+
+/**
+  Sets a 32-bit PCD token value based on a GUID and a token name.
+
+  Sets the 32-bit value for the token specified by Guid and TokenName. Value is returned.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+                       which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to set the current value for.
+  @param   Value       The 32-bit value to set.                   
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSetEx32(Guid, TokenName, Value)  LibPcdSetEx32  ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+
+/**
+  Sets a 64-bit PCD token value based on a GUID and a token name.
+
+  Sets the 64-bit value for the token specified by Guid and TokenName. Value is returned.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid        Pointer to a 128-bit unique value that designates 
+  which namespace to retrieve a value from.
+  @param   TokenName   The name of the PCD token to set the current value for.
+  @param   Value       The 64-bit value to set.                   
+
+  @return Return the Value that was set.
+
+**/
+#define PcdSetEx64(Guid, TokenName, Value)  LibPcdSetEx64  ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+
+/**
+  Sets a pointer to a PCD token buffer based on a GUID and a token name.
+
+  Sets the buffer for the token specified by Guid and TokenName. Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size supported by Guid and TokenName, 
+  then set SizeOfBuffer to the maximum size supported by Guid and TokenName and return 
+  NULL to indicate that the set operation was not actually performed. If SizeOfBuffer 
+  is set to MAX_ADDRESS, then SizeOfBuffer must be set to the maximum size supported by
+  Guid and TokenName and NULL must be returned.
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+  
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param   Guid           Pointer to a 128-bit unique value that designates 
+                          which namespace to retrieve a value from.
+  @param   TokenName      The name of the PCD token to set the current value for.
+  @param   SizeOfBuffer   A pointer to the size, in bytes, of Buffer.                  
+  @param   Buffer         Pointer to the buffer to set.
+    
+  @return Return the pointer to the Buffer that was set.
+
+**/
+#define PcdSetExPtr(Guid, TokenName, SizeOfBuffer, Buffer) \
+                                            LibPcdSetExPtr ((Guid), PcdTokenEx(Guid,TokenName), (SizeOfBuffer), (Buffer))
+
+
+/**
+  Sets a Boolean PCD token value based on a GUID and a token name.
+
+  Sets the Boolean value for the token specified by Guid and TokenName. Value is returned. 
+  If TokenName is not a valid token in the token space specified by Guid, 
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param   Guid           Pointer to a 128-bit unique value that designates 
+                          which namespace to retrieve a value from.
+  @param   TokenName      The name of the PCD token to set the current value for.              
+  @param   Value          The Boolean value to set.
+
+  @return Return the Value that was set.
+
+**/                                         
+#define PcdSetExBool(Guid, TokenName, Value) \
+                                            LibPcdSetExBool((Guid), PcdTokenEx(Guid,TokenName), (Value))
+#endif
+
+/**
+  Sets an 8-bit PCD token value based on a GUID and a token name.
+
+  Sets the 8-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param Guid       Pointer to a 128-bit unique value that designates
+                    which namespace to retrieve a value from.
+  @param TokenName  The name of the PCD token to set the current value for.
+  @param Value      The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetEx8S(Guid, TokenName, Value)     LibPcdSetEx8S ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+/**
+  Sets an 16-bit PCD token value based on a GUID and a token name.
+
+  Sets the 16-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param Guid       Pointer to a 128-bit unique value that designates
+                    which namespace to retrieve a value from.
+  @param TokenName  The name of the PCD token to set the current value for.
+  @param Value      The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetEx16S(Guid, TokenName, Value)    LibPcdSetEx16S ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+/**
+  Sets an 32-bit PCD token value based on a GUID and a token name.
+
+  Sets the 32-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param Guid       Pointer to a 128-bit unique value that designates
+                    which namespace to retrieve a value from.
+  @param TokenName  The name of the PCD token to set the current value for.
+  @param Value      The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetEx32S(Guid, TokenName, Value)    LibPcdSetEx32S ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+/**
+  Sets an 64-bit PCD token value based on a GUID and a token name.
+
+  Sets the 64-bit value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param Guid       Pointer to a 128-bit unique value that designates
+                    which namespace to retrieve a value from.
+  @param TokenName  The name of the PCD token to set the current value for.
+  @param Value      The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetEx64S(Guid, TokenName, Value)    LibPcdSetEx64S ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+/**
+  Sets a pointer to a PCD token buffer based on a GUID and a token name.
+
+  Sets the buffer for the token specified by Guid and TokenName.
+  If SizeOfBuffer is greater than the maximum size supported by Guid and TokenName,
+  then set SizeOfBuffer to the maximum size supported by Guid and TokenName and return
+  RETURN_INVALID_PARAMETER to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the maximum size
+  supported by Guid and TokenName and RETURN_INVALID_PARAMETER must be returned.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param Guid           Pointer to a 128-bit unique value that designates
+                        which namespace to retrieve a value from.
+  @param TokenName      The name of the PCD token to set the current value for.
+  @param SizeOfBuffer   A pointer to the size, in bytes, of Buffer.
+  @param Buffer         Pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetExPtrS(Guid, TokenName, SizeOfBuffer, Buffer) \
+                                            LibPcdSetExPtrS ((Guid), PcdTokenEx(Guid,TokenName), (SizeOfBuffer), (Buffer))
+
+
+/**
+  Sets an boolean PCD token value based on a GUID and a token name.
+
+  Sets the boolean value for the token specified by Guid and TokenName.
+  If TokenName is not a valid token in the token space specified by Guid,
+  then the module will not build.
+
+  If Guid is NULL, then ASSERT().
+
+  @param Guid       Pointer to a 128-bit unique value that designates
+                    which namespace to retrieve a value from.
+  @param TokenName  The name of the PCD token to set the current value for.
+  @param Value      The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+#define PcdSetExBoolS(Guid, TokenName, Value) \
+                                            LibPcdSetExBoolS ((Guid), PcdTokenEx(Guid,TokenName), (Value))
+
+/**
+  This function provides a means by which SKU support can be established in the PCD infrastructure.
+
+  Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
+
+  @param  SkuId   The SKU value that will be used when the PCD service retrieves and sets values
+                  associated with a PCD token.
+
+  @return  Return the SKU ID that was set.
+
+**/
+UINTN
+EFIAPI
+LibPcdSetSku (
+  IN UINTN   SkuId
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 8-bit value for the token specified by TokenNumber. 
+
+**/
+UINT8
+EFIAPI
+LibPcdGet8 (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 16-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 16-bit value for the token specified by TokenNumber. 
+
+**/
+UINT16
+EFIAPI
+LibPcdGet16 (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 32-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 32-bit value for the token specified by TokenNumber.
+
+**/
+UINT32
+EFIAPI
+LibPcdGet32 (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 64-bit value for the token specified by TokenNumber.
+
+**/
+UINT64
+EFIAPI
+LibPcdGet64 (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the pointer to the token specified by TokenNumber.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetPtr (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the Boolean value of the token specified by TokenNumber. 
+
+**/
+BOOLEAN 
+EFIAPI
+LibPcdGetBool (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the size of the token specified by TokenNumber. 
+
+**/
+UINTN
+EFIAPI
+LibPcdGetSize (
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         Pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT8.
+
+**/
+UINT8
+EFIAPI
+LibPcdGetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+
+  Returns the 16-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         Pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT16.
+
+**/
+UINT16
+EFIAPI
+LibPcdGetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  Returns the 32-bit value for the token specified by TokenNumber and Guid.
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         Pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT32.
+
+**/
+UINT32
+EFIAPI
+LibPcdGetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the UINT64.
+
+**/
+UINT64
+EFIAPI
+LibPcdGetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the VOID* pointer.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetExPtr (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the BOOLEAN.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdGetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+  
+  Returns the size of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the size.
+
+**/
+UINTN
+EFIAPI
+LibPcdGetExSize (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSet8 (
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSet16 (
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSet32 (
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSet64 (
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value 
+  specified by Buffer and SizeOfBuffer.  Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size support by TokenNumber, 
+  then set SizeOfBuffer to the maximum size supported by TokenNumber and 
+  return NULL to indicate that the set operation was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 
+  maximum size supported by TokenName and NULL must be returned.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return Return the pointer for the Buffer that was set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetPtr (
+  IN        UINTN             TokenNumber,
+  IN OUT    UINTN             *SizeOfBuffer,
+  IN CONST  VOID              *Buffer
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The boolean value to set.
+
+  @return Return the Value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetBool (
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the Value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value specified by 
+  Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size 
+  supported by TokenNumber and return NULL to indicate that the set operation 
+  was not actually performed.
+  
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]  Guid              Pointer to a 128-bit unique value that 
+                                designates which namespace to set a value from.
+  @param[in]  TokenNumber       The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]  Buffer            A pointer to the buffer to set.
+
+  @return Return the pointer to the Buffer that was set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetExPtr (
+  IN      CONST GUID        *Guid,
+  IN      UINTN             TokenNumber,
+  IN OUT  UINTN             *SizeOfBuffer,
+  IN      VOID              *Buffer
+  );
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          Pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The Boolean value to set.
+
+  @return Return the Value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  );
+#endif
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet8S (
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet16S (
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet32S (
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet64S (
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return RETURN_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
+  maximum size supported by TokenName and RETURN_INVALID_PARAMETER must be returned.
+
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetPtrS (
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetBoolS (
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx8S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx16S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx32S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx64S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified by
+  Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return RETURN_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      Guid          Pointer to a 128-bit unique value that
+                                designates which namespace to set a value from.
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExPtrS (
+  IN CONST GUID     *Guid,
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN       VOID     *Buffer
+  );
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExBoolS (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  );
+
+/**
+  This notification function serves two purposes.
+
+  Firstly, it notifies the module that did the registration that the value of this
+  PCD token has been set.
+  Secondly, it provides a mechanism for the module that did the registration to intercept
+  the set operation and override the value been set if necessary. After the invocation of
+  the callback function, TokenData will be used by PCD service PEIM or driver to modify th
+  internal data in PCD database. 
+
+  @param[in]      CallBackGuid    The PCD token GUID being set.
+  @param[in]      CallBackToken   The PCD token number being set.
+  @param[in, out] TokenData       A pointer to the token data being set.
+  @param[in]      TokenDataSize   The size, in bytes, of the data being set.
+
+**/
+typedef
+VOID
+(EFIAPI *PCD_CALLBACK)(
+  IN        CONST GUID        *CallBackGuid, OPTIONAL
+  IN        UINTN             CallBackToken,
+  IN  OUT   VOID              *TokenData,
+  IN        UINTN             TokenDataSize
+  );
+
+
+/**
+  Set up a notification function that is called when a specified token is set.
+  
+  When the token specified by TokenNumber and Guid is set, 
+  then notification function specified by NotificationFunction is called.  
+  If Guid is NULL, then the default token space is used.
+  If NotificationFunction is NULL, then ASSERT().
+
+  @param[in]  Guid                  Pointer to a 128-bit unique value that designates which 
+                                    namespace to set a value from.  If NULL, then the default 
+                                    token space is used.
+  @param[in]  TokenNumber           The PCD token number to monitor.
+  @param[in]  NotificationFunction  The function to call when the token 
+                                    specified by Guid and TokenNumber is set.
+
+**/
+VOID
+EFIAPI
+LibPcdCallbackOnSet (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  );
+
+
+/**
+  Disable a notification function that was established with LibPcdCallbackonSet().
+  
+  Disable a notification function that was previously established with LibPcdCallbackOnSet().
+  If NotificationFunction is NULL, then ASSERT().
+  If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber, 
+  and NotificationFunction, then ASSERT().
+  
+  @param[in]  Guid                 Specify the GUID token space.
+  @param[in]  TokenNumber          Specify the token number.
+  @param[in]  NotificationFunction The callback function to be unregistered.
+
+**/
+VOID
+EFIAPI
+LibPcdCancelCallback (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  );
+
+
+/**
+  Retrieves the next token in a token space.
+  
+  Retrieves the next PCD token number from the token space specified by Guid.  
+  If Guid is NULL, then the default token space is used.  If TokenNumber is 0, 
+  then the first token number is returned.  Otherwise, the token number that 
+  follows TokenNumber in the token space is returned.  If TokenNumber is the last 
+  token number in the token space, then 0 is returned.  
+  
+  If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]  Guid        Pointer to a 128-bit unique value that designates which namespace 
+                          to set a value from.  If NULL, then the default token space is used.
+  @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD 
+                          token number.
+
+  @return The next valid token number.
+
+**/
+UINTN           
+EFIAPI
+LibPcdGetNextToken (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber
+  );
+
+
+
+/**
+  Used to retrieve the list of available PCD token space GUIDs.
+  
+  Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
+  in the platform.
+  If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
+  If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
+  
+  @param  TokenSpaceGuid  Pointer to the a PCD token space GUID
+
+  @return The next valid token namespace.
+
+**/
+GUID *
+EFIAPI
+LibPcdGetNextTokenSpace (
+  IN CONST GUID  *TokenSpaceGuid
+  );
+
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the Buffer that was set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtr (
+  OUT        VOID       *PatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  );
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrS (
+  OUT      VOID     *PatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  );
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer. Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the Buffer that was set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtrAndSize (
+  OUT       VOID        *PatchVariable,
+  OUT       UINTN       *SizeOfPatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  );
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrAndSizeS (
+  OUT      VOID     *PatchVariable,
+  OUT      UINTN    *SizeOfPatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  );
+
+typedef enum {
+  PCD_TYPE_8,
+  PCD_TYPE_16,
+  PCD_TYPE_32,
+  PCD_TYPE_64,
+  PCD_TYPE_BOOL,
+  PCD_TYPE_PTR
+} PCD_TYPE;
+
+typedef struct {
+  ///
+  /// The returned information associated with the requested TokenNumber. If
+  /// TokenNumber is 0, then PcdType is set to PCD_TYPE_8.
+  ///
+  PCD_TYPE          PcdType;
+  ///
+  /// The size of the data in bytes associated with the TokenNumber specified. If
+  /// TokenNumber is 0, then PcdSize is set 0.
+  ///
+  UINTN             PcdSize;
+  ///
+  /// The null-terminated ASCII string associated with a given token. If the
+  /// TokenNumber specified was 0, then this field corresponds to the null-terminated
+  /// ASCII string associated with the token's namespace Guid. If NULL, there is no
+  /// name associated with this request.
+  ///
+  CHAR8             *PcdName;
+} PCD_INFO;
+
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the default token space specified, then ASSERT().
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfo (
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  );
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfoEx (
+  IN CONST  GUID            *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  );
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+UINTN
+EFIAPI
+LibPcdGetSku (
+  VOID
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PciCf8Lib.h b/MdePkg/Include/Library/PciCf8Lib.h
new file mode 100644
index 000000000000..d77f406ebd16
--- /dev/null
+++ b/MdePkg/Include/Library/PciCf8Lib.h
@@ -0,0 +1,1094 @@
+/** @file
+  Provides services to access PCI Configuration Space using the I/O ports 0xCF8 and 0xCFC.
+  
+  This library is identical to the PCI Library, except the access method for performing PCI 
+  configuration cycles must be through I/O ports 0xCF8 and 0xCFC.  This library only allows 
+  access to PCI Segment #0.
+
+Copyright (c) 2006 - 2012, 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 __PCI_CF8_LIB_H__
+#define __PCI_CF8_LIB_H__
+
+
+/**
+  Macro that converts PCI Bus, PCI Device, PCI Function and PCI Register to an
+  address that can be passed to the PCI Library functions.
+
+  Computes an address that is compatible with the PCI Library functions. The
+  unused upper bits of Bus, Device, Function and Register are stripped prior to
+  the generation of the address.
+
+  @param  Bus       PCI Bus number. Range 0..255.
+  @param  Device    PCI Device number. Range 0..31.
+  @param  Function  PCI Function number. Range 0..7.
+  @param  Register  PCI Register number. Range 0..255.
+
+  @return The encode PCI address.
+
+**/
+#define PCI_CF8_LIB_ADDRESS(Bus,Device,Function,Offset) \
+  (((Offset) & 0xfff) | (((Function) & 0x07) << 12) | (((Device) & 0x1f) << 15) | (((Bus) & 0xff) << 20))
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciCf8RegisterForRuntimeAccess (
+  IN UINTN  Address
+  );
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Read8 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Write8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  );
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Or8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8And8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8AndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Read16 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Write16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Or16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8And16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8AndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Read32 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Write32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Or32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8And32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8AndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If the register specified by StartAddress >= 0x100, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x100, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size read from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciCf8ReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If the register specified by StartAddress >= 0x100, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x100, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciCf8WriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PciExpressLib.h b/MdePkg/Include/Library/PciExpressLib.h
new file mode 100644
index 000000000000..80e9d1279cfd
--- /dev/null
+++ b/MdePkg/Include/Library/PciExpressLib.h
@@ -0,0 +1,1061 @@
+/** @file
+  Provides services to access PCI Configuration Space using the MMIO PCI Express window.
+  
+  This library is identical to the PCI Library, except the access method for performing PCI 
+  configuration cycles must be through the 256 MB PCI Express MMIO window whose base address
+  is defined by PcdPciExpressBaseAddress.
+
+Copyright (c) 2006 - 2012, 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 __PCI_EXPRESS_LIB_H__
+#define __PCI_EXPRESS_LIB_H__
+
+/**
+  Macro that converts PCI Bus, PCI Device, PCI Function and PCI Register to an
+  address that can be passed to the PCI Library functions.
+
+  Computes an address that is compatible with the PCI Library functions. The
+  unused upper bits of Bus, Device, Function and Register are stripped prior to
+  the generation of the address.
+
+  @param  Bus       PCI Bus number. Range 0..255.
+  @param  Device    PCI Device number. Range 0..31.
+  @param  Function  PCI Function number. Range 0..7.
+  @param  Register  PCI Register number. Range 0..4095.
+
+  @return The encode PCI address.
+
+**/
+#define PCI_EXPRESS_LIB_ADDRESS(Bus,Device,Function,Offset) \
+  (((Offset) & 0xfff) | (((Function) & 0x07) << 12) | (((Device) & 0x1f) << 15) | (((Bus) & 0xff) << 20))
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration 
+  registers associated with that PCI device may be accessed after SetVirtualAddressMap() 
+  is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciExpressRegisterForRuntimeAccess (
+  IN UINTN  Address
+  );
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressRead8 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  );
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressRead16 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressRead32 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size read data from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PciLib.h b/MdePkg/Include/Library/PciLib.h
new file mode 100644
index 000000000000..1b1de2904d81
--- /dev/null
+++ b/MdePkg/Include/Library/PciLib.h
@@ -0,0 +1,1062 @@
+/** @file
+  Provides services to access PCI Configuration Space.
+  
+  These functions perform PCI configuration cycles using the default PCI configuration 
+  access method. This may use I/O ports 0xCF8 and 0xCFC to perform PCI configuration accesses, 
+  or it may use MMIO registers relative to the PcdPciExpressBaseAddress, or it may use some 
+  alternate access method.  Modules will typically use the PCI Library for its PCI configuration 
+  accesses.  However, if a module requires a mix of PCI access methods, the PCI CF8 Library or 
+  PCI Express Library may be used in conjunction with the PCI Library.  The functionality of 
+  these three libraries is identical.  The PCI CF8 Library and PCI Express Library simply use 
+  explicit access methods.
+
+Copyright (c) 2006 - 2012, 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 __PCI_LIB_H__
+#define __PCI_LIB_H__
+
+/**
+  Macro that converts PCI Bus, PCI Device, PCI Function and PCI Register to an
+  address that can be passed to the PCI Library functions.
+
+  @param  Bus       PCI Bus number. Range 0..255.
+  @param  Device    PCI Device number. Range 0..31.
+  @param  Function  PCI Function number. Range 0..7.
+  @param  Register  PCI Register number. Range 0..255 for PCI. Range 0..4095
+                    for PCI Express.
+
+  @return The encoded PCI address.
+
+**/
+#define PCI_LIB_ADDRESS(Bus,Device,Function,Register)   \
+  (((Register) & 0xfff) | (((Function) & 0x07) << 12) | (((Device) & 0x1f) << 15) | (((Bus) & 0xff) << 20))
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  );
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  );
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed by a bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  );
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  );
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  );
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PciSegmentLib.h b/MdePkg/Include/Library/PciSegmentLib.h
new file mode 100644
index 000000000000..aad95ca31455
--- /dev/null
+++ b/MdePkg/Include/Library/PciSegmentLib.h
@@ -0,0 +1,1045 @@
+/** @file
+  Provides services to access PCI Configuration Space on a platform with multiple PCI segments.
+  
+  The PCI Segment Library function provide services to read, write, and modify the PCI configuration
+  registers on PCI root bridges on any supported PCI segment.  These library services take a single 
+  address parameter that encodes the PCI Segment, PCI Bus, PCI Device, PCI Function, and PCI Register.  
+  The layout of this address parameter is as follows:
+  
+            PCI Register: Bits 0..11
+            PCI Function  Bits 12..14
+            PCI Device  Bits 15..19
+            PCI Bus Bits 20..27
+            Reserved  Bits 28..31.  Must be 0.
+            PCI Segment Bits 32..47
+            Reserved  Bits 48..63.  Must be 0.
+            
+  | Reserved (MBZ) | Segment | Reserved (MBZ) |     Bus     | Device | Function | Register |
+  63             48  47    32  31           28 27         20 19    15 14      12 11         0
+
+  These functions perform PCI configuration cycles using the default PCI configuration access 
+  method.  This may use I/O ports 0xCF8 and 0xCFC to perform PCI configuration accesses, or it 
+  may use MMIO registers relative to the PcdPciExpressBaseAddress, or it may use some alternate 
+  access method.  Modules will typically use the PCI Segment Library for its PCI configuration 
+  accesses when PCI Segments other than Segment #0 must be accessed.  
+
+Copyright (c) 2006 - 2016, 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 __PCI_SEGMENT_LIB__
+#define __PCI_SEGMENT_LIB__
+
+
+/**
+  Macro that converts PCI Segment, PCI Bus, PCI Device, PCI Function,
+  and PCI Register to an address that can be passed to the PCI Segment Library functions.
+
+  Computes an address that is compatible with the PCI Segment Library functions.
+  The unused upper bits of Segment, Bus, Device, Function,
+  and Register are stripped prior to the generation of the address.
+
+  @param  Segment   PCI Segment number.  Range 0..65535.
+  @param  Bus       PCI Bus number.  Range 0..255.
+  @param  Device    PCI Device number.  Range 0..31.
+  @param  Function  PCI Function number.  Range 0..7.
+  @param  Register  PCI Register number.  Range 0..255 for PCI.  Range 0..4095 for PCI Express.
+
+  @return The address that is compatible with the PCI Segment Library functions.
+
+**/
+#define PCI_SEGMENT_LIB_ADDRESS(Segment,Bus,Device,Function,Register) \
+  ((Segment != 0) ? \
+    ( ((Register) & 0xfff)                 | \
+      (((Function) & 0x07) << 12)          | \
+      (((Device) & 0x1f) << 15)            | \
+      (((Bus) & 0xff) << 20)               | \
+      (LShiftU64 ((Segment) & 0xffff, 32))   \
+    ) :                                      \
+    ( ((Register) & 0xfff)                 | \
+      (((Function) & 0x07) << 12)          | \
+      (((Device) & 0x1f) << 15)            | \
+      (((Bus) & 0xff) << 20)                 \
+    )                                        \
+  )
+
+/**
+  Register a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciSegmentRegisterForRuntimeAccess (
+  IN UINTN  Address
+  );
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 8-bit PCI configuration register specified by Address.
+
+**/
+UINT8
+EFIAPI
+PciSegmentRead8 (
+  IN UINT64                    Address
+  );
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address     Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentWrite8 (
+  IN UINT64                    Address,
+  IN UINT8                     Value
+  );
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     OrData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAnd8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value,
+  followed a  bitwise OR with another 8-bit value.
+  
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldRead8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldWrite8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     Value
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAnd8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  );
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 16-bit PCI configuration register specified by Address.
+
+**/
+UINT16
+EFIAPI
+PciSegmentRead16 (
+  IN UINT64                    Address
+  );
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address     Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+PciSegmentWrite16 (
+  IN UINT64                    Address,
+  IN UINT16                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAnd16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value,
+  followed a  bitwise OR with another 16-bit value.
+  
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldRead16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldWrite16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    Value
+  );
+
+/**
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address. 
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR,
+  and writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  Extra left bits in OrData are stripped.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    The ordinal of the least significant bit in a byte is bit 0.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    The ordinal of the most significant bit in a byte is bit 7.
+  @param  AndData   The value to AND with the read value from the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAnd16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  );
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 32-bit PCI configuration register specified by Address.
+
+**/
+UINT32
+EFIAPI
+PciSegmentRead32 (
+  IN UINT64                    Address
+  );
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address     Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT32
+EFIAPI
+PciSegmentWrite32 (
+  IN UINT64                    Address,
+  IN UINT32                    Value
+  );
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    OrData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAnd32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value,
+  followed a  bitwise OR with another 32-bit value.
+  
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   Address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldRead32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldWrite32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    Value
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  
+  Reads the 32-bit PCI configuration register specified by Address, performs a bitwise
+  AND between the read result and the value specified by AndData, and writes the result
+  to the 32-bit PCI configuration register specified by Address. The value written to
+  the PCI configuration register is returned.  This function must guarantee that all PCI
+  read and write operations are serialized.  Extra left bits in AndData are stripped.
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAnd32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  );
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentReadBuffer (
+  IN  UINT64                   StartAddress,
+  IN  UINTN                    Size,
+  OUT VOID                     *Buffer
+  );
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return The parameter of Size.
+
+**/
+UINTN
+EFIAPI
+PciSegmentWriteBuffer (
+  IN UINT64                    StartAddress,
+  IN UINTN                     Size,
+  IN VOID                      *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PeCoffExtraActionLib.h b/MdePkg/Include/Library/PeCoffExtraActionLib.h
new file mode 100644
index 000000000000..1b73fc184ed1
--- /dev/null
+++ b/MdePkg/Include/Library/PeCoffExtraActionLib.h
@@ -0,0 +1,53 @@
+/** @file
+  Provides services to perform additional actions when a PE/COFF image is loaded
+  or unloaded.  This is useful for environment where symbols need to be loaded 
+  and unloaded to support source level debugging.
+
+  Copyright (c) 2009, 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 __PE_COFF_EXTRA_ACTION_LIB_H__
+#define __PE_COFF_EXTRA_ACTION_LIB_H__
+
+#include <Library/PeCoffLib.h>
+
+/**
+  Performs additional actions after a PE/COFF image has been loaded and relocated.
+
+  If ImageContext is NULL, then ASSERT().
+
+  @param  ImageContext  Pointer to the image context structure that describes the
+                        PE/COFF image that has already been loaded and relocated.
+
+**/
+VOID
+EFIAPI
+PeCoffLoaderRelocateImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+/**
+  Performs additional actions just before a PE/COFF image is unloaded.  Any resources
+  that were allocated by PeCoffLoaderRelocateImageExtraAction() must be freed.
+  
+  If ImageContext is NULL, then ASSERT().
+  
+  @param  ImageContext  Pointer to the image context structure that describes the
+                        PE/COFF image that is being unloaded.
+
+**/
+VOID
+EFIAPI
+PeCoffLoaderUnloadImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PeCoffGetEntryPointLib.h b/MdePkg/Include/Library/PeCoffGetEntryPointLib.h
new file mode 100644
index 000000000000..053d139c3366
--- /dev/null
+++ b/MdePkg/Include/Library/PeCoffGetEntryPointLib.h
@@ -0,0 +1,104 @@
+/** @file
+  Provides a service to retrieve the PE/COFF entry point from a PE/COFF image.
+
+Copyright (c) 2006 - 2010, 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 __PE_COFF_GET_ENTRY_POINT_LIB_H__
+#define __PE_COFF_GET_ENTRY_POINT_LIB_H__
+
+/**
+  Retrieves and returns a pointer to the entry point to a PE/COFF image that has been loaded
+  into system memory with the PE/COFF Loader Library functions.
+
+  Retrieves the entry point to the PE/COFF image specified by Pe32Data and returns this entry
+  point in EntryPoint.  If the entry point could not be retrieved from the PE/COFF image, then
+  return RETURN_INVALID_PARAMETER.  Otherwise return RETURN_SUCCESS.
+  If Pe32Data is NULL, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+
+  @param  Pe32Data                  The pointer to the PE/COFF image that is loaded in system memory.
+  @param  EntryPoint                The pointer to entry point to the PE/COFF image to return.
+
+  @retval RETURN_SUCCESS            EntryPoint was returned.
+  @retval RETURN_INVALID_PARAMETER  The entry point could not be found in the PE/COFF image.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderGetEntryPoint (
+  IN  VOID  *Pe32Data,
+  OUT VOID  **EntryPoint
+  );
+
+/**
+  Returns the machine type of a PE/COFF image.
+
+  Returns the machine type from the PE/COFF image specified by Pe32Data.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return Machine type or zero if not a valid image.
+
+**/
+UINT16
+EFIAPI
+PeCoffLoaderGetMachineType (
+  IN VOID  *Pe32Data
+  );
+
+/**
+  Returns a pointer to the PDB file name for a PE/COFF image that has been
+  loaded into system memory with the PE/COFF Loader Library functions. 
+
+  Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If
+  the PE/COFF image specified by Pe32Data is not a valid, then NULL is
+  returned.  If the PE/COFF image specified by Pe32Data does not contain a
+  debug directory entry, then NULL is returned.  If the debug directory entry
+  in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
+  then NULL is returned.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return The PDB file name for the PE/COFF image specified by Pe32Data, or NULL
+          if it cannot be retrieved.
+
+**/
+VOID *
+EFIAPI
+PeCoffLoaderGetPdbPointer (
+  IN VOID  *Pe32Data
+  );
+
+
+/**
+  Returns the size of the PE/COFF headers
+
+  Returns the size of the PE/COFF header specified by Pe32Data.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return Size of PE/COFF header in bytes, or zero if not a valid image.
+
+**/
+UINT32
+EFIAPI
+PeCoffGetSizeOfHeaders (
+  IN VOID     *Pe32Data
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PeCoffLib.h b/MdePkg/Include/Library/PeCoffLib.h
new file mode 100644
index 000000000000..78b8b10ddefd
--- /dev/null
+++ b/MdePkg/Include/Library/PeCoffLib.h
@@ -0,0 +1,392 @@
+/** @file
+  Provides services to load and relocate a PE/COFF image.
+
+  The PE/COFF Loader Library abstracts the implementation of a PE/COFF loader for
+  IA-32, x86, IPF, and EBC processor types. The library functions are memory-based 
+  and can be ported easily to any environment.
+  
+Copyright (c) 2006 - 2012, 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 __BASE_PE_COFF_LIB_H__
+#define __BASE_PE_COFF_LIB_H__
+
+#include <IndustryStandard/PeImage.h>
+//
+// Return status codes from the PE/COFF Loader services
+//
+#define IMAGE_ERROR_SUCCESS                      0
+#define IMAGE_ERROR_IMAGE_READ                   1  
+#define IMAGE_ERROR_INVALID_PE_HEADER_SIGNATURE  2
+#define IMAGE_ERROR_INVALID_MACHINE_TYPE         3
+#define IMAGE_ERROR_INVALID_SUBSYSTEM            4
+#define IMAGE_ERROR_INVALID_IMAGE_ADDRESS        5
+#define IMAGE_ERROR_INVALID_IMAGE_SIZE           6
+#define IMAGE_ERROR_INVALID_SECTION_ALIGNMENT    7
+#define IMAGE_ERROR_SECTION_NOT_LOADED           8
+#define IMAGE_ERROR_FAILED_RELOCATION            9
+#define IMAGE_ERROR_FAILED_ICACHE_FLUSH          10
+#define IMAGE_ERROR_UNSUPPORTED                  11
+
+/**
+  Reads contents of a PE/COFF image.
+
+  A function of this type reads contents of the PE/COFF image specified by FileHandle. The read 
+  operation copies ReadSize bytes from the PE/COFF image starting at byte offset FileOffset into 
+  the buffer specified by Buffer. The size of the buffer actually read is returned in ReadSize.  
+  If FileOffset specifies an offset past the end of the PE/COFF image, a ReadSize of 0 is returned.
+  A function of this type must be registered in the ImageRead field of a PE_COFF_LOADER_IMAGE_CONTEXT 
+  structure for the PE/COFF Loader Library service to function correctly.  This function abstracts access 
+  to a PE/COFF image so it can be implemented in an environment specific manner.  For example, SEC and PEI 
+  environments may access memory directly to read the contents of a PE/COFF image, and DXE or UEFI 
+  environments may require protocol services to read the contents of PE/COFF image 
+  stored on FLASH, disk, or network devices.
+  
+  If FileHandle is not a valid handle, then ASSERT().
+  If ReadSize is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+
+  @param  FileHandle      Pointer to the file handle to read the PE/COFF image.
+  @param  FileOffset      Offset into the PE/COFF image to begin the read operation.
+  @param  ReadSize        On input, the size in bytes of the requested read operation.  
+                          On output, the number of bytes actually read.
+  @param  Buffer          Output buffer that contains the data read from the PE/COFF image.
+  
+  @retval RETURN_SUCCESS            The specified portion of the PE/COFF image was 
+                                    read and the size return in ReadSize.
+  @retval RETURN_DEVICE_ERROR       The specified portion of the PE/COFF image 
+                                    could not be read due to a device error.
+
+**/
+typedef
+RETURN_STATUS
+(EFIAPI *PE_COFF_LOADER_READ_FILE)(
+  IN     VOID   *FileHandle,
+  IN     UINTN  FileOffset,
+  IN OUT UINTN  *ReadSize,
+  OUT    VOID   *Buffer
+  );
+
+///
+/// The context structure used while PE/COFF image is being loaded and relocated.
+///
+typedef struct {
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the ImageBase in the PE/COFF header.
+  ///
+  PHYSICAL_ADDRESS                  ImageAddress;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the SizeOfImage in the PE/COFF header.
+  /// Image size includes the size of Debug Entry if it is present.
+  ///
+  UINT64                            ImageSize;
+  ///
+  /// Is set to zero by PeCoffLoaderGetImageInfo(). If DestinationAddress is non-zero,
+  /// PeCoffLoaderRelocateImage() will relocate the image using this base address.
+  /// If the DestinationAddress is zero, the ImageAddress will be used as the base
+  /// address of relocation.
+  ///
+  PHYSICAL_ADDRESS                  DestinationAddress;
+  ///
+  /// PeCoffLoaderLoadImage() sets EntryPoint to to the entry point of the PE/COFF image.
+  ///
+  PHYSICAL_ADDRESS                  EntryPoint;
+  ///
+  /// Passed in by the caller to PeCoffLoaderGetImageInfo() and PeCoffLoaderLoadImage()
+  /// to abstract accessing the image from the library.
+  ///
+  PE_COFF_LOADER_READ_FILE          ImageRead;
+  ///
+  /// Used as the FileHandle passed into the ImageRead function when it's called.
+  ///
+  VOID                              *Handle;
+  ///
+  /// Caller allocated buffer of size FixupDataSize that can be optionally allocated
+  /// prior to calling PeCoffLoaderRelocateImage(). 
+  /// This buffer is filled with the information used to fix up the image. 
+  /// The fixups have been applied to the image and this entry is just for information.
+  ///
+  VOID                              *FixupData;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the Section Alignment in the PE/COFF header.
+  /// If the image is a TE image, then this field is set to 0.
+  ///
+  UINT32                            SectionAlignment;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to offset to the PE/COFF header.
+  /// If the PE/COFF image does not start with a DOS header, this value is zero. 
+  /// Otherwise, it's the offset to the PE/COFF header.
+  ///
+  UINT32                            PeCoffHeaderOffset;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the Relative Virtual Address of the debug directory,
+  /// if it exists in the image
+  ///
+  UINT32                            DebugDirectoryEntryRva;
+  ///
+  /// Set by PeCoffLoaderLoadImage() to CodeView area of the PE/COFF Debug directory.
+  ///
+  VOID                              *CodeView;
+  ///
+  /// Set by PeCoffLoaderLoadImage() to point to the PDB entry contained in the CodeView area.
+  /// The PdbPointer points to the filename of the PDB file used for source-level debug of 
+  /// the image by a debugger.
+  ///
+  CHAR8                             *PdbPointer;
+  ///
+  /// Is set by PeCoffLoaderGetImageInfo() to the Section Alignment in the PE/COFF header.
+  ///
+  UINTN                             SizeOfHeaders;
+  ///
+  /// Not used by this library class. Other library classes that layer on  top of this library
+  /// class fill in this value as part of their GetImageInfo call. 
+  /// This allows the caller of the library to know what type of memory needs to be allocated
+  /// to load and relocate the image.
+  ///
+  UINT32                            ImageCodeMemoryType;
+  ///
+  /// Not used by this library class. Other library classes that layer on top of this library 
+  /// class fill in this value as part of their GetImageInfo call.
+  /// This allows the caller of the library to know what type of memory needs to be allocated
+  /// to load and relocate the image.
+  ///
+  UINT32                            ImageDataMemoryType;
+  ///
+  /// Set by any of the library functions if they encounter an error. 
+  ///
+  UINT32                            ImageError;
+  ///
+  /// Set by PeCoffLoaderLoadImage() to indicate the size of FixupData that the caller must
+  /// allocate before calling PeCoffLoaderRelocateImage().
+  ///
+  UINTN                             FixupDataSize;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the machine type stored in the PE/COFF header.
+  ///
+  UINT16                            Machine;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to the subsystem type stored in the PE/COFF header.
+  ///
+  UINT16                            ImageType;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to TRUE if the PE/COFF image does not contain
+  /// relocation information.
+  ///
+  BOOLEAN                           RelocationsStripped;
+  ///
+  /// Set by PeCoffLoaderGetImageInfo() to TRUE if the image is a TE image. 
+  /// For a definition of the TE Image format, see the Platform Initialization Pre-EFI
+  /// Initialization Core Interface Specification.
+  ///
+  BOOLEAN                           IsTeImage;
+  ///
+  /// Set by PeCoffLoaderLoadImage() to the HII resource offset
+  /// if the image contains a custom PE/COFF resource with the type 'HII'.
+  /// Otherwise, the entry remains to be 0.
+  ///
+  PHYSICAL_ADDRESS                  HiiResourceData;
+  ///
+  /// Private storage for implementation specific data. 
+  ///
+  UINT64                            Context;      
+} PE_COFF_LOADER_IMAGE_CONTEXT;
+
+/**
+  Retrieves information about a PE/COFF image.
+
+  Computes the PeCoffHeaderOffset, IsTeImage, ImageType, ImageAddress, ImageSize, 
+  DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, and 
+  DebugDirectoryEntryRva fields of the ImageContext structure.  
+  If ImageContext is NULL, then return RETURN_INVALID_PARAMETER.  
+  If the PE/COFF image accessed through the ImageRead service in the ImageContext 
+  structure is not a supported PE/COFF image type, then return RETURN_UNSUPPORTED.  
+  If any errors occur while computing the fields of ImageContext, 
+  then the error status is returned in the ImageError field of ImageContext.  
+  If the image is a TE image, then SectionAlignment is set to 0.
+  The ImageRead and Handle fields of ImageContext structure must be valid prior 
+  to invoking this service.
+
+  @param  ImageContext              The pointer to the image context structure that 
+                                    describes the PE/COFF image that needs to be 
+                                    examined by this function.
+
+  @retval RETURN_SUCCESS            The information on the PE/COFF image was collected.
+  @retval RETURN_INVALID_PARAMETER  ImageContext is NULL.
+  @retval RETURN_UNSUPPORTED        The PE/COFF image is not supported.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderGetImageInfo (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+/**
+  Applies relocation fixups to a PE/COFF image that was loaded with PeCoffLoaderLoadImage().
+
+  If the DestinationAddress field of ImageContext is 0, then use the ImageAddress field of
+  ImageContext as the relocation base address.  Otherwise, use the DestinationAddress field
+  of ImageContext as the relocation base address.  The caller must allocate the relocation
+  fixup log buffer and fill in the FixupData field of ImageContext prior to calling this function.
+  
+  The ImageRead, Handle, PeCoffHeaderOffset, IsTeImage, Machine, ImageType, ImageAddress, 
+  ImageSize, DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, 
+  DebugDirectoryEntryRva, EntryPoint, FixupDataSize, CodeView, PdbPointer, and FixupData of 
+  the ImageContext structure must be valid prior to invoking this service.
+    
+  If ImageContext is NULL, then ASSERT().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageContext        The pointer to the image context structure that describes the PE/COFF
+                              image that is being relocated.
+
+  @retval RETURN_SUCCESS      The PE/COFF image was relocated.
+                              Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_LOAD_ERROR   The image in not a valid PE/COFF image.
+                              Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_UNSUPPORTED  A relocation record type is not supported.
+                              Extended status information is in the ImageError field of ImageContext.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderRelocateImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+/**
+  Loads a PE/COFF image into memory.
+
+  Loads the PE/COFF image accessed through the ImageRead service of ImageContext into the buffer
+  specified by the ImageAddress and ImageSize fields of ImageContext.  The caller must allocate
+  the load buffer and fill in the ImageAddress and ImageSize fields prior to calling this function.
+  The EntryPoint, FixupDataSize, CodeView, PdbPointer and HiiResourceData fields of ImageContext are computed.
+  The ImageRead, Handle, PeCoffHeaderOffset, IsTeImage, Machine, ImageType, ImageAddress, ImageSize, 
+  DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, and DebugDirectoryEntryRva 
+  fields of the ImageContext structure must be valid prior to invoking this service.
+  
+  If ImageContext is NULL, then ASSERT().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageContext              The pointer to the image context structure that describes the PE/COFF
+                                    image that is being loaded.
+
+  @retval RETURN_SUCCESS            The PE/COFF image was loaded into the buffer specified by
+                                    the ImageAddress and ImageSize fields of ImageContext.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_BUFFER_TOO_SMALL   The caller did not provide a large enough buffer.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_LOAD_ERROR         The PE/COFF image is an EFI Runtime image with no relocations.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_INVALID_PARAMETER  The image address is invalid.
+                                    Extended status information is in the ImageError field of ImageContext.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderLoadImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+
+/**
+  Reads contents of a PE/COFF image from a buffer in system memory.
+   
+  This is the default implementation of a PE_COFF_LOADER_READ_FILE function 
+  that assumes FileHandle pointer to the beginning of a PE/COFF image.   
+  This function reads contents of the PE/COFF image that starts at the system memory 
+  address specified by FileHandle. The read operation copies ReadSize bytes from the 
+  PE/COFF image starting at byte offset FileOffset into the buffer specified by Buffer.  
+  The size of the buffer actually read is returned in ReadSize.
+  
+  If FileHandle is NULL, then ASSERT().
+  If ReadSize is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+
+  @param  FileHandle        The pointer to base of the input stream
+  @param  FileOffset        Offset into the PE/COFF image to begin the read operation.
+  @param  ReadSize          On input, the size in bytes of the requested read operation.  
+                            On output, the number of bytes actually read.
+  @param  Buffer            Output buffer that contains the data read from the PE/COFF image.
+
+  @retval RETURN_SUCCESS    The data is read from FileOffset from the Handle into 
+                            the buffer.
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderImageReadFromMemory (
+  IN     VOID    *FileHandle,
+  IN     UINTN   FileOffset,
+  IN OUT UINTN   *ReadSize,
+  OUT    VOID    *Buffer
+  );
+
+
+/**
+  Reapply fixups on a fixed up PE32/PE32+ image to allow virtual calling at EFI
+  runtime. 
+  
+  This function reapplies relocation fixups to the PE/COFF image specified by ImageBase 
+  and ImageSize so the image will execute correctly when the PE/COFF image is mapped 
+  to the address specified by VirtualImageBase. RelocationData must be identical 
+  to the FiuxupData buffer from the PE_COFF_LOADER_IMAGE_CONTEXT structure 
+  after this PE/COFF image was relocated with PeCoffLoaderRelocateImage().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageBase          The base address of a PE/COFF image that has been loaded 
+                             and relocated into system memory.
+  @param  VirtImageBase      The request virtual address that the PE/COFF image is to
+                             be fixed up for.
+  @param  ImageSize          The size, in bytes, of the PE/COFF image.
+  @param  RelocationData     A pointer to the relocation data that was collected when the PE/COFF 
+                             image was relocated using PeCoffLoaderRelocateImage().
+  
+**/
+VOID
+EFIAPI
+PeCoffLoaderRelocateImageForRuntime (
+  IN  PHYSICAL_ADDRESS        ImageBase,
+  IN  PHYSICAL_ADDRESS        VirtImageBase,
+  IN  UINTN                   ImageSize,
+  IN  VOID                    *RelocationData
+  );
+
+/**
+  Unloads a loaded PE/COFF image from memory and releases its taken resource.
+  Releases any environment specific resources that were allocated when the image 
+  specified by ImageContext was loaded using PeCoffLoaderLoadImage(). 
+ 
+  For NT32 emulator, the PE/COFF image loaded by system needs to release.
+  For real platform, the PE/COFF image loaded by Core doesn't needs to be unloaded, 
+  this function can simply return RETURN_SUCCESS.
+  
+  If ImageContext is NULL, then ASSERT().
+  
+  @param  ImageContext              Pointer to the image context structure that describes the PE/COFF
+                                    image to be unloaded.
+
+  @retval RETURN_SUCCESS            The PE/COFF image was unloaded successfully.
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderUnloadImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+#endif
diff --git a/MdePkg/Include/Library/PeiCoreEntryPoint.h b/MdePkg/Include/Library/PeiCoreEntryPoint.h
new file mode 100644
index 000000000000..11c68bae675e
--- /dev/null
+++ b/MdePkg/Include/Library/PeiCoreEntryPoint.h
@@ -0,0 +1,138 @@
+/** @file
+  Module entry point library for PEI core.
+
+Copyright (c) 2006 - 2008, 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 __MODULE_ENTRY_POINT_H__
+#define __MODULE_ENTRY_POINT_H__
+
+/**
+  The entry point of PE/COFF Image for the PEI Core.
+
+  This function is the entry point for the PEI Foundation, which allows the SEC phase
+  to pass information about the stack, temporary RAM and the Boot Firmware Volume.
+  In addition, it also allows the SEC phase to pass services and data forward for use
+  during the PEI phase in the form of one or more PPIs.
+  There is no limit to the number of additional PPIs that can be passed from SEC into
+  the PEI Foundation. As part of its initialization phase, the PEI Foundation will add
+  these SEC-hosted PPIs to its PPI database such that both the PEI Foundation and any
+  modules can leverage the associated service calls and/or code in these early PPIs.
+  This function is required to call ProcessModuleEntryPointList() with the Context
+  parameter set to NULL.  ProcessModuleEntryPoint() is never expected to return.
+  The PEI Core is responsible for calling ProcessLibraryConstructorList() as soon as
+  the PEI Services Table and the file handle for the PEI Core itself have been established.
+  If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system.
+
+  @param SecCoreData  Points to a data structure containing information about the PEI
+                      core's operating environment, such as the size and location of
+                      temporary RAM, the stack location and the BFV location. 
+
+  @param PpiList      Points to a list of one or more PPI descriptors to be installed
+                      initially by the PEI core. An empty PPI list consists of a single
+                      descriptor with the end-tag EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                      As part of its initialization phase, the PEI Foundation will add
+                      these SEC-hosted PPIs to its PPI database such that both the PEI
+                      Foundation and any modules can leverage the associated service calls
+                      and/or code in these early PPIs.
+
+**/
+VOID
+EFIAPI 
+_ModuleEntryPoint(
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList
+  );
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+
+  This function is required to call _ModuleEntryPoint() passing in SecCoreData and PpiList.
+
+  @param SecCoreData  Points to a data structure containing information about the PEI core's
+                      operating environment, such as the size and location of temporary RAM,
+                      the stack location and the BFV location. 
+
+  @param PpiList      Points to a list of one or more PPI descriptors to be installed
+                      initially by the PEI core.  An empty PPI list consists of a single
+                      descriptor with the end-tag EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                      As part of its initialization phase, the PEI Foundation will add these
+                      SEC-hosted PPIs to its PPI database such that both the PEI Foundation
+                      and any modules can leverage the associated service calls and/or code
+                      in these early PPIs.
+
+**/
+VOID
+EFIAPI
+EfiMain (
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList
+  );
+
+/**
+  Autogenerated function that calls the library constructors for all of the module's
+  dependent libraries.
+
+  This function must be called by the PEI Core once an initial PEI Services Table has been established.
+  This function calls the set of library constructors for the set of library instances that a
+  module depends on.  This include library instances that a module depends on directly and library
+  instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible for collecting
+  the set of library instances, determining which ones have constructors, and calling the library
+  constructors in the proper order based upon the dependencies of each of the library instances.
+  The PEI Core must call this function with a NULL FileHandle value as soon as the initial PEI
+  Services Table has been established.
+
+  @param  FileHandle   Handle of the file being invoked.
+  @param  PeiServices  Describes the list of possible PEI Services.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryConstructorList (
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  IN CONST EFI_PEI_SERVICES     **PeiServices
+  );
+
+
+/**
+  Autogenerated function that calls a set of module entry points.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of module entry points.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the module entry points and calling them in a specified order.
+
+  @param SecCoreData    Points to a data structure containing information about the PEI
+                        core's operating environment, such as the size and location of
+                        temporary RAM, the stack location and the BFV location. 
+
+  @param PpiList        Points to a list of one or more PPI descriptors to be installed
+                        initially by the PEI core. An empty PPI list consists of a single
+                        descriptor with the end-tag EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                        As part of its initialization phase, the PEI Foundation will add
+                        these SEC-hosted PPIs to its PPI database such that both the PEI
+                        Foundation and any modules can leverage the associated service calls
+                        and/or code in these early PPIs. 
+  @param  Context       A pointer to a private context structure defined by the PEI Core
+                        implementation. The implementation of _ModuleEntryPoint() must set
+                        this parameter is NULL to indicate that this is the first PEI phase.
+
+**/
+VOID
+EFIAPI
+ProcessModuleEntryPointList (
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
+  IN VOID                           *Context
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PeiServicesLib.h b/MdePkg/Include/Library/PeiServicesLib.h
new file mode 100644
index 000000000000..5135834cc7c4
--- /dev/null
+++ b/MdePkg/Include/Library/PeiServicesLib.h
@@ -0,0 +1,524 @@
+/** @file
+  Provides library functions for all PEI Services.
+
+Copyright (c) 2006 - 2008, 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 __PEI_SERVICES_LIB_H__
+#define __PEI_SERVICES_LIB_H__
+
+/**
+  This service enables a given PEIM to register an interface into the PEI Foundation.
+
+  @param  PpiList               A pointer to the list of interfaces that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The PpiList pointer is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI PPI descriptors in the list do not have the
+                                EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesInstallPpi (
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *PpiList
+  );
+
+/**
+  This service enables PEIMs to replace an entry in the PPI database with an alternate entry.
+
+  @param  OldPpi                Pointer to the old PEI PPI Descriptors.
+  @param  NewPpi                Pointer to the new PEI PPI Descriptors.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The OldPpi or NewPpi is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI PPI descriptors in the list do not have the
+                                EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+  @retval EFI_NOT_FOUND         The PPI for which the reinstallation was requested has not been
+                                installed.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesReInstallPpi (
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *OldPpi,
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *NewPpi
+  );
+
+/**
+  This service enables PEIMs to discover a given instance of an interface.
+
+  @param  Guid                  A pointer to the GUID whose corresponding interface needs to be
+                                found.
+  @param  Instance              The N-th instance of the interface that is required.
+  @param  PpiDescriptor         A pointer to instance of the EFI_PEI_PPI_DESCRIPTOR.
+  @param  Ppi                   A pointer to the instance of the interface.
+
+  @retval EFI_SUCCESS           The interface was successfully returned.
+  @retval EFI_NOT_FOUND         The PPI descriptor is not found in the database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesLocatePpi (
+  IN CONST EFI_GUID                   *Guid,
+  IN UINTN                      Instance,
+  IN OUT EFI_PEI_PPI_DESCRIPTOR **PpiDescriptor,
+  IN OUT VOID                   **Ppi
+  );
+
+/**
+  This service enables PEIMs to register a given service to be invoked when another service is
+  installed or reinstalled.
+
+  @param  NotifyList            A pointer to the list of notification interfaces that the caller
+                                shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The NotifyList pointer is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI notify descriptors in the list do not have the
+                                EFI_PEI_PPI_DESCRIPTOR_NOTIFY_TYPES bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesNotifyPpi (
+  IN CONST EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyList
+  );
+
+/**
+  This service enables PEIMs to ascertain the present value of the boot mode.
+
+  @param  BootMode              A pointer to contain the value of the boot mode.
+
+  @retval EFI_SUCCESS           The boot mode was returned successfully.
+  @retval EFI_INVALID_PARAMETER BootMode is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesGetBootMode (
+  OUT EFI_BOOT_MODE          *BootMode
+  );
+
+/**
+  This service enables PEIMs to update the boot mode variable.
+
+  @param  BootMode              The value of the boot mode to set.
+
+  @retval EFI_SUCCESS           The value was successfully updated
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesSetBootMode (
+  IN EFI_BOOT_MODE              BootMode
+  );
+
+/**
+  This service enables a PEIM to ascertain the address of the list of HOBs in memory.
+
+  @param  HobList               A pointer to the list of HOBs that the PEI Foundation will initialize.
+
+  @retval EFI_SUCCESS           The list was successfully returned.
+  @retval EFI_NOT_AVAILABLE_YET The HOB list is not yet published.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesGetHobList (
+  OUT VOID                      **HobList
+  );
+
+/**
+  This service enables PEIMs to create various types of HOBs.
+
+  @param  Type                  The type of HOB to be installed.
+  @param  Length                The length of the HOB to be added.
+  @param  Hob                   The address of a pointer that will contain the HOB header.
+
+  @retval EFI_SUCCESS           The HOB was successfully created.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesCreateHob (
+  IN UINT16                     Type,
+  IN UINT16                     Length,
+  OUT VOID                      **Hob
+  );
+
+/**
+  This service enables PEIMs to discover additional firmware volumes.
+
+  @param  Instance              This instance of the firmware volume to find.  The value 0 is the
+                                Boot Firmware Volume (BFV).
+  @param  VolumeHandle          Handle of the firmware volume header of the volume to return.
+
+  @retval EFI_SUCCESS           The volume was found.
+  @retval EFI_NOT_FOUND         The volume was not found.
+  @retval EFI_INVALID_PARAMETER FwVolHeader is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindNextVolume (
+  IN UINTN                          Instance,
+  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle
+  );
+
+/**
+  This service enables PEIMs to discover additional firmware files.
+
+  @param  SearchType            A filter to find files only of this type.
+  @param  VolumeHandle          Pointer to the firmware volume header of the volume to search.
+                                This parameter must point to a valid FFS volume.
+  @param  FileHandle            Handle of the current file from which to begin searching.
+
+  @retval EFI_SUCCESS           The file was found.
+  @retval EFI_NOT_FOUND         The file was not found.
+  @retval EFI_NOT_FOUND         The header checksum was not zero.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindNextFile (
+  IN EFI_FV_FILETYPE            SearchType,
+  IN EFI_PEI_FV_HANDLE          VolumeHandle,
+  IN OUT EFI_PEI_FILE_HANDLE    *FileHandle
+  );
+
+/**
+  This service enables PEIMs to discover sections of a given type within a valid FFS file.
+
+  @param  SectionType           The value of the section type to find.
+  @param  FileHandle            A pointer to the file header that contains the set of sections to
+                                be searched.
+  @param  SectionData           A pointer to the discovered section, if successful.
+
+  @retval EFI_SUCCESS           The section was found.
+  @retval EFI_NOT_FOUND         The section was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindSectionData (
+  IN EFI_SECTION_TYPE           SectionType,
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  OUT VOID                      **SectionData
+  );
+
+/**
+  This service enables PEIMs to discover sections of a given instance and type within a valid FFS file.
+
+  @param  SectionType           The value of the section type to find.
+  @param  SectionInstance       Section instance to find.
+  @param  FileHandle            A pointer to the file header that contains the set 
+                                of sections to be searched.
+  @param  SectionData           A pointer to the discovered section, if successful.
+  @param  AuthenticationStatus  A pointer to the authentication status for this section.
+
+  @retval EFI_SUCCESS           The section was found.
+  @retval EFI_NOT_FOUND         The section was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindSectionData3 (
+  IN EFI_SECTION_TYPE           SectionType,
+  IN UINTN                      SectionInstance,
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  OUT VOID                      **SectionData,
+  OUT UINT32                    *AuthenticationStatus
+  );
+
+/**
+  This service enables PEIMs to register the permanent memory configuration
+  that has been initialized with the PEI Foundation.
+
+  @param  MemoryBegin           The value of a region of installed memory.
+  @param  MemoryLength          The corresponding length of a region of installed memory.
+
+  @retval EFI_SUCCESS           The region was successfully installed in a HOB.
+  @retval EFI_INVALID_PARAMETER MemoryBegin and MemoryLength are illegal for this system.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesInstallPeiMemory (
+  IN EFI_PHYSICAL_ADDRESS       MemoryBegin,
+  IN UINT64                     MemoryLength
+  );
+
+/**
+  This service enables PEIMs to allocate memory after the permanent memory has been installed by a
+  PEIM.
+
+  @param  MemoryType            Type of memory to allocate.
+  @param  Pages                 Number of pages to allocate.
+  @param  Memory                Pointer of memory allocated.
+
+  @retval EFI_SUCCESS           The memory range was successfully allocated.
+  @retval EFI_INVALID_PARAMETER Type is not equal to AllocateAnyPages.
+  @retval EFI_NOT_AVAILABLE_YET Called with permanent memory not available.
+  @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesAllocatePages (
+  IN EFI_MEMORY_TYPE            MemoryType,
+  IN UINTN                      Pages,
+  OUT EFI_PHYSICAL_ADDRESS      *Memory
+  );
+
+/**
+  This service allocates memory from the Hand-Off Block (HOB) heap.
+
+  @param  Size                  The number of bytes to allocate from the pool.
+  @param  Buffer                If the call succeeds, a pointer to a pointer to the allocate
+                                buffer; undefined otherwise.
+
+  @retval EFI_SUCCESS           The allocation was successful
+  @retval EFI_OUT_OF_RESOURCES  There is not enough heap to allocate the requested size.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesAllocatePool (
+  IN UINTN                      Size,
+  OUT VOID                      **Buffer
+  );
+
+/**
+  Resets the entire platform.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_NOT_AVAILABLE_YET The service has not been installed yet.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesResetSystem (
+  VOID
+  );
+
+
+/**
+  This service is a wrapper for the PEI Service FfsFindByName(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param FileName       A pointer to the name of the file to
+                        find within the firmware volume.
+
+  @param VolumeHandle   The firmware volume to search FileHandle
+                        Upon exit, points to the found file's
+                        handle or NULL if it could not be found.
+  @param FileHandle     Pointer to found file handle 
+
+  @retval EFI_SUCCESS             File was found.
+
+  @retval EFI_NOT_FOUND           File was not found.
+
+  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or
+                                  FileName was NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindFileByName (
+  IN CONST  EFI_GUID            *FileName,
+  IN CONST  EFI_PEI_FV_HANDLE   VolumeHandle,
+  OUT       EFI_PEI_FILE_HANDLE *FileHandle
+  );
+
+
+/**
+  This service is a wrapper for the PEI Service FfsGetFileInfo(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param FileHandle   Handle of the file.
+
+  @param FileInfo     Upon exit, points to the file's
+                      information.
+
+  @retval EFI_SUCCESS             File information returned.
+  
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+  
+**/
+EFI_STATUS
+EFIAPI 
+PeiServicesFfsGetFileInfo (
+  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,
+  OUT EFI_FV_FILE_INFO            *FileInfo
+  );
+
+/**
+  This service is a wrapper for the PEI Service FfsGetFileInfo2(), except the pointer to the PEI Services
+  Table has been removed. See the Platform Initialization Pre-EFI Initialization Core Interface
+  Specification for details.
+
+  @param FileHandle   Handle of the file.
+
+  @param FileInfo     Upon exit, points to the file's
+                      information.
+
+  @retval EFI_SUCCESS             File information returned.
+  
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+  
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsGetFileInfo2 (
+  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,
+  OUT EFI_FV_FILE_INFO2           *FileInfo
+  );
+
+/**
+  This service is a wrapper for the PEI Service FfsGetVolumeInfo(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param VolumeHandle   Handle of the volume.
+
+  @param VolumeInfo     Upon exit, points to the volume's
+                        information.
+
+  @retval EFI_SUCCESS             File information returned.
+  
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsGetVolumeInfo (
+  IN  EFI_PEI_FV_HANDLE       VolumeHandle,
+  OUT EFI_FV_INFO             *VolumeInfo
+  );
+
+
+/**
+  This service is a wrapper for the PEI Service RegisterForShadow(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param FileHandle   PEIM's file handle. Must be the currently
+                      executing PEIM.
+  
+  @retval EFI_SUCCESS   The PEIM was successfully registered for
+                        shadowing.
+
+  @retval EFI_ALREADY_STARTED   The PEIM was previously
+                                registered for shadowing.
+
+  @retval EFI_NOT_FOUND   The FileHandle does not refer to a
+                          valid file handle.
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesRegisterForShadow (
+  IN  EFI_PEI_FILE_HANDLE FileHandle
+  );
+
+/**
+  Install a EFI_PEI_FIRMWARE_VOLUME_INFO_PPI instance so the PEI Core will be notified about a new firmware volume.
+  
+  This function allocates, initializes, and installs a new EFI_PEI_FIRMWARE_VOLUME_INFO_PPI using 
+  the parameters passed in to initialize the fields of the EFI_PEI_FIRMWARE_VOLUME_INFO_PPI instance.
+  If the resources can not be allocated for EFI_PEI_FIRMWARE_VOLUME_INFO_PPI, then ASSERT().
+  If the EFI_PEI_FIRMWARE_VOLUME_INFO_PPI can not be installed, then ASSERT().
+
+  
+  @param  FvFormat             Unique identifier of the format of the memory-mapped firmware volume.
+                               This parameter is optional and may be NULL.  
+                               If NULL is specified, the EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed.
+  @param  FvInfo               Points to a buffer which allows the EFI_PEI_FIRMWARE_VOLUME_PPI to process the volume. 
+                               The format of this buffer is specific to the FvFormat. For memory-mapped firmware volumes, 
+                               this typically points to the first byte of the firmware volume.
+  @param  FvInfoSize           The size, in bytes, of FvInfo. For memory-mapped firmware volumes, 
+                               this is typically the size of the firmware volume.
+  @param  ParentFvName         If the new firmware volume originated from a file in a different firmware volume, 
+                               then this parameter specifies the GUID name of the originating firmware volume.
+                               Otherwise, this parameter must be NULL.
+  @param  ParentFileName       If the new firmware volume originated from a file in a different firmware volume, 
+                               then this parameter specifies the GUID file name of the originating firmware file.
+                               Otherwise, this parameter must be NULL.
+**/
+VOID
+EFIAPI
+PeiServicesInstallFvInfoPpi (
+  IN CONST EFI_GUID                *FvFormat, OPTIONAL
+  IN CONST VOID                    *FvInfo,
+  IN       UINT32                  FvInfoSize,
+  IN CONST EFI_GUID                *ParentFvName, OPTIONAL
+  IN CONST EFI_GUID                *ParentFileName OPTIONAL
+  );
+
+/**
+  Install a EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI instance so the PEI Core will be notified about a new firmware volume.
+
+  This function allocates, initializes, and installs a new EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI using
+  the parameters passed in to initialize the fields of the EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI instance.
+  If the resources can not be allocated for EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI, then ASSERT().
+  If the EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI can not be installed, then ASSERT().
+
+  @param  FvFormat             Unique identifier of the format of the memory-mapped
+                               firmware volume.  This parameter is optional and
+                               may be NULL.  If NULL is specified, the
+                               EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed.
+  @param  FvInfo               Points to a buffer which allows the
+                               EFI_PEI_FIRMWARE_VOLUME_PPI to process the volume.
+                               The format of this buffer is specific to the FvFormat.
+                               For memory-mapped firmware volumes, this typically
+                               points to the first byte of the firmware volume.
+  @param  FvInfoSize           The size, in bytes, of FvInfo. For memory-mapped
+                               firmware volumes, this is typically the size of
+                               the firmware volume.
+  @param  ParentFvName         If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID name of the originating firmware
+                               volume. Otherwise, this parameter must be NULL.
+  @param  ParentFileName       If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID file name of the originating
+                               firmware file. Otherwise, this parameter must be NULL.
+  @param  AuthenticationStatus Authentication Status
+**/
+VOID
+EFIAPI
+PeiServicesInstallFvInfo2Ppi (
+  IN CONST EFI_GUID                *FvFormat, OPTIONAL
+  IN CONST VOID                    *FvInfo,
+  IN       UINT32                  FvInfoSize,
+  IN CONST EFI_GUID                *ParentFvName, OPTIONAL
+  IN CONST EFI_GUID                *ParentFileName, OPTIONAL
+  IN       UINT32                  AuthenticationStatus
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PeiServicesTablePointerLib.h b/MdePkg/Include/Library/PeiServicesTablePointerLib.h
new file mode 100644
index 000000000000..f1aa0d4bf349
--- /dev/null
+++ b/MdePkg/Include/Library/PeiServicesTablePointerLib.h
@@ -0,0 +1,74 @@
+/** @file
+  Provides a service to retrieve a pointer to the PEI Services Table.
+
+Copyright (c) 2006 - 2014, 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 __PEI_SERVICES_TABLE_POINTER_LIB_H__
+#define __PEI_SERVICES_TABLE_POINTER_LIB_H__
+
+/**
+  Retrieves the cached value of the PEI Services Table pointer.
+
+  Returns the cached value of the PEI Services Table pointer in a CPU specific manner 
+  as specified in the CPU binding section of the Platform Initialization Pre-EFI 
+  Initialization Core Interface Specification.
+  
+  If the cached PEI Services Table pointer is NULL, then ASSERT().
+
+  @return  The pointer to PeiServices.
+
+**/
+CONST EFI_PEI_SERVICES **
+EFIAPI
+GetPeiServicesTablePointer (
+  VOID
+  );
+
+/**
+  Caches a pointer PEI Services Table. 
+ 
+  Caches the pointer to the PEI Services Table specified by PeiServicesTablePointer 
+  in a CPU specific manner as specified in the CPU binding section of the Platform Initialization 
+  Pre-EFI Initialization Core Interface Specification. 
+  
+  If PeiServicesTablePointer is NULL, then ASSERT().
+  
+  @param    PeiServicesTablePointer   The address of PeiServices pointer.
+**/
+VOID
+EFIAPI
+SetPeiServicesTablePointer (
+  IN CONST EFI_PEI_SERVICES ** PeiServicesTablePointer
+  );
+
+/**
+  Perform CPU specific actions required to migrate the PEI Services Table 
+  pointer from temporary RAM to permanent RAM.
+
+  For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
+  a dedicated CPU register.  This means that there is no memory storage 
+  associated with storing the PEI Services Table pointer, so no additional 
+  migration actions are required for Itanium or ARM CPUs.
+
+**/
+VOID
+EFIAPI
+MigratePeiServicesTablePointer (
+  VOID
+  );
+
+#endif
+
diff --git a/MdePkg/Include/Library/PeimEntryPoint.h b/MdePkg/Include/Library/PeimEntryPoint.h
new file mode 100644
index 000000000000..8364a0582e36
--- /dev/null
+++ b/MdePkg/Include/Library/PeimEntryPoint.h
@@ -0,0 +1,109 @@
+/** @file
+  Module entry point library for PEIM.
+
+Copyright (c) 2006 - 2008, 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 __MODULE_ENTRY_POINT_H__
+#define __MODULE_ENTRY_POINT_H__
+
+///
+/// Declare the EFI/UEFI Specification Revision to which this driver is implemented 
+///
+extern CONST UINT32       _gPeimRevision;
+
+
+/**
+  The entry point of PE/COFF Image for a PEIM.
+
+  This function is the entry point for a PEIM.  This function must call ProcessLibraryConstructorList() 
+  and ProcessModuleEntryPointList().  The return value from ProcessModuleEntryPointList() is returned.
+  If _gPeimRevision is not zero and PeiServices->Hdr.Revision is less than _gPeimRevison, then ASSERT().
+
+  @param  FileHandle  Handle of the file being invoked. 
+  @param  PeiServices Describes the list of possible PEI Services.
+
+  @retval  EFI_SUCCESS   The PEIM executed normally.
+  @retval  !EFI_SUCCESS  The PEIM failed to execute normally.
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  );
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+  
+  This function is required to call _ModuleEntryPoint() passing in FileHandle and PeiServices.
+
+  @param  FileHandle  Handle of the file being invoked. 
+  @param  PeiServices Describes the list of possible PEI Services.
+
+  @retval EFI_SUCCESS  The PEIM executed normally.
+  @retval !EFI_SUCCESS The PEIM failed to execute normally.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  );
+
+/**
+  Autogenerated function that calls the library constructors for all of the module's
+  dependent libraries.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of library constructors for the set of library instances that a
+  module depends on. This includes library instances that a module depends on directly and library
+  instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible for collecting
+  the set of library instances, determine which ones have constructors, and calling the library
+  constructors in the proper order based upon each of the library instances own dependencies.
+
+  @param  FileHandle   Handle of the file being invoked.
+  @param  PeiServices  Describes the list of possible PEI Services.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryConstructorList (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  );
+
+/**
+  Autogenerated function that calls a set of module entry points.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of module entry points.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the module entry points and calling them in a specified order.
+
+  @param  FileHandle  Handle of the file being invoked. 
+  @param  PeiServices Describes the list of possible PEI Services.
+
+  @retval EFI_SUCCESS  The PEIM executed normally.
+  @retval !EFI_SUCCESS The PEIM failed to execute normally.
+ 
+**/
+EFI_STATUS
+EFIAPI
+ProcessModuleEntryPointList (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/PerformanceLib.h b/MdePkg/Include/Library/PerformanceLib.h
new file mode 100644
index 000000000000..28dfc6a8d40b
--- /dev/null
+++ b/MdePkg/Include/Library/PerformanceLib.h
@@ -0,0 +1,366 @@
+/** @file
+  Provides services to log the execution times and retrieve them later.
+
+Copyright (c) 2006 - 2016, 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 __PERFORMANCE_LIB_H__
+#define __PERFORMANCE_LIB_H__
+
+///
+/// Performance library propery mask bits
+///
+#define PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED  0x00000001
+
+/**
+  Creates a record for the beginning of a performance measurement. 
+  
+  Creates a record that contains the Handle, Token, and Module.
+  If TimeStamp is not zero, then TimeStamp is added to the record as the start time.
+  If TimeStamp is zero, then this function reads the current time stamp
+  and adds that time stamp value to the record as the start time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+
+  @retval RETURN_SUCCESS          The start of the measurement was recorded.
+  @retval RETURN_OUT_OF_RESOURCES There are not enough resources to record the measurement.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+StartPerformanceMeasurement (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp
+  );
+
+/**
+  Fills in the end time of a performance measurement. 
+  
+  Looks up the record that matches Handle, Token, and Module.
+  If the record can not be found then return RETURN_NOT_FOUND.
+  If the record is found and TimeStamp is not zero,
+  then TimeStamp is added to the record as the end time.
+  If the record is found and TimeStamp is zero, then this function reads
+  the current time stamp and adds that time stamp value to the record as the end time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+
+  @retval RETURN_SUCCESS          The end of  the measurement was recorded.
+  @retval RETURN_NOT_FOUND        The specified measurement record could not be found.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+EndPerformanceMeasurement (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp
+  );
+
+/**
+  Attempts to retrieve a performance measurement log entry from the performance measurement log. 
+  It can also retrieve the log created by StartPerformanceMeasurementEx and EndPerformanceMeasurementEx,
+  and then eliminate the Identifier.
+
+  Attempts to retrieve the performance log entry specified by LogEntryKey.  If LogEntryKey is
+  zero on entry, then an attempt is made to retrieve the first entry from the performance log,
+  and the key for the second entry in the log is returned.  If the performance log is empty,
+  then no entry is retrieved and zero is returned.  If LogEntryKey is not zero, then the performance
+  log entry associated with LogEntryKey is retrieved, and the key for the next entry in the log is
+  returned.  If LogEntryKey is the key for the last entry in the log, then the last log entry is
+  retrieved and an implementation specific non-zero key value that specifies the end of the performance
+  log is returned.  If LogEntryKey is equal this implementation specific non-zero key value, then no entry
+  is retrieved and zero is returned.  In the cases where a performance log entry can be returned,
+  the log entry is returned in Handle, Token, Module, StartTimeStamp, and EndTimeStamp.
+  If LogEntryKey is not a valid log entry key for the performance measurement log, then ASSERT().
+  If Handle is NULL, then ASSERT().
+  If Token is NULL, then ASSERT().
+  If Module is NULL, then ASSERT().
+  If StartTimeStamp is NULL, then ASSERT().
+  If EndTimeStamp is NULL, then ASSERT().
+
+  @param  LogEntryKey             On entry, the key of the performance measurement log entry to retrieve.
+                                  0, then the first performance measurement log entry is retrieved.
+                                  On exit, the key of the next performance lof entry entry.
+  @param  Handle                  Pointer to environment specific context used to identify the component
+                                  being measured.  
+  @param  Token                   Pointer to a Null-terminated ASCII string that identifies the component
+                                  being measured. 
+  @param  Module                  Pointer to a Null-terminated ASCII string that identifies the module
+                                  being measured.
+  @param  StartTimeStamp          Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was started.
+  @param  EndTimeStamp            Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was ended.
+
+  @return The key for the next performance log entry (in general case).
+
+**/
+UINTN
+EFIAPI
+GetPerformanceMeasurement (
+  IN  UINTN       LogEntryKey, 
+  OUT CONST VOID  **Handle,
+  OUT CONST CHAR8 **Token,
+  OUT CONST CHAR8 **Module,
+  OUT UINT64      *StartTimeStamp,
+  OUT UINT64      *EndTimeStamp
+  );
+
+/**
+  Creates a record for the beginning of a performance measurement.
+
+  Creates a record that contains the Handle, Token, Module and Identifier.
+  If TimeStamp is not zero, then TimeStamp is added to the record as the start time.
+  If TimeStamp is zero, then this function reads the current time stamp
+  and adds that time stamp value to the record as the start time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+  @param  Identifier              32-bit identifier. If the value is 0, the created record
+                                  is same as the one created by StartPerformanceMeasurement.
+
+  @retval RETURN_SUCCESS          The start of the measurement was recorded.
+  @retval RETURN_OUT_OF_RESOURCES There are not enough resources to record the measurement.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+StartPerformanceMeasurementEx (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp,
+  IN UINT32       Identifier
+  );
+
+/**
+  Fills in the end time of a performance measurement.
+
+  Looks up the record that matches Handle, Token and Module.
+  If the record can not be found then return RETURN_NOT_FOUND.
+  If the record is found and TimeStamp is not zero,
+  then TimeStamp is added to the record as the end time.
+  If the record is found and TimeStamp is zero, then this function reads
+  the current time stamp and adds that time stamp value to the record as the end time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+  @param  Identifier              32-bit identifier. If the value is 0, the found record
+                                  is same as the one found by EndPerformanceMeasurement.
+
+  @retval RETURN_SUCCESS          The end of  the measurement was recorded.
+  @retval RETURN_NOT_FOUND        The specified measurement record could not be found.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+EndPerformanceMeasurementEx (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp,
+  IN UINT32       Identifier
+  );
+
+/**
+  Attempts to retrieve a performance measurement log entry from the performance measurement log.
+  It can also retrieve the log created by StartPerformanceMeasurement and EndPerformanceMeasurement,
+  and then assign the Identifier with 0.
+
+  Attempts to retrieve the performance log entry specified by LogEntryKey.  If LogEntryKey is
+  zero on entry, then an attempt is made to retrieve the first entry from the performance log,
+  and the key for the second entry in the log is returned.  If the performance log is empty,
+  then no entry is retrieved and zero is returned.  If LogEntryKey is not zero, then the performance
+  log entry associated with LogEntryKey is retrieved, and the key for the next entry in the log is
+  returned.  If LogEntryKey is the key for the last entry in the log, then the last log entry is
+  retrieved and an implementation specific non-zero key value that specifies the end of the performance
+  log is returned.  If LogEntryKey is equal this implementation specific non-zero key value, then no entry
+  is retrieved and zero is returned.  In the cases where a performance log entry can be returned,
+  the log entry is returned in Handle, Token, Module, StartTimeStamp, EndTimeStamp and Identifier.
+  If LogEntryKey is not a valid log entry key for the performance measurement log, then ASSERT().
+  If Handle is NULL, then ASSERT().
+  If Token is NULL, then ASSERT().
+  If Module is NULL, then ASSERT().
+  If StartTimeStamp is NULL, then ASSERT().
+  If EndTimeStamp is NULL, then ASSERT().
+  If Identifier is NULL, then ASSERT().
+
+  @param  LogEntryKey             On entry, the key of the performance measurement log entry to retrieve.
+                                  0, then the first performance measurement log entry is retrieved.
+                                  On exit, the key of the next performance of entry entry.
+  @param  Handle                  Pointer to environment specific context used to identify the component
+                                  being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string that identifies the component
+                                  being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string that identifies the module
+                                  being measured.
+  @param  StartTimeStamp          Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was started.
+  @param  EndTimeStamp            Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was ended.
+  @param  Identifier              Pointer to the 32-bit identifier that was recorded.
+
+  @return The key for the next performance log entry (in general case).
+
+**/
+UINTN
+EFIAPI
+GetPerformanceMeasurementEx (
+  IN  UINTN       LogEntryKey, 
+  OUT CONST VOID  **Handle,
+  OUT CONST CHAR8 **Token,
+  OUT CONST CHAR8 **Module,
+  OUT UINT64      *StartTimeStamp,
+  OUT UINT64      *EndTimeStamp,
+  OUT UINT32      *Identifier
+  );
+
+/**
+  Returns TRUE if the performance measurement macros are enabled. 
+  
+  This function returns TRUE if the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+  PcdPerformanceLibraryPropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval TRUE                    The PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+                                  PcdPerformanceLibraryPropertyMask is set.
+  @retval FALSE                   The PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+                                  PcdPerformanceLibraryPropertyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PerformanceMeasurementEnabled (
+  VOID
+  );
+
+/**
+  Macro that calls EndPerformanceMeasurement().
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then EndPerformanceMeasurement() is called.
+
+**/
+#define PERF_END(Handle, Token, Module, TimeStamp)                    \
+  do {                                                                \
+    if (PerformanceMeasurementEnabled ()) {                           \
+      EndPerformanceMeasurement (Handle, Token, Module, TimeStamp);   \
+    }                                                                 \
+  } while (FALSE)
+
+/**
+  Macro that calls StartPerformanceMeasurement().
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then StartPerformanceMeasurement() is called.
+
+**/
+#define PERF_START(Handle, Token, Module, TimeStamp)                  \
+  do {                                                                \
+    if (PerformanceMeasurementEnabled ()) {                           \
+      StartPerformanceMeasurement (Handle, Token, Module, TimeStamp); \
+    }                                                                 \
+  } while (FALSE)
+
+/**
+  Macro that calls EndPerformanceMeasurementEx().
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then EndPerformanceMeasurementEx() is called.
+
+**/
+#define PERF_END_EX(Handle, Token, Module, TimeStamp, Identifier)                   \
+  do {                                                                              \
+    if (PerformanceMeasurementEnabled ()) {                                         \
+      EndPerformanceMeasurementEx (Handle, Token, Module, TimeStamp, Identifier);   \
+    }                                                                               \
+  } while (FALSE)
+
+/**
+  Macro that calls StartPerformanceMeasurementEx().
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then StartPerformanceMeasurementEx() is called.
+
+**/
+#define PERF_START_EX(Handle, Token, Module, TimeStamp, Identifier)                 \
+  do {                                                                              \
+    if (PerformanceMeasurementEnabled ()) {                                         \
+      StartPerformanceMeasurementEx (Handle, Token, Module, TimeStamp, Identifier); \
+    }                                                                               \
+  } while (FALSE)
+
+/**
+  Macro that marks the beginning of performance measurement source code.
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then this macro marks the beginning of source code that is included in a module.
+  Otherwise, the source lines between PERF_CODE_BEGIN() and PERF_CODE_END() are not included in a module.
+
+**/
+#define PERF_CODE_BEGIN()  do { if (PerformanceMeasurementEnabled ()) { UINT8  __PerformanceCodeLocal
+
+/**
+  Macro that marks the end of performance measurement source code.
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then this macro marks the end of source code that is included in a module.
+  Otherwise, the source lines between PERF_CODE_BEGIN() and PERF_CODE_END() are not included in a module.
+
+**/
+#define PERF_CODE_END()    __PerformanceCodeLocal = 0; __PerformanceCodeLocal++; } } while (FALSE)
+
+/**
+  Macro that declares a section of performance measurement source code.
+
+  If the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set,
+  then the source code specified by Expression is included in a module.
+  Otherwise, the source specified by Expression is not included in a module.
+
+  @param  Expression              Performance measurement source code to include in a module.
+
+**/
+#define PERF_CODE(Expression)  \
+  PERF_CODE_BEGIN ();          \
+  Expression                   \
+  PERF_CODE_END ()
+
+
+#endif
diff --git a/MdePkg/Include/Library/PostCodeLib.h b/MdePkg/Include/Library/PostCodeLib.h
new file mode 100644
index 000000000000..bfc0b227079a
--- /dev/null
+++ b/MdePkg/Include/Library/PostCodeLib.h
@@ -0,0 +1,150 @@
+/** @file
+  Provides services to send progress/error codes to a POST card.
+
+Copyright (c) 2006 - 2008, 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 __POST_CODE_LIB_H__
+#define __POST_CODE_LIB_H__
+
+#define POST_CODE_PROPERTY_POST_CODE_ENABLED              0x00000008
+#define POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED  0x00000010
+
+/**
+  Sends a 32-bit value to a POST card.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.  
+  Some implementations of this library function may perform I/O operations 
+  directly to a POST card device.  Other implementations may send Value to 
+  ReportStatusCode(), and the status code reporting mechanism will eventually 
+  display the 32-bit value on the status reporting device.
+  
+  PostCode() must actively prevent recursion.  If PostCode() is called while 
+  processing another Post Code Library function, then 
+  PostCode() must return Value immediately.
+
+  @param  Value  The 32-bit value to write to the POST card.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCode (
+  IN UINT32  Value
+  );
+
+
+/**
+  Sends a 32-bit value to a POST and associated ASCII string.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.
+  If Description is not NULL, then the ASCII string specified by Description is 
+  also passed to the handler that displays the POST card value.  Some 
+  implementations of this library function may perform I/O operations directly 
+  to a POST card device.  Other implementations may send Value to ReportStatusCode(), 
+  and the status code reporting mechanism will eventually display the 32-bit 
+  value on the status reporting device.  
+
+  PostCodeWithDescription()must actively prevent recursion.  If 
+  PostCodeWithDescription() is called while processing another any other Post 
+  Code Library function, then PostCodeWithDescription() must return Value 
+  immediately.
+
+  @param  Value        The 32-bit value to write to the POST card.
+  @param  Description  Pointer to an ASCII string that is a description of the 
+                       POST code value.  This is an optional parameter that may 
+                       be NULL.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCodeWithDescription (
+  IN UINT32       Value,
+  IN CONST CHAR8  *Description  OPTIONAL
+  );
+
+
+/**
+  Returns TRUE if POST Codes are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_ENABLED 
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeEnabled (
+  VOID
+  );
+
+
+/**
+  Returns TRUE if POST code descriptions are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeDescriptionEnabled (
+  VOID
+  );
+
+
+/**
+  Sends a 32-bit value to a POST card.
+
+  If POST codes are enabled in PcdPostCodeProperyMask, then call PostCode() 
+  passing in Value.  Value is returned.
+
+  @param  Value  The 32-bit value to write to the POST card.
+
+  @return  Value The 32-bit value to write to the POST card.
+
+**/
+#define POST_CODE(Value)  PostCodeEnabled() ? PostCode(Value) : Value
+
+/**
+  Sends a 32-bit value to a POST and associated ASCII string.
+
+  If POST codes and POST code descriptions are enabled in 
+  PcdPostCodeProperyMask, then call PostCodeWithDescription() passing in 
+  Value and Description.  If only POST codes are enabled, then call PostCode() 
+  passing in Value.  Value is returned.
+
+  @param  Value        The 32-bit value to write to the POST card.
+  @param  Description  Pointer to an ASCII string that is a description of the 
+                       POST code value.
+
+  @return Value        The 32-bit value to write to the POST card.
+**/
+#define POST_CODE_WITH_DESCRIPTION(Value,Description)  \
+  PostCodeEnabled()                              ?     \
+    (PostCodeDescriptionEnabled()                ?     \
+      PostCodeWithDescription(Value,Description) :     \
+      PostCode(Value))                           :     \
+    Value
+
+#endif
diff --git a/MdePkg/Include/Library/PrintLib.h b/MdePkg/Include/Library/PrintLib.h
new file mode 100644
index 000000000000..e9cd0842979d
--- /dev/null
+++ b/MdePkg/Include/Library/PrintLib.h
@@ -0,0 +1,1052 @@
+/** @file
+  Provides services to print a formatted string to a buffer. All combinations of
+  Unicode and ASCII strings are supported.
+
+Copyright (c) 2006 - 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.
+
+  The Print Library functions provide a simple means to produce formatted output 
+  strings.  Many of the output functions use a format string to describe how to 
+  format the output of variable arguments.  The format string consists of normal 
+  text and argument descriptors.  There are no restrictions for how the normal 
+  text and argument descriptors can be mixed.  The following end of line(EOL) 
+  translations must be performed on the contents of the format string:
+  
+     - '\\r' is translated to '\\r'
+     - '\\r\\n' is translated to '\\r\\n'
+     - '\\n' is translated to '\\r\\n' 
+     - '\\n\\r' is translated to '\\r\\n'
+  
+  This does not follow the ANSI C standard for sprint().  The format of argument 
+  descriptors is described below.  The ANSI C standard for sprint() has been 
+  followed for some of the format types, and has not been followed for others.  
+  The exceptions are noted below.
+
+    %[flags][width][.precision]type
+
+  [flags]:
+    - -       
+      - The field is left justified.  If not flag is not specified, then the 
+        field is right justified.
+    - space   
+      - Prefix a space character to a number.  Only valid for types X, x, and d.
+    - + 
+      - Prefix a plus character to a number.  Only valid for types X, x, and d.  
+        If both space and + are specified, then space is ignored.
+    - 0
+      - Pad with 0 characters to the left of a number.  Only valid for types 
+        X, x, and d.
+    - ,
+      - Place a comma every 3rd digit of the number.  Only valid for type d.
+        If 0 is also specified, then 0 is ignored.
+    - L, l
+      - The number being printed is size UINT64.  Only valid for types X, x, and d.
+        If this flag is not specified, then the number being printed is size int.
+    - NOTE: All invalid flags are ignored.
+
+  [width]:
+
+    - *
+      - The width of the field is specified by a UINTN argument in the 
+        argument list.
+    - number
+      - The number specified as a decimal value represents the width of 
+        the field.
+    - NOTE: If [width] is not specified, then a field width of 0 is assumed.
+
+  [.precision]:
+
+    - *
+      - The precision of the field is specified by a UINTN argument in the 
+        argument list.
+    - number
+      - The number specified as a decimal value represents the precision of 
+        the field.
+    - NOTE: If [.precision] is not specified, then a precision of 0 is assumed.
+
+  type:
+
+    - %
+      - Print a %%.
+    - c
+      - The argument is a Unicode character.  ASCII characters can be printed 
+        using this type too by making sure bits 8..15 of the argument are set to 0.
+    - x
+      - The argument is an unsigned hexadecimal number.  The characters used are 0..9 and 
+        A..F.  If the flag 'L' is not specified, then the argument is assumed 
+        to be size int.  This does not follow ANSI C.
+    - X
+      - The argument is an unsigned hexadecimal number and the number is padded with 
+        zeros.  This is equivalent to a format string of "0x". If the flag 
+        'L' is not specified, then the argument is assumed to be size int.  
+        This does not follow ANSI C.
+    - d
+      - The argument is a signed decimal number.  If the flag 'L' is not specified, 
+        then the argument is assumed to be size int.  
+    - u
+      - The argument is a unsigned decimal number.  If the flag 'L' is not specified, 
+        then the argument is assumed to be size int.
+    - p
+      - The argument is a pointer that is a (VOID *), and it is printed as an 
+        unsigned hexadecimal number  The characters used are 0..9 and A..F.
+    - a
+      - The argument is a pointer to an ASCII string.  
+        This does not follow ANSI C.
+    - S, s
+      - The argument is a pointer to a Unicode string.  
+        This does not follow ANSI C.
+    - g
+      - The argument is a pointer to a GUID structure.  The GUID is printed 
+        in the format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.  
+        This does not follow ANSI C.
+    - t
+      - The argument is a pointer to an EFI_TIME structure.  The time and 
+        date are printed in the format "mm/dd/yyyy hh:mm" where mm is the 
+        month zero padded, dd is the day zero padded, yyyy is the year zero 
+        padded, hh is the hour zero padded, and mm is minutes zero padded.  
+        This does not follow ANSI C. 
+    - r
+      - The argument is a RETURN_STATUS value.  This value is converted to 
+        a string following the table below.  This does not follow ANSI C. 
+      - RETURN_SUCCESS               
+        - "Success"
+      - RETURN_LOAD_ERROR            
+        - "Load Error"
+      - RETURN_INVALID_PARAMETER     
+        - "Invalid Parameter"
+      - RETURN_UNSUPPORTED           
+        - "Unsupported"
+      - RETURN_BAD_BUFFER_SIZE       
+        - "Bad Buffer Size"
+      - RETURN_BUFFER_TOO_SMALL      
+        - "Buffer Too Small"
+      - RETURN_NOT_READY             
+        - "Not Ready"
+      - RETURN_DEVICE_ERROR          
+        - "Device Error"
+      - RETURN_WRITE_PROTECTED       
+        - "Write Protected"
+      - RETURN_OUT_OF_RESOURCES      
+        - "Out of Resources"
+      - RETURN_VOLUME_CORRUPTED      
+        - "Volume Corrupt"
+      - RETURN_VOLUME_FULL           
+        - "Volume Full"
+      - RETURN_NO_MEDIA              
+        - "No Media"
+      - RETURN_MEDIA_CHANGED         
+        - "Media changed"
+      - RETURN_NOT_FOUND             
+        - "Not Found"
+      - RETURN_ACCESS_DENIED         
+        - "Access Denied"
+      - RETURN_NO_RESPONSE           
+        - "No Response"
+      - RETURN_NO_MAPPING            
+        - "No mapping"
+      - RETURN_TIMEOUT               
+        - "Time out"
+      - RETURN_NOT_STARTED           
+        - "Not started"
+      - RETURN_ALREADY_STARTED       
+        - "Already started"
+      - RETURN_ABORTED               
+        - "Aborted"
+      - RETURN_ICMP_ERROR            
+        - "ICMP Error"
+      - RETURN_TFTP_ERROR            
+        - "TFTP Error"
+      - RETURN_PROTOCOL_ERROR        
+        - "Protocol Error"
+      - RETURN_WARN_UNKNOWN_GLYPH    
+        - "Warning Unknown Glyph"
+      - RETURN_WARN_DELETE_FAILURE   
+        - "Warning Delete Failure"
+      - RETURN_WARN_WRITE_FAILURE    
+        - "Warning Write Failure"
+      - RETURN_WARN_BUFFER_TOO_SMALL 
+        - "Warning Buffer Too Small"
+
+**/
+
+#ifndef __PRINT_LIB_H__
+#define __PRINT_LIB_H__
+
+///
+/// Define the maximum number of characters that are required to
+/// encode with a NULL terminator a decimal, hexadecimal, GUID,   
+/// or TIME value.
+///  
+///  Maximum Length Decimal String     = 28
+///    "-9,223,372,036,854,775,808"
+///  Maximum Length Hexadecimal String = 17
+///    "FFFFFFFFFFFFFFFF"
+///  Maximum Length GUID               = 37
+///    "00000000-0000-0000-0000-000000000000"
+///  Maximum Length TIME               = 18
+///    "12/12/2006  12:12"
+///
+#define MAXIMUM_VALUE_CHARACTERS  38
+
+///
+/// Flags bitmask values use in UnicodeValueToString() and 
+/// AsciiValueToString()
+///
+#define LEFT_JUSTIFY      0x01
+#define COMMA_TYPE        0x08
+#define PREFIX_ZERO       0x20
+#define RADIX_HEX         0x80
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on
+  a Null-terminated Unicode format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeVSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on
+  a Null-terminated Unicode format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeBSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  BASE_LIST     Marker
+  );
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  Unicode format string and variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  ...
+  );
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeVSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  IN  VA_LIST      Marker
+  );
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeBSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  IN  BASE_LIST    Marker
+  );
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Converts a decimal value to a Null-terminated Unicode string.
+  
+  Converts the decimal number specified by Value to a Null-terminated Unicode 
+  string specified by Buffer containing at most Width characters. No padding of spaces 
+  is ever performed. If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
+  The number of Unicode characters in Buffer is returned, not including the Null-terminator.
+  If the conversion contains more than Width characters, then only the first
+  Width characters are returned, and the total number of characters 
+  required to perform the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be 
+  formatted in hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer  The pointer to the output buffer for the produced Null-terminated
+                  Unicode string.
+  @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
+  @param  Value   The 64-bit signed value to convert to a string.
+  @param  Width   The maximum number of Unicode characters to place in Buffer, not including
+                  the Null-terminator.
+  
+  @return The number of Unicode characters in Buffer, not including the Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeValueToString (
+  IN OUT CHAR16  *Buffer,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  );
+
+#endif
+
+/**
+  Converts a decimal value to a Null-terminated Unicode string.
+
+  Converts the decimal number specified by Value to a Null-terminated Unicode
+  string specified by Buffer containing at most Width characters. No padding of
+  spaces is ever performed. If Width is 0 then a width of
+  MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more than
+  Width characters, then only the first Width characters are placed in Buffer.
+  Additional conversion parameters are specified in Flags.
+
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be formatted in
+  hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in
+  Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, then
+  Buffer is padded with '0' characters so the combination of the optional '-'
+  sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated Unicode string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of Unicode characters to place in
+                      Buffer, not including the Null-terminator.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If PcdMaximumUnicodeStringLength is not
+                                   zero, and BufferSize is greater than
+                                   (PcdMaximumUnicodeStringLength *
+                                   sizeof (CHAR16) + 1).
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeValueToStringS (
+  IN OUT CHAR16  *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiVSPrint (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR8   *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiBSPrint (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR8   *FormatString,
+  IN  BASE_LIST     Marker
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiSPrint (
+  OUT CHAR8        *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiVSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiBSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  BASE_LIST     Marker
+  );
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  ...
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Converts a decimal value to a Null-terminated ASCII string.
+  
+  Converts the decimal number specified by Value to a Null-terminated ASCII string 
+  specified by Buffer containing at most Width characters. No padding of spaces 
+  is ever performed.
+  If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
+  The number of ASCII characters in Buffer is returned, not including the Null-terminator.
+  If the conversion contains more than Width characters, then only the first Width
+  characters are returned, and the total number of characters required to perform
+  the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be 
+  formatted in hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+  
+  If Buffer is NULL, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer  A pointer to the output buffer for the produced Null-terminated
+                  ASCII string.
+  @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
+  @param  Value   The 64-bit signed value to convert to a string.
+  @param  Width   The maximum number of ASCII characters to place in Buffer, not including
+                  the Null-terminator.
+  
+  @return The number of ASCII characters in Buffer, not including the Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiValueToString (
+  OUT CHAR8      *Buffer,
+  IN  UINTN      Flags,
+  IN  INT64      Value,
+  IN  UINTN      Width
+  );
+
+#endif
+
+/**
+  Converts a decimal value to a Null-terminated Ascii string.
+
+  Converts the decimal number specified by Value to a Null-terminated Ascii
+  string specified by Buffer containing at most Width characters. No padding of
+  spaces is ever performed. If Width is 0 then a width of
+  MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more than
+  Width characters, then only the first Width characters are placed in Buffer.
+  Additional conversion parameters are specified in Flags.
+
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be formatted in
+  hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in
+  Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, then
+  Buffer is padded with '0' characters so the combination of the optional '-'
+  sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated Ascii string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of Ascii characters to place in
+                      Buffer, not including the Null-terminator.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If PcdMaximumAsciiStringLength is not
+                                   zero, and BufferSize is greater than
+                                   PcdMaximumAsciiStringLength.
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiValueToStringS (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  );
+
+/**
+  Returns the number of characters that would be produced by if the formatted 
+  output were produced not including the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If FormatString is NULL, then ASSERT() and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more
+  than PcdMaximumUnicodeStringLength Unicode characters not including the
+  Null-terminator, then ASSERT() and 0 is returned.
+
+  @param[in]  FormatString    A Null-terminated Unicode format string.
+  @param[in]  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of characters that would be produced, not including the 
+          Null-terminator.
+**/
+UINTN
+EFIAPI
+SPrintLength (
+  IN  CONST CHAR16   *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+/**
+  Returns the number of characters that would be produced by if the formatted 
+  output were produced not including the Null-terminator.
+
+  If FormatString is NULL, then ASSERT() and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more
+  than PcdMaximumAsciiStringLength Ascii characters not including the
+  Null-terminator, then ASSERT() and 0 is returned.
+
+  @param[in]  FormatString    A Null-terminated ASCII format string.
+  @param[in]  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of characters that would be produced, not including the 
+          Null-terminator.
+**/
+UINTN
+EFIAPI
+SPrintLengthAsciiFormat (
+  IN  CONST CHAR8   *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/ReportStatusCodeLib.h b/MdePkg/Include/Library/ReportStatusCodeLib.h
new file mode 100644
index 000000000000..0fe55ca7d0db
--- /dev/null
+++ b/MdePkg/Include/Library/ReportStatusCodeLib.h
@@ -0,0 +1,492 @@
+/** @file
+  Provides services to log status code records.
+
+Copyright (c) 2006 - 2010, 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 __REPORT_STATUS_CODE_LIB_H__
+#define __REPORT_STATUS_CODE_LIB_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Pi/PiStatusCode.h>
+#include <Protocol/DevicePath.h>
+
+//
+// Declare bits for PcdReportStatusCodePropertyMask
+//
+#define REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED          0x00000001
+#define REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED             0x00000002
+#define REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED             0x00000004
+
+/**
+  Converts a status code to an 8-bit POST code value.
+
+  Converts the status code specified by CodeType and Value to an 8-bit POST code 
+  and returns the 8-bit POST code in PostCode.  If CodeType is an 
+  EFI_PROGRESS_CODE or CodeType is an EFI_ERROR_CODE, then bits 0..4 of PostCode 
+  are set to bits 16..20 of Value, and bits 5..7 of PostCode are set to bits 
+  24..26 of Value., and TRUE is returned.  Otherwise, FALSE is returned.  
+
+  If PostCode is NULL, then ASSERT().
+
+  @param  CodeType  The type of status code being converted.
+  @param  Value     The status code value being converted.
+  @param  PostCode  A pointer to the 8-bit POST code value to return. 
+
+  @retval  TRUE   The status code specified by CodeType and Value was converted 
+                  to an 8-bit POST code and returned in PostCode.
+  @retval  FALSE  The status code specified by CodeType and Value could not be 
+                  converted to an 8-bit POST code value.
+
+**/
+BOOLEAN
+EFIAPI
+CodeTypeToPostCode (
+  IN  EFI_STATUS_CODE_TYPE   CodeType,
+  IN  EFI_STATUS_CODE_VALUE  Value,
+  OUT UINT8                  *PostCode
+  );
+
+
+/**
+  Extracts ASSERT() information from a status code structure.
+
+  Converts the status code specified by CodeType, Value, and Data to the ASSERT()
+  arguments specified by Filename, Description, and LineNumber.  If CodeType is 
+  an EFI_ERROR_CODE, and CodeType has a severity of EFI_ERROR_UNRECOVERED, and 
+  Value has an operation mask of EFI_SW_EC_ILLEGAL_SOFTWARE_STATE, extract 
+  Filename, Description, and LineNumber from the optional data area of the 
+  status code buffer specified by Data.  The optional data area of Data contains 
+  a Null-terminated ASCII string for the FileName, followed by a Null-terminated 
+  ASCII string for the Description, followed by a 32-bit LineNumber.  If the 
+  ASSERT() information could be extracted from Data, then return TRUE.  
+  Otherwise, FALSE is returned.  
+
+  If Data is NULL, then ASSERT().
+  If Filename is NULL, then ASSERT().
+  If Description is NULL, then ASSERT().
+  If LineNumber is NULL, then ASSERT().
+
+  @param  CodeType     The type of status code being converted.
+  @param  Value        The status code value being converted.
+  @param  Data         The pointer to status code data buffer. 
+  @param  Filename     The pointer to the source file name that generated the ASSERT().
+  @param  Description  The pointer to the description of the ASSERT().
+  @param  LineNumber   The pointer to source line number that generated the ASSERT().
+
+  @retval  TRUE   The status code specified by CodeType, Value, and Data was 
+                  converted ASSERT() arguments specified by Filename, Description, 
+                  and LineNumber.
+  @retval  FALSE  The status code specified by CodeType, Value, and Data could 
+                  not be converted to ASSERT() arguments.
+
+**/
+BOOLEAN
+EFIAPI
+ReportStatusCodeExtractAssertInfo (
+  IN EFI_STATUS_CODE_TYPE        CodeType,
+  IN EFI_STATUS_CODE_VALUE       Value,  
+  IN CONST EFI_STATUS_CODE_DATA  *Data, 
+  OUT CHAR8                      **Filename,
+  OUT CHAR8                      **Description,
+  OUT UINT32                     *LineNumber
+  );
+
+
+/**
+  Extracts DEBUG() information from a status code structure.
+
+  Converts the status code specified by Data to the DEBUG() arguments specified 
+  by ErrorLevel, Marker, and Format.  If type GUID in Data is 
+  EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID, then extract ErrorLevel, Marker, and 
+  Format from the optional data area of the status code buffer specified by Data.  
+  The optional data area of Data contains a 32-bit ErrorLevel followed by Marker 
+  which is 12 UINTN parameters, followed by a Null-terminated ASCII string for 
+  the Format.  If the DEBUG() information could be extracted from Data, then 
+  return TRUE.  Otherwise, FALSE is returned.
+
+  If Data is NULL, then ASSERT().
+  If ErrorLevel is NULL, then ASSERT().
+  If Marker is NULL, then ASSERT().
+  If Format is NULL, then ASSERT().
+
+  @param  Data        The pointer to status code data buffer. 
+  @param  ErrorLevel  The pointer to error level mask for a debug message.
+  @param  Marker      The pointer to the variable argument list associated with Format.
+  @param  Format      The pointer to a Null-terminated ASCII format string of a 
+                      debug message.
+
+  @retval  TRUE   The status code specified by Data was converted DEBUG() arguments 
+                  specified by ErrorLevel, Marker, and Format.
+  @retval  FALSE  The status code specified by Data could not be converted to 
+                  DEBUG() arguments.
+
+**/
+BOOLEAN
+EFIAPI
+ReportStatusCodeExtractDebugInfo (
+  IN CONST EFI_STATUS_CODE_DATA  *Data, 
+  OUT UINT32                     *ErrorLevel,
+  OUT BASE_LIST                  *Marker,
+  OUT CHAR8                      **Format
+  );
+
+
+/**
+  Reports a status code.
+
+  Reports the status code specified by the parameters Type and Value.  Status 
+  code also require an instance, caller ID, and extended data.  This function 
+  passed in a zero instance, NULL extended data, and a caller ID of 
+  gEfiCallerIdGuid, which is the GUID for the module.  
+  
+  ReportStatusCode()must actively prevent recursion.  If ReportStatusCode() 
+  is called while processing another any other Report Status Code Library function,
+  then ReportStatusCode() must return immediately.
+
+  @param  Type   Status code type. 
+  @param  Value  Status code value.
+
+  @retval  EFI_SUCCESS       The status code was reported.
+  @retval  EFI_DEVICE_ERROR  There status code could not be reported due to a 
+                             device error.
+  @retval  EFI_UNSUPPORTED   The report status code is not supported.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCode (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value
+  );
+
+
+/**
+  Reports a status code with a Device Path Protocol as the extended data.
+
+  Allocates and fills in the extended data section of a status code with the 
+  Device Path Protocol specified by DevicePath.  This function is responsible 
+  for allocating a buffer large enough for the standard header and the device 
+  path.  The standard header is filled in with an implementation dependent GUID.
+  The status code is reported with a zero instance and a caller ID of gEfiCallerIdGuid.
+
+  ReportStatusCodeWithDevicePath()must actively prevent recursion.  If 
+  ReportStatusCodeWithDevicePath() is called while processing another any other 
+  Report Status Code Library function, then ReportStatusCodeWithDevicePath() 
+  must return EFI_DEVICE_ERROR immediately.
+
+  If DevicePath is NULL, then ASSERT().
+
+  @param  Type        The status code type. 
+  @param  Value       The status code value.
+  @param  DevicePath  The pointer to the Device Path Protocol to be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended 
+                                 data specified by DevicePath.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the 
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeWithDevicePath (
+  IN EFI_STATUS_CODE_TYPE            Type,
+  IN EFI_STATUS_CODE_VALUE           Value,
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  );
+
+
+/**
+  Reports a status code with an extended data buffer.
+
+  Allocates and fills in the extended data section of a status code with the 
+  extended data specified by ExtendedData and ExtendedDataSize.  ExtendedData 
+  is assumed to be one of the data structures specified in Related Definitions.  
+  These data structure do not have the standard header, so this function is 
+  responsible for allocating a buffer large enough for the standard header and 
+  the extended data passed into this function.  The standard header is filled 
+  in with an implementation dependent GUID.  The status code is reported 
+  with a zero instance and a caller ID of gEfiCallerIdGuid.
+
+  ReportStatusCodeWithExtendedData()must actively prevent recursion.  If 
+  ReportStatusCodeWithExtendedData() is called while processing another any other 
+  Report Status Code Library function, then ReportStatusCodeWithExtendedData() 
+  must return EFI_DEVICE_ERROR immediately.
+
+  If ExtendedData is NULL, then ASSERT().
+  If ExtendedDataSize is 0, then ASSERT().
+
+  @param  Type              The status code type. 
+  @param  Value             The status code value.
+  @param  ExtendedData      The pointer to the extended data buffer to be reported.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer to 
+                            be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended 
+                                 data specified by ExtendedData and ExtendedDataSize.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the 
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeWithExtendedData (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN CONST VOID             *ExtendedData,
+  IN UINTN                  ExtendedDataSize
+  );
+
+
+/**
+  Reports a status code with full parameters.
+
+  The function reports a status code.  If ExtendedData is NULL and ExtendedDataSize 
+  is 0, then an extended data buffer is not reported.  If ExtendedData is not 
+  NULL and ExtendedDataSize is not 0, then an extended data buffer is allocated.  
+  ExtendedData is assumed not have the standard status code header, so this function 
+  is responsible for allocating a buffer large enough for the standard header and 
+  the extended data passed into this function.  The standard header is filled in 
+  with a GUID specified by ExtendedDataGuid.  If ExtendedDataGuid is NULL, then a 
+  GUID of gEfiStatusCodeSpecificDataGuid is used.  The status code is reported with 
+  an instance specified by Instance and a caller ID specified by CallerId.  If 
+  CallerId is NULL, then a caller ID of gEfiCallerIdGuid is used.
+
+  ReportStatusCodeEx()must actively prevent recursion.  If ReportStatusCodeEx() 
+  is called while processing another any other Report Status Code Library function, 
+  then ReportStatusCodeEx() must return EFI_DEVICE_ERROR immediately.
+
+  If ExtendedData is NULL and ExtendedDataSize is not zero, then ASSERT().
+  If ExtendedData is not NULL and ExtendedDataSize is zero, then ASSERT().
+
+  @param  Type              The status code type. 
+  @param  Value             The status code value.
+  @param  Instance          The status code instance number.
+  @param  CallerId          The pointer to a GUID that identifies the caller of this 
+                            function.  If this parameter is NULL, then a caller 
+                            ID of gEfiCallerIdGuid is used.
+  @param  ExtendedDataGuid  The pointer to the GUID for the extended data buffer.  
+                            If this parameter is NULL, then a the status code 
+                            standard header is filled in with an implementation dependent GUID.
+  @param  ExtendedData      The pointer to the extended data buffer.  This is an 
+                            optional parameter that may be NULL.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer.
+
+  @retval  EFI_SUCCESS           The status code was reported.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate 
+                                 the extended data section if it was specified.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeEx (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN UINT32                 Instance,
+  IN CONST EFI_GUID         *CallerId          OPTIONAL,
+  IN CONST EFI_GUID         *ExtendedDataGuid  OPTIONAL,
+  IN CONST VOID             *ExtendedData      OPTIONAL,
+  IN UINTN                  ExtendedDataSize
+  );
+
+
+/**
+  Returns TRUE if status codes of type EFI_PROGRESS_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED 
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportProgressCodeEnabled (
+  VOID
+  );
+
+
+/**
+  Returns TRUE if status codes of type EFI_ERROR_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED 
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise, FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportErrorCodeEnabled (
+  VOID
+  );
+
+
+/**
+  Returns TRUE if status codes of type EFI_DEBUG_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED 
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of 
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportDebugCodeEnabled (
+  VOID
+  );
+
+
+/**
+  Reports a status code with minimal parameters if the status code type is enabled.
+
+  If the status code type specified by Type is enabled in 
+  PcdReportStatusCodeProperyMask, then call ReportStatusCode() passing in Type 
+  and Value.
+
+  @param  Type   The status code type. 
+  @param  Value  The status code value.
+
+  @retval  EFI_SUCCESS       The status code was reported.
+  @retval  EFI_DEVICE_ERROR  There status code could not be reported due to a device error.
+  @retval  EFI_UNSUPPORTED   Report status code is not supported.
+
+**/
+#define REPORT_STATUS_CODE(Type,Value)                                                          \
+  (ReportProgressCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) ?  \
+  ReportStatusCode(Type,Value)                                                               :  \
+  (ReportErrorCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE)       ?  \
+  ReportStatusCode(Type,Value)                                                               :  \
+  (ReportDebugCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE)       ?  \
+  ReportStatusCode(Type,Value)                                                               :  \
+  EFI_UNSUPPORTED
+
+
+/**
+  Reports a status code with a Device Path Protocol as the extended data if the 
+  status code type is enabled.
+
+  If the status code type specified by Type is enabled in 
+  PcdReportStatusCodeProperyMask, then call ReportStatusCodeWithDevicePath() 
+  passing in Type, Value, and DevicePath.
+
+  @param  Type        The status code type. 
+  @param  Value       The status code value.
+  @param  DevicePath  Pointer to the Device Path Protocol to be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended 
+                                 data specified by DevicePath.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the 
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+#define REPORT_STATUS_CODE_WITH_DEVICE_PATH(Type,Value,DevicePathParameter)                     \
+  (ReportProgressCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) ?  \
+  ReportStatusCodeWithDevicePath(Type,Value,DevicePathParameter)                             :  \
+  (ReportErrorCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE)       ?  \
+  ReportStatusCodeWithDevicePath(Type,Value,DevicePathParameter)                             :  \
+  (ReportDebugCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE)       ?  \
+  ReportStatusCodeWithDevicePath(Type,Value,DevicePathParameter)                             :  \
+  EFI_UNSUPPORTED
+
+
+/**
+  Reports a status code with an extended data buffer if the status code type 
+  is enabled.
+
+  If the status code type specified by Type is enabled in 
+  PcdReportStatusCodeProperyMask, then call ReportStatusCodeWithExtendedData() 
+  passing in Type, Value, ExtendedData, and ExtendedDataSize.
+
+  @param  Type              The status code type. 
+  @param  Value             The status code value.
+  @param  ExtendedData      The pointer to the extended data buffer to be reported.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer to
+                            be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended 
+                                 data specified by ExtendedData and ExtendedDataSize.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the 
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+#define REPORT_STATUS_CODE_WITH_EXTENDED_DATA(Type,Value,ExtendedData,ExtendedDataSize)         \
+  (ReportProgressCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) ?  \
+  ReportStatusCodeWithExtendedData(Type,Value,ExtendedData,ExtendedDataSize)                 :  \
+  (ReportErrorCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE)       ?  \
+  ReportStatusCodeWithExtendedData(Type,Value,ExtendedData,ExtendedDataSize)                 :  \
+  (ReportDebugCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE)       ?  \
+  ReportStatusCodeWithExtendedData(Type,Value,ExtendedData,ExtendedDataSize)                 :  \
+  EFI_UNSUPPORTED
+
+/**
+  Reports a status code specifying all parameters if the status code type is enabled.
+
+  If the status code type specified by Type is enabled in 
+  PcdReportStatusCodeProperyMask, then call ReportStatusCodeEx() passing in Type, 
+  Value, Instance, CallerId, ExtendedDataGuid, ExtendedData, and ExtendedDataSize.
+
+  @param  Type              The status code type. 
+  @param  Value             The status code value.
+  @param  Instance          The status code instance number.
+  @param  CallerId          The pointer to a GUID that identifies the caller of this 
+                            function.  If this parameter is NULL, then a caller 
+                            ID of gEfiCallerIdGuid is used.
+  @param  ExtendedDataGuid  Pointer to the GUID for the extended data buffer.  
+                            If this parameter is NULL, then a the status code 
+                            standard header is filled in with an implementation dependent GUID.
+  @param  ExtendedData      Pointer to the extended data buffer.  This is an 
+                            optional parameter that may be NULL.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer.
+
+  @retval  EFI_SUCCESS           The status code was reported.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the 
+                                 extended data section if it was specified.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+  @retval  EFI_DEVICE_ERROR      A call to a Report Status Code Library function
+                                 is already in progress.
+
+**/
+#define REPORT_STATUS_CODE_EX(Type,Value,Instance,CallerId,ExtendedDataGuid,ExtendedData,ExtendedDataSize)  \
+  (ReportProgressCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE)             ?  \
+  ReportStatusCodeEx(Type,Value,Instance,CallerId,ExtendedDataGuid,ExtendedData,ExtendedDataSize)        :  \
+  (ReportErrorCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE)                   ?  \
+  ReportStatusCodeEx(Type,Value,Instance,CallerId,ExtendedDataGuid,ExtendedData,ExtendedDataSize)        :  \
+  (ReportDebugCodeEnabled() && ((Type) & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE)                   ?  \
+  ReportStatusCodeEx(Type,Value,Instance,CallerId,ExtendedDataGuid,ExtendedData,ExtendedDataSize)        :  \
+  EFI_UNSUPPORTED
+
+#endif
diff --git a/MdePkg/Include/Library/ResourcePublicationLib.h b/MdePkg/Include/Library/ResourcePublicationLib.h
new file mode 100644
index 000000000000..c15f58f48ebc
--- /dev/null
+++ b/MdePkg/Include/Library/ResourcePublicationLib.h
@@ -0,0 +1,42 @@
+/** @file
+  Provides a service to publish discovered system resources.
+
+Copyright (c) 2006 - 2008, 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 __RESOURCE_PUBLICATION_LIB__
+#define __RESOURCE_PUBLICATION_LIB__
+
+/**
+  Declares the presence of permanent system memory in the platform.
+
+  Declares that the system memory buffer specified by MemoryBegin and MemoryLength
+  as permanent memory that may be used for general purpose use by software.
+  The amount of memory available to software may be less than MemoryLength
+  if published memory has alignment restrictions. 
+  If MemoryLength is 0, then ASSERT().
+  If MemoryLength is greater than (MAX_ADDRESS - MemoryBegin + 1), then ASSERT(). 
+
+  @param  MemoryBegin               The start address of the memory being declared.
+  @param  MemoryLength              The number of bytes of memory being declared.
+
+  @retval  RETURN_SUCCESS           The memory buffer was published.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources to publish the memory buffer
+
+**/
+RETURN_STATUS
+EFIAPI
+PublishSystemMemory (
+  IN PHYSICAL_ADDRESS       MemoryBegin,
+  IN UINT64                 MemoryLength
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/RngLib.h b/MdePkg/Include/Library/RngLib.h
new file mode 100644
index 000000000000..4b0b90cd346d
--- /dev/null
+++ b/MdePkg/Include/Library/RngLib.h
@@ -0,0 +1,86 @@
+/** @file
+  Provides random number generator services.
+
+Copyright (c) 2015, 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 __RNG_LIB_H__
+#define __RNG_LIB_H__
+
+/**
+  Generates a 16-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 16-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber16 (
+  OUT     UINT16                    *Rand
+  );
+
+/**
+  Generates a 32-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 32-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber32 (
+  OUT     UINT32                    *Rand
+  );
+
+/**
+  Generates a 64-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 64-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber64 (
+  OUT     UINT64                    *Rand
+  );
+
+/**
+  Generates a 128-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 128-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber128 (
+  OUT     UINT64                    *Rand
+  );
+
+#endif  // __RNG_LIB_H__
diff --git a/MdePkg/Include/Library/S3BootScriptLib.h b/MdePkg/Include/Library/S3BootScriptLib.h
new file mode 100644
index 000000000000..160a6d869adb
--- /dev/null
+++ b/MdePkg/Include/Library/S3BootScriptLib.h
@@ -0,0 +1,602 @@
+/** @file 
+  Defines library APIs used by modules to save EFI Boot Script Opcodes.  
+  These OpCode will be restored by S3 related modules. 
+  Note that some of the API defined in the Library class may not 
+  be provided in the Framework version library instance, which means some of these 
+  APIs cannot be used if the underlying firmware is Framework and not PI.
+
+  Copyright (c) 2006 - 2014, 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 _S3_BOOT_SCRIPT_LIB_H_
+#define _S3_BOOT_SCRIPT_LIB_H_
+
+#include <Library/BaseLib.h>
+#include <IndustryStandard/SmBus.h>
+
+/**
+  Macro that converts PCI Bus, PCI Device, PCI Function and PCI Register to an
+  address that can be passed to the S3 Boot Script Library PCI functions.
+
+  @param  Bus       PCI Bus number. Range 0..255.
+  @param  Device    PCI Device number. Range 0..31.
+  @param  Function  PCI Function number. Range 0..7.
+  @param  Register  PCI Register number. Range 0..255 for PCI. Range 0..4095
+                    for PCI Express.
+
+  @return The encoded PCI address.
+
+**/
+#define S3_BOOT_SCRIPT_LIB_PCI_ADDRESS(Bus,Device,Function,Register)   \
+  (UINT64) ( \
+  (((UINTN) Bus) << 24) | \
+  (((UINTN) Device) << 16) | \
+  (((UINTN) Function) << 8) | \
+  (((UINTN) (Register)) < 256 ? ((UINTN) (Register)) : (UINT64) (LShiftU64 ((UINT64) (Register), 32))))
+ 
+///
+/// S3 Boot Script Width.
+///
+typedef enum {
+  S3BootScriptWidthUint8,        ///< 8-bit operation.
+  S3BootScriptWidthUint16,       ///< 16-bit operation.
+  S3BootScriptWidthUint32,       ///< 32-bit operation.  
+  S3BootScriptWidthUint64,       ///< 64-bit operation.
+  S3BootScriptWidthFifoUint8,    ///< 8-bit FIFO operation.
+  S3BootScriptWidthFifoUint16,   ///< 16-bit FIFO operation.
+  S3BootScriptWidthFifoUint32,   ///< 32-bit FIFO operation.
+  S3BootScriptWidthFifoUint64,   ///< 64-bit FIFO operation.
+  S3BootScriptWidthFillUint8,    ///< 8-bit Fill operation.
+  S3BootScriptWidthFillUint16,   ///< 16-bit Fill operation.
+  S3BootScriptWidthFillUint32,   ///< 32-bit Fill operation.
+  S3BootScriptWidthFillUint64,   ///< 64-bit Fill operation.
+  S3BootScriptWidthMaximum
+} S3_BOOT_SCRIPT_LIB_WIDTH;
+
+/**
+  Save I/O write to boot script.
+
+  @param[in] Width     The width of the I/O operations.
+  @param[in] Address   The base address of the I/O operations.
+  @param[in] Count     The number of I/O operations to perform.
+  @param[in] Buffer    The source buffer from which to write data.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  UINTN                     Count,
+  IN  VOID                      *Buffer
+  );
+
+/**
+  Adds a record for an I/O modify operation into a S3 boot script table.
+
+  @param[in] Width      The width of the I/O operations.
+  @param[in] Address    The base address of the I/O operations.
+  @param[in] Data       A pointer to the data to be OR-ed.
+  @param[in] DataMask   A pointer to the data mask to be AND-ed with the data
+                        read from the register.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  VOID                      *Data,
+  IN  VOID                      *DataMask
+  );
+
+/**
+  Adds a record for a memory write operation into a specified boot script table.
+
+  @param[in] Width     The width of the I/O operations.
+  @param[in] Address   The base address of the memory operations
+  @param[in] Count     The number of memory operations to perform.
+  @param[in] Buffer    The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  UINTN                     Count,
+  IN  VOID                      *Buffer
+  );
+
+/**
+  Adds a record for a memory modify operation into a specified boot script table.
+
+  @param[in] Width      The width of the I/O operations.
+  @param[in] Address    The base address of the memory operations. Address needs 
+                        alignment, if required
+  @param[in] Data       A pointer to the data to be OR-ed.
+  @param[in] DataMask   A pointer to the data mask to be AND-ed with the data 
+                        read from the register.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  VOID                      *Data,
+  IN  VOID                      *DataMask
+  );
+
+/**
+  Adds a record for a PCI configuration space write operation into a specified boot script table.
+
+  @param[in] Width     The width of the I/O operations.
+  @param[in] Address   The address within the PCI configuration space.
+  @param[in] Count     The number of PCI operations to perform.
+  @param[in] Buffer    The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table to perform 
+                                   the operation.
+  @retval RETURN_SUCCESS           The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfgWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  UINTN                     Count,
+  IN  VOID                      *Buffer
+  );
+
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param[in] Width      The width of the I/O operations.
+  @param[in] Address    The address within the PCI configuration space.
+  @param[in] Data       A pointer to the data to be OR-ed.The size depends on Width.
+  @param[in] DataMask   A pointer to the data mask to be AND-ed.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN__SUCCESS           The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfgReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  VOID                      *Data,
+  IN  VOID                      *DataMask
+  );
+
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param[in] Width     The width of the I/O operations.
+  @param[in] Segment   The PCI segment number for Address.
+  @param[in] Address   The address within the PCI configuration space.
+  @param[in] Count     The number of PCI operations to perform.
+  @param[in] Buffer    The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfg2Write (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN UINT16                    Segment,
+  IN UINT64                    Address,
+  IN UINTN                     Count,
+  IN VOID                      *Buffer
+  );
+
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param[in] Width      The width of the I/O operations.
+  @param[in] Segment    The PCI segment number for Address.
+  @param[in] Address    The address within the PCI configuration space.
+  @param[in] Data       A pointer to the data to be OR-ed. The size depends on Width.
+  @param[in] DataMask   A pointer to the data mask to be AND-ed.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfg2ReadWrite (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN UINT16                    Segment,
+  IN UINT64                    Address,
+  IN VOID                      *Data,
+  IN VOID                      *DataMask
+  );
+
+/**
+  Adds a record for an SMBus command execution into a specified boot script table.
+
+  @param[in] SmBusAddress   Address that encodes the SMBUS Slave Address, SMBUS 
+                            Command, SMBUS Data Length, and PEC.
+  @param[in] Operation      Indicates which particular SMBus protocol it will use 
+                            to execute the SMBus transactions.
+  @param[in] Length         A pointer to signify the number of bytes that this 
+                            operation will do.
+  @param[in] Buffer         Contains the value of data to execute to the SMBUS 
+                            slave device.
+  
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveSmbusExecute (
+  IN  UINTN                SmBusAddress, 
+  IN  EFI_SMBUS_OPERATION  Operation,
+  IN  UINTN                *Length,
+  IN  VOID                 *Buffer
+  );
+
+/**
+  Adds a record for an execution stall on the processor into a specified boot script table.
+
+  @param[in] Duration   The duration in microseconds of the stall.
+  
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveStall (
+  IN  UINTN  Duration
+  );
+
+/**
+  Adds a record for dispatching specified arbitrary code into a specified boot script table.
+
+  @param[in] EntryPoint   The entry point of the code to be dispatched.
+  @param[in] Context      The argument to be passed into the EntryPoint of the code 
+                          to be dispatched.
+  
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveDispatch2 (
+  IN  VOID  *EntryPoint,
+  IN  VOID  *Context
+  );
+
+/**
+  Adds a record for dispatching specified arbitrary code into a specified boot script table.
+
+  @param[in] EntryPoint   The entry point of the code to be dispatched.
+  
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveDispatch (
+  IN  VOID *EntryPoint
+  );
+
+/**
+  Adds a record for memory reads of the memory location and continues when the exit 
+  criteria is satisfied, or after a defined duration.
+
+  Please aware, below interface is different with PI specification, Vol 5:
+  EFI_S3_SAVE_STATE_PROTOCOL.Write() for EFI_BOOT_SCRIPT_MEM_POLL_OPCODE.
+  "Duration" below is microseconds, while "Delay" in PI specification means
+  the number of 100ns units to poll.
+
+  @param[in] Width       The width of the memory operations.
+  @param[in] Address     The base address of the memory operations.
+  @param[in] BitMask     A pointer to the bit mask to be AND-ed with the data read 
+                         from the register.
+  @param[in] BitValue    A pointer to the data value after to be Masked.
+  @param[in] Duration    The duration in microseconds of the stall.
+  @param[in] LoopTimes   The times of the register polling.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemPoll (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN  UINT64                    Address,
+  IN  VOID                      *BitMask,
+  IN  VOID                      *BitValue,
+  IN  UINTN                     Duration,
+  IN  UINT64                    LoopTimes
+  );
+
+/**
+  Store arbitrary information in the boot script table. This opcode is a no-op on 
+  dispatch and is only used for debugging script issues.
+  
+  @param[in] InformationLength   Length of the data in bytes
+  @param[in] Information        Information to be logged in the boot scrpit
+ 
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveInformation (
+  IN  UINT32  InformationLength, 
+  IN  VOID    *Information
+  );
+/**
+  Adds a record for I/O reads the I/O location and continues when the exit criteria
+   is satisfied, or after a defined duration.
+  
+  @param  Width                 The width of the I/O operations. 
+  @param  Address               The base address of the I/O operations.
+  @param  Data                  The comparison value used for the polling exit criteria.
+  @param  DataMask              The mask used for the polling criteria. The bits in 
+                                the bytes below Width which are zero in Data are 
+                                ignored when polling the memory address.
+  @param  Delay                 The number of 100ns units to poll. Note that timer 
+                                available may be of insufficient granularity, so the 
+                                delay may be longer.
+
+ @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table to perform the 
+                                  operation.
+ @retval RETURN_SUCCESS           The opcode was added.
+ @note   The FRAMEWORK version implementation does not support this API 
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoPoll (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH       Width,
+  IN UINT64                     Address,
+  IN VOID                      *Data,
+  IN VOID                      *DataMask, 
+  IN UINT64                     Delay   
+  );
+
+/**
+  Adds a record for PCI configuration space reads and continues when the exit 
+  criteria is satisfied ,or after a defined duration.
+
+  @param  Width                 The width of the I/O operations. 
+  @param  Address               The address within the PCI configuration space.
+  @param  Data                  The comparison value used for the polling exit 
+                                criteria.
+  @param  DataMask              Mask used for the polling criteria. The bits in 
+                                the bytes below Width which are zero in Data are
+                                ignored when polling the memory address.
+  @param  Delay                 The number of 100ns units to poll. Note that timer 
+                                available may be of insufficient granularity, so the 
+                                delay may be longer.
+
+ @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table to perform the 
+                                 operation.
+ @retval RETURN_SUCCESS           The opcode was added.
+ @note   The FRAMEWORK version implementation does not support this API 
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciPoll (
+   IN S3_BOOT_SCRIPT_LIB_WIDTH   Width,
+   IN UINT64                     Address,
+   IN VOID                      *Data,
+   IN VOID                      *DataMask,
+   IN UINT64                     Delay
+  );
+/**
+  Adds a record for PCI configuration space reads and continues when the exit criteria 
+  is satisfied, or after a defined duration.
+
+  @param  Width                 The width of the I/O operations. 
+  @param  Segment               The PCI segment number for Address.
+  @param  Address               The address within the PCI configuration space.
+  @param  Data                  The comparison value used for the polling exit 
+                                criteria.
+  @param  DataMask              Mask used for the polling criteria. The bits in 
+                                the bytes below Width which are zero
+                                in Data are ignored when polling the memory address
+  @param  Delay                 The number of 100ns units to poll. Note that timer 
+                                available may be of insufficient granularity so the delay 
+                                may be longer.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table to perform the 
+                                   operation.
+  @retval RETURN_SUCCESS           The opcode was added.
+  @note  A known Limitations in the implementation: When interpreting the opcode  
+         EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE, EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE
+         and EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE, the 'Segment' parameter is assumed as 
+         Zero, or else, assert.
+         The FRAMEWORK version implementation does not support this API.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePci2Poll (
+   IN S3_BOOT_SCRIPT_LIB_WIDTH      Width,
+   IN UINT16                        Segment,
+   IN UINT64                        Address,
+   IN VOID                         *Data,
+   IN VOID                         *DataMask,
+   IN UINT64                        Delay
+  );
+/**
+  Save ASCII string information specified by Buffer to boot script with opcode 
+  EFI_BOOT_SCRIPT_INFORMATION_OPCODE.
+
+  @param[in] String   The Null-terminated ASCII string to store into the S3 boot 
+                      script table.
+
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table to perform 
+                                    the operation.
+  @retval RETURN_SUCCESS            The opcode was added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveInformationAsciiString (
+  IN  CONST CHAR8  *String
+  );
+
+/**
+  This is an function to close the S3 boot script table. The function could only 
+  be called in BOOT time phase. To comply with the Framework spec definition on 
+  EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable(), this function will fulfill following things:
+  1. Closes the specified boot script table
+  2. It allocates a new memory pool to duplicate all the boot scripts in the specified table. 
+     Once this function is called, the table maintained by the library will be destroyed 
+     after it is copied into the allocated pool.
+  3. Any attempts to add a script record after calling this function will cause a 
+     new table to be created by the library.
+  4. The base address of the allocated pool will be returned in Address. Note that 
+     after using the boot script table, the CALLER is responsible for freeing the 
+     pool that is allocated by this function. 
+
+  In Spec PI1.1, this EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable() is retired. This 
+  API is supplied here to meet the requirements of the Framework Spec.
+  
+  If anyone does call CloseTable() on a real platform, then the caller is responsible
+  for figuring out how to get the script to run on an S3 resume because the boot script 
+  maintained by the lib will be destroyed.
+ 
+  @return the base address of the new copy of the boot script table.   
+
+**/
+UINT8*
+EFIAPI
+S3BootScriptCloseTable (
+  VOID
+  );
+
+/**
+  Executes the S3 boot script table.
+
+  @retval RETURN_SUCCESS       The boot script table was executed successfully.
+  @retval RETURN_UNSUPPORTED   Invalid script table or opcode.  
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptExecute (
+  VOID
+  );
+/**
+  Move the last boot script entry to the position 
+
+  @param  BeforeOrAfter         Specifies whether the opcode is stored before 
+                                (TRUE) or after (FALSE) the positionin the boot 
+                                script table specified by Position. If Position 
+                                is NULL or points to NULL then the new opcode is 
+                                inserted at the beginning of the table (if TRUE) 
+                                or end of the table (if FALSE).
+  @param  Position              On entry, specifies the position in the boot script 
+                                table where the opcode will be inserted, either 
+                                before or after, depending on BeforeOrAfter. On 
+                                exit, specifies the position of the inserted opcode 
+                                in the boot script table.
+
+  @retval RETURN_OUT_OF_RESOURCES  The table is not available.
+  @retval RETURN_INVALID_PARAMETER The Position is not a valid position in the 
+                                   boot script table.
+  @retval RETURN_SUCCESS           The opcode was inserted.
+  @note   The FRAMEWORK version implementation does not support this API. 
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptMoveLastOpcode (
+  IN     BOOLEAN                        BeforeOrAfter,
+  IN OUT VOID                         **Position OPTIONAL
+  );
+/**
+  Find a label within the boot script table and, if not present, optionally create it.
+
+  @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE)
+                                or after (FALSE) the position in the boot script table 
+                                specified by Position.
+  @param  CreateIfNotFound      Specifies whether the label will be created if the  
+                                label does not exists (TRUE) or not (FALSE).
+  @param  Position              On entry, specifies the position in the boot script 
+                                table where the opcode will be inserted, either 
+                                before or after, depending on BeforeOrAfter. On exit, 
+                                specifies the positionof the inserted opcode in 
+                                the boot script table.
+  @param  Label                 Points to the label which will be inserted in the 
+                                boot script table.
+  @retval EFI_SUCCESS           The operation succeeded. A record was added into 
+                                the specified script table.
+  @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script 
+                                is not supported. If the opcode is unknow or not 
+                                supported because of the PCD Feature Flags.
+  @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
+  @note   The FRAMEWORK version implementation does not support this API 
+
+**/
+RETURN_STATUS
+EFIAPI 
+S3BootScriptLabel (
+  IN       BOOLEAN                      BeforeOrAfter,
+  IN       BOOLEAN                      CreateIfNotFound,
+  IN OUT   VOID                       **Position OPTIONAL,
+  IN CONST CHAR8                       *Label
+  );
+/**
+  Compare two positions in the boot script table and return their relative position.
+  @param  Position1             The positions in the boot script table to compare
+  @param  Position2             The positions in the boot script table to compare
+  @param  RelativePosition      On return, points to the result of the comparison
+
+  @retval EFI_SUCCESS           The operation succeeded. A record was added into the
+                                specified script table.
+  @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script 
+                                is not supported. If the opcode is unknow or not s
+                                upported because of the PCD Feature Flags.
+  @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
+  @note   The FRAMEWORK version implementation does not support this API 
+**/
+RETURN_STATUS
+EFIAPI 
+S3BootScriptCompare (
+  IN  UINT8                       *Position1,
+  IN  UINT8                       *Position2,
+  OUT UINTN                       *RelativePosition
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/S3IoLib.h b/MdePkg/Include/Library/S3IoLib.h
new file mode 100644
index 000000000000..5905eaf7191d
--- /dev/null
+++ b/MdePkg/Include/Library/S3IoLib.h
@@ -0,0 +1,2677 @@
+/** @file
+  I/O and MMIO Library Services that do I/O and also enable the I/O operation
+  to be replayed during an S3 resume. This library class maps directly on top
+  of the IoLib class. 
+
+  Copyright (c) 2006 - 2012, 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 __S3_IO_LIB_H__
+#define __S3_IO_LIB_H__
+
+/**
+  Reads an 8-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port   The I/O port to read.
+
+  @return   The value read.
+
+**/
+UINT8
+EFIAPI
+S3IoRead8 (
+  IN UINTN  Port
+  );
+
+/**
+  Writes an 8-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port    The I/O port to write.
+  @param[in]  Value   The value to write to the I/O port.
+
+  @return   The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoWrite8 (
+  IN UINTN  Port,
+  IN UINT8  Value
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, writes the
+  result back to the 8-bit I/O port, and saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port     The I/O port to write.
+  @param[in]  OrData   The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoOr8 (
+  IN UINTN  Port,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, writes the result back
+  to the 8-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoAnd8 (
+  IN UINTN  Port,
+  IN UINT8  AndData
+  );
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 8-bit I/O port, and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoAndThenOr8 (
+  IN UINTN  Port,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field of an I/O register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+
+  @return   The value read.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldRead8 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. 
+  Remaining bits in Value are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldWrite8 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  Value
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, writes the
+  result back to the bit field in the 8-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  OrData     The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldOr8 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, writes the
+  result back to the bit field in the 8-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldAnd8 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, writes the result back to the bit field in the
+  8-bit port, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldAndThenOr8 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a 16-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port   The I/O port to read.
+
+  @return   The value read.
+
+**/
+UINT16
+EFIAPI
+S3IoRead16 (
+  IN UINTN  Port
+  );
+
+/**
+  Writes a 16-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port    The I/O port to write.
+  @param[in]  Value   The value to write to the I/O port.
+
+  @return   The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoWrite16 (
+  IN UINTN   Port,
+  IN UINT16  Value
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, writes the
+  result back to the 16-bit I/O port, and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port     The I/O port to write.
+  @param[in]  OrData   The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoOr16 (
+  IN UINTN   Port,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, writes the result back
+  to the 16-bit I/O port , and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoAnd16 (
+  IN UINTN   Port,
+  IN UINT16  AndData
+  );
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 16-bit I/O port, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoAndThenOr16 (
+  IN UINTN   Port,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field of an I/O register saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+
+  @return   The value read.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldRead16 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldWrite16 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  Value
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, writes the
+  result back to the bit field in the 16-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  OrData     The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldOr16 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, writes the
+  result back to the bit field in the 16-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldAnd16 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, writes the result back to the bit field in the
+  16-bit port, and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldAndThenOr16 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a 32-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port   The I/O port to read.
+
+  @return   The value read.
+
+**/
+UINT32
+EFIAPI
+S3IoRead32 (
+  IN UINTN  Port
+  );
+
+/**
+  Writes a 32-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port    The I/O port to write.
+  @param[in]  Value   The value to write to the I/O port.
+
+  @return   The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoWrite32 (
+  IN UINTN   Port,
+  IN UINT32  Value
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, writes the
+  result back to the 32-bit I/O port, and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port     The I/O port to write.
+  @param[in]  OrData   The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoOr32 (
+  IN UINTN   Port,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, writes the result back
+  to the 32-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoAnd32 (
+  IN UINTN   Port,
+  IN UINT32  AndData
+  );
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 32-bit I/O port, and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoAndThenOr32 (
+  IN UINTN   Port,
+  IN UINT32  AndData,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a bit field of an I/O register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+
+  @return   The value read.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldRead32 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldWrite32 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  Value
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, writes the
+  result back to the bit field in the 32-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  OrData     The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldOr32 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, writes the
+  result back to the bit field in the 32-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldAnd32 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, writes the result back to the bit field in the
+  32-bit port, and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldAndThenOr32 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a 64-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port   The I/O port to read.
+
+  @return   The value read.
+
+**/
+UINT64
+EFIAPI
+S3IoRead64 (
+  IN UINTN  Port
+  );
+
+/**
+  Writes a 64-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port    The I/O port to write.
+  @param[in]  Value   The value to write to the I/O port.
+
+  @return   The value written to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoWrite64 (
+  IN UINTN   Port,
+  IN UINT64  Value
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, writes the
+  result back to the 64-bit I/O port, and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port     The I/O port to write.
+  @param[in]  OrData   The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoOr64 (
+  IN UINTN   Port,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, writes the result back
+  to the 64-bit I/O port, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoAnd64 (
+  IN UINTN   Port,
+  IN UINT64  AndData
+  );
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 64-bit I/O port, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param[in]  Port      The I/O port to write.
+  @param[in]  AndData   The value to AND with the read value from the I/O port.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoAndThenOr64 (
+  IN UINTN   Port,
+  IN UINT64  AndData,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a bit field of an I/O register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+
+  @return   The value read.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldRead64 (
+  IN UINTN  Port,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to an I/O register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldWrite64 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  Value
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, writes the
+  result back to the bit field in the 64-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  OrData     The value to OR with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldOr64 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, writes the
+  result back to the bit field in the 64-bit port, and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldAnd64 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  AndData
+  );
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, writes the result back to the bit field in the
+  64-bit port, and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Port       The I/O port to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  AndData    The value to AND with the read value from the I/O port.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldAndThenOr64 (
+  IN UINTN   Port,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  AndData,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads an 8-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to read.
+
+  @return   The value read.
+
+**/
+UINT8
+EFIAPI
+S3MmioRead8 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes an 8-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  Value     The value to write to the MMIO register.
+
+  @return   The value written the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioWrite8 (
+  IN UINTN  Address,
+  IN UINT8  Value
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, writes the
+  result back to the 8-bit MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  OrData    The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioOr8 (
+  IN UINTN  Address,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, writes the result
+  back to the 8-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioAnd8 (
+  IN UINTN  Address,
+  IN UINT8  AndData
+  );
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 8-bit MMIO register, and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioAndThenOr8 (
+  IN UINTN  Address,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Address    MMIO register to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+
+  @return   The value read.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldRead8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to an MMIO register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldWrite8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  Value
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, 
+  writes the result back to the bit field in the 8-bit MMIO register, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  OrData     The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldOr8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldAnd8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, writes the result back to the bit field in the
+  8-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..7.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldAndThenOr8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a 16-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to read.
+
+  @return   The value read.
+
+**/
+UINT16
+EFIAPI
+S3MmioRead16 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes a 16-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized, and saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  Value     The value to write to the MMIO register.
+
+  @return   The value written the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioWrite16 (
+  IN UINTN   Address,
+  IN UINT16  Value
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, writes the
+  result back to the 16-bit MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  OrData    The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioOr16 (
+  IN UINTN   Address,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, writes the result
+  back to the 16-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioAnd16 (
+  IN UINTN   Address,
+  IN UINT16  AndData
+  );
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 16-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioAndThenOr16 (
+  IN UINTN   Address,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Address    MMIO register to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+
+  @return   The value read.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldRead16 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldWrite16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  Value
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, 
+  writes the result back to the bit field in the 16-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  OrData     The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldOr16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldAnd16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, writes the result back to the bit field in the
+  16-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..15.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldAndThenOr16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a 32-bit MMIO register saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to read.
+
+  @return   The value read.
+
+**/
+UINT32
+EFIAPI
+S3MmioRead32 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes a 32-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  Value     The value to write to the MMIO register.
+
+  @return   The value written the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioWrite32 (
+  IN UINTN   Address,
+  IN UINT32  Value
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, writes the
+  result back to the 32-bit MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  OrData    The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioOr32 (
+  IN UINTN   Address,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, writes the result
+  back to the 32-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioAnd32 (
+  IN UINTN   Address,
+  IN UINT32  AndData
+  );
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 32-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioAndThenOr32 (
+  IN UINTN    Address,
+  IN UINT32   AndData,
+  IN UINT32   OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Address    MMIO register to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+
+  @return   The value read.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldRead32 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldWrite32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  Value
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, 
+  writes the result back to the bit field in the 32-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  OrData     The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldOr32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldAnd32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, writes the result back to the bit field in the
+  32-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..31.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldAndThenOr32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a 64-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to read.
+
+  @return   The value read.
+
+**/
+UINT64
+EFIAPI
+S3MmioRead64 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes a 64-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  Value     The value to write to the MMIO register.
+
+  @return   The value written the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioWrite64 (
+  IN UINTN   Address,
+  IN UINT64  Value
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, writes the
+  result back to the 64-bit MMIO register, and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  OrData    The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioOr64 (
+  IN UINTN   Address,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, writes the result
+  back to the 64-bit MMIO register, and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioAnd64 (
+  IN UINTN              Address,
+  IN UINT64             AndData
+  );
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, writes the result back to the 64-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param[in]  Address   The MMIO register to write.
+  @param[in]  AndData   The value to AND with the read value from the MMIO register.
+  @param[in]  OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioAndThenOr64 (
+  IN UINTN   Address,
+  IN UINT64  AndData,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a bit field of a MMIO register saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in]  Address    MMIO register to read.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+
+  @return   The value read.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldRead64 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a MMIO register, and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  Value      New value of the bit field.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldWrite64 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  Value
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, 
+  writes the result back to the bit field in the 64-bit MMIO register, and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  OrData     The value to OR with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldOr64 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  OrData
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldAnd64 (
+  IN UINTN    Address,
+  IN UINTN    StartBit,
+  IN UINTN    EndBit,
+  IN UINT64   AndData
+  );
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, writes the result back to the bit field in the
+  64-bit MMIO register, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in]  Address    The MMIO register to write.
+  @param[in]  StartBit   The ordinal of the least significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  EndBit     The ordinal of the most significant bit in the bit field.
+                         Range 0..63.
+  @param[in]  AndData    The value to AND with the read value from the MMIO register.
+  @param[in]  OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldAndThenOr64 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT64  AndData,
+  IN UINT64  OrData
+  );
+
+/**
+  Copies data from MMIO region to system memory by using 8-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of bytes to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied from.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[out] Buffer         Pointer to a system memory buffer receiving the data read.
+
+  @return   Buffer.
+
+**/
+UINT8 *
+EFIAPI
+S3MmioReadBuffer8 (
+  IN  UINTN  StartAddress,
+  IN  UINTN  Length,
+  OUT UINT8  *Buffer
+  );
+
+/**
+  Copies data from MMIO region to system memory by using 16-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of bytes to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied from.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[out] Buffer         Pointer to a system memory buffer receiving the data read.
+
+  @return   Buffer.
+
+**/
+UINT16 *
+EFIAPI
+S3MmioReadBuffer16 (
+  IN  UINTN   StartAddress,
+  IN  UINTN   Length,
+  OUT UINT16  *Buffer
+  );
+
+/**
+  Copies data from MMIO region to system memory by using 32-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied from.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[out] Buffer         Pointer to a system memory buffer receiving the data read.
+
+  @return   Buffer.
+
+**/
+UINT32 *
+EFIAPI
+S3MmioReadBuffer32 (
+  IN  UINTN   StartAddress,
+  IN  UINTN   Length,
+  OUT UINT32  *Buffer
+  );
+
+/**
+  Copies data from MMIO region to system memory by using 64-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied from.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[out] Buffer         Pointer to a system memory buffer receiving the data read.
+
+  @return   Buffer.
+
+**/
+UINT64 *
+EFIAPI
+S3MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  );
+
+/**
+  Copies data from system memory to MMIO region by using 8-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied to.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[in]  Buffer         Pointer to a system memory buffer containing the data to write.
+
+  @return   Buffer.
+
+**/
+UINT8 *
+EFIAPI
+S3MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  );
+
+/**
+  Copies data from system memory to MMIO region by using 16-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of bytes to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied to.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[in]  Buffer         Pointer to a system memory buffer containing the data to write.
+
+  @return   Buffer.
+
+**/
+UINT16 *
+EFIAPI
+S3MmioWriteBuffer16 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT16  *Buffer
+  );
+
+/**
+  Copies data from system memory to MMIO region by using 32-bit access,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of bytes to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied to.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[in]  Buffer         Pointer to a system memory buffer containing the data to write.
+
+  @return   Buffer.
+
+**/
+UINT32 *
+EFIAPI
+S3MmioWriteBuffer32 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT32  *Buffer
+  );
+
+/**
+  Copies data from system memory to MMIO region by using 64-bit access, 
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of bytes to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param[in]  StartAddress   Starting address for the MMIO region to be copied to.
+  @param[in]  Length         Size in bytes of the copy.
+  @param[in]  Buffer         Pointer to a system memory buffer containing the data to write.
+
+  @return   Buffer.
+
+**/
+UINT64 *
+EFIAPI
+S3MmioWriteBuffer64 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT64  *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/S3PciLib.h b/MdePkg/Include/Library/S3PciLib.h
new file mode 100644
index 000000000000..3d8f497f9930
--- /dev/null
+++ b/MdePkg/Include/Library/S3PciLib.h
@@ -0,0 +1,1052 @@
+/** @file
+  The PCI configuration Library Services that carry out PCI configuration and enable
+  the PCI operations to be replayed during an S3 resume. This library class
+  maps directly on top of the PciLib class. 
+
+  Copyright (c) 2006 - 2012, 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 __S3_PCI_LIB_H__
+#define __S3_PCI_LIB_H__
+
+/**
+  Macro that converts PCI Bus, PCI Device, PCI Function and PCI Register to an
+  address that can be passed to the S3 PCI Library functions.
+
+  @param  Bus       The PCI Bus number. Range 0..255.
+  @param  Device    The PCI Device number. Range 0..31.
+  @param  Function  The PCI Function number. Range 0..7.
+  @param  Register  The PCI Register number. Range 0..255 for PCI. Range 0..4095
+                    for PCI Express.
+
+  @return The encoded PCI address.
+
+**/
+#define S3_PCI_LIB_ADDRESS(Bus,Device,Function,Register)   \
+  (((Register) & 0xfff) | (((Function) & 0x07) << 12) | (((Device) & 0x1f) << 15) | (((Bus) & 0xff) << 20))
+
+/**
+ 
+  Reads and returns the 8-bit PCI configuration register specified by Address, 
+  and saves the value in the S3 script to be replayed on S3 resume.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+
+  @return   The value read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciRead8 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes an 8-bit PCI configuration register, and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] Value     The value to write.
+
+  @return   The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciWrite8 (
+  IN UINTN  Address,
+  IN UINT8  Value
+  );
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] OrData    The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciOr8 (
+  IN UINTN  Address,
+  IN UINT8  OrData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param[in]  Address   The address that encodes the PCI Bus, Device, Function and
+                        Register.
+  @param[in]  AndData   The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciAnd8 (
+  IN UINTN  Address,
+  IN UINT8  AndData
+  );
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] AndData   The value to AND with the PCI configuration register.
+  @param[in] OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciAndThenOr8 (
+  IN UINTN  Address,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to read.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+
+  @return   The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldRead8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param[in] Value      New value of the bit field.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldWrite8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  Value
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port, and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param[in] OrData     The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldOr8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldAnd8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData
+  );
+
+/**
+  Reads a bit field in an 8-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+  @param[in] OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldAndThenOr8 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit,
+  IN UINT8  AndData,
+  IN UINT8  OrData
+  );
+
+/**
+  Reads a 16-bit PCI configuration register, and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+
+  @return   The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciRead16 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes a 16-bit PCI configuration register, and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] Value     The value to write.
+
+  @return   The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciWrite16 (
+  IN UINTN   Address,
+  IN UINT16  Value
+  );
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] OrData    The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciOr16 (
+  IN UINTN   Address,
+  IN UINT16  OrData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] AndData   The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciAnd16 (
+  IN UINTN   Address,
+  IN UINT16  AndData
+  );
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] AndData   The value to AND with the PCI configuration register.
+  @param[in] OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciAndThenOr16 (
+  IN UINTN   Address,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to read.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+
+  @return   The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldRead16 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param[in] Value      New value of the bit field.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldWrite16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  Value
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port, and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param[in] OrData     The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldOr16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldAnd16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData
+  );
+
+/**
+  Reads a bit field in a 16-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+  @param[in] OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldAndThenOr16 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT16  AndData,
+  IN UINT16  OrData
+  );
+
+/**
+  Reads a 32-bit PCI configuration register, and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+
+  @return   The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciRead32 (
+  IN UINTN  Address
+  );
+
+/**
+  Writes a 32-bit PCI configuration register, and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] Value     The value to write.
+
+  @return   The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciWrite32 (
+  IN UINTN   Address,
+  IN UINT32  Value
+  );
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] OrData    The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciOr32 (
+  IN UINTN   Address,
+  IN UINT32  OrData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] AndData   The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciAnd32 (
+  IN UINTN   Address,
+  IN UINT32  AndData
+  );
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value, and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param[in] Address   The address that encodes the PCI Bus, Device, Function and
+                       Register.
+  @param[in] AndData   The value to AND with the PCI configuration register.
+  @param[in] OrData    The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciAndThenOr32 (
+  IN UINTN   Address,
+  IN UINT32  AndData,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a bit field of a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+ 
+  @param[in] Address    The PCI configuration register to read.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+
+  @return   The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldRead32 (
+  IN UINTN  Address,
+  IN UINTN  StartBit,
+  IN UINTN  EndBit
+  );
+
+/**
+  Writes a bit field to a PCI configuration register, and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param[in] Value      New value of the bit field.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldWrite32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  Value
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port, and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param[in] OrData     The value to OR with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldOr32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldAnd32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData
+  );
+
+/**
+  Reads a bit field in a 32-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port, and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param[in] Address    The PCI configuration register to write.
+  @param[in] StartBit   The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param[in] EndBit     The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param[in] AndData    The value to AND with the PCI configuration register.
+  @param[in] OrData     The value to OR with the result of the AND operation.
+
+  @return   The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldAndThenOr32 (
+  IN UINTN   Address,
+  IN UINTN   StartBit,
+  IN UINTN   EndBit,
+  IN UINT32  AndData,
+  IN UINT32  OrData
+  );
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer,
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]  StartAddress   Starting address that encodes the PCI Bus, Device,
+                             Function and Register.
+  @param[in]  Size           Size in bytes of the transfer.
+  @param[out] Buffer         The pointer to a buffer receiving the data read.
+
+  @return   Size.
+
+**/
+UINTN
+EFIAPI
+S3PciReadBuffer (
+  IN  UINTN  StartAddress,
+  IN  UINTN  Size,
+  OUT VOID   *Buffer
+  );
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space, and saves the value in the S3 script to be replayed on S3
+  resume.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in] StartAddress   Starting address that encodes the PCI Bus, Device,
+                            Function and Register.
+  @param[in] Size           Size in bytes of the transfer.
+  @param[in] Buffer         The pointer to a buffer containing the data to write.
+
+  @return   Size.
+
+**/
+UINTN
+EFIAPI
+S3PciWriteBuffer (
+  IN UINTN  StartAddress,
+  IN UINTN  Size,
+  IN VOID   *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/S3SmbusLib.h b/MdePkg/Include/Library/S3SmbusLib.h
new file mode 100644
index 000000000000..2f24378d2d58
--- /dev/null
+++ b/MdePkg/Include/Library/S3SmbusLib.h
@@ -0,0 +1,455 @@
+/** @file
+  Smbus Library Services that conduct SMBus transactions and enable the operatation
+  to be replayed during an S3 resume. This library class maps directly on top
+  of the SmbusLib class.
+
+  Copyright (c) 2007 - 2010, 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 __S3_SMBUS_LIB_H__
+#define __S3_SMBUS_LIB_H__
+
+/**
+  Executes an SMBUS quick read command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS  		 The SMBUS command was executed.
+                             RETURN_TIMEOUT  		 A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR The request was not completed because a failure
+                              was recorded in the Host Status Register bit.  Device errors are a result
+                              of a transaction collision, illegal command field, unclaimed cycle
+                              (host initiated), or bus error (collision).
+                             RETURN_UNSUPPORTED  	The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+S3SmBusQuickRead (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status       OPTIONAL
+  );
+
+/**
+  Executes an SMBUS quick write command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS  		The SMBUS command was executed.
+                             RETURN_TIMEOUT  		A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_UNSUPPORTED  	The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+S3SmBusQuickWrite (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status       OPTIONAL
+  );
+
+/**
+  Executes an SMBUS receive byte command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS  		The SMBUS command was executed.
+                             RETURN_TIMEOUT  		A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  	The SMBus operation is not supported.
+
+  @return   The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+S3SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS send byte command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[in]  Value          The 8-bit value to send.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus errors (collisions).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+S3SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read data byte command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+S3SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write data byte command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[in]  Value          The 8-bit value to write.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+S3SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read data word command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+S3SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write data word command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[in]  Value          The 16-bit value to write.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+S3SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS process call command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[in]  Value          The 16-bit value to write.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+S3SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read block command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Buffer         The pointer to the buffer to store the bytes read from the SMBUS.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_SUCCESS The SMBUS command was executed.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+S3SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write block command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[out] Buffer         The pointer to the buffer to store the bytes read from the SMBUS.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+S3SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS block process call command, and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param[in]  SmBusAddress   The address that encodes the SMBUS Slave Address,
+                             SMBUS Command, SMBUS Data Length, and PEC.
+  @param[in]  WriteBuffer    The pointer to the buffer of bytes to write to the SMBUS.
+  @param[out] ReadBuffer     The pointer to the buffer of bytes to read from the SMBUS.
+  @param[out] Status         The return status for the executed command.
+                             This is an optional parameter and may be NULL.
+                             RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                             RETURN_DEVICE_ERROR  The request was not completed because a failure
+                             was recorded in the Host Status Register bit.  Device errors are a result
+                             of a transaction collision, illegal command field, unclaimed cycle
+                             (host initiated), or bus error (collision).
+                             RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect).
+                             RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return   The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+S3SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/S3StallLib.h b/MdePkg/Include/Library/S3StallLib.h
new file mode 100644
index 000000000000..e723d18bda01
--- /dev/null
+++ b/MdePkg/Include/Library/S3StallLib.h
@@ -0,0 +1,39 @@
+/** @file
+  Stall Services that perform stalls and also enable the Stall operatation
+  to be replayed during an S3 resume. This library class maps directly on top
+  of the Timer class. 
+
+  Copyright (c) 2007 - 2010, 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 __S3_STALL_LIB_H__
+#define __S3_STALL_LIB_H__
+
+/**
+  Stalls the CPU for at least the given number of microseconds and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param[in] MicroSeconds   The minimum number of microseconds to delay.
+
+  @return   MicroSeconds.
+
+**/
+UINTN
+EFIAPI
+S3Stall (
+  IN UINTN  MicroSeconds
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/SalLib.h b/MdePkg/Include/Library/SalLib.h
new file mode 100644
index 000000000000..94e4af8e591c
--- /dev/null
+++ b/MdePkg/Include/Library/SalLib.h
@@ -0,0 +1,59 @@
+/** @file
+  Provides library services to make SAL Calls.
+
+Copyright (c) 2007 - 2008, 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 __SAL_LIB__
+#define __SAL_LIB__
+
+#include <IndustryStandard/Sal.h>
+
+/**
+  Makes a SAL procedure call.
+  
+  This is a wrapper function to make a SAL procedure call.  
+  No parameter checking is performed on the 8 input parameters,
+  but there are some common rules that the caller should follow
+  when making a SAL call.  Any address passed to SAL as buffers
+  for return parameters must be 8-byte aligned.  Unaligned
+  addresses may cause undefined results.  For those parameters
+  defined as reserved or some fields defined as reserved must be
+  zero filled or the invalid argument return value may be returned
+  or undefined result may occur during the execution of the procedure.
+  This function is only available on Intel Itanium-based platforms.
+
+  @param  Index       The SAL procedure Index number
+  @param  Arg2        The 2nd parameter for SAL procedure calls
+  @param  Arg3        The 3rd parameter for SAL procedure calls
+  @param  Arg4        The 4th parameter for SAL procedure calls
+  @param  Arg5        The 5th parameter for SAL procedure calls
+  @param  Arg6        The 6th parameter for SAL procedure calls
+  @param  Arg7        The 7th parameter for SAL procedure calls
+  @param  Arg8        The 8th parameter for SAL procedure calls
+
+  @return SAL returned registers.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SalCall (
+  IN UINT64  Index,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/SerialPortLib.h b/MdePkg/Include/Library/SerialPortLib.h
new file mode 100644
index 000000000000..f56b76debd8b
--- /dev/null
+++ b/MdePkg/Include/Library/SerialPortLib.h
@@ -0,0 +1,180 @@
+/** @file
+  This library class provides common serial I/O port functions.
+
+Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2012 - 2014, ARM Ltd. All rights reserved.
+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 __SERIAL_PORT_LIB__
+#define __SERIAL_PORT_LIB__
+
+#include <Uefi/UefiBaseType.h>
+#include <Protocol/SerialIo.h>
+
+/**
+  Initialize the serial device hardware.
+  
+  If no initialization is required, then return RETURN_SUCCESS.
+  If the serial device was successfully initialized, then return RETURN_SUCCESS.
+  If the serial device could not be initialized, then return RETURN_DEVICE_ERROR.
+  
+  @retval RETURN_SUCCESS        The serial device was initialized.
+  @retval RETURN_DEVICE_ERROR   The serial device could not be initialized.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortInitialize (
+  VOID
+  );
+
+/**
+  Write data from buffer to serial device. 
+ 
+  Writes NumberOfBytes data bytes from Buffer to the serial device.  
+  The number of bytes actually written to the serial device is returned.
+  If the return value is less than NumberOfBytes, then the write operation failed.
+  If Buffer is NULL, then ASSERT(). 
+  If NumberOfBytes is zero, then return 0.
+
+  @param  Buffer           Pointer to the data buffer to be written.
+  @param  NumberOfBytes    Number of bytes to written to the serial device.
+
+  @retval 0                NumberOfBytes is 0.
+  @retval >0               The number of bytes written to the serial device.  
+                           If this value is less than NumberOfBytes, then the write operation failed.
+
+**/
+UINTN
+EFIAPI
+SerialPortWrite (
+  IN UINT8     *Buffer,
+  IN UINTN     NumberOfBytes
+  );
+
+
+/**
+  Read data from serial device and save the datas in buffer.
+ 
+  Reads NumberOfBytes data bytes from a serial device into the buffer
+  specified by Buffer. The number of bytes actually read is returned. 
+  If the return value is less than NumberOfBytes, then the rest operation failed.
+  If Buffer is NULL, then ASSERT(). 
+  If NumberOfBytes is zero, then return 0.
+
+  @param  Buffer           Pointer to the data buffer to store the data read from the serial device.
+  @param  NumberOfBytes    Number of bytes which will be read.
+
+  @retval 0                Read data failed, no data is to be read.
+  @retval >0               Actual number of bytes read from serial device.
+
+**/
+UINTN
+EFIAPI
+SerialPortRead (
+  OUT UINT8   *Buffer,
+  IN  UINTN   NumberOfBytes
+  );
+
+/**
+  Polls a serial device to see if there is any data waiting to be read.
+
+  Polls a serial device to see if there is any data waiting to be read.
+  If there is data waiting to be read from the serial device, then TRUE is returned.
+  If there is no data waiting to be read from the serial device, then FALSE is returned.
+
+  @retval TRUE             Data is waiting to be read from the serial device.
+  @retval FALSE            There is no data waiting to be read from the serial device.
+
+**/
+BOOLEAN
+EFIAPI
+SerialPortPoll (
+  VOID
+  );
+
+/**
+  Sets the control bits on a serial device.
+
+  @param Control                Sets the bits of Control that are settable.
+
+  @retval RETURN_SUCCESS        The new control bits were set on the serial device.
+  @retval RETURN_UNSUPPORTED    The serial device does not support this operation.
+  @retval RETURN_DEVICE_ERROR   The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortSetControl (
+  IN UINT32 Control
+  );
+
+/**
+  Retrieve the status of the control bits on a serial device.
+
+  @param Control                A pointer to return the current control signals from the serial device.
+
+  @retval RETURN_SUCCESS        The control bits were read from the serial device.
+  @retval RETURN_UNSUPPORTED    The serial device does not support this operation.
+  @retval RETURN_DEVICE_ERROR   The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortGetControl (
+  OUT UINT32 *Control
+  );
+
+/**
+  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity,
+  data bits, and stop bits on a serial device.
+
+  @param BaudRate           The requested baud rate. A BaudRate value of 0 will use the
+                            device's default interface speed.
+                            On output, the value actually set.
+  @param ReveiveFifoDepth   The requested depth of the FIFO on the receive side of the
+                            serial interface. A ReceiveFifoDepth value of 0 will use
+                            the device's default FIFO depth.
+                            On output, the value actually set.
+  @param Timeout            The requested time out for a single character in microseconds.
+                            This timeout applies to both the transmit and receive side of the
+                            interface. A Timeout value of 0 will use the device's default time
+                            out value.
+                            On output, the value actually set.
+  @param Parity             The type of parity to use on this serial device. A Parity value of
+                            DefaultParity will use the device's default parity value.
+                            On output, the value actually set.
+  @param DataBits           The number of data bits to use on the serial device. A DataBits
+                            vaule of 0 will use the device's default data bit setting.
+                            On output, the value actually set.
+  @param StopBits           The number of stop bits to use on this serial device. A StopBits
+                            value of DefaultStopBits will use the device's default number of
+                            stop bits.
+                            On output, the value actually set.
+
+  @retval RETURN_SUCCESS            The new attributes were set on the serial device.
+  @retval RETURN_UNSUPPORTED        The serial device does not support this operation.
+  @retval RETURN_INVALID_PARAMETER  One or more of the attributes has an unsupported value.
+  @retval RETURN_DEVICE_ERROR       The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortSetAttributes (
+  IN OUT UINT64             *BaudRate,
+  IN OUT UINT32             *ReceiveFifoDepth,
+  IN OUT UINT32             *Timeout,
+  IN OUT EFI_PARITY_TYPE    *Parity,
+  IN OUT UINT8              *DataBits,
+  IN OUT EFI_STOP_BITS_TYPE *StopBits
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/SmbusLib.h b/MdePkg/Include/Library/SmbusLib.h
new file mode 100644
index 000000000000..35bf932ac690
--- /dev/null
+++ b/MdePkg/Include/Library/SmbusLib.h
@@ -0,0 +1,497 @@
+/** @file
+  Provides library functions to access SMBUS devices. Libraries of this class
+  must be ported to a specific SMBUS controller.
+
+Copyright (c) 2006 - 2008, 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 __SMBUS_LIB__
+#define __SMBUS_LIB__
+
+/**
+  Macro that converts SMBUS slave address, SMBUS command, SMBUS data length,
+  and PEC to a value that can be passed to the SMBUS Library functions.
+
+  Computes an address that is compatible with the SMBUS Library functions.
+  The unused upper bits of SlaveAddress, Command, and Length are stripped
+  prior to the generation of the address.
+  
+  @param  SlaveAddress    SMBUS Slave Address.  Range 0..127.
+  @param  Command         SMBUS Command.  Range 0..255.
+  @param  Length          SMBUS Data Length.  Range 0..32.
+  @param  Pec             TRUE if Packet Error Checking is enabled.  Otherwise FALSE.
+
+**/
+#define SMBUS_LIB_ADDRESS(SlaveAddress,Command,Length,Pec)  \
+  ( ((Pec) ? BIT22: 0)                  | \
+    (((SlaveAddress) & 0x7f) << 1)      | \
+    (((Command)      & 0xff) << 8)      | \
+    (((Length)       & 0x3f) << 16)       \
+  )
+
+/**
+  Macro that returns the SMBUS Slave Address value from an SmBusAddress Parameter value.
+  
+  @param SmBusAddress   Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC 
+**/
+#define SMBUS_LIB_SLAVE_ADDRESS(SmBusAddress)      (((SmBusAddress) >> 1)  & 0x7f)
+
+/**
+  Macro that returns the SMBUS Command value from an SmBusAddress Parameter value.
+  
+  @param SmBusAddress   Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC
+**/
+#define SMBUS_LIB_COMMAND(SmBusAddress)            (((SmBusAddress) >> 8)  & 0xff)
+
+/**
+  Macro that returns the SMBUS Data Length value from an SmBusAddress Parameter value.
+  
+  @param SmBusAddress Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC 
+**/
+#define SMBUS_LIB_LENGTH(SmBusAddress)             (((SmBusAddress) >> 16) & 0x3f)
+
+/**
+  Macro that returns the SMBUS PEC value from an SmBusAddress Parameter value.
+  
+  @param SmBusAddress Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC   
+**/
+#define SMBUS_LIB_PEC(SmBusAddress)                ((BOOLEAN) (((SmBusAddress) & BIT22) != 0))
+
+/**
+  Macro that returns the set of reserved bits from an SmBusAddress Parameter value.
+  
+  @param SmBusAddress Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC   
+**/
+#define SMBUS_LIB_RESERVED(SmBusAddress)           ((SmBusAddress) & ~(BIT23 - 2))
+
+/**
+  Executes an SMBUS quick read command.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS  The SMBUS command was executed.
+                        RETURN_TIMEOUT  A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickRead (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  );
+
+/**
+  Executes an SMBUS quick write command.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickWrite (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  );
+
+/**
+  Executes an SMBUS receive byte command.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS send byte command.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to send.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read data byte command.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write data byte command.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read data word command.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+  
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write data word command.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS process call command.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS read block command.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS write block command.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.  
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+/**
+  Executes an SMBUS block process call command.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  WriteBuffer   Pointer to the buffer of bytes to write to the SMBUS.
+  @param  ReadBuffer    Pointer to the buffer of bytes to read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  );
+
+
+#endif
diff --git a/MdePkg/Include/Library/SmiHandlerProfileLib.h b/MdePkg/Include/Library/SmiHandlerProfileLib.h
new file mode 100644
index 000000000000..a544addd133b
--- /dev/null
+++ b/MdePkg/Include/Library/SmiHandlerProfileLib.h
@@ -0,0 +1,81 @@
+/** @file
+  Provides services to log the SMI handler registration.
+
+  This API provides services for the SMM Child Dispatch Protocols provider,
+  to register SMI handler information to SmmCore.
+
+  NOTE:
+  There is no need to update the consumers of SMST->SmiHandlerRegister() or
+  the consumers of SMM Child Dispatch Protocols.
+  The SmmCore (who produces SMST) should have ability to register such
+  information directly.
+  The SmmChildDispatcher (who produces SMM Child Dispatch Protocols) should
+  be responsible to call the services to register information to SMM Core.
+
+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 __SMI_HANDLER_PROFILE_LIB_H__
+#define __SMI_HANDLER_PROFILE_LIB_H__
+
+#include <PiSmm.h>
+
+/**
+  This function is called by SmmChildDispatcher module to report
+  a new SMI handler is registered, to SmmCore.
+
+  @param HandlerGuid     The GUID to identify the type of the handler.
+                         For the SmmChildDispatch protocol, the HandlerGuid
+                         must be the GUID of SmmChildDispatch protocol.
+  @param Handler         The SMI handler.
+  @param CallerAddress   The address of the module who registers the SMI handler.
+  @param Context         The context of the SMI handler.
+                         For the SmmChildDispatch protocol, the Context
+                         must match the one defined for SmmChildDispatch protocol.
+  @param ContextSize     The size of the context in bytes.
+                         For the SmmChildDispatch protocol, the Context
+                         must match the one defined for SmmChildDispatch protocol.
+
+  @retval EFI_SUCCESS           The information is recorded.
+  @retval EFI_UNSUPPORTED       The feature is unsupported.
+  @retval EFI_OUT_OF_RESOURCES  There is no enough resource to record the information.
+**/
+EFI_STATUS
+EFIAPI
+SmiHandlerProfileRegisterHandler (
+  IN EFI_GUID                       *HandlerGuid,
+  IN EFI_SMM_HANDLER_ENTRY_POINT2   Handler,
+  IN PHYSICAL_ADDRESS               CallerAddress,
+  IN VOID                           *Context, OPTIONAL
+  IN UINTN                          ContextSize OPTIONAL
+  );
+
+/**
+  This function is called by SmmChildDispatcher module to report
+  an existing SMI handler is unregistered, to SmmCore.
+
+  @param HandlerGuid     The GUID to identify the type of the handler.
+                         For the SmmChildDispatch protocol, the HandlerGuid
+                         must be the GUID of SmmChildDispatch protocol.
+  @param Handler         The SMI handler.
+
+  @retval EFI_SUCCESS           The original record is removed.
+  @retval EFI_UNSUPPORTED       The feature is unsupported.
+  @retval EFI_NOT_FOUND         There is no record for the HandlerGuid and handler.
+**/
+EFI_STATUS
+EFIAPI
+SmiHandlerProfileUnregisterHandler (
+  IN EFI_GUID                       *HandlerGuid,
+  IN EFI_SMM_HANDLER_ENTRY_POINT2   Handler
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/SmmLib.h b/MdePkg/Include/Library/SmmLib.h
new file mode 100644
index 000000000000..999c41038428
--- /dev/null
+++ b/MdePkg/Include/Library/SmmLib.h
@@ -0,0 +1,89 @@
+/** @file
+  Library class name: SmmLib
+  
+  SMM Library Services that abstracts both S/W SMI generation and detection. 
+
+  Copyright (c) 2007 - 2010, 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 __SMM_LIB_H__
+#define __SMM_LIB_H__
+
+
+/**
+  Triggers an SMI at boot time.  
+
+  This function triggers a software SMM interrupt at boot time.
+
+**/
+VOID
+EFIAPI
+TriggerBootServiceSoftwareSmi (
+  VOID
+  );
+
+
+/**
+  Triggers an SMI at run time.  
+
+  This function triggers a software SMM interrupt at run time.
+
+**/
+VOID
+EFIAPI
+TriggerRuntimeSoftwareSmi (
+  VOID
+  );
+
+
+/**
+  Test if a boot time software SMI happened.  
+
+  This function tests if a software SMM interrupt happened. If a software SMM interrupt happened and
+  it was triggered at boot time, it returns TRUE. Otherwise, it returns FALSE.
+
+  @retval TRUE   A software SMI triggered at boot time happened.
+  @retval FLASE  No software SMI happened, or the software SMI was triggered at run time.
+
+**/
+BOOLEAN
+EFIAPI
+IsBootServiceSoftwareSmi (
+  VOID
+  );
+
+
+/**
+  Test if a run time software SMI happened.  
+
+  This function tests if a software SMM interrupt happened. If a software SMM interrupt happened and
+  it was triggered at run time, it returns TRUE. Otherwise, it returns FALSE.
+
+  @retval TRUE   A software SMI triggered at run time happened.
+  @retval FLASE  No software SMI happened or the software SMI was triggered at boot time.
+
+**/
+BOOLEAN
+EFIAPI
+IsRuntimeSoftwareSmi (
+  VOID
+  );
+
+/**
+  Clear APM SMI Status Bit; Set the EOS bit. 
+  
+**/
+VOID
+EFIAPI
+ClearSmi (
+  VOID
+  );
+#endif
diff --git a/MdePkg/Include/Library/SmmMemLib.h b/MdePkg/Include/Library/SmmMemLib.h
new file mode 100644
index 000000000000..d460ae9577b8
--- /dev/null
+++ b/MdePkg/Include/Library/SmmMemLib.h
@@ -0,0 +1,138 @@
+/** @file
+  Provides services for SMM Memory Operation.
+
+  The SMM Mem Library provides function for checking if buffer is outside SMRAM and valid.
+  It also provides functions for copy data from SMRAM to non-SMRAM, from non-SMRAM to SMRAM,
+  from non-SMRAM to non-SMRAM, or set data in non-SMRAM.
+  
+  Copyright (c) 2015, 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 _SMM_MEM_LIB_H_
+#define _SMM_MEM_LIB_H_
+
+/**
+  This function check if the buffer is valid per processor architecture and not overlap with SMRAM.
+
+  @param Buffer  The buffer start address to be checked.
+  @param Length  The buffer length to be checked.
+
+  @retval TRUE  This buffer is valid per processor architecture and not overlap with SMRAM.
+  @retval FALSE This buffer is not valid per processor architecture or overlap with SMRAM.
+**/
+BOOLEAN
+EFIAPI
+SmmIsBufferOutsideSmmValid (
+  IN EFI_PHYSICAL_ADDRESS  Buffer,
+  IN UINT64                Length
+  );
+
+/**
+  Copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if source buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it return EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant.
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMemToSmram (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  );
+
+/**
+  Copies a source buffer (SMRAM) to a destination buffer (NON-SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if destination buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant.
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMemFromSmram (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  );
+
+/**
+  Copies a source buffer (NON-SMRAM) to a destination buffer (NON-SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if source buffer and destination buffer are valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant, and it must handle the case where source buffer overlaps destination buffer.
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  );
+
+/**
+  Fills a target buffer (NON-SMRAM) with a byte value.
+
+  This function fills a target buffer (non-SMRAM) with a byte value.
+  It checks if target buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it fills memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+  
+  @retval EFI_SECURITY_VIOLATION The Buffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is set.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmSetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  );
+
+#endif
\ No newline at end of file
diff --git a/MdePkg/Include/Library/SmmPeriodicSmiLib.h b/MdePkg/Include/Library/SmmPeriodicSmiLib.h
new file mode 100644
index 000000000000..dee4d98f55d6
--- /dev/null
+++ b/MdePkg/Include/Library/SmmPeriodicSmiLib.h
@@ -0,0 +1,184 @@
+/** @file
+  Provides services to enable and disable periodic SMI handlers.
+
+Copyright (c) 2011, 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 __PERIODIC_SMI_LIB_H__
+#define __PERIODIC_SMI_LIB_H__
+
+#define PERIODIC_SMI_LIBRARY_ANY_CPU  0xffffffff
+
+/**
+  This function returns a pointer to a table of supported periodic
+  SMI tick periods in 100 ns units sorted from largest to smallest.  
+  The table contains a array of UINT64 values terminated by a tick 
+  period value of 0.  The returned table must be treated as read-only
+  data and must not be freed.
+  
+  @return  A pointer to a table of UINT64 tick period values in 
+           100ns units sorted from largest to smallest terminated 
+           by a tick period of 0.
+  
+**/
+UINT64 *
+EFIAPI
+PeriodicSmiSupportedTickPeriod (
+  VOID
+  );
+
+/**
+  This function returns the time in 100ns units since the periodic SMI
+  handler function was called.  If the periodic SMI handler was resumed
+  through PeriodicSmiYield(), then the time returned is the time in
+  100ns units since PeriodicSmiYield() returned.
+
+  @return  The actual time in 100ns units that the periodic SMI handler
+           has been executing.  If this function is not called from within
+           an enabled periodic SMI handler, then 0 is returned.
+
+**/
+UINT64
+EFIAPI
+PeriodicSmiExecutionTime (
+  VOID
+  );
+
+/**
+  This function returns control back to the SMM Foundation.  When the next 
+  periodic SMI for the currently executing handler is triggered, the periodic
+  SMI handler will restarted from its registered DispatchFunction entry point.
+  If this function is not called from within an enabled periodic SMI handler, 
+  then control is returned to the calling function.
+
+**/
+VOID
+EFIAPI  
+PeriodicSmiExit (
+  VOID
+  );
+
+/**
+  This function yields control back to the SMM Foundation.  When the next 
+  periodic SMI for the currently executing handler is triggered, the periodic
+  SMI handler will be resumed and this function will return.  Use of this 
+  function requires a seperate stack for the periodic SMI handler.  A non zero
+  stack size must be specified in PeriodicSmiEnable() for this function to be 
+  used.  
+  
+  If the stack size passed into PeriodicSmiEnable() was zero, the 0 is returned.
+  
+  If this function is not called from within an enabled periodic SMI handler, 
+  then 0 is returned.
+
+  @return  The actual time in 100ns units elapsed since this function was
+           called.  A value of 0 indicates an unknown amount of time.
+
+**/
+UINT64
+EFIAPI  
+PeriodicSmiYield (
+  VOID
+  );
+
+/**
+  This function is a prototype for a periodic SMI handler function 
+  that may be enabled with PeriodicSmiEnable() and disabled with
+  PeriodicSmiDisable().
+
+  @param[in] Context      Content registered with PeriodicSmiEnable().
+  @param[in] ElapsedTime  The actual time in 100ns units elapsed since
+                          this function was called.  A value of 0 indicates 
+                          an unknown amount of time.
+                            
+**/
+typedef
+VOID
+(EFIAPI *PERIODIC_SMI_LIBRARY_HANDLER) (
+  IN CONST VOID  *Context OPTIONAL,
+  IN UINT64      ElapsedTime
+  );
+  
+/**
+  This function enables a periodic SMI handler.
+  
+  @param[in, out] DispatchHandle   A pointer to the handle associated with the 
+                                   enabled periodic SMI handler.  This is an 
+                                   optional parameter that may be NULL.  If it is 
+                                   NULL, then the handle will not be returned, 
+                                   which means that the periodic SMI handler can 
+                                   never be disabled.
+  @param[in]     DispatchFunction  A pointer to a periodic SMI handler function.
+  @param[in]     Context           Optional content to pass into DispatchFunction.
+  @param[in]     TickPeriod        The requested tick period in 100ns units that 
+                                   control should be givien to the periodic SMI
+                                   handler.  Must be one of the supported values
+                                   returned by PeriodicSmiSupportedPickPeriod().
+  @param[in]     Cpu               Specifies the CPU that is required to execute
+                                   the periodic SMI handler.  If Cpu is 
+                                   PERIODIC_SMI_LIBRARY_ANY_CPU, then the periodic 
+                                   SMI handler will always be executed on the SMST 
+                                   CurrentlyExecutingCpu, which may vary across 
+                                   periodic SMIs.  If Cpu is between 0 and the SMST 
+                                   NumberOfCpus, then the periodic SMI will always
+                                   be executed on the requested CPU.
+  @param[in]     StackSize         The size, in bytes, of the stack to allocate for
+                                   use by the periodic SMI handler.  If 0, then the
+                                   default stack will be used.
+                            
+  @retval EFI_INVALID_PARAMETER  DispatchFunction is NULL.
+  @retval EFI_UNSUPPORTED        TickPeriod is not a supported tick period.  The 
+                                 supported tick periods can be retrieved using 
+                                 PeriodicSmiSupportedTickPeriod().
+  @retval EFI_INVALID_PARAMETER  Cpu is not PERIODIC_SMI_LIBRARY_ANY_CPU or in 
+                                 the range 0 to SMST NumberOfCpus.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to enable the 
+                                 periodic SMI handler.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to allocate the 
+                                 stack speficied by StackSize.
+  @retval EFI_SUCCESS            The periodic SMI handler was enabled.
+  
+**/
+EFI_STATUS 
+EFIAPI
+PeriodicSmiEnable (
+  IN OUT EFI_HANDLE                    *DispatchHandle,    OPTIONAL
+  IN     PERIODIC_SMI_LIBRARY_HANDLER  DispatchFunction,
+  IN     CONST VOID                    *Context,           OPTIONAL
+  IN     UINT64                        TickPeriod,
+  IN     UINTN                         Cpu,
+  IN     UINTN                         StackSize
+  );
+
+/**
+  This function disables a periodic SMI handler that has been previously
+  enabled with PeriodicSmiEnable().
+  
+  @param[in] DispatchHandle  A handle associated with a previously enabled periodic 
+                             SMI handler.  This is an optional parameter that may
+                             be NULL.  If it is NULL, then the active periodic SMI
+                             handlers is disabled.
+
+  @retval FALSE  DispatchHandle is NULL and there is no active periodic SMI handler.
+  @retval FALSE  The periodic SMI handler specified by DispatchHandle has 
+                 not been enabled with PeriodicSmiEnable().
+  @retval TRUE   The periodic SMI handler specified by DispatchHandle has 
+                 been disabled.  If DispatchHandle is NULL, then the active
+                 periodic SMI handler has been disabled.
+  
+**/
+BOOLEAN 
+EFIAPI
+PeriodicSmiDisable (
+  IN EFI_HANDLE  DispatchHandle    OPTIONAL
+  );
+  
+#endif
diff --git a/MdePkg/Include/Library/SmmServicesTableLib.h b/MdePkg/Include/Library/SmmServicesTableLib.h
new file mode 100644
index 000000000000..b8c0d5660fc3
--- /dev/null
+++ b/MdePkg/Include/Library/SmmServicesTableLib.h
@@ -0,0 +1,43 @@
+/** @file
+  Provides a service to retrieve a pointer to the SMM Services Table.
+  Only available to SMM module types.
+
+Copyright (c) 2009, 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 __SMM_SERVICES_TABLE_LIB_H__
+#define __SMM_SERVICES_TABLE_LIB_H__
+
+#include <PiSmm.h>
+
+///
+/// Cache pointer to the SMM Services Table
+///
+extern EFI_SMM_SYSTEM_TABLE2   *gSmst;
+
+/**
+  This function allows the caller to determine if the driver is executing in 
+  System Management Mode(SMM).
+
+  This function returns TRUE if the driver is executing in SMM and FALSE if the 
+  driver is not executing in SMM.
+
+  @retval  TRUE  The driver is executing in System Management Mode (SMM).
+  @retval  FALSE The driver is not executing in System Management Mode (SMM). 
+
+**/
+BOOLEAN
+EFIAPI
+InSmm (
+  VOID
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/SynchronizationLib.h b/MdePkg/Include/Library/SynchronizationLib.h
new file mode 100644
index 000000000000..bfdf6f4222ed
--- /dev/null
+++ b/MdePkg/Include/Library/SynchronizationLib.h
@@ -0,0 +1,295 @@
+/** @file
+  Provides synchronization functions.
+
+Copyright (c) 2006 - 2016, 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 __SYNCHRONIZATION_LIB__
+#define __SYNCHRONIZATION_LIB__
+
+///
+/// Definitions for SPIN_LOCK
+///
+typedef volatile UINTN              SPIN_LOCK;
+
+
+/**
+  Retrieves the architecture-specific spin lock alignment requirements for
+  optimal spin lock performance.
+
+  This function retrieves the spin lock alignment requirements for optimal
+  performance on a given CPU architecture. The spin lock alignment is byte alignment. 
+  It must be a power of two and is returned by this function. If there are no alignment
+  requirements, then 1 must be returned. The spin lock synchronization
+  functions must function correctly if the spin lock size and alignment values
+  returned by this function are not used at all. These values are hints to the
+  consumers of the spin lock synchronization functions to obtain optimal spin
+  lock performance.
+
+  @return The architecture-specific spin lock alignment.
+
+**/
+UINTN
+EFIAPI
+GetSpinLockProperties (
+  VOID
+  );
+
+
+/**
+  Initializes a spin lock to the released state and returns the spin lock.
+
+  This function initializes the spin lock specified by SpinLock to the released
+  state, and returns SpinLock. Optimal performance can be achieved by calling
+  GetSpinLockProperties() to determine the size and alignment requirements for
+  SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to initialize to the released
+                    state.
+
+  @return SpinLock in release state.
+
+**/
+SPIN_LOCK *
+EFIAPI
+InitializeSpinLock (
+  OUT      SPIN_LOCK                 *SpinLock
+  );
+
+
+/**
+  Waits until a spin lock can be placed in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns SpinLock. Otherwise, this function waits
+  indefinitely for the spin lock to be released, and then places it in the
+  acquired state and returns SpinLock. All state transitions of SpinLock must
+  be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+  If PcdSpinLockTimeout is not zero, and SpinLock is can not be acquired in
+  PcdSpinLockTimeout microseconds, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @return SpinLock acquired lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+AcquireSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  );
+
+
+/**
+  Attempts to place a spin lock in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns TRUE. Otherwise, FALSE is returned. All state
+  transitions of SpinLock must be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @retval TRUE  SpinLock was placed in the acquired state.
+  @retval FALSE SpinLock could not be acquired.
+
+**/
+BOOLEAN
+EFIAPI
+AcquireSpinLockOrFail (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  );
+
+
+/**
+  Releases a spin lock.
+
+  This function places the spin lock specified by SpinLock in the release state
+  and returns SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to release.
+
+  @return SpinLock released lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+ReleaseSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  );
+
+
+/**
+  Performs an atomic increment of a 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedIncrement (
+  IN      volatile UINT32           *Value
+  );
+
+
+/**
+  Performs an atomic decrement of a 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedDecrement (
+  IN      volatile UINT32           *Value
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+**/
+UINT16
+EFIAPI
+InterlockedCompareExchange16 (
+  IN OUT  volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  );
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InterlockedCompareExchange32 (
+  IN OUT  volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InterlockedCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a pointer value.
+
+  Performs an atomic compare exchange operation on the pointer value specified
+  by Value. If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned. If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange operation must be
+  performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the pointer value for the compare exchange
+                        operation.
+  @param  CompareValue  Pointer value used in compare operation.
+  @param  ExchangeValue Pointer value used in exchange operation.
+
+  @return The original *Value before exchange.
+**/
+VOID *
+EFIAPI
+InterlockedCompareExchangePointer (
+  IN OUT  VOID                      * volatile *Value,
+  IN      VOID                      *CompareValue,
+  IN      VOID                      *ExchangeValue
+  );
+
+#endif
+
+
diff --git a/MdePkg/Include/Library/TimerLib.h b/MdePkg/Include/Library/TimerLib.h
new file mode 100644
index 000000000000..f0d898a9894f
--- /dev/null
+++ b/MdePkg/Include/Library/TimerLib.h
@@ -0,0 +1,114 @@
+/** @file
+  Provides calibrated delay and performance counter services.
+
+Copyright (c) 2006 - 2011, 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 __TIMER_LIB__
+#define __TIMER_LIB__
+
+/**
+  Stalls the CPU for at least the given number of microseconds.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return The value of MicroSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+MicroSecondDelay (
+  IN      UINTN                     MicroSeconds
+  );
+
+/**
+  Stalls the CPU for at least the given number of nanoseconds.
+
+  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
+
+  @param  NanoSeconds The minimum number of nanoseconds to delay.
+
+  @return The value of NanoSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+NanoSecondDelay (
+  IN      UINTN                     NanoSeconds
+  );
+
+/**
+  Retrieves the current value of a 64-bit free running performance counter.
+
+  The counter can either count up by 1 or count down by 1. If the physical
+  performance counter counts by a larger increment, then the counter values
+  must be translated. The properties of the counter can be retrieved from
+  GetPerformanceCounterProperties().
+
+  @return The current value of the free running performance counter.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounter (
+  VOID
+  );
+
+/**
+  Retrieves the 64-bit frequency in Hz and the range of performance counter
+  values.
+
+  If StartValue is not NULL, then the value that the performance counter starts
+  with immediately after is it rolls over is returned in StartValue. If
+  EndValue is not NULL, then the value that the performance counter end with
+  immediately before it rolls over is returned in EndValue. The 64-bit
+  frequency of the performance counter in Hz is always returned. If StartValue
+  is less than EndValue, then the performance counter counts up. If StartValue
+  is greater than EndValue, then the performance counter counts down. For
+  example, a 64-bit free running counter that counts up would have a StartValue
+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
+
+  @param  StartValue  The value the performance counter starts with when it
+                      rolls over.
+  @param  EndValue    The value that the performance counter ends with before
+                      it rolls over.
+
+  @return The frequency in Hz.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  OUT      UINT64                    *StartValue,  OPTIONAL
+  OUT      UINT64                    *EndValue     OPTIONAL
+  );
+
+/**
+  Converts elapsed ticks of performance counter to time in nanoseconds.
+
+  This function converts the elapsed ticks of running performance counter to
+  time value in unit of nanoseconds.
+
+  @param  Ticks     The number of elapsed ticks of running performance counter.
+
+  @return The elapsed time in nanoseconds.
+
+**/
+UINT64
+EFIAPI
+GetTimeInNanoSecond (
+  IN      UINT64                     Ticks
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiApplicationEntryPoint.h b/MdePkg/Include/Library/UefiApplicationEntryPoint.h
new file mode 100644
index 000000000000..c84282397c73
--- /dev/null
+++ b/MdePkg/Include/Library/UefiApplicationEntryPoint.h
@@ -0,0 +1,154 @@
+/** @file
+  Module entry point library for UEFI Applications.
+
+Copyright (c) 2007 - 2008, 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_APPLICATION_ENTRY_POINT_H__
+#define __UEFI_APPLICATION_ENTRY_POINT_H__
+
+///
+/// Declare the EFI/UEFI Specification Revision to which this driver is implemented 
+///
+extern CONST UINT32        _gUefiDriverRevision;
+
+
+/**
+  Entry point to UEFI Application.
+
+  This function is the entry point for a UEFI Application. This function must call
+  ProcessLibraryConstructorList(), ProcessModuleEntryPointList(), and ProcessLibraryDestructorList().
+  The return value from ProcessModuleEntryPointList() is returned.
+  If _gUefiDriverRevision is not zero and SystemTable->Hdr.Revision is less than _gUefiDriverRevison,
+  then return EFI_INCOMPATIBLE_VERSION.
+
+  @param  ImageHandle  The image handle of the UEFI Application.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The UEFI Application exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint(). 
+
+  @param  ImageHandle  The image handle of the UEFI Application.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The UEFI Application exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Invokes the library destructors for all dependent libraries and terminates
+  the UEFI Application. 
+
+  This function calls ProcessLibraryDestructorList() and the EFI Boot Service Exit()
+  with a status specified by Status.
+
+  @param  Status  Status returned by the application that is exiting.
+  
+**/
+VOID
+EFIAPI
+Exit (
+  IN EFI_STATUS  Status
+  );
+
+
+/**
+  Autogenerated function that calls the library constructors for all of the module's
+  dependent libraries.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of library constructors for the set of library instances
+  that a module depends on. This includes library instances that a module depends on
+  directly and library instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible for
+  collecting the set of library instances, determine which ones have constructors, and
+  calling the library constructors in the proper order based upon each of the library
+  instances own dependencies.
+
+  @param  ImageHandle  The image handle of the UEFI Application.
+  @param  SystemTable  A pointer to the EFI System Table.
+  
+**/
+VOID
+EFIAPI
+ProcessLibraryConstructorList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Autogenerated function that calls the library descructors for all of the module's
+  dependent libraries.
+
+  This function may be called by _ModuleEntryPoint()or Exit().
+  This function calls the set of library destructors for the set of library instances
+  that a module depends on.  This includes library instances that a module depends on
+  directly and library instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the set of library instances, determine which ones have destructors,
+  and calling the library destructors in the proper order based upon each of the library
+  instances own dependencies.
+
+  @param  ImageHandle  The image handle of the UEFI Application.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryDestructorList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+/**
+  This function calls the set of module entry points. It must be called by _ModuleEntryPoint().
+
+  This function is autogenerated by build tools and those build tools are 
+  responsible for collecting the module entry points and calling them in a specified order.
+
+  @param  ImageHandle    The image handle of the UEFI Application.
+  @param  SystemTable    A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS   The UEFI Application executed normally.
+  @retval  !EFI_SUCCESS  The UEFI Application failed to execute normally.
+
+**/
+EFI_STATUS
+EFIAPI
+ProcessModuleEntryPointList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiBootServicesTableLib.h b/MdePkg/Include/Library/UefiBootServicesTableLib.h
new file mode 100644
index 000000000000..b382a8d51ed7
--- /dev/null
+++ b/MdePkg/Include/Library/UefiBootServicesTableLib.h
@@ -0,0 +1,34 @@
+/** @file
+  Provides a service to retrieve a pointer to the EFI Boot Services Table.
+  Only available to DXE and UEFI module types.
+
+Copyright (c) 2006 - 2008, 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_BOOT_SERVICES_TABLE_LIB_H__
+#define __UEFI_BOOT_SERVICES_TABLE_LIB_H__
+
+///
+/// Cache the Image Handle
+///
+extern EFI_HANDLE         gImageHandle;
+
+///
+/// Cache pointer to the EFI System Table
+///
+extern EFI_SYSTEM_TABLE   *gST;
+
+///
+/// Cache pointer to the EFI Boot Services Table
+///
+extern EFI_BOOT_SERVICES  *gBS;
+
+#endif
diff --git a/MdePkg/Include/Library/UefiDecompressLib.h b/MdePkg/Include/Library/UefiDecompressLib.h
new file mode 100644
index 000000000000..2a7a91e5c1d9
--- /dev/null
+++ b/MdePkg/Include/Library/UefiDecompressLib.h
@@ -0,0 +1,108 @@
+/** @file
+  Provides services to decompress a buffer using the UEFI Decompress algorithm.
+
+  The UEFI Decompress Library enables the decompression of objects that 
+  were compressed using the UEFI compression scheme. The UEFI Decompress 
+  Library is independent of environment and requires the caller to allocate 
+  all required memory buffers.
+
+Copyright (c) 2006 - 2008, 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_DECPOMPRESS_LIB_H__
+#define __UEFI_DECPOMPRESS_LIB_H__
+
+/**
+  Given a compressed source buffer, this function retrieves the size of 
+  the uncompressed buffer and the size of the scratch buffer required 
+  to decompress the compressed source buffer.
+
+  Retrieves the size of the uncompressed buffer and the temporary scratch buffer 
+  required to decompress the buffer specified by Source and SourceSize.
+  If the size of the uncompressed buffer or the size of the scratch buffer cannot
+  be determined from the compressed data specified by Source and SourceData, 
+  then RETURN_INVALID_PARAMETER is returned.  Otherwise, the size of the uncompressed
+  buffer is returned in DestinationSize, the size of the scratch buffer is returned
+  in ScratchSize, and RETURN_SUCCESS is returned.
+  This function does not have scratch buffer available to perform a thorough 
+  checking of the validity of the source data.  It just retrieves the "Original Size"
+  field from the beginning bytes of the source data and output it as DestinationSize.
+  And ScratchSize is specific to the decompression implementation.
+
+  If Source is NULL, then ASSERT().
+  If DestinationSize is NULL, then ASSERT().
+  If ScratchSize is NULL, then ASSERT().
+
+  @param  Source          The source buffer containing the compressed data.
+  @param  SourceSize      The size, in bytes, of the source buffer.
+  @param  DestinationSize A pointer to the size, in bytes, of the uncompressed buffer
+                          that will be generated when the compressed buffer specified
+                          by Source and SourceSize is decompressed.
+  @param  ScratchSize     A pointer to the size, in bytes, of the scratch buffer that
+                          is required to decompress the compressed buffer specified 
+                          by Source and SourceSize.
+
+  @retval  RETURN_SUCCESS The size of the uncompressed data was returned 
+                          in DestinationSize and the size of the scratch 
+                          buffer was returned in ScratchSize.
+  @retval  RETURN_INVALID_PARAMETER 
+                          The size of the uncompressed data or the size of 
+                          the scratch buffer cannot be determined from 
+                          the compressed data specified by Source 
+                          and SourceSize.
+**/
+RETURN_STATUS
+EFIAPI
+UefiDecompressGetInfo (
+  IN  CONST VOID  *Source,
+  IN  UINT32      SourceSize,
+  OUT UINT32      *DestinationSize,
+  OUT UINT32      *ScratchSize
+  );
+
+/**
+  Decompresses a compressed source buffer.
+
+  Extracts decompressed data to its original form.
+  This function is designed so that the decompression algorithm can be implemented
+  without using any memory services.  As a result, this function is not allowed to
+  call any memory allocation services in its implementation.  It is the caller's 
+  responsibility to allocate and free the Destination and Scratch buffers.
+  If the compressed source data specified by Source is successfully decompressed 
+  into Destination, then RETURN_SUCCESS is returned.  If the compressed source data 
+  specified by Source is not in a valid compressed data format,
+  then RETURN_INVALID_PARAMETER is returned.
+
+  If Source is NULL, then ASSERT().
+  If Destination is NULL, then ASSERT().
+  If the required scratch buffer size > 0 and Scratch is NULL, then ASSERT().
+
+  @param  Source      The source buffer containing the compressed data.
+  @param  Destination The destination buffer to store the decompressed data
+  @param  Scratch     A temporary scratch buffer that is used to perform the decompression.
+                      This is an optional parameter that may be NULL if the 
+                      required scratch buffer size is 0.
+                     
+  @retval  RETURN_SUCCESS Decompression completed successfully, and 
+                          the uncompressed buffer is returned in Destination.
+  @retval  RETURN_INVALID_PARAMETER 
+                          The source buffer specified by Source is corrupted 
+                          (not in a valid compressed format).
+**/
+RETURN_STATUS
+EFIAPI
+UefiDecompress (
+  IN CONST VOID  *Source,
+  IN OUT VOID    *Destination,
+  IN OUT VOID    *Scratch  OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiDriverEntryPoint.h b/MdePkg/Include/Library/UefiDriverEntryPoint.h
new file mode 100644
index 000000000000..f0812bc2722a
--- /dev/null
+++ b/MdePkg/Include/Library/UefiDriverEntryPoint.h
@@ -0,0 +1,195 @@
+/** @file
+  Module entry point library for UEFI drivers, DXE Drivers, DXE Runtime Drivers,
+  and DXE SMM Drivers.
+
+Copyright (c) 2006 - 2008, 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 __MODULE_ENTRY_POINT_H__
+#define __MODULE_ENTRY_POINT_H__
+
+///
+///Declare the PI Specification Revision that this driver requires to execute correctly.
+///
+extern CONST UINT32                   _gDxeRevision;
+
+///
+/// Declare the EFI/UEFI Specification Revision to which this driver is implemented 
+///
+extern CONST UINT32                   _gUefiDriverRevision;
+
+///
+/// Declare the number of unload handler in the image. 
+///
+extern CONST UINT8                    _gDriverUnloadImageCount;
+
+
+/**
+  The entry point of PE/COFF Image for a DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver. 
+
+  This function is the entry point for a DXE Driver, DXE Runtime Driver, DXE SMM Driver,
+  or UEFI Driver.  This function must call ProcessLibraryConstructorList() and
+  ProcessModuleEntryPointList(). If the return status from ProcessModuleEntryPointList()
+  is an error status, then ProcessLibraryDestructorList() must be called. The return value
+  from ProcessModuleEntryPointList() is returned. If _gDriverUnloadImageCount is greater
+  than zero, then an unload handler must be registered for this image and the unload handler
+  must invoke ProcessModuleUnloadList().
+  If _gUefiDriverRevision is not zero and SystemTable->Hdr.Revision is less than _gUefiDriverRevison,
+  then return EFI_INCOMPATIBLE_VERSION.
+
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The DXE Driver, DXE Runtime Driver, DXE SMM Driver,
+                                     or UEFI Driver exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint(). 
+
+  This function is required to call _ModuleEntryPoint() passing in ImageHandle, and SystemTable.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The DXE Driver, DXE Runtime Driver, DXE SMM Driver,
+                                     or UEFI Driver exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Invokes the library destructors for all dependent libraries and terminates the
+  DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver. 
+
+  This function calls ProcessLibraryDestructorList() and the EFI Boot Service Exit()
+  with a status specified by Status.
+
+  @param  Status Status returned by the driver that is exiting.
+
+**/
+VOID
+EFIAPI
+ExitDriver (
+  IN EFI_STATUS  Status
+  );
+
+
+/**
+  Autogenerated function that calls the library constructors for all of the module's
+  dependent libraries.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of library constructors for the set of library instances
+  that a module depends on.  This includes library instances that a module depends on
+  directly and library instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the set of library instances, determine which ones have constructors,
+  and calling the library constructors in the proper order based upon each of the library
+  instances own dependencies.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryConstructorList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Autogenerated function that calls the library descructors for all of the module's
+  dependent libraries.
+
+  This function may be called by _ModuleEntryPoint() or ExitDriver().
+  This function calls the set of library destructors for the set of library instances
+  that a module depends on. This includes library instances that a module depends on
+  directly and library instances that a module depends on indirectly through other libraries.  
+  This function is autogenerated by build tools and those build tools are responsible for
+  collecting the set of library instances, determine which ones have destructors, and calling
+  the library destructors in the proper order based upon each of the library instances own dependencies.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+**/
+VOID
+EFIAPI
+ProcessLibraryDestructorList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Autogenerated function that calls a set of module entry points.
+
+  This function must be called by _ModuleEntryPoint().
+  This function calls the set of module entry points.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the module entry points and calling them in a specified order.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS   The DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver executed normally.
+  @retval  !EFI_SUCCESS  The DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver failed to execute normally.
+**/
+EFI_STATUS
+EFIAPI
+ProcessModuleEntryPointList (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+
+/**
+  Autogenerated function that calls a set of module unload handlers.
+
+  This function must be called from the unload handler registered by _ModuleEntryPoint().
+  This function calls the set of module unload handlers.  
+  This function is autogenerated by build tools and those build tools are responsible
+  for collecting the module unload handlers and calling them in a specified order.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE SMM Driver, or UEFI Driver.
+
+  @retval  EFI_SUCCESS  The unload handlers executed normally.
+  @retval  !EFI_SUCCESS The unload handlers failed to execute normally.
+
+**/
+EFI_STATUS
+EFIAPI
+ProcessModuleUnloadList (
+  IN EFI_HANDLE  ImageHandle
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiLib.h b/MdePkg/Include/Library/UefiLib.h
new file mode 100644
index 000000000000..d91bcf83954f
--- /dev/null
+++ b/MdePkg/Include/Library/UefiLib.h
@@ -0,0 +1,1493 @@
+/** @file
+  Provides library functions for common UEFI operations. Only available to DXE
+  and UEFI module types.
+
+  The UEFI Library provides functions and macros that simplify the development of 
+  UEFI Drivers and UEFI Applications.  These functions and macros help manage EFI 
+  events, build simple locks utilizing EFI Task Priority Levels (TPLs), install 
+  EFI Driver Model related protocols, manage Unicode string tables for UEFI Drivers, 
+  and print messages on the console output and standard error devices.
+
+  Note that a reserved macro named MDEPKG_NDEBUG is introduced for the intention
+  of size reduction when compiler optimization is disabled. If MDEPKG_NDEBUG is
+  defined, then debug and assert related macros wrapped by it are the NULL implementations.
+
+Copyright (c) 2006 - 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 __UEFI_LIB_H__
+#define __UEFI_LIB_H__
+
+#include <Protocol/DriverBinding.h>
+#include <Protocol/DriverConfiguration.h>
+#include <Protocol/ComponentName.h>
+#include <Protocol/ComponentName2.h>
+#include <Protocol/DriverDiagnostics.h>
+#include <Protocol/DriverDiagnostics2.h>
+#include <Protocol/GraphicsOutput.h>
+
+#include <Library/BaseLib.h>
+
+///
+/// Unicode String Table
+///
+typedef struct {
+  CHAR8   *Language;
+  CHAR16  *UnicodeString;
+} EFI_UNICODE_STRING_TABLE;
+
+///
+/// EFI Lock Status
+///
+typedef enum {
+  EfiLockUninitialized = 0,
+  EfiLockReleased      = 1,
+  EfiLockAcquired      = 2
+} EFI_LOCK_STATE;
+
+///
+/// EFI Lock 
+///
+typedef struct {
+  EFI_TPL         Tpl;
+  EFI_TPL         OwnerTpl;
+  EFI_LOCK_STATE  Lock;
+} EFI_LOCK;
+
+/**
+  Macro that returns the number of 100 ns units for a specified number of microseconds.
+  This is useful for managing EFI timer events.
+
+  @param  Microseconds           The number of microseconds.
+
+  @return The number of 100 ns units equivalent to the number of microseconds specified
+          by Microseconds.
+
+**/
+#define EFI_TIMER_PERIOD_MICROSECONDS(Microseconds) MultU64x32((UINT64)(Microseconds), 10)
+
+/**
+  Macro that returns the number of 100 ns units for a specified number of milliseconds.
+  This is useful for managing EFI timer events.
+
+  @param  Milliseconds           The number of milliseconds.
+
+  @return The number of 100 ns units equivalent to the number of milliseconds specified
+          by Milliseconds.
+
+**/
+#define EFI_TIMER_PERIOD_MILLISECONDS(Milliseconds) MultU64x32((UINT64)(Milliseconds), 10000)
+
+/**
+  Macro that returns the number of 100 ns units for a specified number of seconds.
+  This is useful for managing EFI timer events.
+
+  @param  Seconds                The number of seconds.
+
+  @return The number of 100 ns units equivalent to the number of seconds specified
+          by Seconds.
+
+**/
+#define EFI_TIMER_PERIOD_SECONDS(Seconds)           MultU64x32((UINT64)(Seconds), 10000000)
+
+/**
+  Macro that returns the a pointer to the next EFI_MEMORY_DESCRIPTOR in an array 
+  returned from GetMemoryMap().  
+
+  @param  MemoryDescriptor  A pointer to an EFI_MEMORY_DESCRIPTOR.
+
+  @param  Size              The size, in bytes, of the current EFI_MEMORY_DESCRIPTOR.
+
+  @return A pointer to the next EFI_MEMORY_DESCRIPTOR.
+
+**/
+#define NEXT_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \
+  ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) + (Size)))
+
+/**
+  Retrieves a pointer to the system configuration table from the EFI System Table
+  based on a specified GUID.
+  
+  This function searches the list of configuration tables stored in the EFI System Table
+  for a table with a GUID that matches TableGuid. If a match is found, then a pointer to
+  the configuration table is returned in Table, and EFI_SUCCESS is returned. If a matching GUID
+  is not found, then EFI_NOT_FOUND is returned.
+  If TableGuid is NULL, then ASSERT().
+  If Table is NULL, then ASSERT().
+
+  @param  TableGuid       The pointer to table's GUID type..
+  @param  Table           The pointer to the table associated with TableGuid in the EFI System Table.
+
+  @retval EFI_SUCCESS     A configuration table matching TableGuid was found.
+  @retval EFI_NOT_FOUND   A configuration table matching TableGuid could not be found.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetSystemConfigurationTable (  
+  IN  EFI_GUID  *TableGuid,
+  OUT VOID      **Table
+  );
+
+/**
+  Creates and returns a notification event and registers that event with all the protocol
+  instances specified by ProtocolGuid.
+
+  This function causes the notification function to be executed for every protocol of type
+  ProtocolGuid instance that exists in the system when this function is invoked. If there are
+  no instances of ProtocolGuid in the handle database at the time this function is invoked,
+  then the notification function is still executed one time. In addition, every time a protocol
+  of type ProtocolGuid instance is installed or reinstalled, the notification function is also
+  executed. This function returns the notification event that was created. 
+  If ProtocolGuid is NULL, then ASSERT().
+  If NotifyTpl is not a legal TPL value, then ASSERT().
+  If NotifyFunction is NULL, then ASSERT().
+  If Registration is NULL, then ASSERT().
+
+
+  @param  ProtocolGuid    Supplies GUID of the protocol upon whose installation the event is fired.
+  @param  NotifyTpl       Supplies the task priority level of the event notifications.
+  @param  NotifyFunction  Supplies the function to notify when the event is signaled.
+  @param  NotifyContext   The context parameter to pass to NotifyFunction.
+  @param  Registration    A pointer to a memory location to receive the registration value.
+                          This value is passed to LocateHandle() to obtain new handles that
+                          have been added that support the ProtocolGuid-specified protocol. 
+
+  @return The notification event that was created.
+
+**/
+EFI_EVENT
+EFIAPI
+EfiCreateProtocolNotifyEvent(
+  IN  EFI_GUID          *ProtocolGuid,
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT VOID              **Registration
+  );
+
+/**
+  Creates a named event that can be signaled with EfiNamedEventSignal().
+
+  This function creates an event using NotifyTpl, NoifyFunction, and NotifyContext.
+  This event is signaled with EfiNamedEventSignal(). This provides the ability for one or more
+  listeners on the same event named by the GUID specified by Name. 
+  If Name is NULL, then ASSERT().
+  If NotifyTpl is not a legal TPL value, then ASSERT().
+  If NotifyFunction is NULL, then ASSERT().
+
+  @param  Name                  Supplies GUID name of the event.
+  @param  NotifyTpl             Supplies the task priority level of the event notifications.
+  @param  NotifyFunction        Supplies the function to notify when the event is signaled.
+  @param  NotifyContext         The context parameter to pass to NotifyFunction. 
+  @param  Registration          A pointer to a memory location to receive the registration value.
+
+  @retval EFI_SUCCESS           A named event was created.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to create the named event.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiNamedEventListen (
+  IN CONST EFI_GUID    *Name,
+  IN EFI_TPL           NotifyTpl,
+  IN EFI_EVENT_NOTIFY  NotifyFunction,
+  IN CONST VOID        *NotifyContext,  OPTIONAL
+  OUT VOID             *Registration OPTIONAL
+  );
+
+/**
+  Signals a named event created with EfiNamedEventListen().
+
+  This function signals the named event specified by Name. The named event must have been
+  created with EfiNamedEventListen().
+  If Name is NULL, then ASSERT().
+
+  @param  Name                  Supplies the GUID name of the event.
+
+  @retval EFI_SUCCESS           A named event was signaled.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to signal the named event.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiNamedEventSignal (
+  IN CONST EFI_GUID  *Name
+  );
+
+/**
+  Signals an event group by placing a new event in the group temporarily and
+  signaling it.
+
+  @param[in] EventGroup          Supplies the unique identifier of the event
+                                 group to signal.
+
+  @retval EFI_SUCCESS            The event group was signaled successfully.
+  @retval EFI_INVALID_PARAMETER  EventGroup is NULL.
+  @return                        Error codes that report problems about event
+                                 creation or signaling.
+**/
+EFI_STATUS
+EFIAPI
+EfiEventGroupSignal (
+  IN CONST EFI_GUID *EventGroup
+  );
+
+/**
+  An empty function that can be used as NotifyFunction parameter of
+  CreateEvent() or CreateEventEx().
+
+  @param Event              Event whose notification function is being invoked.
+  @param Context            The pointer to the notification function's context,
+                            which is implementation-dependent.
+
+**/
+VOID
+EFIAPI
+EfiEventEmptyFunction (
+  IN EFI_EVENT              Event,
+  IN VOID                   *Context
+  );
+
+/** 
+  Returns the current TPL.
+
+  This function returns the current TPL.  There is no EFI service to directly 
+  retrieve the current TPL. Instead, the RaiseTPL() function is used to raise 
+  the TPL to TPL_HIGH_LEVEL.  This will return the current TPL.  The TPL level 
+  can then immediately be restored back to the current TPL level with a call 
+  to RestoreTPL().
+
+  @return The current TPL.
+
+**/
+EFI_TPL
+EFIAPI
+EfiGetCurrentTpl (
+  VOID
+  );
+
+/**
+  Initializes a basic mutual exclusion lock.
+
+  This function initializes a basic mutual exclusion lock to the released state 
+  and returns the lock.  Each lock provides mutual exclusion access at its task 
+  priority level.  Since there is no preemption or multiprocessor support in EFI,
+  acquiring the lock only consists of raising to the locks TPL.
+  If Lock is NULL, then ASSERT().
+  If Priority is not a valid TPL value, then ASSERT().
+
+  @param  Lock       A pointer to the lock data structure to initialize.
+  @param  Priority   The EFI TPL associated with the lock.
+
+  @return The lock.
+
+**/
+EFI_LOCK *
+EFIAPI
+EfiInitializeLock (
+  IN OUT EFI_LOCK  *Lock,
+  IN EFI_TPL        Priority
+  );
+
+/**
+  Initializes a basic mutual exclusion lock.
+
+  This macro initializes the contents of a basic mutual exclusion lock to the 
+  released state.  Each lock provides mutual exclusion access at its task 
+  priority level.  Since there is no preemption or multiprocessor support in EFI,
+  acquiring the lock only consists of raising to the locks TPL.
+
+  @param  Priority  The task priority level of the lock.
+
+  @return The lock.
+
+**/
+#define EFI_INITIALIZE_LOCK_VARIABLE(Priority) \
+  {Priority, TPL_APPLICATION, EfiLockReleased }
+
+
+/**
+  Macro that calls DebugAssert() if an EFI_LOCK structure is not in the locked state.
+
+  If MDEPKG_NDEBUG is not defined and the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED 
+  bit of PcdDebugProperyMask is set, then this macro evaluates the EFI_LOCK 
+  structure specified by Lock.  If Lock is not in the locked state, then
+  DebugAssert() is called passing in the source filename, source line number, 
+  and Lock.
+
+  If Lock is NULL, then ASSERT().
+
+  @param  LockParameter  A pointer to the lock to acquire.
+
+**/
+#if !defined(MDEPKG_NDEBUG)       
+  #define ASSERT_LOCKED(LockParameter)                  \
+    do {                                                \
+      if (DebugAssertEnabled ()) {                      \
+        ASSERT (LockParameter != NULL);                 \
+        if ((LockParameter)->Lock != EfiLockAcquired) { \
+          _ASSERT (LockParameter not locked);           \
+        }                                               \
+      }                                                 \
+    } while (FALSE)
+#else
+  #define ASSERT_LOCKED(LockParameter)
+#endif
+
+
+/**
+  Acquires ownership of a lock.
+
+  This function raises the system's current task priority level to the task 
+  priority level of the mutual exclusion lock.  Then, it places the lock in the 
+  acquired state.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+  If Lock is already in the acquired state, then ASSERT().
+
+  @param  Lock              A pointer to the lock to acquire.
+
+**/
+VOID
+EFIAPI
+EfiAcquireLock (
+  IN EFI_LOCK  *Lock
+  );
+
+/**
+  Acquires ownership of a lock.
+
+  This function raises the system's current task priority level to the task priority
+  level of the mutual exclusion lock.  Then, it attempts to place the lock in the acquired state.
+  If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned.
+  Otherwise, EFI_SUCCESS is returned.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+
+  @param  Lock              A pointer to the lock to acquire.
+
+  @retval EFI_SUCCESS       The lock was acquired.
+  @retval EFI_ACCESS_DENIED The lock could not be acquired because it is already owned.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiAcquireLockOrFail (
+  IN EFI_LOCK  *Lock
+  );
+
+/**
+  Releases ownership of a lock.
+
+  This function transitions a mutual exclusion lock from the acquired state to 
+  the released state, and restores the system's task priority level to its 
+  previous level.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+  If Lock is already in the released state, then ASSERT().
+
+  @param  Lock  A pointer to the lock to release.
+
+**/
+VOID
+EFIAPI
+EfiReleaseLock (
+  IN EFI_LOCK  *Lock
+  );
+
+/**
+  Tests whether a controller handle is being managed by a specific driver.
+
+  This function tests whether the driver specified by DriverBindingHandle is
+  currently managing the controller specified by ControllerHandle.  This test
+  is performed by evaluating if the the protocol specified by ProtocolGuid is
+  present on ControllerHandle and is was opened by DriverBindingHandle with an
+  attribute of EFI_OPEN_PROTOCOL_BY_DRIVER. 
+  If ProtocolGuid is NULL, then ASSERT().
+
+  @param  ControllerHandle     A handle for a controller to test.
+  @param  DriverBindingHandle  Specifies the driver binding handle for the
+                               driver.
+  @param  ProtocolGuid         Specifies the protocol that the driver specified
+                               by DriverBindingHandle opens in its Start()
+                               function.
+
+  @retval EFI_SUCCESS          ControllerHandle is managed by the driver
+                               specified by DriverBindingHandle.
+  @retval EFI_UNSUPPORTED      ControllerHandle is not managed by the driver
+                               specified by DriverBindingHandle.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiTestManagedDevice (
+  IN CONST EFI_HANDLE       ControllerHandle,
+  IN CONST EFI_HANDLE       DriverBindingHandle,
+  IN CONST EFI_GUID         *ProtocolGuid
+  );
+
+/**
+  Tests whether a child handle is a child device of the controller.
+
+  This function tests whether ChildHandle is one of the children of
+  ControllerHandle.  This test is performed by checking to see if the protocol
+  specified by ProtocolGuid is present on ControllerHandle and opened by
+  ChildHandle with an attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
+  If ProtocolGuid is NULL, then ASSERT().
+
+  @param  ControllerHandle     A handle for a (parent) controller to test. 
+  @param  ChildHandle          A child handle to test.
+  @param  ProtocolGuid         Supplies the protocol that the child controller
+                               opens on its parent controller. 
+
+  @retval EFI_SUCCESS          ChildHandle is a child of the ControllerHandle.
+  @retval EFI_UNSUPPORTED      ChildHandle is not a child of the
+                               ControllerHandle.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiTestChildHandle (
+  IN CONST EFI_HANDLE       ControllerHandle,
+  IN CONST EFI_HANDLE       ChildHandle,
+  IN CONST EFI_GUID         *ProtocolGuid
+  );
+
+/**
+  This function looks up a Unicode string in UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages and a Unicode string is found in
+  UnicodeStringTable that matches the language code specified by Language, then it
+  is returned in UnicodeString.
+
+  @param  Language                A pointer to the ISO 639-2 language code for the 
+                                  Unicode string to look up and return.
+  @param  SupportedLanguages      A pointer to the set of ISO 639-2 language codes 
+                                  that the Unicode string table supports.  Language 
+                                  must be a member of this set.
+  @param  UnicodeStringTable      A pointer to the table of Unicode strings.
+  @param  UnicodeString           A pointer to the Unicode string from UnicodeStringTable
+                                  that matches the language specified by Language.
+
+  @retval EFI_SUCCESS             The Unicode string that matches the language 
+                                  specified by Language was found
+                                  in the table of Unicode strings UnicodeStringTable, 
+                                  and it was returned in UnicodeString.
+  @retval EFI_INVALID_PARAMETER   Language is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is NULL.
+  @retval EFI_UNSUPPORTED         SupportedLanguages is NULL.
+  @retval EFI_UNSUPPORTED         UnicodeStringTable is NULL.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not a 
+                                  member of SupportedLanguages.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not 
+                                  supported by UnicodeStringTable.
+
+**/
+EFI_STATUS
+EFIAPI
+LookupUnicodeString (
+  IN CONST CHAR8                     *Language,
+  IN CONST CHAR8                     *SupportedLanguages,
+  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
+  OUT CHAR16                         **UnicodeString
+  );
+
+/**
+  This function looks up a Unicode string in UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages and a Unicode string is found in
+  UnicodeStringTable that matches the language code specified by Language, then
+  it is returned in UnicodeString.
+
+  @param  Language             A pointer to an ASCII string containing the ISO 639-2 or the
+                               RFC 4646 language code for the Unicode string to look up and
+                               return. If Iso639Language is TRUE, then this ASCII string is
+                               not assumed to be Null-terminated, and only the first three
+                               characters are used. If Iso639Language is FALSE, then this ASCII
+                               string must be Null-terminated. 
+  @param  SupportedLanguages   A pointer to a Null-terminated ASCII string that contains a
+                               set of ISO 639-2 or RFC 4646 language codes that the Unicode
+                               string table supports.  Language must be a member of this set.
+                               If Iso639Language is TRUE, then this string contains one or more
+                               ISO 639-2 language codes with no separator characters. If Iso639Language
+                               is FALSE, then is string contains one or more RFC 4646 language
+                               codes separated by ';'.
+  @param  UnicodeStringTable   A pointer to the table of Unicode strings. Type EFI_UNICODE_STRING_TABLE
+                               is defined in "Related Definitions".
+  @param  UnicodeString        A pointer to the Null-terminated Unicode string from UnicodeStringTable
+                               that matches the language specified by Language.
+  @param  Iso639Language       Specifies the supported language code format. If it is TRUE, then
+                               Language and SupportedLanguages follow ISO 639-2 language code format.
+                               Otherwise, they follow the RFC 4646 language code format.
+
+
+  @retval  EFI_SUCCESS            The Unicode string that matches the language specified by Language
+                                  was found in the table of Unicode strings UnicodeStringTable, and
+                                  it was returned in UnicodeString.
+  @retval  EFI_INVALID_PARAMETER  Language is NULL.  
+  @retval  EFI_INVALID_PARAMETER  UnicodeString is NULL.  
+  @retval  EFI_UNSUPPORTED        SupportedLanguages is NULL.  
+  @retval  EFI_UNSUPPORTED        UnicodeStringTable is NULL.  
+  @retval  EFI_UNSUPPORTED        The language specified by Language is not a member of SupportedLanguages.  
+  @retval  EFI_UNSUPPORTED        The language specified by Language is not supported by UnicodeStringTable.
+
+**/
+EFI_STATUS
+EFIAPI
+LookupUnicodeString2 (
+  IN CONST CHAR8                     *Language,
+  IN CONST CHAR8                     *SupportedLanguages,
+  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
+  OUT CHAR16                         **UnicodeString,
+  IN BOOLEAN                         Iso639Language
+  );
+
+/**
+  This function adds a Unicode string to UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages then UnicodeString is added to 
+  UnicodeStringTable.  New buffers are allocated for both Language and 
+  UnicodeString.  The contents of Language and UnicodeString are copied into 
+  these new buffers.  These buffers are automatically freed when 
+  FreeUnicodeStringTable() is called.
+
+  @param  Language                A pointer to the ISO 639-2 language code for the Unicode 
+                                  string to add.
+  @param  SupportedLanguages      A pointer to the set of ISO 639-2 language codes
+                                  that the Unicode string table supports.
+                                  Language must be a member of this set.
+  @param  UnicodeStringTable      A pointer to the table of Unicode strings.
+  @param  UnicodeString           A pointer to the Unicode string to add.
+
+  @retval EFI_SUCCESS             The Unicode string that matches the language 
+                                  specified by Language was found in the table of 
+                                  Unicode strings UnicodeStringTable, and it was 
+                                  returned in UnicodeString.
+  @retval EFI_INVALID_PARAMETER   Language is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is an empty string.
+  @retval EFI_UNSUPPORTED         SupportedLanguages is NULL.
+  @retval EFI_ALREADY_STARTED     A Unicode string with language Language is 
+                                  already present in UnicodeStringTable.
+  @retval EFI_OUT_OF_RESOURCES    There is not enough memory to add another 
+                                  Unicode string to UnicodeStringTable.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not a 
+                                  member of SupportedLanguages.
+
+**/
+EFI_STATUS
+EFIAPI
+AddUnicodeString (
+  IN CONST CHAR8               *Language,
+  IN CONST CHAR8               *SupportedLanguages,
+  IN EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
+  IN CONST CHAR16              *UnicodeString
+  );
+
+/**
+  This function adds the Null-terminated Unicode string specified by UnicodeString
+  to UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages then UnicodeString is added to
+  UnicodeStringTable.  New buffers are allocated for both Language and UnicodeString.
+  The contents of Language and UnicodeString are copied into these new buffers.
+  These buffers are automatically freed when EfiLibFreeUnicodeStringTable() is called.
+
+  @param  Language            A pointer to an ASCII string containing the ISO 639-2 or
+                              the RFC 4646 language code for the Unicode string to add.
+                              If Iso639Language is TRUE, then this ASCII string is not
+                              assumed to be Null-terminated, and only the first three
+                              chacters are used. If Iso639Language is FALSE, then this
+                              ASCII string must be Null-terminated.
+  @param  SupportedLanguages  A pointer to a Null-terminated ASCII string that contains
+                              a set of ISO 639-2 or RFC 4646 language codes that the Unicode
+                              string table supports.  Language must be a member of this set.
+                              If Iso639Language is TRUE, then this string contains one or more
+                              ISO 639-2 language codes with no separator characters.
+                              If Iso639Language is FALSE, then is string contains one or more
+                              RFC 4646 language codes separated by ';'.
+  @param  UnicodeStringTable  A pointer to the table of Unicode strings. Type EFI_UNICODE_STRING_TABLE
+                              is defined in "Related Definitions".
+  @param  UnicodeString       A pointer to the Unicode string to add.  
+  @param  Iso639Language      Specifies the supported language code format. If it is TRUE,
+                              then Language and SupportedLanguages follow ISO 639-2 language code format.
+                              Otherwise, they follow RFC 4646 language code format.
+
+  @retval EFI_SUCCESS            The Unicode string that matches the language specified by
+                                 Language was found in the table of Unicode strings UnicodeStringTable,
+                                 and it was returned in UnicodeString.  
+  @retval EFI_INVALID_PARAMETER  Language is NULL.  
+  @retval EFI_INVALID_PARAMETER  UnicodeString is NULL.  
+  @retval EFI_INVALID_PARAMETER  UnicodeString is an empty string.  
+  @retval EFI_UNSUPPORTED        SupportedLanguages is NULL.  
+  @retval EFI_ALREADY_STARTED    A Unicode string with language Language is already present in
+                                 UnicodeStringTable.  
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory to add another Unicode string UnicodeStringTable.  
+  @retval EFI_UNSUPPORTED        The language specified by Language is not a member of SupportedLanguages.
+
+**/
+EFI_STATUS
+EFIAPI
+AddUnicodeString2 (
+  IN CONST CHAR8               *Language,
+  IN CONST CHAR8               *SupportedLanguages,
+  IN EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
+  IN CONST CHAR16              *UnicodeString,
+  IN BOOLEAN                   Iso639Language
+  );
+
+/**
+  This function frees the table of Unicode strings in UnicodeStringTable.
+
+  If UnicodeStringTable is NULL, then EFI_SUCCESS is returned.
+  Otherwise, each language code, and each Unicode string in the Unicode string 
+  table are freed, and EFI_SUCCESS is returned.
+
+  @param  UnicodeStringTable  A pointer to the table of Unicode strings.
+
+  @retval EFI_SUCCESS         The Unicode string table was freed.
+
+**/
+EFI_STATUS
+EFIAPI
+FreeUnicodeStringTable (
+  IN EFI_UNICODE_STRING_TABLE  *UnicodeStringTable
+  );
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  The 
+  returned buffer is allocated using AllocatePool().  The caller is responsible
+  for freeing this buffer with FreePool().
+
+  If Name is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[in]  Guid  The pointer to an EFI_GUID structure.
+
+  @retval NULL   The variable could not be retrieved.
+  @retval NULL   There are not enough resources available for the variable contents.
+  @retval Other  A pointer to allocated buffer containing the variable contents.
+
+**/
+VOID *
+EFIAPI
+GetVariable (
+  IN CONST CHAR16    *Name,
+  IN CONST EFI_GUID  *Guid
+  );
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  This 
+  function always uses the EFI_GLOBAL_VARIABLE GUID to retrieve variables.
+  The returned buffer is allocated using AllocatePool().  The caller is 
+  responsible for freeing this buffer with FreePool().
+
+  If Name is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+
+  @retval NULL   The variable could not be retrieved.
+  @retval NULL   There are not enough resources available for the variable contents.
+  @retval Other  A pointer to allocated buffer containing the variable contents.
+
+**/
+VOID *
+EFIAPI
+GetEfiGlobalVariable (
+  IN CONST CHAR16  *Name
+  );
+#endif
+
+
+/**
+  Returns the status whether get the variable success. The function retrieves 
+  variable  through the UEFI Runtime Service GetVariable().  The 
+  returned buffer is allocated using AllocatePool().  The caller is responsible
+  for freeing this buffer with FreePool().
+
+  If Name  is NULL, then ASSERT().
+  If Guid  is NULL, then ASSERT().
+  If Value is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[in]  Guid  The pointer to an EFI_GUID structure
+  @param[out] Value The buffer point saved the variable info.
+  @param[out] Size  The buffer size of the variable.
+
+  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.
+  @return EFI_SUCCESS               Find the specified variable.
+  @return Others Errors             Return errors from call to gRT->GetVariable.
+
+**/
+EFI_STATUS
+EFIAPI
+GetVariable2 (
+  IN CONST CHAR16    *Name,
+  IN CONST EFI_GUID  *Guid,
+  OUT VOID           **Value,
+  OUT UINTN          *Size OPTIONAL
+  );
+
+/**
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  This 
+  function always uses the EFI_GLOBAL_VARIABLE GUID to retrieve variables.
+  The returned buffer is allocated using AllocatePool().  The caller is 
+  responsible for freeing this buffer with FreePool().
+
+  If Name  is NULL, then ASSERT().
+  If Value is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[out] Value The buffer point saved the variable info.
+  @param[out] Size  The buffer size of the variable.
+
+  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.
+  @return EFI_SUCCESS               Find the specified variable.
+  @return Others Errors             Return errors from call to gRT->GetVariable.
+
+**/
+EFI_STATUS
+EFIAPI
+GetEfiGlobalVariable2 (
+  IN CONST CHAR16    *Name,
+  OUT VOID           **Value,
+  OUT UINTN          *Size OPTIONAL
+  );
+
+/**
+  Returns a pointer to an allocated buffer that contains the best matching language 
+  from a set of supported languages.  
+  
+  This function supports both ISO 639-2 and RFC 4646 language codes, but language 
+  code types may not be mixed in a single call to this function.  The language 
+  code returned is allocated using AllocatePool().  The caller is responsible for 
+  freeing the allocated buffer using FreePool().  This function supports a variable
+  argument list that allows the caller to pass in a prioritized list of language 
+  codes to test against all the language codes in SupportedLanguages. 
+
+  If SupportedLanguages is NULL, then ASSERT().
+
+  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that
+                                  contains a set of language codes in the format 
+                                  specified by Iso639Language.
+  @param[in]  Iso639Language      If TRUE, then all language codes are assumed to be
+                                  in ISO 639-2 format.  If FALSE, then all language
+                                  codes are assumed to be in RFC 4646 language format
+  @param[in]  ...                 A variable argument list that contains pointers to 
+                                  Null-terminated ASCII strings that contain one or more
+                                  language codes in the format specified by Iso639Language.
+                                  The first language code from each of these language
+                                  code lists is used to determine if it is an exact or
+                                  close match to any of the language codes in 
+                                  SupportedLanguages.  Close matches only apply to RFC 4646
+                                  language codes, and the matching algorithm from RFC 4647
+                                  is used to determine if a close match is present.  If 
+                                  an exact or close match is found, then the matching
+                                  language code from SupportedLanguages is returned.  If
+                                  no matches are found, then the next variable argument
+                                  parameter is evaluated.  The variable argument list 
+                                  is terminated by a NULL.
+
+  @retval NULL   The best matching language could not be found in SupportedLanguages.
+  @retval NULL   There are not enough resources available to return the best matching 
+                 language.
+  @retval Other  A pointer to a Null-terminated ASCII string that is the best matching 
+                 language in SupportedLanguages.
+
+**/
+CHAR8 *
+EFIAPI
+GetBestLanguage (
+  IN CONST CHAR8  *SupportedLanguages, 
+  IN BOOLEAN      Iso639Language,
+  ...
+  );
+
+/**
+  Draws a dialog box to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE and waits for a keystroke
+  from the console input device specified by ConIn defined in the 
+  EFI_SYSTEM_TABLE.
+
+  If there are no strings in the variable argument list, then ASSERT().
+  If all the strings in the variable argument list are empty, then ASSERT().
+
+  @param[in]   Attribute  Specifies the foreground and background color of the popup.
+  @param[out]  Key        A pointer to the EFI_KEY value of the key that was 
+                          pressed.  This is an optional parameter that may be NULL.
+                          If it is NULL then no wait for a keypress will be performed.
+  @param[in]  ...         The variable argument list that contains pointers to Null-
+                          terminated Unicode strings to display in the dialog box.  
+                          The variable argument list is terminated by a NULL.
+
+**/
+VOID
+EFIAPI
+CreatePopUp (
+  IN  UINTN          Attribute,                
+  OUT EFI_INPUT_KEY  *Key,      OPTIONAL
+  ...
+  );
+
+/**
+  Retrieves the width of a Unicode character.
+
+  This function computes and returns the width of the Unicode character specified
+  by UnicodeChar.
+
+  @param  UnicodeChar   A Unicode character.
+
+  @retval 0             The width if UnicodeChar could not be determined.
+  @retval 1             UnicodeChar is a narrow glyph.
+  @retval 2             UnicodeChar is a wide glyph.
+
+**/
+UINTN
+EFIAPI
+GetGlyphWidth (
+  IN CHAR16  UnicodeChar
+  );
+
+/**
+  Computes the display length of a Null-terminated Unicode String.
+
+  This function computes and returns the display length of the Null-terminated Unicode
+  string specified by String.  If String is NULL then 0 is returned. If any of the widths
+  of the Unicode characters in String can not be determined, then 0 is returned. The display
+  width of String can be computed by summing the display widths of each Unicode character
+  in String.  Unicode characters that are narrow glyphs have a width of 1, and Unicode
+  characters that are width glyphs have a width of 2. 
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String      A pointer to a Null-terminated Unicode string.
+
+  @return The display length of the Null-terminated Unicode string specified by String.
+  
+**/
+UINTN
+EFIAPI
+UnicodeStringDisplayLength (
+  IN CONST CHAR16  *String
+  );
+
+//
+// Functions that abstract early Framework contamination of UEFI.
+//
+/**
+  Create, Signal, and Close the Ready to Boot event using EfiSignalEventReadyToBoot().
+  
+  This function abstracts the signaling of the Ready to Boot Event. The Framework moved
+  from a proprietary to UEFI 2.0 based mechanism. This library abstracts the caller
+  from how this event is created to prevent to code form having to change with the
+  version of the specification supported.
+
+**/
+VOID
+EFIAPI
+EfiSignalEventReadyToBoot (
+  VOID
+  );
+
+/**
+  Create, Signal, and Close the Ready to Boot event using EfiSignalEventLegacyBoot().
+
+  This function abstracts the signaling of the Legacy Boot Event. The Framework moved from
+  a proprietary to UEFI 2.0 based mechanism.  This library abstracts the caller from how
+  this event is created to prevent to code form having to change with the version of the
+  specification supported.
+
+**/
+VOID
+EFIAPI
+EfiSignalEventLegacyBoot (
+  VOID
+  );
+
+/**
+  Creates an EFI event in the Legacy Boot Event Group.
+
+  Prior to UEFI 2.0 this was done via a non blessed UEFI extensions and this library
+  abstracts the implementation mechanism of this event from the caller. This function
+  abstracts the creation of the Legacy Boot Event. The Framework moved from a proprietary
+  to UEFI 2.0 based mechanism.  This library abstracts the caller from how this event
+  is created to prevent to code form having to change with the version of the
+  specification supported.
+  If LegacyBootEvent is NULL, then ASSERT().
+
+  @param  LegacyBootEvent   Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       The event was created.
+  @retval Other             The event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventLegacyBoot (
+  OUT EFI_EVENT  *LegacyBootEvent
+  );
+
+/**
+  Create an EFI event in the Legacy Boot Event Group and allows
+  the caller to specify a notification function.  
+  
+  This function abstracts the creation of the Legacy Boot Event.
+  The Framework moved from a proprietary to UEFI 2.0 based mechanism.
+  This library abstracts the caller from how this event is created to prevent
+  to code form having to change with the version of the specification supported.
+  If LegacyBootEvent is NULL, then ASSERT().
+
+  @param  NotifyTpl         The task priority level of the event.
+  @param  NotifyFunction    The notification function to call when the event is signaled.
+  @param  NotifyContext     The content to pass to NotifyFunction when the event is signaled.
+  @param  LegacyBootEvent   Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       The event was created.
+  @retval Other             The event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventLegacyBootEx (
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,  OPTIONAL
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT EFI_EVENT         *LegacyBootEvent
+  );
+
+/**
+  Create an EFI event in the Ready To Boot Event Group.
+
+  Prior to UEFI 2.0 this was done via a non-standard UEFI extension, and this library
+  abstracts the implementation mechanism of this event from the caller.   
+  This function abstracts the creation of the Ready to Boot Event.  The Framework 
+  moved from a proprietary to UEFI 2.0-based mechanism.  This library abstracts 
+  the caller from how this event is created to prevent the code form having to 
+  change with the version of the specification supported.
+  If ReadyToBootEvent is NULL, then ASSERT().
+
+  @param  ReadyToBootEvent   Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       The event was created.
+  @retval Other             The event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventReadyToBoot (
+  OUT EFI_EVENT  *ReadyToBootEvent
+  );
+
+/**
+  Create an EFI event in the Ready To Boot Event Group and allows
+  the caller to specify a notification function.  
+  
+  This function abstracts the creation of the Ready to Boot Event.
+  The Framework moved from a proprietary to UEFI 2.0 based mechanism.
+  This library abstracts the caller from how this event is created to prevent
+  to code form having to change with the version of the specification supported.
+  If ReadyToBootEvent is NULL, then ASSERT().
+
+  @param  NotifyTpl         The task priority level of the event.
+  @param  NotifyFunction    The notification function to call when the event is signaled.
+  @param  NotifyContext     The content to pass to NotifyFunction when the event is signaled.
+  @param  ReadyToBootEvent  Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       The event was created.
+  @retval Other             The event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventReadyToBootEx (
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,  OPTIONAL
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT EFI_EVENT         *ReadyToBootEvent
+  );
+
+/**
+  Initialize a Firmware Volume (FV) Media Device Path node.
+  
+  The Framework FwVol Device Path changed to conform to the UEFI 2.0 specification.  
+  This library function abstracts initializing a device path node.  
+  Initialize the MEDIA_FW_VOL_FILEPATH_DEVICE_PATH data structure.  This device 
+  path changed in the DXE CIS version 0.92 in a non back ward compatible way to 
+  not conflict with the UEFI 2.0 specification.  This function abstracts the 
+  differences from the caller.
+  If FvDevicePathNode is NULL, then ASSERT().
+  If NameGuid is NULL, then ASSERT().
+  
+  @param  FvDevicePathNode  The pointer to a FV device path node to initialize
+  @param  NameGuid          FV file name to use in FvDevicePathNode
+
+**/
+VOID
+EFIAPI
+EfiInitializeFwVolDevicepathNode (
+  IN OUT MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvDevicePathNode,
+  IN CONST EFI_GUID                         *NameGuid
+  );
+
+/**
+  Check to see if the Firmware Volume (FV) Media Device Path is valid 
+  
+  The Framework FwVol Device Path changed to conform to the UEFI 2.0 specification.  
+  This library function abstracts validating a device path node.
+  Check the MEDIA_FW_VOL_FILEPATH_DEVICE_PATH data structure to see if it's valid.  
+  If it is valid, then return the GUID file name from the device path node.  Otherwise, 
+  return NULL.  This device path changed in the DXE CIS version 0.92 in a non backward 
+  compatible way to not conflict with the UEFI 2.0 specification.  This function abstracts 
+  the differences from the caller.
+  If FvDevicePathNode is NULL, then ASSERT().
+
+  @param  FvDevicePathNode  The pointer to FV device path to check.
+
+  @retval NULL              FvDevicePathNode is not valid.
+  @retval Other             FvDevicePathNode is valid and pointer to NameGuid was returned.
+
+**/
+EFI_GUID *
+EFIAPI
+EfiGetNameGuidFromFwVolDevicePathNode (
+  IN CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvDevicePathNode
+  );
+
+/** 
+  Prints a formatted Unicode string to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted Unicode string to the console output device 
+  specified by ConOut in EFI_SYSTEM_TABLE and returns the number of Unicode 
+  characters that printed to ConOut.  If the length of the formatted Unicode 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->ConOut is NULL, then ASSERT().
+
+  @param Format   A null-terminated Unicode format string.
+  @param ...      The variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return Number of Unicode characters printed to ConOut.
+
+**/
+UINTN
+EFIAPI
+Print (
+  IN CONST CHAR16  *Format,
+  ...
+  );
+
+/** 
+  Prints a formatted Unicode string to the console output device specified by 
+  StdErr defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted Unicode string to the console output device 
+  specified by StdErr in EFI_SYSTEM_TABLE and returns the number of Unicode 
+  characters that printed to StdErr.  If the length of the formatted Unicode 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->StdErr is NULL, then ASSERT().
+
+  @param Format   A null-terminated Unicode format string.
+  @param ...      The variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return Number of Unicode characters printed to StdErr.
+
+**/
+UINTN
+EFIAPI
+ErrorPrint (
+  IN CONST CHAR16  *Format,
+  ...
+  );
+
+/** 
+  Prints a formatted ASCII string to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted ASCII string to the console output device 
+  specified by ConOut in EFI_SYSTEM_TABLE and returns the number of ASCII 
+  characters that printed to ConOut.  If the length of the formatted ASCII 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
+  If Format is NULL, then ASSERT().
+  If gST->ConOut is NULL, then ASSERT().
+
+  @param Format   A null-terminated ASCII format string.
+  @param ...      The variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return Number of ASCII characters printed to ConOut.
+
+**/
+UINTN
+EFIAPI
+AsciiPrint (
+  IN CONST CHAR8  *Format,
+  ...
+  );
+
+/** 
+  Prints a formatted ASCII string to the console output device specified by 
+  StdErr defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted ASCII string to the console output device 
+  specified by StdErr in EFI_SYSTEM_TABLE and returns the number of ASCII 
+  characters that printed to StdErr.  If the length of the formatted ASCII 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
+  If Format is NULL, then ASSERT().
+  If gST->StdErr is NULL, then ASSERT().
+
+  @param Format   A null-terminated ASCII format string.
+  @param ...      The variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return Number of ASCII characters printed to ConErr.
+
+**/
+UINTN
+EFIAPI
+AsciiErrorPrint (
+  IN CONST CHAR8  *Format,
+  ...
+  );
+
+
+/**
+  Prints a formatted Unicode string to a graphics console device specified by 
+  ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
+
+  This function prints a formatted Unicode string to the graphics console device 
+  specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of 
+  Unicode characters displayed, not including partial characters that may be clipped 
+  by the right edge of the display.  If the length of the formatted Unicode string is
+  greater than PcdUefiLibMaxPrintBufferSize, then at most the first 
+  PcdUefiLibMaxPrintBufferSize characters are printed.  The EFI_HII_FONT_PROTOCOL
+  is used to convert the string to a bitmap using the glyphs registered with the 
+  HII database.  No wrapping is performed, so any portions of the string the fall
+  outside the active display region will not be displayed.
+
+  If a graphics console device is not associated with the ConsoleOutputHandle 
+  defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
+  If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no 
+  string is printed, and 0 is returned.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->ConsoleOutputHandle is NULL, then ASSERT().
+
+  @param  PointX       X coordinate to print the string.
+  @param  PointY       Y coordinate to print the string.
+  @param  ForeGround   The foreground color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the foreground color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  BackGround   The background color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL, 
+                       then the background color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Format       A null-terminated Unicode format string.  See Print Library 
+                       for the supported format string syntax.
+  @param  ...          Variable argument list whose contents are accessed based on 
+                       the format string specified by Format.         
+
+  @return  The number of Unicode characters printed.
+
+**/
+UINTN
+EFIAPI
+PrintXY (
+  IN UINTN                            PointX,
+  IN UINTN                            PointY,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *ForeGround, OPTIONAL
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *BackGround, OPTIONAL
+  IN CONST CHAR16                     *Format,
+  ...
+  );
+
+/**
+  Prints a formatted ASCII string to a graphics console device specified by 
+  ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
+
+  This function prints a formatted ASCII string to the graphics console device 
+  specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of 
+  ASCII characters displayed, not including partial characters that may be clipped 
+  by the right edge of the display.  If the length of the formatted ASCII string is
+  greater than PcdUefiLibMaxPrintBufferSize, then at most the first 
+  PcdUefiLibMaxPrintBufferSize characters are printed.  The EFI_HII_FONT_PROTOCOL
+  is used to convert the string to a bitmap using the glyphs registered with the 
+  HII database.  No wrapping is performed, so any portions of the string the fall
+  outside the active display region will not be displayed.
+
+  If a graphics console device is not associated with the ConsoleOutputHandle 
+  defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
+  If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no 
+  string is printed, and 0 is returned.
+  If Format is NULL, then ASSERT().
+  If gST->ConsoleOutputHandle is NULL, then ASSERT().
+
+  @param  PointX       X coordinate to print the string.
+  @param  PointY       Y coordinate to print the string.
+  @param  ForeGround   The foreground color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the foreground color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  BackGround   The background color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL, 
+                       then the background color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Format       A null-terminated ASCII format string.  See Print Library 
+                       for the supported format string syntax.
+  @param  ...          The variable argument list whose contents are accessed based on 
+                       the format string specified by Format.         
+
+  @return  The number of ASCII characters printed.
+
+**/
+UINTN
+EFIAPI
+AsciiPrintXY (
+  IN UINTN                            PointX,
+  IN UINTN                            PointY,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *ForeGround, OPTIONAL
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *BackGround, OPTIONAL
+  IN CONST CHAR8                      *Format,
+  ...
+  );
+
+/**
+  Installs and completes the initialization of a Driver Binding Protocol instance.
+  
+  Installs the Driver Binding Protocol specified by DriverBinding onto the handle
+  specified by DriverBindingHandle. If DriverBindingHandle is NULL, then DriverBinding
+  is installed onto a newly created handle. DriverBindingHandle is typically the same
+  as the driver's ImageHandle, but it can be different if the driver produces multiple
+  Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If DriverBinding can not be installed onto a handle, then ASSERT().
+
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+
+  @retval EFI_SUCCESS           The protocol installation completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough system resources to install the protocol.
+  @retval Others                Status from gBS->InstallMultipleProtocolInterfaces().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallDriverBinding (
+  IN CONST EFI_HANDLE             ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE       *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding,
+  IN EFI_HANDLE                   DriverBindingHandle
+  );
+
+
+/**
+  Installs and completes the initialization of a Driver Binding Protocol instance and
+  optionally installs the Component Name, Driver Configuration and Driver Diagnostics Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the
+  optional Component Name, optional Driver Configure and optional Driver Diagnostic
+  Protocols onto the driver's DriverBindingHandle. If DriverBindingHandle is NULL,
+  then the protocols are installed onto a newly created handle. DriverBindingHandle
+  is typically the same as the driver's ImageHandle, but it can be different if the
+  driver produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+  
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+  @param  ComponentName        A Component Name Protocol instance that this driver is producing.
+  @param  DriverConfiguration  A Driver Configuration Protocol instance that this driver is producing.
+  @param  DriverDiagnostics    A Driver Diagnostics Protocol instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in the pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallAllDriverProtocols (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics    OPTIONAL
+  );
+
+
+
+/**
+  Installs Driver Binding Protocol with optional Component Name and Component Name 2 Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the
+  optional Component Name and optional Component Name 2 protocols onto the driver's
+  DriverBindingHandle.  If DriverBindingHandle is NULL, then the protocols are installed
+  onto a newly created handle.  DriverBindingHandle is typically the same as the driver's
+  ImageHandle, but it can be different if the driver produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+  @param  ComponentName        A Component Name Protocol instance that this driver is producing.
+  @param  ComponentName2       A Component Name 2 Protocol instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallDriverBindingComponentName2 (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN CONST EFI_COMPONENT_NAME2_PROTOCOL       *ComponentName2       OPTIONAL
+  );
+
+
+/**
+  Installs Driver Binding Protocol with optional Component Name, Component Name 2, Driver
+  Configuration, Driver Configuration 2, Driver Diagnostics, and Driver Diagnostics 2 Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the optional
+  Component Name, optional Component Name 2, optional Driver Configuration, optional Driver Configuration 2,
+  optional Driver Diagnostic, and optional Driver Diagnostic 2 Protocols onto the driver's DriverBindingHandle.
+  DriverBindingHandle is typically the same as the driver's ImageHandle, but it can be different if the driver
+  produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+
+
+  @param  ImageHandle           The image handle of the driver.
+  @param  SystemTable           The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding         A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle   The handle that DriverBinding is to be installed onto.  If this
+                                parameter is NULL, then a new handle is created.
+  @param  ComponentName         A Component Name Protocol instance that this driver is producing.
+  @param  ComponentName2        A Component Name 2 Protocol instance that this driver is producing.
+  @param  DriverConfiguration   A Driver Configuration Protocol instance that this driver is producing.
+  @param  DriverConfiguration2  A Driver Configuration Protocol 2 instance that this driver is producing.
+  @param  DriverDiagnostics     A Driver Diagnostics Protocol instance that this driver is producing.
+  @param  DriverDiagnostics2    A Driver Diagnostics Protocol 2 instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallAllDriverProtocols2 (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,        OPTIONAL
+  IN CONST EFI_COMPONENT_NAME2_PROTOCOL       *ComponentName2,       OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration,  OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION2_PROTOCOL *DriverConfiguration2, OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics,    OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS2_PROTOCOL   *DriverDiagnostics2    OPTIONAL
+  );
+
+/** 
+  Appends a formatted Unicode string to a Null-terminated Unicode string
+ 
+  This function appends a formatted Unicode string to the Null-terminated 
+  Unicode string specified by String.   String is optional and may be NULL.
+  Storage for the formatted Unicode string returned is allocated using 
+  AllocatePool().  The pointer to the appended string is returned.  The caller
+  is responsible for freeing the returned string.
+ 
+  If String is not NULL and not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is NULL, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  @param[in] String         A Null-terminated Unicode string.
+  @param[in] FormatString   A Null-terminated Unicode format string.
+  @param[in]  Marker        VA_LIST marker for the variable argument list.
+
+  @retval NULL    There was not enough available memory.
+  @return         Null-terminated Unicode string is that is the formatted 
+                  string appended to String.
+**/
+CHAR16*
+EFIAPI
+CatVSPrint (
+  IN  CHAR16  *String, OPTIONAL
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  );
+
+/** 
+  Appends a formatted Unicode string to a Null-terminated Unicode string
+ 
+  This function appends a formatted Unicode string to the Null-terminated 
+  Unicode string specified by String.   String is optional and may be NULL.
+  Storage for the formatted Unicode string returned is allocated using 
+  AllocatePool().  The pointer to the appended string is returned.  The caller
+  is responsible for freeing the returned string.
+ 
+  If String is not NULL and not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is NULL, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  @param[in] String         A Null-terminated Unicode string.
+  @param[in] FormatString   A Null-terminated Unicode format string.
+  @param[in] ...            The variable argument list whose contents are 
+                            accessed based on the format string specified by 
+                            FormatString.
+
+  @retval NULL    There was not enough available memory.
+  @return         Null-terminated Unicode string is that is the formatted 
+                  string appended to String.
+**/
+CHAR16 *
+EFIAPI
+CatSPrint (
+  IN  CHAR16  *String, OPTIONAL
+  IN  CONST CHAR16  *FormatString,
+  ...
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiRuntimeLib.h b/MdePkg/Include/Library/UefiRuntimeLib.h
new file mode 100644
index 000000000000..03d7fb768f20
--- /dev/null
+++ b/MdePkg/Include/Library/UefiRuntimeLib.h
@@ -0,0 +1,588 @@
+/** @file
+  Provides library functions for each of the UEFI Runtime Services.
+  Only available to DXE and UEFI module types.
+
+Copyright (c) 2006 - 2010, 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 __UEFI_RUNTIME_LIB__
+#define __UEFI_RUNTIME_LIB__
+
+/**
+  This function allows the caller to determine if UEFI ExitBootServices() has been called.
+
+  This function returns TRUE after all the EVT_SIGNAL_EXIT_BOOT_SERVICES functions have
+  executed as a result of the OS calling ExitBootServices().  Prior to this time FALSE
+  is returned. This function is used by runtime code to decide it is legal to access
+  services that go away after ExitBootServices().
+
+  @retval  TRUE  The system has finished executing the EVT_SIGNAL_EXIT_BOOT_SERVICES event.
+  @retval  FALSE The system has not finished executing the EVT_SIGNAL_EXIT_BOOT_SERVICES event.
+
+**/
+BOOLEAN
+EFIAPI
+EfiAtRuntime (
+  VOID
+  );
+
+/**
+  This function allows the caller to determine if UEFI SetVirtualAddressMap() has been called. 
+
+  This function returns TRUE after all the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE functions have
+  executed as a result of the OS calling SetVirtualAddressMap(). Prior to this time FALSE
+  is returned. This function is used by runtime code to decide it is legal to access services
+  that go away after SetVirtualAddressMap().
+
+  @retval  TRUE  The system has finished executing the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
+  @retval  FALSE The system has not finished executing the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
+
+**/
+BOOLEAN
+EFIAPI
+EfiGoneVirtual (
+  VOID
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetTime().
+
+  The GetTime() function returns a time that was valid sometime during the call to the function.
+  While the returned EFI_TIME structure contains TimeZone and Daylight savings time information,
+  the actual clock does not maintain these values. The current time zone and daylight saving time
+  information returned by GetTime() are the values that were last set via SetTime().
+  The GetTime() function should take approximately the same amount of time to read the time each
+  time it is called. All reported device capabilities are to be rounded up.
+  During runtime, if a PC-AT CMOS device is present in the platform, the caller must synchronize
+  access to the device before calling GetTime().
+
+  @param  Time         A pointer to storage to receive a snapshot of the current time.
+  @param  Capabilities An optional pointer to a buffer to receive the real time clock device's
+                       capabilities.
+
+  @retval  EFI_SUCCESS            The operation completed successfully.
+  @retval  EFI_INVALID_PARAMETER  Time is NULL.
+  @retval  EFI_DEVICE_ERROR       The time could not be retrieved due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetTime (
+  OUT EFI_TIME                    *Time,
+  OUT EFI_TIME_CAPABILITIES       *Capabilities  OPTIONAL
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetTime().
+
+  The SetTime() function sets the real time clock device to the supplied time, and records the
+  current time zone and daylight savings time information. The SetTime() function is not allowed
+  to loop based on the current time. For example, if the device does not support a hardware reset
+  for the sub-resolution time, the code is not to implement the feature by waiting for the time to
+  wrap.
+  During runtime, if a PC-AT CMOS device is present in the platform, the caller must synchronize
+  access to the device before calling SetTime().
+
+  @param  Time  A pointer to the current time. Type EFI_TIME is defined in the GetTime()
+                function description. Full error checking is performed on the different
+                fields of the EFI_TIME structure (refer to the EFI_TIME definition in the
+                GetTime() function description for full details), and EFI_INVALID_PARAMETER
+                is returned if any field is out of range.
+
+  @retval  EFI_SUCCESS            The operation completed successfully.
+  @retval  EFI_INVALID_PARAMETER  A time field is out of range.
+  @retval  EFI_DEVICE_ERROR       The time could not be set due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetTime (
+  IN EFI_TIME                   *Time
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetWakeupTime().
+
+  The alarm clock time may be rounded from the set alarm clock time to be within the resolution
+  of the alarm clock device. The resolution of the alarm clock device is defined to be one second.
+  During runtime, if a PC-AT CMOS device is present in the platform the caller must synchronize
+  access to the device before calling GetWakeupTime().
+
+  @param  Enabled  Indicates if the alarm is currently enabled or disabled.
+  @param  Pending  Indicates if the alarm signal is pending and requires acknowledgement.
+  @param  Time     The current alarm setting. Type EFI_TIME is defined in the GetTime()
+                   function description.
+
+  @retval  EFI_SUCCESS            The alarm settings were returned.
+  @retval  EFI_INVALID_PARAMETER  Enabled is NULL.
+  @retval  EFI_INVALID_PARAMETER  Pending is NULL.
+  @retval  EFI_INVALID_PARAMETER  Time is NULL.
+  @retval  EFI_DEVICE_ERROR       The wakeup time could not be retrieved due to a hardware error.
+  @retval  EFI_UNSUPPORTED        A wakeup timer is not supported on this platform.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetWakeupTime (
+  OUT BOOLEAN                     *Enabled,
+  OUT BOOLEAN                     *Pending,
+  OUT EFI_TIME                    *Time
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetWakeupTime()
+
+  Setting a system wakeup alarm causes the system to wake up or power on at the set time.
+  When the alarm fires, the alarm signal is latched until it is acknowledged by calling SetWakeupTime()
+  to disable the alarm. If the alarm fires before the system is put into a sleeping or off state,
+  since the alarm signal is latched the system will immediately wake up. If the alarm fires while
+  the system is off and there is insufficient power to power on the system, the system is powered
+  on when power is restored.
+
+  @param  Enable  Enable or disable the wakeup alarm.
+  @param  Time    If Enable is TRUE, the time to set the wakeup alarm for. Type EFI_TIME
+                  is defined in the GetTime() function description. If Enable is FALSE,
+                  then this parameter is optional, and may be NULL.
+
+  @retval  EFI_SUCCESS            If Enable is TRUE, then the wakeup alarm was enabled.
+                                  If Enable is FALSE, then the wakeup alarm was disabled.
+  @retval  EFI_INVALID_PARAMETER  A time field is out of range.
+  @retval  EFI_DEVICE_ERROR       The wakeup time could not be set due to a hardware error.
+  @retval  EFI_UNSUPPORTED        A wakeup timer is not supported on this platform.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetWakeupTime (
+  IN BOOLEAN                      Enable,
+  IN EFI_TIME                     *Time   OPTIONAL
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetVariable().
+
+  Each vendor may create and manage its own variables without the risk of name conflicts by
+  using a unique VendorGuid. When a variable is set, its Attributes are supplied to indicate
+  how the data variable should be stored and maintained by the system. The attributes affect
+  when the variable may be accessed and volatility of the data. Any attempts to access a variable
+  that does not have the attribute set for runtime access will yield the EFI_NOT_FOUND error.
+  If the Data buffer is too small to hold the contents of the variable, the error EFI_BUFFER_TOO_SMALL
+  is returned and DataSize is set to the required buffer size to obtain the data.
+
+  @param  VariableName the name of the vendor's variable, it's a Null-Terminated Unicode String
+  @param  VendorGuid   Unify identifier for vendor.
+  @param  Attributes   Point to memory location to return the attributes of variable. If the point
+                       is NULL, the parameter would be ignored.
+  @param  DataSize     As input, point to the maximum size of return Data-Buffer.
+                       As output, point to the actual size of the returned Data-Buffer.
+  @param  Data         Point to return Data-Buffer.
+
+  @retval  EFI_SUCCESS            The function completed successfully.
+  @retval  EFI_NOT_FOUND          The variable was not found.
+  @retval  EFI_BUFFER_TOO_SMALL   The DataSize is too small for the result. DataSize has
+                                  been updated with the size needed to complete the request.
+  @retval  EFI_INVALID_PARAMETER  VariableName is NULL.
+  @retval  EFI_INVALID_PARAMETER  VendorGuid is NULL.
+  @retval  EFI_INVALID_PARAMETER  DataSize is NULL.
+  @retval  EFI_INVALID_PARAMETER  The DataSize is not too small and Data is NULL.
+  @retval  EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval  EFI_SECURITY_VIOLATION The variable could not be retrieved due to an authentication failure.
+**/
+EFI_STATUS
+EFIAPI
+EfiGetVariable (
+  IN      CHAR16                   *VariableName,
+  IN      EFI_GUID                 *VendorGuid,
+  OUT     UINT32                   *Attributes OPTIONAL,
+  IN OUT  UINTN                    *DataSize,
+  OUT     VOID                     *Data
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextVariableName().
+
+  GetNextVariableName() is called multiple times to retrieve the VariableName and VendorGuid of
+  all variables currently available in the system. On each call to GetNextVariableName() the
+  previous results are passed into the interface, and on output the interface returns the next
+  variable name data. When the entire variable list has been returned, the error EFI_NOT_FOUND
+  is returned.
+
+  @param  VariableNameSize As input, point to maximum size of variable name.
+                           As output, point to actual size of variable name.
+  @param  VariableName     As input, supplies the last VariableName that was returned by
+                           GetNextVariableName().
+                           As output, returns the name of variable. The name
+                           string is Null-Terminated Unicode string.
+  @param  VendorGuid       As input, supplies the last VendorGuid that was returned by
+                           GetNextVriableName().
+                           As output, returns the VendorGuid of the current variable.
+
+  @retval  EFI_SUCCESS           The function completed successfully.
+  @retval  EFI_NOT_FOUND         The next variable was not found.
+  @retval  EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the result.
+                                 VariableNameSize has been updated with the size needed
+                                 to complete the request.
+  @retval  EFI_INVALID_PARAMETER VariableNameSize is NULL.
+  @retval  EFI_INVALID_PARAMETER VariableName is NULL.
+  @retval  EFI_INVALID_PARAMETER VendorGuid is NULL.
+  @retval  EFI_DEVICE_ERROR      The variable name could not be retrieved due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetNextVariableName (
+  IN OUT UINTN                    *VariableNameSize,
+  IN OUT CHAR16                   *VariableName,
+  IN OUT EFI_GUID                 *VendorGuid
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextVariableName()
+
+  Variables are stored by the firmware and may maintain their values across power cycles. Each vendor
+  may create and manage its own variables without the risk of name conflicts by using a unique VendorGuid.
+
+  @param  VariableName the name of the vendor's variable, as a
+                       Null-Terminated Unicode String
+  @param  VendorGuid   Unify identifier for vendor.
+  @param  Attributes   Point to memory location to return the attributes of variable. If the point
+                       is NULL, the parameter would be ignored.
+  @param  DataSize     The size in bytes of Data-Buffer.
+  @param  Data         Point to the content of the variable.
+
+  @retval  EFI_SUCCESS            The firmware has successfully stored the variable and its data as
+                                  defined by the Attributes.
+  @retval  EFI_INVALID_PARAMETER  An invalid combination of attribute bits was supplied, or the
+                                  DataSize exceeds the maximum allowed.
+  @retval  EFI_INVALID_PARAMETER  VariableName is an empty Unicode string.
+  @retval  EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.
+  @retval  EFI_DEVICE_ERROR       The variable could not be saved due to a hardware failure.
+  @retval  EFI_WRITE_PROTECTED    The variable in question is read-only.
+  @retval  EFI_WRITE_PROTECTED    The variable in question cannot be deleted.
+  @retval  EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
+                                  set but the AuthInfo does NOT pass the validation check carried
+                                  out by the firmware.
+  @retval  EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetVariable (
+  IN CHAR16                       *VariableName,
+  IN EFI_GUID                     *VendorGuid,
+  IN UINT32                       Attributes,
+  IN UINTN                        DataSize,
+  IN VOID                         *Data
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextHighMonotonicCount().
+
+  The platform's monotonic counter is comprised of two 32-bit quantities: the high 32 bits and
+  the low 32 bits. During boot service time the low 32-bit value is volatile: it is reset to zero
+  on every system reset and is increased by 1 on every call to GetNextMonotonicCount(). The high
+  32-bit value is nonvolatile and is increased by 1 whenever the system resets or whenever the low
+  32-bit count (returned by GetNextMonoticCount()) overflows.
+
+  @param  HighCount Pointer to returned value.
+
+  @retval  EFI_SUCCESS           The next high monotonic count was returned.
+  @retval  EFI_DEVICE_ERROR      The device is not functioning properly.
+  @retval  EFI_INVALID_PARAMETER HighCount is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetNextHighMonotonicCount (
+  OUT UINT32                      *HighCount
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service ResetSystem().
+
+  The ResetSystem()function resets the entire platform, including all processors and devices,and reboots the system.
+  Calling this interface with ResetType of EfiResetCold causes a system-wide reset. This sets all circuitry within
+  the system to its initial state. This type of reset is asynchronous to system operation and operates without regard
+  to cycle boundaries. EfiResetCold is tantamount to a system power cycle.
+  Calling this interface with ResetType of EfiResetWarm causes a system-wide initialization. The processors are set to
+  their initial state, and pending cycles are not corrupted. If the system does not support this reset type, then an
+  EfiResetCold must be performed.
+  Calling this interface with ResetType of EfiResetShutdown causes the system to enter a power state equivalent to the
+  ACPI G2/S5 or G3 states. If the system does not support this reset type, then when the system is rebooted, it should
+  exhibit the EfiResetCold attributes.
+  The platform may optionally log the parameters from any non-normal reset that occurs.
+  The ResetSystem() function does not return.
+
+  @param  ResetType   The type of reset to perform.
+  @param  ResetStatus The status code for the reset. If the system reset is part of a normal operation, the status code
+                      would be EFI_SUCCESS. If the system reset is due to some type of failure the most appropriate EFI
+                      Status code would be used.
+  @param  DataSizeThe size, in bytes, of ResetData.
+  @param  ResetData   For a ResetType of EfiResetCold, EfiResetWarm, or EfiResetShutdown the data buffer starts with a
+                      Null-terminated Unicode string, optionally followed by additional binary data. The string is a
+                      description that the caller may use to further indicate the reason for the system reset. ResetData
+                      is only valid if ResetStatus is something other then EFI_SUCCESS. This pointer must be a physical
+                      address. For a ResetType of EfiRestUpdate the data buffer also starts with a Null-terminated string
+                      that is followed by a physical VOID * to an EFI_CAPSULE_HEADER.
+
+**/
+VOID
+EFIAPI
+EfiResetSystem (
+  IN EFI_RESET_TYPE               ResetType,
+  IN EFI_STATUS                   ResetStatus,
+  IN UINTN                        DataSize,
+  IN VOID                         *ResetData OPTIONAL
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service ConvertPointer().  
+
+  The ConvertPointer() function is used by an EFI component during the SetVirtualAddressMap() operation.
+  ConvertPointer()must be called using physical address pointers during the execution of SetVirtualAddressMap().
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  Address            The pointer to a pointer that is to be fixed to be the
+                             value needed for the new virtual address mapping being
+                             applied.
+
+  @retval  EFI_SUCCESS            The pointer pointed to by Address was modified.
+  @retval  EFI_NOT_FOUND          The pointer pointed to by Address was not found to be part of
+                                  the current memory map. This is normally fatal.
+  @retval  EFI_INVALID_PARAMETER  Address is NULL.
+  @retval  EFI_INVALID_PARAMETER  *Address is NULL and DebugDispositio
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertPointer (
+  IN UINTN                  DebugDisposition,
+  IN OUT VOID               **Address
+  );
+
+/**
+  Determines the new virtual address that is to be used on subsequent memory accesses.
+
+  For IA32, x64, and EBC, this service is a wrapper for the UEFI Runtime Service
+  ConvertPointer().  See the UEFI Specification for details. 
+  For IPF, this function interprets Address as a pointer to an EFI_PLABEL structure
+  and both the EntryPoint and GP fields of an EFI_PLABEL are converted from physical
+  to virtiual addressing.  Since IPF allows the GP to point to an address outside
+  a PE/COFF image, the physical to virtual offset for the EntryPoint field is used
+  to adjust the GP field.  The UEFI Runtime Service ConvertPointer() is used to convert
+  EntryPoint and the status code for this conversion is always returned.   If the convertion
+  of EntryPoint fails, then neither EntryPoint nor GP are modified.  See the UEFI
+  Specification for details on the UEFI Runtime Service ConvertPointer().
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  Address            The pointer to a pointer that is to be fixed to be the
+                             value needed for the new virtual address mapping being
+                             applied.
+
+  @return  EFI_STATUS value from EfiConvertPointer().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertFunctionPointer (
+  IN UINTN                DebugDisposition,
+  IN OUT VOID             **Address
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetVirtualAddressMap().
+
+  The SetVirtualAddressMap() function is used by the OS loader. The function can only be called
+  at runtime, and is called by the owner of the system's memory map. I.e., the component which
+  called ExitBootServices(). All events of type EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE must be signaled
+  before SetVirtualAddressMap() returns.
+
+  @param  MemoryMapSize         The size in bytes of VirtualMap.
+  @param  DescriptorSize        The size in bytes of an entry in the VirtualMap.
+  @param  DescriptorVersion     The version of the structure entries in VirtualMap.
+  @param  VirtualMap            An array of memory descriptors which contain new virtual
+                                address mapping information for all runtime ranges. Type
+                                EFI_MEMORY_DESCRIPTOR is defined in the
+                                GetMemoryMap() function description.
+
+  @retval EFI_SUCCESS           The virtual address map has been applied.
+  @retval EFI_UNSUPPORTED       EFI firmware is not at runtime, or the EFI firmware is already in
+                                virtual address mapped mode.
+  @retval EFI_INVALID_PARAMETER DescriptorSize or DescriptorVersion is
+                                invalid.
+  @retval EFI_NO_MAPPING        A virtual address was not supplied for a range in the memory
+                                map that requires a mapping.
+  @retval EFI_NOT_FOUND         A virtual address was supplied for an address that is not found
+                                in the memory map.
+**/
+EFI_STATUS
+EFIAPI
+EfiSetVirtualAddressMap (
+  IN UINTN                          MemoryMapSize,
+  IN UINTN                          DescriptorSize,
+  IN UINT32                         DescriptorVersion,
+  IN CONST EFI_MEMORY_DESCRIPTOR    *VirtualMap
+  );
+
+
+/**
+  Convert the standard Lib double linked list to a virtual mapping.
+
+  This service uses EfiConvertPointer() to walk a double linked list and convert all the link
+  pointers to their virtual mappings. This function is only guaranteed to work during the
+  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event and calling it at other times has undefined results.
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  ListHead           Head of linked list to convert.
+
+  @retval  EFI_SUCCESS  Successfully executed the function.
+  @retval  !EFI_SUCCESS Failed to execute the function.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertList (
+  IN UINTN                DebugDisposition,
+  IN OUT LIST_ENTRY       *ListHead
+  );
+
+/**
+  This service is a wrapper for the UEFI Runtime Service UpdateCapsule().
+
+  Passes capsules to the firmware with both virtual and physical mapping. Depending on the intended
+  consumption, the firmware may process the capsule immediately. If the payload should persist across a
+  system reset, the reset value returned from EFI_QueryCapsuleCapabilities must be passed into ResetSystem()
+  and will cause the capsule to be processed by the firmware as part of the reset process.
+
+  @param  CapsuleHeaderArray    Virtual pointer to an array of virtual pointers to the capsules
+                                being passed into update capsule. Each capsules is assumed to
+                                stored in contiguous virtual memory. The capsules in the
+                                CapsuleHeaderArray must be the same capsules as the
+                                ScatterGatherList. The CapsuleHeaderArray must
+                                have the capsules in the same order as the ScatterGatherList.
+  @param  CapsuleCount          Number of pointers to EFI_CAPSULE_HEADER in
+                                CaspuleHeaderArray.
+  @param  ScatterGatherList     Physical pointer to a set of
+                                EFI_CAPSULE_BLOCK_DESCRIPTOR that describes the
+                                location in physical memory of a set of capsules. See Related
+                                Definitions for an explanation of how more than one capsule is
+                                passed via this interface. The capsules in the
+                                ScatterGatherList must be in the same order as the
+                                CapsuleHeaderArray. This parameter is only referenced if
+                                the capsules are defined to persist across system reset.
+
+  @retval EFI_SUCCESS           A valid capsule was passed. If CAPSULE_FLAGS_PERSIT_ACROSS_RESET is not set,
+                                the capsule has been successfully processed by the firmware.
+  @retval EFI_INVALID_PARAMETER CapsuleSize is NULL, or an incompatible set of flags were
+                                set in the capsule header.
+  @retval EFI_INVALID_PARAMETER CapsuleCount is 0
+  @retval EFI_DEVICE_ERROR      The capsule update was started, but failed due to a device error.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform.
+  @retval EFI_OUT_OF_RESOURCES  There were insufficient resources to process the capsule.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiUpdateCapsule (
+  IN EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+  IN UINTN                    CapsuleCount,
+  IN EFI_PHYSICAL_ADDRESS     ScatterGatherList OPTIONAL
+  );
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service QueryCapsuleCapabilities().
+
+  The QueryCapsuleCapabilities() function allows a caller to test to see if a capsule or
+  capsules can be updated via UpdateCapsule(). The Flags values in the capsule header and
+  size of the entire capsule is checked.
+  If the caller needs to query for generic capsule capability a fake EFI_CAPSULE_HEADER can be
+  constructed where CapsuleImageSize is equal to HeaderSize that is equal to sizeof
+  (EFI_CAPSULE_HEADER). To determine reset requirements,
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET should be set in the Flags field of the
+  EFI_CAPSULE_HEADER.
+  The firmware must support any capsule that has the
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET flag set in EFI_CAPSULE_HEADER. The
+  firmware sets the policy for what capsules are supported that do not have the
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET flag set.
+
+  @param  CapsuleHeaderArray    Virtual pointer to an array of virtual pointers to the capsules
+                                being passed into update capsule. The capsules are assumed to
+                                stored in contiguous virtual memory.
+  @param  CapsuleCount          Number of pointers to EFI_CAPSULE_HEADER in
+                                CaspuleHeaderArray.
+  @param  MaximumCapsuleSize     On output the maximum size that UpdateCapsule() can
+                                support as an argument to UpdateCapsule() via
+                                CapsuleHeaderArray and ScatterGatherList.
+                                Undefined on input.
+  @param  ResetType             Returns the type of reset required for the capsule update.
+
+  @retval EFI_SUCCESS           A valid answer was returned.
+  @retval EFI_INVALID_PARAMETER MaximumCapsuleSize is NULL.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform, and
+                                MaximumCapsuleSize and ResetType are undefined.
+  @retval EFI_OUT_OF_RESOURCES  There were insufficient resources to process the query request.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiQueryCapsuleCapabilities (
+  IN  EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+  IN  UINTN                    CapsuleCount,
+  OUT UINT64                   *MaximumCapsuleSize,
+  OUT EFI_RESET_TYPE           *ResetType
+  );
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service QueryVariableInfo().
+
+  The QueryVariableInfo() function allows a caller to obtain the information about the
+  maximum size of the storage space available for the EFI variables, the remaining size of the storage
+  space available for the EFI variables and the maximum size of each individual EFI variable,
+  associated with the attributes specified.
+  The returned MaximumVariableStorageSize, RemainingVariableStorageSize,
+  MaximumVariableSize information may change immediately after the call based on other
+  runtime activities including asynchronous error events. Also, these values associated with different
+  attributes are not additive in nature.
+
+  @param  Attributes            Attributes bitmask to specify the type of variables on
+                                which to return information. Refer to the
+                                GetVariable() function description.
+  @param  MaximumVariableStorageSize
+                                On output the maximum size of the storage space
+                                available for the EFI variables associated with the
+                                attributes specified.
+  @param  RemainingVariableStorageSize
+                                Returns the remaining size of the storage space
+                                available for the EFI variables associated with the
+                                attributes specified.
+  @param  MaximumVariableSize   Returns the maximum size of the individual EFI
+                                variables associated with the attributes specified.
+
+  @retval EFI_SUCCESS           A valid answer was returned.
+  @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied.
+  @retval EFI_UNSUPPORTED       EFI_UNSUPPORTED The attribute is not supported on this platform, and the
+                                MaximumVariableStorageSize,
+                                RemainingVariableStorageSize, MaximumVariableSize
+                                are undefined.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiQueryVariableInfo (
+  IN UINT32   Attributes,
+  OUT UINT64  *MaximumVariableStorageSize,
+  OUT UINT64  *RemainingVariableStorageSize,
+  OUT UINT64  *MaximumVariableSize
+  );
+
+#endif
+
diff --git a/MdePkg/Include/Library/UefiRuntimeServicesTableLib.h b/MdePkg/Include/Library/UefiRuntimeServicesTableLib.h
new file mode 100644
index 000000000000..609f2abeea72
--- /dev/null
+++ b/MdePkg/Include/Library/UefiRuntimeServicesTableLib.h
@@ -0,0 +1,32 @@
+/** @file
+  Provides a service to retrieve a pointer to the EFI Runtime Services Table.
+
+  This library does not contain any functions or macros.  It simply exports the
+  global variable gRT that is a pointer to the EFI Runtime Services Table as defined
+  in the UEFI Specification.  The global variable gRT must be preinitialized to NULL.
+  The library constructor must set gRT to point at the EFI Runtime Services Table so
+  it is available at the module's entry point. Since there is overhead in initializing
+  this global variable, only those modules that actually require access to the EFI
+  Runtime Services Table should use this library.
+  Only available to DXE and UEFI module types.
+
+Copyright (c) 2006 - 2008, 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_RUNTIME_SERVICES_TABLE_LIB_H__
+#define __UEFI_RUNTIME_SERVICES_TABLE_LIB_H__
+
+///
+/// Cached copy of the EFI Runtime Services Table
+///
+extern EFI_RUNTIME_SERVICES  *gRT;
+
+#endif
diff --git a/MdePkg/Include/Library/UefiScsiLib.h b/MdePkg/Include/Library/UefiScsiLib.h
new file mode 100644
index 000000000000..5257f765845b
--- /dev/null
+++ b/MdePkg/Include/Library/UefiScsiLib.h
@@ -0,0 +1,1181 @@
+/** @file
+  Provides the functions to submit Scsi commands defined in SCSI-2 specification for SCSI devices.
+
+  This library class provides the functions to submit SCSI commands defined in SCSI-2 specification
+  for hard drive, CD and DVD devices that are the most common SCSI boot targets used by UEFI platforms.
+  This library class depends on SCSI I/O Protocol defined in UEFI Specification and SCSI-2 industry standard.
+
+Copyright (c) 2006 - 2015, 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 __SCSI_LIB_H__
+#define __SCSI_LIB_H__
+
+#include <Protocol/ScsiIo.h>
+
+/**
+  Execute Test Unit Ready SCSI command on a specific SCSI target.
+
+  Executes the Test Unit Ready command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]     ScsiIo             A pointer to the SCSI I/O Protocol instance
+                                    for the specific SCSI target.
+  @param[in]     Timeout            The timeout in 100 ns units to use for the execution
+                                    of this SCSI Request Packet. A Timeout value of
+                                    zero means that this function will wait indefinitely
+                                    for the SCSI Request Packet to execute. If Timeout
+                                    is greater than zero, then this function will return
+                                    EFI_TIMEOUT if the time required to execute the SCSI
+                                    Request Packet is greater than Timeout.
+  @param[in, out] SenseData         A pointer to sense data that was generated by
+                                    the execution of the SCSI Request Packet. This
+                                    buffer must be allocated by the caller.
+                                    If SenseDataLength is 0, then this parameter is
+                                    optional and may be NULL.
+  @param[in, out] SenseDataLength   On input, a pointer to the length in bytes of
+                                    the SenseData buffer. On output, a pointer to
+                                    the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus The status of the SCSI Host Controller that produces
+                                    the SCSI bus containing the SCSI target specified by
+                                    ScsiIo when the SCSI Request Packet was executed.
+                                    See the EFI SCSI I/O Protocol in the UEFI Specification
+                                    for details on the possible return values.
+  @param[out]     TargetStatus      The status returned by the SCSI target specified
+                                    by ScsiIo when the SCSI Request Packet was executed
+                                    on the SCSI Host Controller. See the EFI SCSI I/O
+                                    Protocol in the UEFI Specification for details on
+                                    the possible return values. 
+
+  @retval EFI_SUCCESS               The command was executed successfully.
+                                    See HostAdapterStatus, TargetStatus, SenseDataLength,
+                                    and SenseData in that order for additional status
+                                    information.
+  @retval EFI_NOT_READY             The SCSI Request Packet could not be sent because
+                                    there are too many SCSI Command Packets already
+                                    queued. The SCSI Request Packet was not sent, so
+                                    no additional status information is available.
+                                    The caller may retry again later.
+  @retval EFI_DEVICE_ERROR          A device error occurred while attempting to send
+                                    SCSI Request Packet.  See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in that
+                                    order for additional status information.
+  @retval EFI_UNSUPPORTED           The command described by the SCSI Request Packet
+                                    is not supported by the SCSI initiator(i.e., SCSI
+                                    Host Controller). The SCSI Request Packet was not
+                                    sent, so no additional status information is available.
+  @retval EFI_TIMEOUT               A timeout occurred while waiting for the SCSI Request
+                                    Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                    SenseDataLength, and SenseData in that order for
+                                    additional status information.
+  @retval EFI_INVALID_PARAMETER     The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiTestUnitReadyCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus
+  );
+
+
+/**
+  Execute Inquiry SCSI command on a specific SCSI target.
+
+  Executes the Inquiry command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If InquiryDataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If InquiryDataLength is non-zero and InquiryDataBuffer is not NULL, InquiryDataBuffer
+  must meet buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo                 A pointer to the SCSI I/O Protocol instance
+                                         for the specific SCSI target.
+  @param[in]      Timeout                The timeout in 100 ns units to use for the
+                                         execution of this SCSI Request Packet. A Timeout
+                                         value of zero means that this function will wait
+                                         indefinitely for the SCSI Request Packet to execute.
+                                         If Timeout is greater than zero, then this function
+                                         will return EFI_TIMEOUT if the time required to
+                                         execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out] SenseData              A pointer to sense data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If SenseDataLength is 0, then this parameter
+                                         is optional and may be NULL.
+  @param[in, out] SenseDataLength        On input, the length in bytes of the SenseData buffer.
+                                         On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus      The status of the SCSI Host Controller that
+                                         produces the SCSI bus containing the SCSI
+                                         target specified by ScsiIo when the SCSI
+                                         Request Packet was executed.  See the EFI
+                                         SCSI I/O Protocol in the UEFI Specification
+                                         for details on the possible return values.
+  @param[out]     TargetStatus           The status returned by the SCSI target specified
+                                         by ScsiIo when the SCSI Request Packet was
+                                         executed on the SCSI Host Controller.
+                                         See the EFI SCSI I/O Protocol in the UEFI
+                                         Specification for details on the possible
+                                         return values. 
+  @param[in, out] InquiryDataBuffer      A pointer to inquiry data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If InquiryDataLength is 0, then this parameter
+                                         is optional and may be NULL. 
+  @param[in, out] InquiryDataLength      On input, a pointer to the length in bytes
+                                         of the InquiryDataBuffer buffer.
+                                         On output, a pointer to the number of bytes
+                                         written to the InquiryDataBuffer buffer.
+  @param[in]      EnableVitalProductData If TRUE, then the supported vital product
+                                         data is returned in InquiryDataBuffer.
+                                         If FALSE, then the standard inquiry data is
+                                         returned in InquiryDataBuffer. 
+
+  @retval EFI_SUCCESS                    The command was executed successfully. See HostAdapterStatus,
+                                         TargetStatus, SenseDataLength, and SenseData in that order
+                                         for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE            The SCSI Request Packet was executed, but the entire
+                                         InquiryDataBuffer could not be transferred. The actual
+                                         number of bytes transferred is returned in InquiryDataLength.
+  @retval EFI_NOT_READY                  The SCSI Request Packet could not be sent because there
+                                         are too many SCSI Command Packets already queued.
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR               A device error occurred while attempting to send SCSI
+                                         Request Packet.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for additional
+                                         status information.
+  @retval EFI_UNSUPPORTED                The command described by the SCSI Request Packet is not
+                                         supported by the SCSI initiator(i.e., SCSI  Host Controller).
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available.
+  @retval EFI_TIMEOUT                    A timeout occurred while waiting for the SCSI Request
+                                         Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for
+                                         additional status information.
+  @retval EFI_INVALID_PARAMETER          The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiInquiryCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *InquiryDataBuffer,    OPTIONAL
+  IN OUT UINT32                *InquiryDataLength,
+  IN     BOOLEAN               EnableVitalProductData
+  );
+
+
+/**
+  Execute Inquiry SCSI command on a specific SCSI target.
+
+  Executes the Inquiry command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If InquiryDataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If InquiryDataLength is non-zero and InquiryDataBuffer is not NULL, InquiryDataBuffer
+  must meet buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo                 A pointer to the SCSI I/O Protocol instance
+                                         for the specific SCSI target.
+  @param[in]      Timeout                The timeout in 100 ns units to use for the
+                                         execution of this SCSI Request Packet. A Timeout
+                                         value of zero means that this function will wait
+                                         indefinitely for the SCSI Request Packet to execute.
+                                         If Timeout is greater than zero, then this function
+                                         will return EFI_TIMEOUT if the time required to
+                                         execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out] SenseData              A pointer to sense data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If SenseDataLength is 0, then this parameter
+                                         is optional and may be NULL.
+  @param[in, out] SenseDataLength        On input, the length in bytes of the SenseData buffer.
+                                         On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus      The status of the SCSI Host Controller that
+                                         produces the SCSI bus containing the SCSI
+                                         target specified by ScsiIo when the SCSI
+                                         Request Packet was executed.  See the EFI
+                                         SCSI I/O Protocol in the UEFI Specification
+                                         for details on the possible return values.
+  @param[out]     TargetStatus           The status returned by the SCSI target specified
+                                         by ScsiIo when the SCSI Request Packet was
+                                         executed on the SCSI Host Controller.
+                                         See the EFI SCSI I/O Protocol in the UEFI
+                                         Specification for details on the possible
+                                         return values. 
+  @param[in, out] InquiryDataBuffer      A pointer to inquiry data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If InquiryDataLength is 0, then this parameter
+                                         is optional and may be NULL. 
+  @param[in, out] InquiryDataLength      On input, a pointer to the length in bytes
+                                         of the InquiryDataBuffer buffer.
+                                         On output, a pointer to the number of bytes
+                                         written to the InquiryDataBuffer buffer.
+  @param[in]      EnableVitalProductData If TRUE, then the supported vital product
+                                         data for the PageCode is returned in InquiryDataBuffer.
+                                         If FALSE, then the standard inquiry data is
+                                         returned in InquiryDataBuffer and PageCode is ignored.
+  @param[in]      PageCode               The page code of the vital product data.
+                                         It's ignored if EnableVitalProductData is FALSE.
+
+  @retval EFI_SUCCESS                    The command executed successfully. See HostAdapterStatus,
+                                         TargetStatus, SenseDataLength, and SenseData in that order
+                                         for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE            The SCSI Request Packet was executed, but the entire
+                                         InquiryDataBuffer could not be transferred. The actual
+                                         number of bytes transferred is returned in InquiryDataLength.
+  @retval EFI_NOT_READY                  The SCSI Request Packet could not be sent because there
+                                         are too many SCSI Command Packets already queued.
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR               A device error occurred while attempting to send SCSI
+                                         Request Packet.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for additional
+                                         status information.
+  @retval EFI_UNSUPPORTED                The command described by the SCSI Request Packet is not
+                                         supported by the SCSI initiator(i.e., SCSI  Host Controller).
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available.
+  @retval EFI_TIMEOUT                    A timeout occurred while waiting for the SCSI Request
+                                         Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for
+                                         additional status information.
+  @retval EFI_INVALID_PARAMETER          The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiInquiryCommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *InquiryDataBuffer,    OPTIONAL
+  IN OUT UINT32                *InquiryDataLength,
+  IN     BOOLEAN               EnableVitalProductData,
+  IN     UINT8                 PageCode
+  );
+
+
+/**
+  Execute Mode Sense(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Mode Sense(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The DBDField, PageControl, and PageCode parameters
+  are used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo             A pointer to the SCSI I/O Protocol instance
+                                     for the specific SCSI target.
+  @param[in]      Timeout            The timeout in 100 ns units to use for the
+                                     execution of this SCSI Request Packet. A Timeout
+                                     value of zero means that this function will wait
+                                     indefinitely for the SCSI Request Packet to execute.
+                                     If Timeout is greater than zero, then this function
+                                     will return EFI_TIMEOUT if the time required to
+                                     execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out]  SenseData         A pointer to sense data that was generated
+                                     by the execution of the SCSI Request Packet.
+                                     This buffer must be allocated by the caller.
+                                     If SenseDataLength is 0, then this parameter
+                                     is optional and may be NULL.
+  @param[in, out]  SenseDataLength   On input, the length in bytes of the SenseData buffer.
+                                     On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus  The status of the SCSI Host Controller that
+                                     produces the SCSI bus containing the SCSI target
+                                     specified by ScsiIo when the SCSI Request Packet
+                                     was executed. See the EFI SCSI I/O Protocol in the
+                                     UEFI Specification for details on the possible
+                                     return values.
+  @param[out]     TargetStatus       The status returned by the SCSI target specified
+                                     by ScsiIo when the SCSI Request Packet was executed
+                                     on the SCSI Host Controller.  See the EFI SCSI
+                                     I/O Protocol in the UEFI Specification for details
+                                     on the possible return values.
+  @param[in, out]  DataBuffer        A pointer to data that was generated by the
+                                     execution of the SCSI Request Packet.  This
+                                     buffer must be allocated by the caller. If
+                                     DataLength is 0, then this parameter is optional
+                                     and may be NULL. 
+  @param[in, out]  DataLength        On input, a pointer to the length in bytes of
+                                     the DataBuffer buffer.  On output, a pointer
+                                     to the number of bytes written to the DataBuffer
+                                     buffer. 
+  @param[in]      DBDField           Specifies the DBD field of the CDB for this SCSI Command.
+  @param[in]      PageControl        Specifies the PC field of the CDB for this SCSI Command. 
+  @param[in]      PageCode           Specifies the Page Control field of the CDB for this SCSI Command. 
+
+  @retval EFI_SUCCESS                The command was executed successfully.
+                                     See HostAdapterStatus, TargetStatus, SenseDataLength,
+                                     and SenseData in that order for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE        The SCSI Request Packet was executed, but the
+                                     entire DataBuffer could not be transferred.
+                                     The actual number of bytes transferred is returned
+                                     in DataLength.
+  @retval EFI_NOT_READY              The SCSI Request Packet could not be sent because
+                                     there are too many SCSI Command Packets already queued.
+                                     The SCSI Request Packet was not sent, so no additional
+                                     status information is available.  The caller may retry
+                                     again later.
+  @retval EFI_DEVICE_ERROR           A device error occurred while attempting to send
+                                     SCSI Request Packet.  See HostAdapterStatus, TargetStatus,
+                                     SenseDataLength, and SenseData in that order for
+                                     additional status information.
+  @retval EFI_UNSUPPORTED            The command described by the SCSI Request Packet
+                                     is not supported by the SCSI initiator(i.e., SCSI
+                                     Host Controller). The SCSI Request Packet was not
+                                     sent, so no additional status information is available.
+  @retval EFI_TIMEOUT                A timeout occurred while waiting for the SCSI
+                                     Request Packet to execute.  See HostAdapterStatus,
+                                     TargetStatus, SenseDataLength, and SenseData in that
+                                     order for additional status information.
+  @retval EFI_INVALID_PARAMETER      The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiModeSense10Command (
+  IN     EFI_SCSI_IO_PROTOCOL    *ScsiIo,
+  IN     UINT64                  Timeout,
+  IN OUT VOID                    *SenseData,  OPTIONAL
+  IN OUT UINT8                   *SenseDataLength,
+     OUT UINT8                   *HostAdapterStatus,
+     OUT UINT8                   *TargetStatus,
+  IN OUT VOID                    *DataBuffer, OPTIONAL
+  IN OUT UINT32                  *DataLength,
+  IN     UINT8                   DBDField,    OPTIONAL
+  IN     UINT8                   PageControl,
+  IN     UINT8                   PageCode
+  );
+
+
+
+/**
+  Execute Request Sense SCSI command on a specific SCSI target.
+
+  Executes the Request Sense command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]       ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]       Timeout              The length of timeout period.
+  @param[in, out]  SenseData            A pointer to output sense data.
+  @param[in, out]  SenseDataLength      The length of output sense data.
+  @param[out]      HostAdapterStatus    The status of Host Adapter.
+  @param[out]      TargetStatus         The status of the target.
+
+  @retval EFI_SUCCESS                   Command is executed successfully.
+  @retval EFI_NOT_READY                 The SCSI Request Packet could not be sent because there are
+                                        too many SCSI Command Packets already queued.
+  @retval EFI_DEVICE_ERROR              A device error occurred while attempting to send SCSI Request Packet.
+  @retval EFI_UNSUPPORTED               The command described by the SCSI Request Packet is not supported by
+                                        the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval EFI_TIMEOUT                   A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval EFI_INVALID_PARAMETER         The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRequestSenseCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus
+  );
+
+
+/**
+  Execute Read Capacity SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read Capacity command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The Pmi parameter is used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      Pmi                  Partial medium indicator.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire
+                                       DataBuffer could not be transferred. The actual
+                                       number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because
+                                       there are too many SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet
+                                       is not supported by the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiReadCapacityCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,    OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,   OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     BOOLEAN               Pmi
+  );
+
+
+/**
+  Execute Read Capacity SCSI 16 command on a specific SCSI target.
+
+  Executes the SCSI Read Capacity 16 command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The Pmi parameter is used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      Pmi                  Partial medium indicator.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire
+                                       DataBuffer could not be transferred. The actual
+                                       number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because
+                                       there are too many SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet
+                                       is not supported by the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiReadCapacity16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer, OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     BOOLEAN               Pmi
+  );
+
+
+/**
+  Execute Read(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The StartLba and SectorSize parameters are used to
+  construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 10 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead10Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize
+  );
+
+
+/**
+  Execute Write(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Write(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The StartLba and SectorSize parameters are used to construct
+  the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite10Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize
+  );
+
+/**
+  Execute Read(16) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read(16) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The StartLba and SectorSize parameters are used to
+  construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize
+  );
+
+
+/**
+  Execute Write(16) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Write(16) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The StartLba and SectorSize parameters are used to construct
+  the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize
+  );
+
+
+/**
+  Execute blocking/non-blocking Read(10) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Read(10) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Read(10) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead10CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  );
+
+
+/**
+  Execute blocking/non-blocking Write(10) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Write(10) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Write(10) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite10CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  );
+
+
+/**
+  Execute blocking/non-blocking Read(16) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Read(16) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Read(16) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead16CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  );
+
+
+/**
+  Execute blocking/non-blocking Write(16) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Write(16) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Write(16) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite16CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Include/Library/UefiUsbLib.h b/MdePkg/Include/Library/UefiUsbLib.h
new file mode 100644
index 000000000000..a2eab6961125
--- /dev/null
+++ b/MdePkg/Include/Library/UefiUsbLib.h
@@ -0,0 +1,563 @@
+/** @file
+  Provides most USB APIs to support the Hid requests defined in USB Hid 1.1 spec
+  and the standard requests defined in USB 1.1 spec.
+
+Copyright (c) 2006 - 2008, 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 __USB_DXE_LIB_H__
+#define __USB_DXE_LIB_H__
+
+#include <Protocol/UsbIo.h>
+
+/**
+  Get the descriptor of the specified USB HID interface.
+
+  Submit a UsbGetHidDescriptor() request for the USB device specified by UsbIo
+  and Interface, and return the HID descriptor in HidDescriptor.
+  If UsbIo is NULL, then ASSERT().
+  If HidDescriptor is NULL, then ASSERT().
+
+  @param  UsbIo          A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface      The index of the HID interface on the USB target.
+  @param  HidDescriptor  Pointer to the USB HID descriptor that was retrieved from
+                         the specified USB target and interface. Type EFI_USB_HID_DESCRIPTOR
+                         is defined in the MDE Package Industry Standard include file Usb.h.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetHidDescriptor (
+  IN  EFI_USB_IO_PROTOCOL        *UsbIo,
+  IN  UINT8                      Interface,
+  OUT EFI_USB_HID_DESCRIPTOR     *HidDescriptor
+  );
+
+
+/**
+  Get the report descriptor of the specified USB HID interface.
+
+  Submit a USB get HID report descriptor request for the USB device specified by
+  UsbIo and Interface, and return the report descriptor in DescriptorBuffer.
+  If UsbIo is NULL, then ASSERT().
+  If DescriptorBuffer is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The index of the report interface on the USB target.
+  @param  DescriptorLength  The size, in bytes, of DescriptorBuffer.
+  @param  DescriptorBuffer  A pointer to the buffer to store the report class descriptor.
+
+  @retval  EFI_SUCCESS           The request executed successfully.
+  @retval  EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                 buffer specified by DescriptorLength and DescriptorBuffer
+                                 is not large enough to hold the result of the request.
+  @retval  EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR      The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetReportDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT16                  DescriptorLength,
+  OUT UINT8                   *DescriptorBuffer
+  );
+
+/**
+  Get the HID protocol of the specified USB HID interface.
+
+  Submit a USB get HID protocol request for the USB device specified by UsbIo
+  and Interface, and return the protocol retrieved in Protocol.
+  If UsbIo is NULL, then ASSERT().
+  If Protocol is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  Protocol   A pointer to the protocol for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetProtocolRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  OUT UINT8                   *Protocol
+  );
+
+/**
+  Set the HID protocol of the specified USB HID interface.
+
+  Submit a USB set HID protocol request for the USB device specified by UsbIo
+  and Interface, and set the protocol to the value specified by Protocol.
+  If UsbIo is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  Protocol   The protocol value to set for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetProtocolRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   Protocol
+  );
+
+/**
+  Set the idle rate of the specified USB HID report.
+
+  Submit a USB set HID report idle request for the USB device specified by UsbIo,
+  Interface, and ReportId, and set the idle rate to the value specified by Duration.
+  If UsbIo is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  ReportId   The identifier of the report to retrieve.
+  @param  Duration   The idle rate to set for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetIdleRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   ReportId,
+  IN UINT8                   Duration
+  );
+
+/**
+  Get the idle rate of the specified USB HID report.
+
+  Submit a USB get HID report idle request for the USB device specified by UsbIo,
+  Interface, and ReportId, and return the ide rate in Duration.
+  If UsbIo is NULL, then ASSERT().
+  If Duration is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  ReportId   The identifier of the report to retrieve.
+  @param  Duration   A pointer to the idle rate retrieved from the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetIdleRequest (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT8                   ReportId,
+  OUT UINT8                   *Duration
+  );
+
+/**
+  Set the report descriptor of the specified USB HID interface.
+
+  Submit a USB set HID report request for the USB device specified by UsbIo,
+  Interface, ReportId, and ReportType, and set the report descriptor using the
+  buffer specified by ReportLength and Report.
+  If UsbIo is NULL, then ASSERT().
+  If Report is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface     The index of the report interface on the USB target.
+  @param  ReportId      The identifier of the report to retrieve.
+  @param  ReportType    The type of report to retrieve.
+  @param  ReportLength  The size, in bytes, of Report.
+  @param  Report        A pointer to the report descriptor buffer to set.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetReportRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   ReportId,
+  IN UINT8                   ReportType,
+  IN UINT16                  ReportLen,
+  IN UINT8                   *Report
+  );
+
+/**
+  Get the report descriptor of the specified USB HID interface.
+
+  Submit a USB get HID report request for the USB device specified by UsbIo,
+  Interface, ReportId, and ReportType, and return the report in the buffer
+  specified by Report.
+  If UsbIo is NULL, then ASSERT().
+  If Report is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface     The index of the report interface on the USB target.
+  @param  ReportId      The identifier of the report to retrieve.
+  @param  ReportType    The type of report to retrieve.
+  @param  ReportLength  The size, in bytes, of Report.
+  @param  Report        A pointer to the buffer to store the report descriptor.
+
+  @retval  EFI_SUCCESS           The request executed successfully.
+  @retval  EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                 buffer specified by ReportLength and Report is not
+                                 large enough to hold the result of the request.
+  @retval  EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR      The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetReportRequest (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT8                   ReportId,
+  IN  UINT8                   ReportType,
+  IN  UINT16                  ReportLen,
+  OUT UINT8                   *Report
+  );
+
+/**
+  Get the descriptor of the specified USB device.
+
+  Submit a USB get descriptor request for the USB device specified by UsbIo, Value,
+  and Index, and return the descriptor in the buffer specified by Descriptor.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Descriptor is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Value             The device request value.
+  @param  Index             The device request index.
+  @param  DescriptorLength  The size, in bytes, of Descriptor.
+  @param  Descriptor        A pointer to the descriptor buffer to get.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS           The request executed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                buffer specified by DescriptorLength and Descriptor
+                                is not large enough to hold the result of the request.
+  @retval EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR      The request failed due to a device error. The transfer
+                                status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Value,
+  IN  UINT16                  Index,
+  IN  UINT16                  DescriptorLength,
+  OUT VOID                    *Descriptor,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Set the descriptor of the specified USB device.
+
+  Submit a USB set descriptor request for the USB device specified by UsbIo,
+  Value, and Index, and set the descriptor using the buffer specified by DesriptorLength
+  and Descriptor.  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Descriptor is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Value             The device request value.
+  @param  Index             The device request index.
+  @param  DescriptorLength  The size, in bytes, of Descriptor.
+  @param  Descriptor        A pointer to the descriptor buffer to set.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+                             The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Value,
+  IN  UINT16                  Index,
+  IN  UINT16                  DescriptorLength,
+  IN  VOID                    *Descriptor,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Get the interface setting of the specified USB device.
+
+  Submit a USB get interface request for the USB device specified by UsbIo,
+  and Interface, and place the result in the buffer specified by AlternateSetting.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If AlternateSetting is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The interface index value.
+  @param  AlternateSetting  A pointer to the alternate setting to be retrieved.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetInterface (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Interface,
+  OUT UINT16                  *AlternateSetting,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Set the interface setting of the specified USB device.
+
+  Submit a USB set interface request for the USB device specified by UsbIo, and
+  Interface, and set the alternate setting to the value specified by AlternateSetting.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The interface index value.
+  @param  AlternateSetting  The alternate setting to be set.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS  The request executed successfully.
+  @retval EFI_TIMEOUT  A timeout occurred executing the request.
+  @retval EFI_SUCCESS  The request failed due to a device error.
+                       The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetInterface (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Interface,
+  IN  UINT16                  AlternateSetting,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Get the device configuration.
+
+  Submit a USB get configuration request for the USB device specified by UsbIo
+  and place the result in the buffer specified by ConfigurationValue. The status
+  of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If ConfigurationValue is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo               A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  ConfigurationValue  A pointer to the device configuration to be retrieved.
+  @param  Status              A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS        The request executed successfully.
+  @retval EFI_TIMEOUT        A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR   The request failed due to a device error.
+                             The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetConfiguration (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  OUT UINT16                  *ConfigurationValue,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Set the device configuration.
+
+  Submit a USB set configuration request for the USB device specified by UsbIo
+  and set the device configuration to the value specified by ConfigurationValue.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo               A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  ConfigurationValue  The device configuration value to be set.
+  @param  Status              A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetConfiguration (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  ConfigurationValue,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Set the specified feature of the specified device.
+
+  Submit a USB set device feature request for the USB device specified by UsbIo,
+  Recipient, and Target to the value specified by Value.  The status of the
+  transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient  The USB data recipient type (i.e. Device, Interface, Endpoint).
+                     Type USB_TYPES_DEFINITION is defined in the MDE Package Industry
+                     Standard include file Usb.h.
+  @param  Value      The value of the feature to be set.
+  @param  Target     The index of the device to be set.
+  @param  Status     A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetFeature (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Value,
+  IN  UINT16                  Target,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Clear the specified feature of the specified device.
+
+  Submit a USB clear device feature request for the USB device specified by UsbIo,
+  Recipient, and Target to the value specified by Value.  The status of the transfer
+  is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient  The USB data recipient type (i.e. Device, Interface, Endpoint).
+                     Type USB_TYPES_DEFINITION is defined in the MDE Package Industry Standard
+                     include file Usb.h.
+  @param  Value      The value of the feature to be cleared.
+  @param  Target     The index of the device to be cleared.
+  @param  Status     A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbClearFeature (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Value,
+  IN  UINT16                  Target,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Get the status of the specified device.
+
+  Submit a USB device get status request for the USB device specified by UsbIo,
+  Recipient, and Target, and place the result in the buffer specified by DeviceStatus.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If DeviceStatus is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient     The USB data recipient type (i.e. Device, Interface, Endpoint).
+                        Type USB_TYPES_DEFINITION is defined in the MDE Package Industry Standard
+                        include file Usb.h.
+  @param  Target        The index of the device to be get the status of.
+  @param  DeviceStatus  A pointer to the device status to be retrieved.
+  @param  Status        A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetStatus (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Target,
+  OUT UINT16                  *DeviceStatus,
+  OUT UINT32                  *Status
+  );
+
+/**
+  Clear halt feature of the specified usb endpoint.
+
+  Retrieve the USB endpoint descriptor specified by UsbIo and EndPoint.
+  If the USB endpoint descriptor can not be retrieved, then return EFI_NOT_FOUND.
+  If the endpoint descriptor is found, then clear the halt feature of this USB endpoint.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo     A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Endpoint  The endpoint address.
+  @param  Status    A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+  @retval EFI_NOT_FOUND     The specified USB endpoint descriptor can not be found
+
+**/
+EFI_STATUS
+EFIAPI
+UsbClearEndpointHalt (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Endpoint,
+  OUT UINT32                  *Status
+  );
+
+#endif
diff --git a/MdePkg/Include/Pi/PiBootMode.h b/MdePkg/Include/Pi/PiBootMode.h
new file mode 100644
index 000000000000..793833bccd4e
--- /dev/null
+++ b/MdePkg/Include/Pi/PiBootMode.h
@@ -0,0 +1,42 @@
+/** @file
+  Present the boot mode values in PI.
+
+  Copyright (c) 2006 - 2012, 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.
+
+  @par Revision Reference:
+  PI Version 1.2.1A
+
+**/
+
+#ifndef __PI_BOOT_MODE_H__
+#define __PI_BOOT_MODE_H__
+
+///
+/// EFI boot mode
+///
+typedef UINT32  EFI_BOOT_MODE;
+
+//
+// 0x21 - 0xf..f are reserved.
+//
+#define BOOT_WITH_FULL_CONFIGURATION                  0x00
+#define BOOT_WITH_MINIMAL_CONFIGURATION               0x01
+#define BOOT_ASSUMING_NO_CONFIGURATION_CHANGES        0x02
+#define BOOT_WITH_FULL_CONFIGURATION_PLUS_DIAGNOSTICS 0x03
+#define BOOT_WITH_DEFAULT_SETTINGS                    0x04
+#define BOOT_ON_S4_RESUME                             0x05
+#define BOOT_ON_S5_RESUME                             0x06
+#define BOOT_WITH_MFG_MODE_SETTINGS                   0x07
+#define BOOT_ON_S2_RESUME                             0x10
+#define BOOT_ON_S3_RESUME                             0x11
+#define BOOT_ON_FLASH_UPDATE                          0x12
+#define BOOT_IN_RECOVERY_MODE                         0x20
+
+#endif
diff --git a/MdePkg/Include/Pi/PiDependency.h b/MdePkg/Include/Pi/PiDependency.h
new file mode 100644
index 000000000000..da2cfee5f50b
--- /dev/null
+++ b/MdePkg/Include/Pi/PiDependency.h
@@ -0,0 +1,47 @@
+/** @file
+  Present the dependency expression values in PI.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  PI Version 1.0
+
+**/
+#ifndef __PI_DEPENDENCY_H__
+#define __PI_DEPENDENCY_H__
+
+/// 
+/// If present, this must be the first and only opcode,
+/// EFI_DEP_BEFORE may be used by DXE and SMM drivers.
+/// 
+#define EFI_DEP_BEFORE        0x00
+
+/// 
+/// If present, this must be the first and only opcode,
+/// EFI_DEP_AFTER may be used by DXE and SMM drivers.
+/// 
+#define EFI_DEP_AFTER         0x01
+
+#define EFI_DEP_PUSH          0x02
+#define EFI_DEP_AND           0x03
+#define EFI_DEP_OR            0x04
+#define EFI_DEP_NOT           0x05
+#define EFI_DEP_TRUE          0x06
+#define EFI_DEP_FALSE         0x07
+#define EFI_DEP_END           0x08
+
+
+/// 
+/// If present, this must be the first opcode,
+/// EFI_DEP_SOR is only used by DXE driver.
+/// 
+#define EFI_DEP_SOR           0x09
+
+#endif 
diff --git a/MdePkg/Include/Pi/PiDxeCis.h b/MdePkg/Include/Pi/PiDxeCis.h
new file mode 100644
index 000000000000..5c157a8179e0
--- /dev/null
+++ b/MdePkg/Include/Pi/PiDxeCis.h
@@ -0,0 +1,740 @@
+/** @file
+  Include file matches things in PI.
+
+Copyright (c) 2006 - 2015, 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.             
+
+  @par Revision Reference:
+  PI Version 1.4
+
+**/
+
+#ifndef __PI_DXECIS_H__
+#define __PI_DXECIS_H__
+
+#include <Uefi/UefiMultiPhase.h>
+#include <Pi/PiMultiPhase.h>
+
+///
+/// Global Coherencey Domain types - Memory type.
+///
+typedef enum {
+  ///
+  /// A memory region that is visible to the boot processor. However, there are no system
+  /// components that are currently decoding this memory region.
+  ///
+  EfiGcdMemoryTypeNonExistent,
+  ///
+  /// A memory region that is visible to the boot processor. This memory region is being
+  /// decoded by a system component, but the memory region is not considered to be either
+  /// system memory or memory-mapped I/O.
+  ///
+  EfiGcdMemoryTypeReserved,
+  ///
+  /// A memory region that is visible to the boot processor. A memory controller is
+  /// currently decoding this memory region and the memory controller is producing a
+  /// tested system memory region that is available to the memory services.
+  ///
+  EfiGcdMemoryTypeSystemMemory,
+  ///
+  /// A memory region that is visible to the boot processor. This memory region is
+  /// currently being decoded by a component as memory-mapped I/O that can be used to
+  /// access I/O devices in the platform.
+  ///
+  EfiGcdMemoryTypeMemoryMappedIo,
+  ///
+  /// A memory region that is visible to the boot processor. 
+  /// This memory supports byte-addressable non-volatility. 
+  ///
+  EfiGcdMemoryTypePersistentMemory,
+  ///
+  /// A memory region that provides higher reliability relative to other memory in the
+  /// system. If all memory has the same reliability, then this bit is not used.
+  ///
+  EfiGcdMemoryTypeMoreReliable,
+  EfiGcdMemoryTypeMaximum
+} EFI_GCD_MEMORY_TYPE;
+
+///
+/// Global Coherencey Domain types - IO type.
+///
+typedef enum {
+  ///
+  /// An I/O region that is visible to the boot processor. However, there are no system
+  /// components that are currently decoding this I/O region.
+  ///
+  EfiGcdIoTypeNonExistent,
+  ///
+  /// An I/O region that is visible to the boot processor. This I/O region is currently being
+  /// decoded by a system component, but the I/O region cannot be used to access I/O devices.
+  ///
+  EfiGcdIoTypeReserved,
+  ///
+  /// An I/O region that is visible to the boot processor. This I/O region is currently being
+  /// decoded by a system component that is producing I/O ports that can be used to access I/O devices.
+  ///
+  EfiGcdIoTypeIo,
+  EfiGcdIoTypeMaximum
+} EFI_GCD_IO_TYPE;
+
+///
+/// The type of allocation to perform.
+/// 
+typedef enum {
+  ///
+  /// The GCD memory space map is searched from the lowest address up to the highest address
+  /// looking for unallocated memory ranges.
+  ///
+  EfiGcdAllocateAnySearchBottomUp,
+  ///
+  /// The GCD memory space map is searched from the lowest address up 
+  /// to the specified MaxAddress looking for unallocated memory ranges.
+  ///
+  EfiGcdAllocateMaxAddressSearchBottomUp,
+  ///
+  /// The GCD memory space map is checked to see if the memory range starting 
+  /// at the specified Address is available.
+  ///
+  EfiGcdAllocateAddress,
+  ///
+  /// The GCD memory space map is searched from the highest address down to the lowest address 
+  /// looking for unallocated memory ranges.
+  ///
+  EfiGcdAllocateAnySearchTopDown,
+  ///
+  /// The GCD memory space map is searched from the specified MaxAddress 
+  /// down to the lowest address looking for unallocated memory ranges.
+  ///
+  EfiGcdAllocateMaxAddressSearchTopDown,
+  EfiGcdMaxAllocateType
+} EFI_GCD_ALLOCATE_TYPE;
+
+///
+/// EFI_GCD_MEMORY_SPACE_DESCRIPTOR.
+/// 
+typedef struct {
+  ///
+  /// The physical address of the first byte in the memory region. Type
+  /// EFI_PHYSICAL_ADDRESS is defined in the AllocatePages() function
+  /// description in the UEFI 2.0 specification.
+  /// 
+  EFI_PHYSICAL_ADDRESS  BaseAddress;
+
+  ///
+  /// The number of bytes in the memory region.
+  /// 
+  UINT64                Length;
+
+  ///
+  /// The bit mask of attributes that the memory region is capable of supporting. The bit
+  /// mask of available attributes is defined in the GetMemoryMap() function description
+  /// in the UEFI 2.0 specification.
+  /// 
+  UINT64                Capabilities;
+  ///
+  /// The bit mask of attributes that the memory region is currently using. The bit mask of
+  /// available attributes is defined in GetMemoryMap().
+  /// 
+  UINT64                Attributes;
+  ///
+  /// Type of the memory region. Type EFI_GCD_MEMORY_TYPE is defined in the
+  /// AddMemorySpace() function description.
+  /// 
+  EFI_GCD_MEMORY_TYPE   GcdMemoryType;
+
+  ///
+  /// The image handle of the agent that allocated the memory resource described by
+  /// PhysicalStart and NumberOfBytes. If this field is NULL, then the memory
+  /// resource is not currently allocated. Type EFI_HANDLE is defined in
+  /// InstallProtocolInterface() in the UEFI 2.0 specification.
+  /// 
+  EFI_HANDLE            ImageHandle;
+
+  ///
+  /// The device handle for which the memory resource has been allocated. If
+  /// ImageHandle is NULL, then the memory resource is not currently allocated. If this
+  /// field is NULL, then the memory resource is not associated with a device that is
+  /// described by a device handle. Type EFI_HANDLE is defined in
+  /// InstallProtocolInterface() in the UEFI 2.0 specification.
+  /// 
+  EFI_HANDLE            DeviceHandle;
+} EFI_GCD_MEMORY_SPACE_DESCRIPTOR;
+
+///
+/// EFI_GCD_IO_SPACE_DESCRIPTOR.
+/// 
+typedef struct {
+  ///
+  /// Physical address of the first byte in the I/O region. Type
+  /// EFI_PHYSICAL_ADDRESS is defined in the AllocatePages() function
+  /// description in the UEFI 2.0 specification.
+  /// 
+  EFI_PHYSICAL_ADDRESS  BaseAddress;
+
+  ///
+  /// Number of bytes in the I/O region.
+  ///
+  UINT64                Length;
+
+  /// 
+  /// Type of the I/O region. Type EFI_GCD_IO_TYPE is defined in the
+  /// AddIoSpace() function description.
+  /// 
+  EFI_GCD_IO_TYPE       GcdIoType;
+
+  /// 
+  /// The image handle of the agent that allocated the I/O resource described by
+  /// PhysicalStart and NumberOfBytes. If this field is NULL, then the I/O
+  /// resource is not currently allocated. Type EFI_HANDLE is defined in
+  /// InstallProtocolInterface() in the UEFI 2.0 specification.
+  /// 
+  EFI_HANDLE            ImageHandle;
+
+  ///
+  /// The device handle for which the I/O resource has been allocated. If ImageHandle
+  /// is NULL, then the I/O resource is not currently allocated. If this field is NULL, then
+  /// the I/O resource is not associated with a device that is described by a device handle.
+  /// Type EFI_HANDLE is defined in InstallProtocolInterface() in the UEFI
+  /// 2.0 specification.
+  /// 
+  EFI_HANDLE            DeviceHandle;
+} EFI_GCD_IO_SPACE_DESCRIPTOR;
+
+
+/**
+  Adds reserved memory, system memory, or memory-mapped I/O resources to the
+  global coherency domain of the processor.
+
+  @param  GcdMemoryType    The type of memory resource being added.
+  @param  BaseAddress      The physical address that is the start address
+                           of the memory resource being added.
+  @param  Length           The size, in bytes, of the memory resource that
+                           is being added.
+  @param  Capabilities     The bit mask of attributes that the memory 
+                           resource region supports.
+
+  @retval EFI_SUCCESS            The memory resource was added to the global
+                                 coherency domain of the processor.
+  @retval EFI_INVALID_PARAMETER  GcdMemoryType is invalid.
+  @retval EFI_INVALID_PARAMETER  Length is zero.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough system resources to add
+                                 the memory resource to the global coherency 
+                                 domain of the processor.
+  @retval EFI_UNSUPPORTED        The processor does not support one or more bytes
+                                 of the memory resource range specified by 
+                                 BaseAddress and Length.
+  @retval EFI_ACCESS_DENIED      One or more bytes of the memory resource range
+                                 specified by BaseAddress and Length conflicts 
+                                 with a memory resource range that was previously
+                                 added to the global coherency domain of the processor.
+  @retval EFI_ACCESS_DENIED      One or more bytes of the memory resource range
+                                 specified by BaseAddress and Length was allocated
+                                 in a prior call to AllocateMemorySpace().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ADD_MEMORY_SPACE)(
+  IN EFI_GCD_MEMORY_TYPE   GcdMemoryType,
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length,
+  IN UINT64                Capabilities
+  );
+
+/**
+  Allocates nonexistent memory, reserved memory, system memory, or memorymapped
+  I/O resources from the global coherency domain of the processor.
+
+  @param  GcdAllocateType  The type of allocation to perform.
+  @param  GcdMemoryType    The type of memory resource being allocated.
+  @param  Alignment        The log base 2 of the boundary that BaseAddress must
+                           be aligned on output. Align with 2^Alignment.
+  @param  Length           The size in bytes of the memory resource range that
+                           is being allocated.
+  @param  BaseAddress      A pointer to a physical address to allocate.
+  @param  Imagehandle      The image handle of the agent that is allocating 
+                           the memory resource.
+  @param  DeviceHandle     The device handle for which the memory resource
+                           is being allocated.
+
+  @retval EFI_INVALID_PARAMETER GcdAllocateType is invalid.
+  @retval EFI_INVALID_PARAMETER GcdMemoryType is invalid.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_INVALID_PARAMETER BaseAddress is NULL.
+  @retval EFI_INVALID_PARAMETER ImageHandle is NULL.
+  @retval EFI_NOT_FOUND         The memory resource request could not be satisfied.
+                                No descriptor contains the desired space.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to allocate the memory
+                                resource from the global coherency domain of the processor.
+  @retval EFI_SUCCESS           The memory resource was allocated from the global coherency
+                                domain of the processor.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_MEMORY_SPACE)(
+  IN     EFI_GCD_ALLOCATE_TYPE               GcdAllocateType,
+  IN     EFI_GCD_MEMORY_TYPE                 GcdMemoryType,
+  IN     UINTN                               Alignment,
+  IN     UINT64                              Length,
+  IN OUT EFI_PHYSICAL_ADDRESS                *BaseAddress,
+  IN     EFI_HANDLE                          ImageHandle,
+  IN     EFI_HANDLE                          DeviceHandle OPTIONAL
+  );
+
+/**
+  Frees nonexistent memory, reserved memory, system memory, or memory-mapped
+  I/O resources from the global coherency domain of the processor.
+
+  @param  BaseAddress      The physical address that is the start address of the memory resource being freed.
+  @param  Length           The size in bytes of the memory resource range that is being freed.
+
+  @retval EFI_SUCCESS           The memory resource was freed from the global coherency domain of
+                                the processor.
+  @retval EFI_INVALID_PARAMETER Length is zero.   
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
+                                resource range specified by BaseAddress and Length.
+  @retval EFI_NOT_FOUND         The memory resource range specified by BaseAddress and
+                                Length was not allocated with previous calls to AllocateMemorySpace().
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to free the memory resource
+                                from the global coherency domain of the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_MEMORY_SPACE)(
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length
+  );
+
+/**
+  Removes reserved memory, system memory, or memory-mapped I/O resources from
+  the global coherency domain of the processor.
+
+  @param  BaseAddress      The physical address that is the start address of the memory resource being removed.
+  @param  Length           The size in bytes of the memory resource that is being removed.
+
+  @retval EFI_SUCCESS           The memory resource was removed from the global coherency
+                                domain of the processor.
+  @retval EFI_INVALID_PARAMETER Length is zero. 
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
+                                resource range specified by BaseAddress and Length.
+  @retval EFI_NOT_FOUND         One or more bytes of the memory resource range specified by
+                                BaseAddress and Length was not added with previous calls to
+                                AddMemorySpace().
+  @retval EFI_ACCESS_DEFINED    One or more bytes of the memory resource range specified by
+                                BaseAddress and Length has been allocated with AllocateMemorySpace().
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to remove the memory
+                                resource from the global coherency domain of the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REMOVE_MEMORY_SPACE)(
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length
+  );
+
+/**
+  Retrieves the descriptor for a memory region containing a specified address.
+
+  @param  BaseAddress      The physical address that is the start address of a memory region.
+  @param  Descriptor       A pointer to a caller allocated descriptor.
+
+  @retval EFI_SUCCESS           The descriptor for the memory resource region containing
+                                BaseAddress was returned in Descriptor.
+  @retval EFI_INVALID_PARAMETER Descriptor is NULL.
+  @retval EFI_NOT_FOUND         A memory resource range containing BaseAddress was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MEMORY_SPACE_DESCRIPTOR)(
+  IN  EFI_PHYSICAL_ADDRESS             BaseAddress,
+  OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *Descriptor
+  );
+
+/**
+  Modifies the attributes for a memory region in the global coherency domain of the
+  processor.
+
+  @param  BaseAddress      The physical address that is the start address of a memory region.
+  @param  Length           The size in bytes of the memory region.
+  @param  Attributes       The bit mask of attributes to set for the memory region.
+
+  @retval EFI_SUCCESS           The attributes were set for the memory region.
+  @retval EFI_INVALID_PARAMETER Length is zero. 
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
+                                resource range specified by BaseAddress and Length.
+  @retval EFI_UNSUPPORTED       The bit mask of attributes is not support for the memory resource
+                                range specified by BaseAddress and Length.
+  @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
+                                BaseAddress and Length cannot be modified.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
+                                the memory resource range.
+  @retval EFI_NOT_AVAILABLE_YET The attributes cannot be set because CPU architectural protocol is
+                                not available yet.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_MEMORY_SPACE_ATTRIBUTES)(
+  IN EFI_PHYSICAL_ADDRESS         BaseAddress,
+  IN UINT64                       Length,
+  IN UINT64                       Attributes
+  );
+
+/**
+  Modifies the capabilities for a memory region in the global coherency domain of the
+  processor.
+
+  @param  BaseAddress      The physical address that is the start address of a memory region.
+  @param  Length           The size in bytes of the memory region.
+  @param  Capabilities     The bit mask of capabilities that the memory region supports.
+
+  @retval EFI_SUCCESS           The capabilities were set for the memory region.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_UNSUPPORTED       The capabilities specified by Capabilities do not include the
+                                memory region attributes currently in use.
+  @retval EFI_ACCESS_DENIED     The capabilities for the memory resource range specified by
+                                BaseAddress and Length cannot be modified.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the capabilities
+                                of the memory resource range.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_MEMORY_SPACE_CAPABILITIES) (
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length,
+  IN UINT64                Capabilities
+  );
+
+/**
+  Returns a map of the memory resources in the global coherency domain of the
+  processor.
+
+  @param  NumberOfDescriptors A pointer to number of descriptors returned in the MemorySpaceMap buffer.
+  @param  MemorySpaceMap      A pointer to the array of EFI_GCD_MEMORY_SPACE_DESCRIPTORs.
+
+  @retval EFI_SUCCESS           The memory space map was returned in the MemorySpaceMap
+                                buffer, and the number of descriptors in MemorySpaceMap was
+                                returned in NumberOfDescriptors.
+  @retval EFI_INVALID_PARAMETER NumberOfDescriptors is NULL.
+  @retval EFI_INVALID_PARAMETER MemorySpaceMap is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate MemorySpaceMap.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MEMORY_SPACE_MAP)(
+  OUT UINTN                            *NumberOfDescriptors,
+  OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR  **MemorySpaceMap
+  );
+
+/**
+  Adds reserved I/O or I/O resources to the global coherency domain of the processor.
+
+  @param  GcdIoType        The type of I/O resource being added.
+  @param  BaseAddress      The physical address that is the start address of the I/O resource being added.
+  @param  Length           The size in bytes of the I/O resource that is being added.
+
+  @retval EFI_SUCCESS           The I/O resource was added to the global coherency domain of
+                                the processor.
+  @retval EFI_INVALID_PARAMETER GcdIoType is invalid.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to add the I/O resource to
+                                the global coherency domain of the processor.
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the I/O
+                                resource range specified by BaseAddress and Length.
+  @retval EFI_ACCESS_DENIED     One or more bytes of the I/O resource range specified by
+                                BaseAddress and Length conflicts with an I/O resource
+                                range that was previously added to the global coherency domain
+                                of the processor.
+  @retval EFI_ACCESS_DENIED     One or more bytes of the I/O resource range specified by
+                                BaseAddress and Length was allocated in a prior call to
+                                AllocateIoSpace().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ADD_IO_SPACE)(
+  IN EFI_GCD_IO_TYPE       GcdIoType,
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length
+  );
+
+/**
+  Allocates nonexistent I/O, reserved I/O, or I/O resources from the global coherency
+  domain of the processor.
+
+  @param  GcdAllocateType  The type of allocation to perform.
+  @param  GcdIoType        The type of I/O resource being allocated.
+  @param  Alignment        The log base 2 of the boundary that BaseAddress must be aligned on output.
+  @param  Length           The size in bytes of the I/O resource range that is being allocated.
+  @param  BaseAddress      A pointer to a physical address.
+  @param  Imagehandle      The image handle of the agent that is allocating the I/O resource.
+  @param  DeviceHandle     The device handle for which the I/O resource is being allocated.
+
+  @retval EFI_SUCCESS           The I/O resource was allocated from the global coherency domain
+                                of the processor.
+  @retval EFI_INVALID_PARAMETER GcdAllocateType is invalid.
+  @retval EFI_INVALID_PARAMETER GcdIoType is invalid.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_INVALID_PARAMETER BaseAddress is NULL.
+  @retval EFI_INVALID_PARAMETER ImageHandle is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to allocate the I/O
+                                resource from the global coherency domain of the processor.
+  @retval EFI_NOT_FOUND         The I/O resource request could not be satisfied.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_IO_SPACE)(
+  IN     EFI_GCD_ALLOCATE_TYPE               GcdAllocateType,
+  IN     EFI_GCD_IO_TYPE                     GcdIoType,
+  IN     UINTN                               Alignment,
+  IN     UINT64                              Length,
+  IN OUT EFI_PHYSICAL_ADDRESS                *BaseAddress,
+  IN     EFI_HANDLE                          ImageHandle,
+  IN     EFI_HANDLE                          DeviceHandle OPTIONAL
+  );
+
+/**
+  Frees nonexistent I/O, reserved I/O, or I/O resources from the global coherency
+  domain of the processor.
+
+  @param  BaseAddress      The physical address that is the start address of the I/O resource being freed.
+  @param  Length           The size in bytes of the I/O resource range that is being freed.
+
+  @retval EFI_SUCCESS           The I/O resource was freed from the global coherency domain of the
+                                processor.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the I/O resource
+                                range specified by BaseAddress and Length.
+  @retval EFI_NOT_FOUND         The I/O resource range specified by BaseAddress and Length
+                                was not allocated with previous calls to AllocateIoSpace().
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to free the I/O resource from
+                                the global coherency domain of the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_IO_SPACE)(
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length
+  );
+
+/**
+  Removes reserved I/O or I/O resources from the global coherency domain of the
+  processor.
+
+  @param  BaseAddress      A pointer to a physical address that is the start address of the I/O resource being
+                           removed.
+  @param Length            The size in bytes of the I/O resource that is being removed.
+
+  @retval EFI_SUCCESS           The I/O resource was removed from the global coherency domain
+                                of the processor.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the I/O
+                                resource range specified by BaseAddress and Length.
+  @retval EFI_NOT_FOUND         One or more bytes of the I/O resource range specified by
+                                BaseAddress and Length was not added with previous
+                                calls to AddIoSpace().
+  @retval EFI_ACCESS_DENIED     One or more bytes of the I/O resource range specified by
+                                BaseAddress and Length has been allocated with
+                                AllocateIoSpace().
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to remove the I/O
+                                resource from the global coherency domain of the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REMOVE_IO_SPACE)(
+  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
+  IN UINT64                Length
+  );
+
+/**
+  Retrieves the descriptor for an I/O region containing a specified address.
+
+  @param  BaseAddress      The physical address that is the start address of an I/O region.
+  @param  Descriptor       A pointer to a caller allocated descriptor.
+
+  @retval EFI_SUCCESS           The descriptor for the I/O resource region containing
+                                BaseAddress was returned in Descriptor.
+  @retval EFI_INVALID_PARAMETER Descriptor is NULL.
+  @retval EFI_NOT_FOUND         An I/O resource range containing BaseAddress was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_IO_SPACE_DESCRIPTOR)(
+  IN  EFI_PHYSICAL_ADDRESS         BaseAddress,
+  OUT EFI_GCD_IO_SPACE_DESCRIPTOR  *Descriptor
+  );
+
+/**
+  Returns a map of the I/O resources in the global coherency domain of the processor.
+
+  @param  NumberOfDescriptors A pointer to number of descriptors returned in the IoSpaceMap buffer.
+  @param  MemorySpaceMap      A pointer to the array of EFI_GCD_IO_SPACE_DESCRIPTORs.
+
+  @retval EFI_SUCCESS           The I/O space map was returned in the IoSpaceMap buffer, and
+                                the number of descriptors in IoSpaceMap was returned in
+                                NumberOfDescriptors.
+  @retval EFI_INVALID_PARAMETER NumberOfDescriptors is NULL.
+  @retval EFI_INVALID_PARAMETER IoSpaceMap is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate IoSpaceMap.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_IO_SPACE_MAP)(
+  OUT UINTN                        *NumberOfDescriptors,
+  OUT EFI_GCD_IO_SPACE_DESCRIPTOR  **IoSpaceMap
+  );
+
+
+
+/**
+  Loads and executed DXE drivers from firmware volumes.
+
+  The Dispatch() function searches for DXE drivers in firmware volumes that have been 
+  installed since the last time the Dispatch() service was called. It then evaluates 
+  the dependency expressions of all the DXE drivers and loads and executes those DXE
+  drivers whose dependency expression evaluate to TRUE. This service must interact with
+  the Security Architectural Protocol to authenticate DXE drivers before they are executed.
+  This process is continued until no more DXE drivers can be executed.
+
+  @retval EFI_SUCCESS         One or more DXE driver were dispatched.
+  @retval EFI_NOT_FOUND       No DXE drivers were dispatched.
+  @retval EFI_ALREADY_STARTED An attempt is being made to start the DXE Dispatcher recursively.
+                              Thus, no action was taken.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISPATCH)(
+  VOID
+  );
+
+/**
+  Clears the Schedule on Request (SOR) flag for a component that is stored in a firmware volume.
+
+  @param  FirmwareVolumeHandle The handle of the firmware volume that contains the file specified by FileName.
+  @param  FileName             A pointer to the name of the file in a firmware volume.
+
+  @retval EFI_SUCCESS         The DXE driver was found and its SOR bit was cleared.
+  @retval EFI_NOT_FOUND       The DXE driver does not exist, or the DXE driver exists and its SOR
+                              bit is not set.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCHEDULE)(
+  IN EFI_HANDLE  FirmwareVolumeHandle,
+  IN CONST EFI_GUID    *FileName
+  );
+
+/**
+  Promotes a file stored in a firmware volume from the untrusted to the trusted state.
+
+  @param  FirmwareVolumeHandle The handle of the firmware volume that contains the file specified by FileName.
+  @param  DriverName           A pointer to the name of the file in a firmware volume.
+
+  @return Status of promoting FFS from untrusted to trusted
+          state.
+  @retval EFI_NOT_FOUND       The file was not found in the untrusted state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TRUST)(
+  IN EFI_HANDLE  FirmwareVolumeHandle,
+  IN CONST EFI_GUID    *FileName
+  );
+
+/**
+  Creates a firmware volume handle for a firmware volume that is present in system memory.
+
+  @param  FirmwareVolumeHeader A pointer to the header of the firmware volume.
+  @param  Size                 The size, in bytes, of the firmware volume.
+  @param  FirmwareVolumeHandle On output, a pointer to the created handle.
+
+  @retval EFI_SUCCESS          The EFI_FIRMWARE_VOLUME_PROTOCOL and
+                               EFI_DEVICE_PATH_PROTOCOL were installed onto
+                               FirmwareVolumeHandle for the firmware volume described
+                               by FirmwareVolumeHeader and Size.
+  @retval EFI_VOLUME_CORRUPTED The firmware volume described by FirmwareVolumeHeader
+                               and Size is corrupted.
+  @retval EFI_OUT_OF_RESOURCES There are not enough system resources available to produce the
+                               EFI_FIRMWARE_VOLUME_PROTOCOL and EFI_DEVICE_PATH_PROTOCOL 
+                               for the firmware volume described by FirmwareVolumeHeader and Size.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PROCESS_FIRMWARE_VOLUME)(
+  IN CONST VOID                       *FirmwareVolumeHeader,
+  IN UINTN                            Size,
+  OUT EFI_HANDLE                      *FirmwareVolumeHandle
+  );
+
+//
+// DXE Services Table
+//
+#define DXE_SERVICES_SIGNATURE            0x565245535f455844ULL
+#define DXE_SPECIFICATION_MAJOR_REVISION  1
+#define DXE_SPECIFICATION_MINOR_REVISION  40
+#define DXE_SERVICES_REVISION             ((DXE_SPECIFICATION_MAJOR_REVISION<<16) | (DXE_SPECIFICATION_MINOR_REVISION))
+
+typedef struct {
+  ///
+  /// The table header for the DXE Services Table.
+  /// This header contains the DXE_SERVICES_SIGNATURE and DXE_SERVICES_REVISION values.
+  ///
+  EFI_TABLE_HEADER                Hdr;
+
+  //
+  // Global Coherency Domain Services
+  //
+  EFI_ADD_MEMORY_SPACE            AddMemorySpace;
+  EFI_ALLOCATE_MEMORY_SPACE       AllocateMemorySpace;
+  EFI_FREE_MEMORY_SPACE           FreeMemorySpace;
+  EFI_REMOVE_MEMORY_SPACE         RemoveMemorySpace;
+  EFI_GET_MEMORY_SPACE_DESCRIPTOR GetMemorySpaceDescriptor;
+  EFI_SET_MEMORY_SPACE_ATTRIBUTES SetMemorySpaceAttributes;
+  EFI_GET_MEMORY_SPACE_MAP        GetMemorySpaceMap;
+  EFI_ADD_IO_SPACE                AddIoSpace;
+  EFI_ALLOCATE_IO_SPACE           AllocateIoSpace;
+  EFI_FREE_IO_SPACE               FreeIoSpace;
+  EFI_REMOVE_IO_SPACE             RemoveIoSpace;
+  EFI_GET_IO_SPACE_DESCRIPTOR     GetIoSpaceDescriptor;
+  EFI_GET_IO_SPACE_MAP            GetIoSpaceMap;
+
+  //
+  // Dispatcher Services
+  //
+  EFI_DISPATCH                    Dispatch;
+  EFI_SCHEDULE                    Schedule;
+  EFI_TRUST                       Trust;
+  //
+  // Service to process a single firmware volume found in a capsule
+  //
+  EFI_PROCESS_FIRMWARE_VOLUME     ProcessFirmwareVolume;
+  //
+  // Extensions to Global Coherency Domain Services
+  //
+  EFI_SET_MEMORY_SPACE_CAPABILITIES SetMemorySpaceCapabilities;
+} DXE_SERVICES;
+
+typedef DXE_SERVICES EFI_DXE_SERVICES;
+
+#endif
diff --git a/MdePkg/Include/Pi/PiFirmwareFile.h b/MdePkg/Include/Pi/PiFirmwareFile.h
new file mode 100644
index 000000000000..5591608baf1c
--- /dev/null
+++ b/MdePkg/Include/Pi/PiFirmwareFile.h
@@ -0,0 +1,494 @@
+/** @file
+  The firmware file related definitions in PI.
+
+Copyright (c) 2006 - 2015, 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.
+
+  @par Revision Reference:
+  PI Version 1.4.
+
+**/
+
+
+#ifndef __PI_FIRMWARE_FILE_H__
+#define __PI_FIRMWARE_FILE_H__
+
+#pragma pack(1)
+///
+/// Used to verify the integrity of the file.
+///
+typedef union {
+  struct {
+    ///
+    /// The IntegrityCheck.Checksum.Header field is an 8-bit checksum of the file
+    /// header. The State and IntegrityCheck.Checksum.File fields are assumed
+    /// to be zero and the checksum is calculated such that the entire header sums to zero.
+    ///
+    UINT8   Header;
+    ///
+    /// If the FFS_ATTRIB_CHECKSUM (see definition below) bit of the Attributes
+    /// field is set to one, the IntegrityCheck.Checksum.File field is an 8-bit
+    /// checksum of the file data.
+    /// If the FFS_ATTRIB_CHECKSUM bit of the Attributes field is cleared to zero,
+    /// the IntegrityCheck.Checksum.File field must be initialized with a value of
+    /// 0xAA. The IntegrityCheck.Checksum.File field is valid any time the
+    /// EFI_FILE_DATA_VALID bit is set in the State field.
+    ///
+    UINT8   File;
+  } Checksum;
+  ///
+  /// This is the full 16 bits of the IntegrityCheck field.
+  ///
+  UINT16    Checksum16;
+} EFI_FFS_INTEGRITY_CHECK;
+
+///
+/// FFS_FIXED_CHECKSUM is the checksum value used when the
+/// FFS_ATTRIB_CHECKSUM attribute bit is clear.
+///
+#define FFS_FIXED_CHECKSUM  0xAA
+
+typedef UINT8 EFI_FV_FILETYPE;
+typedef UINT8 EFI_FFS_FILE_ATTRIBUTES;
+typedef UINT8 EFI_FFS_FILE_STATE;
+
+///
+/// File Types Definitions
+///
+#define EFI_FV_FILETYPE_ALL                   0x00
+#define EFI_FV_FILETYPE_RAW                   0x01
+#define EFI_FV_FILETYPE_FREEFORM              0x02
+#define EFI_FV_FILETYPE_SECURITY_CORE         0x03
+#define EFI_FV_FILETYPE_PEI_CORE              0x04
+#define EFI_FV_FILETYPE_DXE_CORE              0x05
+#define EFI_FV_FILETYPE_PEIM                  0x06
+#define EFI_FV_FILETYPE_DRIVER                0x07
+#define EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER  0x08
+#define EFI_FV_FILETYPE_APPLICATION           0x09
+#define EFI_FV_FILETYPE_SMM                   0x0A
+#define EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE 0x0B
+#define EFI_FV_FILETYPE_COMBINED_SMM_DXE      0x0C
+#define EFI_FV_FILETYPE_SMM_CORE              0x0D
+#define EFI_FV_FILETYPE_OEM_MIN               0xc0
+#define EFI_FV_FILETYPE_OEM_MAX               0xdf
+#define EFI_FV_FILETYPE_DEBUG_MIN             0xe0
+#define EFI_FV_FILETYPE_DEBUG_MAX             0xef
+#define EFI_FV_FILETYPE_FFS_MIN               0xf0
+#define EFI_FV_FILETYPE_FFS_MAX               0xff
+#define EFI_FV_FILETYPE_FFS_PAD               0xf0
+///
+/// FFS File Attributes.
+///
+#define FFS_ATTRIB_LARGE_FILE         0x01
+#define FFS_ATTRIB_FIXED              0x04
+#define FFS_ATTRIB_DATA_ALIGNMENT     0x38
+#define FFS_ATTRIB_CHECKSUM           0x40
+
+///
+/// FFS File State Bits.
+///
+#define EFI_FILE_HEADER_CONSTRUCTION  0x01
+#define EFI_FILE_HEADER_VALID         0x02
+#define EFI_FILE_DATA_VALID           0x04
+#define EFI_FILE_MARKED_FOR_UPDATE    0x08
+#define EFI_FILE_DELETED              0x10
+#define EFI_FILE_HEADER_INVALID       0x20
+
+
+///
+/// Each file begins with the header that describe the
+/// contents and state of the files.
+///
+typedef struct {
+  ///
+  /// This GUID is the file name. It is used to uniquely identify the file.
+  ///
+  EFI_GUID                Name;
+  ///
+  /// Used to verify the integrity of the file.
+  ///
+  EFI_FFS_INTEGRITY_CHECK IntegrityCheck;
+  ///
+  /// Identifies the type of file.
+  ///
+  EFI_FV_FILETYPE         Type;
+  ///
+  /// Declares various file attribute bits.
+  ///
+  EFI_FFS_FILE_ATTRIBUTES Attributes;
+  ///
+  /// The length of the file in bytes, including the FFS header.
+  ///
+  UINT8                   Size[3];
+  ///
+  /// Used to track the state of the file throughout the life of the file from creation to deletion.
+  ///
+  EFI_FFS_FILE_STATE      State;
+} EFI_FFS_FILE_HEADER;
+
+typedef struct {
+  ///
+  /// This GUID is the file name. It is used to uniquely identify the file. There may be only
+  /// one instance of a file with the file name GUID of Name in any given firmware
+  /// volume, except if the file type is EFI_FV_FILETYPE_FFS_PAD.
+  ///
+  EFI_GUID                  Name;
+
+  ///
+  /// Used to verify the integrity of the file.
+  ///
+  EFI_FFS_INTEGRITY_CHECK   IntegrityCheck;
+
+  ///
+  /// Identifies the type of file.
+  ///
+  EFI_FV_FILETYPE           Type;
+
+  ///
+  /// Declares various file attribute bits.
+  ///
+  EFI_FFS_FILE_ATTRIBUTES   Attributes;
+
+  ///
+  /// The length of the file in bytes, including the FFS header.
+  /// The length of the file data is either (Size - sizeof(EFI_FFS_FILE_HEADER)). This calculation means a
+  /// zero-length file has a Size of 24 bytes, which is sizeof(EFI_FFS_FILE_HEADER).
+  /// Size is not required to be a multiple of 8 bytes. Given a file F, the next file header is
+  /// located at the next 8-byte aligned firmware volume offset following the last byte of the file F.
+  ///
+  UINT8                     Size[3];
+
+  ///
+  /// Used to track the state of the file throughout the life of the file from creation to deletion.
+  ///
+  EFI_FFS_FILE_STATE        State;
+
+  ///
+  /// If FFS_ATTRIB_LARGE_FILE is set in Attributes, then ExtendedSize exists and Size must be set to zero.
+  /// If FFS_ATTRIB_LARGE_FILE is not set then EFI_FFS_FILE_HEADER is used.
+  ///
+  UINT64                    ExtendedSize;
+} EFI_FFS_FILE_HEADER2;
+
+#define IS_FFS_FILE2(FfsFileHeaderPtr) \
+    (((((EFI_FFS_FILE_HEADER *) (UINTN) FfsFileHeaderPtr)->Attributes) & FFS_ATTRIB_LARGE_FILE) == FFS_ATTRIB_LARGE_FILE)
+
+#define FFS_FILE_SIZE(FfsFileHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_FFS_FILE_HEADER *) (UINTN) FfsFileHeaderPtr)->Size) & 0x00ffffff))
+
+#define FFS_FILE2_SIZE(FfsFileHeaderPtr) \
+    ((UINT32) (((EFI_FFS_FILE_HEADER2 *) (UINTN) FfsFileHeaderPtr)->ExtendedSize))
+
+typedef UINT8 EFI_SECTION_TYPE;
+
+///
+/// Pseudo type. It is used as a wild card when retrieving sections.
+///  The section type EFI_SECTION_ALL matches all section types.
+///
+#define EFI_SECTION_ALL                   0x00
+
+///
+/// Encapsulation section Type values.
+///
+#define EFI_SECTION_COMPRESSION           0x01
+
+#define EFI_SECTION_GUID_DEFINED          0x02
+
+#define EFI_SECTION_DISPOSABLE            0x03
+
+///
+/// Leaf section Type values.
+///
+#define EFI_SECTION_PE32                  0x10
+#define EFI_SECTION_PIC                   0x11
+#define EFI_SECTION_TE                    0x12
+#define EFI_SECTION_DXE_DEPEX             0x13
+#define EFI_SECTION_VERSION               0x14
+#define EFI_SECTION_USER_INTERFACE        0x15
+#define EFI_SECTION_COMPATIBILITY16       0x16
+#define EFI_SECTION_FIRMWARE_VOLUME_IMAGE 0x17
+#define EFI_SECTION_FREEFORM_SUBTYPE_GUID 0x18
+#define EFI_SECTION_RAW                   0x19
+#define EFI_SECTION_PEI_DEPEX             0x1B
+#define EFI_SECTION_SMM_DEPEX             0x1C
+
+///
+/// Common section header.
+///
+typedef struct {
+  ///
+  /// A 24-bit unsigned integer that contains the total size of the section in bytes,
+  /// including the EFI_COMMON_SECTION_HEADER.
+  ///
+  UINT8             Size[3];
+  EFI_SECTION_TYPE  Type;
+  ///
+  /// Declares the section type.
+  ///
+} EFI_COMMON_SECTION_HEADER;
+
+typedef struct {
+  ///
+  /// A 24-bit unsigned integer that contains the total size of the section in bytes,
+  /// including the EFI_COMMON_SECTION_HEADER.
+  ///
+  UINT8             Size[3];
+
+  EFI_SECTION_TYPE  Type;
+
+  ///
+  /// If Size is 0xFFFFFF, then ExtendedSize contains the size of the section. If
+  /// Size is not equal to 0xFFFFFF, then this field does not exist.
+  ///
+  UINT32            ExtendedSize;
+} EFI_COMMON_SECTION_HEADER2;
+
+///
+/// Leaf section type that contains an
+/// IA-32 16-bit executable image.
+///
+typedef EFI_COMMON_SECTION_HEADER  EFI_COMPATIBILITY16_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2 EFI_COMPATIBILITY16_SECTION2;
+
+///
+/// CompressionType of EFI_COMPRESSION_SECTION.
+///
+#define EFI_NOT_COMPRESSED        0x00
+#define EFI_STANDARD_COMPRESSION  0x01
+///
+/// An encapsulation section type in which the
+/// section data is compressed.
+///
+typedef struct {
+  ///
+  /// Usual common section header. CommonHeader.Type = EFI_SECTION_COMPRESSION.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// The UINT32 that indicates the size of the section data after decompression.
+  ///
+  UINT32                      UncompressedLength;
+  ///
+  /// Indicates which compression algorithm is used.
+  ///
+  UINT8                       CompressionType;
+} EFI_COMPRESSION_SECTION;
+
+typedef struct {
+  ///
+  /// Usual common section header. CommonHeader.Type = EFI_SECTION_COMPRESSION.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// UINT32 that indicates the size of the section data after decompression.
+  ///
+  UINT32                        UncompressedLength;
+  ///
+  /// Indicates which compression algorithm is used.
+  ///
+  UINT8                         CompressionType;
+} EFI_COMPRESSION_SECTION2;
+
+///
+/// An encapsulation section type in which the section data is disposable.
+/// A disposable section is an encapsulation section in which the section data may be disposed of during
+/// the process of creating or updating a firmware image without significant impact on the usefulness of
+/// the file. The Type field in the section header is set to EFI_SECTION_DISPOSABLE. This
+/// allows optional or descriptive data to be included with the firmware file which can be removed in
+/// order to conserve space. The contents of this section are implementation specific, but might contain
+/// debug data or detailed integration instructions.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_DISPOSABLE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_DISPOSABLE_SECTION2;
+
+///
+/// The leaf section which could be used to determine the dispatch order of DXEs.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_DXE_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_DXE_DEPEX_SECTION2;
+
+///
+/// The leaf section which contains a PI FV.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_FIRMWARE_VOLUME_IMAGE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_FIRMWARE_VOLUME_IMAGE_SECTION2;
+
+///
+/// The leaf section which contains a single GUID.
+///
+typedef struct {
+  ///
+  /// Common section header. CommonHeader.Type = EFI_SECTION_FREEFORM_SUBTYPE_GUID.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// This GUID is defined by the creator of the file. It is a vendor-defined file type.
+  ///
+  EFI_GUID                    SubTypeGuid;
+} EFI_FREEFORM_SUBTYPE_GUID_SECTION;
+
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_FREEFORM_SUBTYPE_GUID.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// This GUID is defined by the creator of the file. It is a vendor-defined file type.
+  ///
+  EFI_GUID                      SubTypeGuid;
+} EFI_FREEFORM_SUBTYPE_GUID_SECTION2;
+
+///
+/// Attributes of EFI_GUID_DEFINED_SECTION.
+///
+#define EFI_GUIDED_SECTION_PROCESSING_REQUIRED  0x01
+#define EFI_GUIDED_SECTION_AUTH_STATUS_VALID    0x02
+///
+/// The leaf section which is encapsulation defined by specific GUID.
+///
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_GUID_DEFINED.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// The GUID that defines the format of the data that follows. It is a vendor-defined section type.
+  ///
+  EFI_GUID                    SectionDefinitionGuid;
+  ///
+  /// Contains the offset in bytes from the beginning of the common header to the first byte of the data.
+  ///
+  UINT16                      DataOffset;
+  ///
+  /// The bit field that declares some specific characteristics of the section contents.
+  ///
+  UINT16                      Attributes;
+} EFI_GUID_DEFINED_SECTION;
+
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_GUID_DEFINED.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// The GUID that defines the format of the data that follows. It is a vendor-defined section type.
+  ///
+  EFI_GUID                      SectionDefinitionGuid;
+  ///
+  /// Contains the offset in bytes from the beginning of the common header to the first byte of the data.
+  ///
+  UINT16                        DataOffset;
+  ///
+  /// The bit field that declares some specific characteristics of the section contents.
+  ///
+  UINT16                        Attributes;
+} EFI_GUID_DEFINED_SECTION2;
+
+///
+/// The leaf section which contains PE32+ image.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PE32_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PE32_SECTION2;
+
+///
+/// The leaf section used to determine the dispatch order of PEIMs.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PEI_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PEI_DEPEX_SECTION2;
+
+///
+/// A leaf section type that contains a position-independent-code (PIC) image.
+/// A PIC image section is a leaf section that contains a position-independent-code (PIC) image.
+/// In addition to normal PE32+ images that contain relocation information, PEIM executables may be
+/// PIC and are referred to as PIC images. A PIC image is the same as a PE32+ image except that all
+/// relocation information has been stripped from the image and the image can be moved and will
+/// execute correctly without performing any relocation or other fix-ups. EFI_PIC_SECTION2 must
+/// be used if the section is 16MB or larger.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PIC_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PIC_SECTION2;
+
+///
+/// The leaf section which constains the position-independent-code image.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_TE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_TE_SECTION2;
+
+///
+/// The leaf section which contains an array of zero or more bytes.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_RAW_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_RAW_SECTION2;
+
+///
+/// The SMM dependency expression section is a leaf section that contains a dependency expression that
+/// is used to determine the dispatch order for SMM drivers. Before the SMRAM invocation of the
+/// SMM driver's entry point, this dependency expression must evaluate to TRUE. See the Platform
+/// Initialization Specification, Volume 2, for details regarding the format of the dependency expression.
+/// The dependency expression may refer to protocols installed in either the UEFI or the SMM protocol
+/// database. EFI_SMM_DEPEX_SECTION2 must be used if the section is 16MB or larger.
+///
+typedef EFI_COMMON_SECTION_HEADER EFI_SMM_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2 EFI_SMM_DEPEX_SECTION2;
+
+///
+/// The leaf section which contains a unicode string that
+/// is human readable file name.
+///
+typedef struct {
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+
+  ///
+  /// Array of unicode string.
+  ///
+  CHAR16                      FileNameString[1];
+} EFI_USER_INTERFACE_SECTION;
+
+typedef struct {
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  CHAR16                        FileNameString[1];
+} EFI_USER_INTERFACE_SECTION2;
+
+///
+/// The leaf section which contains a numeric build number and
+/// an optional unicode string that represents the file revision.
+///
+typedef struct {
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  UINT16                      BuildNumber;
+
+  ///
+  /// Array of unicode string.
+  ///
+  CHAR16                      VersionString[1];
+} EFI_VERSION_SECTION;
+
+typedef struct {
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// A UINT16 that represents a particular build. Subsequent builds have monotonically
+  /// increasing build numbers relative to earlier builds.
+  ///
+  UINT16                        BuildNumber;
+  CHAR16                        VersionString[1];
+} EFI_VERSION_SECTION2;
+
+#define IS_SECTION2(SectionHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) (UINTN) SectionHeaderPtr)->Size) & 0x00ffffff) == 0x00ffffff)
+
+#define SECTION_SIZE(SectionHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) (UINTN) SectionHeaderPtr)->Size) & 0x00ffffff))
+
+#define SECTION2_SIZE(SectionHeaderPtr) \
+    (((EFI_COMMON_SECTION_HEADER2 *) (UINTN) SectionHeaderPtr)->ExtendedSize)
+
+#pragma pack()
+
+#endif
+
diff --git a/MdePkg/Include/Pi/PiFirmwareVolume.h b/MdePkg/Include/Pi/PiFirmwareVolume.h
new file mode 100644
index 000000000000..6ef2f1fc33f3
--- /dev/null
+++ b/MdePkg/Include/Pi/PiFirmwareVolume.h
@@ -0,0 +1,234 @@
+/** @file
+  The firmware volume related definitions in PI.
+
+  Copyright (c) 2006 - 2013, 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.
+
+  @par Revision Reference:
+  PI Version 1.3
+
+**/
+
+#ifndef __PI_FIRMWAREVOLUME_H__
+#define __PI_FIRMWAREVOLUME_H__
+
+///
+/// EFI_FV_FILE_ATTRIBUTES
+///
+typedef UINT32  EFI_FV_FILE_ATTRIBUTES;
+
+//
+// Value of EFI_FV_FILE_ATTRIBUTES.
+//
+#define EFI_FV_FILE_ATTRIB_ALIGNMENT      0x0000001F
+#define EFI_FV_FILE_ATTRIB_FIXED          0x00000100
+#define EFI_FV_FILE_ATTRIB_MEMORY_MAPPED  0x00000200
+
+///
+/// type of EFI FVB attribute
+///
+typedef UINT32  EFI_FVB_ATTRIBUTES_2;
+
+//
+// Attributes bit definitions
+//
+#define EFI_FVB2_READ_DISABLED_CAP  0x00000001
+#define EFI_FVB2_READ_ENABLED_CAP   0x00000002
+#define EFI_FVB2_READ_STATUS        0x00000004
+#define EFI_FVB2_WRITE_DISABLED_CAP 0x00000008
+#define EFI_FVB2_WRITE_ENABLED_CAP  0x00000010
+#define EFI_FVB2_WRITE_STATUS       0x00000020
+#define EFI_FVB2_LOCK_CAP           0x00000040
+#define EFI_FVB2_LOCK_STATUS        0x00000080
+#define EFI_FVB2_STICKY_WRITE       0x00000200
+#define EFI_FVB2_MEMORY_MAPPED      0x00000400
+#define EFI_FVB2_ERASE_POLARITY     0x00000800
+#define EFI_FVB2_READ_LOCK_CAP      0x00001000
+#define EFI_FVB2_READ_LOCK_STATUS   0x00002000
+#define EFI_FVB2_WRITE_LOCK_CAP     0x00004000
+#define EFI_FVB2_WRITE_LOCK_STATUS  0x00008000
+#define EFI_FVB2_ALIGNMENT          0x001F0000
+#define EFI_FVB2_ALIGNMENT_1        0x00000000
+#define EFI_FVB2_ALIGNMENT_2        0x00010000
+#define EFI_FVB2_ALIGNMENT_4        0x00020000
+#define EFI_FVB2_ALIGNMENT_8        0x00030000
+#define EFI_FVB2_ALIGNMENT_16       0x00040000
+#define EFI_FVB2_ALIGNMENT_32       0x00050000
+#define EFI_FVB2_ALIGNMENT_64       0x00060000
+#define EFI_FVB2_ALIGNMENT_128      0x00070000
+#define EFI_FVB2_ALIGNMENT_256      0x00080000
+#define EFI_FVB2_ALIGNMENT_512      0x00090000
+#define EFI_FVB2_ALIGNMENT_1K       0x000A0000
+#define EFI_FVB2_ALIGNMENT_2K       0x000B0000
+#define EFI_FVB2_ALIGNMENT_4K       0x000C0000
+#define EFI_FVB2_ALIGNMENT_8K       0x000D0000
+#define EFI_FVB2_ALIGNMENT_16K      0x000E0000
+#define EFI_FVB2_ALIGNMENT_32K      0x000F0000
+#define EFI_FVB2_ALIGNMENT_64K      0x00100000
+#define EFI_FVB2_ALIGNMENT_128K     0x00110000
+#define EFI_FVB2_ALIGNMENT_256K     0x00120000
+#define EFI_FVB2_ALIGNMENT_512K     0x00130000
+#define EFI_FVB2_ALIGNMENT_1M       0x00140000
+#define EFI_FVB2_ALIGNMENT_2M       0x00150000
+#define EFI_FVB2_ALIGNMENT_4M       0x00160000
+#define EFI_FVB2_ALIGNMENT_8M       0x00170000
+#define EFI_FVB2_ALIGNMENT_16M      0x00180000
+#define EFI_FVB2_ALIGNMENT_32M      0x00190000
+#define EFI_FVB2_ALIGNMENT_64M      0x001A0000
+#define EFI_FVB2_ALIGNMENT_128M     0x001B0000
+#define EFI_FVB2_ALIGNMENT_256M     0x001C0000
+#define EFI_FVB2_ALIGNMENT_512M     0x001D0000
+#define EFI_FVB2_ALIGNMENT_1G       0x001E0000
+#define EFI_FVB2_ALIGNMENT_2G       0x001F0000
+#define EFI_FVB2_WEAK_ALIGNMENT     0x80000000
+
+typedef struct {
+  ///
+  /// The number of sequential blocks which are of the same size.
+  ///
+  UINT32 NumBlocks;
+  ///
+  /// The size of the blocks.
+  ///
+  UINT32 Length;
+} EFI_FV_BLOCK_MAP_ENTRY;
+
+///
+/// Describes the features and layout of the firmware volume.
+///
+typedef struct {
+  ///
+  /// The first 16 bytes are reserved to allow for the reset vector of
+  /// processors whose reset vector is at address 0.
+  ///
+  UINT8                     ZeroVector[16];
+  ///
+  /// Declares the file system with which the firmware volume is formatted.
+  ///
+  EFI_GUID                  FileSystemGuid;
+  ///
+  /// Length in bytes of the complete firmware volume, including the header.
+  ///
+  UINT64                    FvLength;
+  ///
+  /// Set to EFI_FVH_SIGNATURE
+  ///
+  UINT32                    Signature;
+  ///
+  /// Declares capabilities and power-on defaults for the firmware volume.
+  ///
+  EFI_FVB_ATTRIBUTES_2      Attributes;
+  ///
+  /// Length in bytes of the complete firmware volume header.
+  ///
+  UINT16                    HeaderLength;
+  ///
+  /// A 16-bit checksum of the firmware volume header. A valid header sums to zero.
+  ///
+  UINT16                    Checksum;
+  ///
+  /// Offset, relative to the start of the header, of the extended header
+  /// (EFI_FIRMWARE_VOLUME_EXT_HEADER) or zero if there is no extended header.
+  ///
+  UINT16                    ExtHeaderOffset;
+  ///
+  /// This field must always be set to zero.
+  ///
+  UINT8                     Reserved[1];
+  ///
+  /// Set to 2. Future versions of this specification may define new header fields and will
+  /// increment the Revision field accordingly.
+  ///
+  UINT8                     Revision;
+  ///
+  /// An array of run-length encoded FvBlockMapEntry structures. The array is
+  /// terminated with an entry of {0,0}.
+  ///
+  EFI_FV_BLOCK_MAP_ENTRY    BlockMap[1];
+} EFI_FIRMWARE_VOLUME_HEADER;
+
+#define EFI_FVH_SIGNATURE SIGNATURE_32 ('_', 'F', 'V', 'H')
+
+///
+/// Firmware Volume Header Revision definition
+///
+#define EFI_FVH_REVISION  0x02
+
+///
+/// Extension header pointed by ExtHeaderOffset of volume header.
+///
+typedef struct {
+  ///
+  /// Firmware volume name.
+  ///
+  EFI_GUID  FvName;
+  ///
+  /// Size of the rest of the extension header, including this structure.
+  ///
+  UINT32    ExtHeaderSize;
+} EFI_FIRMWARE_VOLUME_EXT_HEADER;
+
+///
+/// Entry struture for describing FV extension header
+///
+typedef struct {
+  ///
+  /// Size of this header extension.
+  ///
+  UINT16    ExtEntrySize;
+  ///
+  /// Type of the header.
+  ///
+  UINT16    ExtEntryType;
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY;
+
+#define EFI_FV_EXT_TYPE_OEM_TYPE  0x01
+///
+/// This extension header provides a mapping between a GUID and an OEM file type.
+///
+typedef struct {
+  ///
+  /// Standard extension entry, with the type EFI_FV_EXT_TYPE_OEM_TYPE.
+  ///
+  EFI_FIRMWARE_VOLUME_EXT_ENTRY Hdr;
+  ///
+  /// A bit mask, one bit for each file type between 0xC0 (bit 0) and 0xDF (bit 31). If a bit
+  /// is '1', then the GUID entry exists in Types. If a bit is '0' then no GUID entry exists in Types.
+  ///
+  UINT32    TypeMask;
+  ///
+  /// An array of GUIDs, each GUID representing an OEM file type.
+  ///
+  /// EFI_GUID  Types[1];
+  ///
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY_OEM_TYPE;
+
+#define EFI_FV_EXT_TYPE_GUID_TYPE 0x0002
+
+///
+/// This extension header EFI_FIRMWARE_VOLUME_EXT_ENTRY_GUID_TYPE provides a vendor specific
+/// GUID FormatType type which includes a length and a successive series of data bytes.
+///
+typedef struct {
+  ///
+  /// Standard extension entry, with the type EFI_FV_EXT_TYPE_OEM_TYPE.
+  ///
+  EFI_FIRMWARE_VOLUME_EXT_ENTRY     Hdr;
+  ///
+  /// Vendor-specific GUID.
+  ///
+  EFI_GUID                          FormatType;
+  ///
+  /// An arry of bytes of length Length.
+  ///
+  /// UINT8                             Data[1];
+  ///
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY_GUID_TYPE;
+
+#endif
diff --git a/MdePkg/Include/Pi/PiHob.h b/MdePkg/Include/Pi/PiHob.h
new file mode 100644
index 000000000000..d7dad133a70a
--- /dev/null
+++ b/MdePkg/Include/Pi/PiHob.h
@@ -0,0 +1,479 @@
+/** @file
+  HOB related definitions in PI.
+
+Copyright (c) 2006 - 2016, 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.
+
+  @par Revision Reference:
+  PI Version 1.4a
+
+**/
+
+#ifndef __PI_HOB_H__
+#define __PI_HOB_H__
+
+//
+// HobType of EFI_HOB_GENERIC_HEADER.
+//
+#define EFI_HOB_TYPE_HANDOFF              0x0001
+#define EFI_HOB_TYPE_MEMORY_ALLOCATION    0x0002
+#define EFI_HOB_TYPE_RESOURCE_DESCRIPTOR  0x0003
+#define EFI_HOB_TYPE_GUID_EXTENSION       0x0004
+#define EFI_HOB_TYPE_FV                   0x0005
+#define EFI_HOB_TYPE_CPU                  0x0006
+#define EFI_HOB_TYPE_MEMORY_POOL          0x0007
+#define EFI_HOB_TYPE_FV2                  0x0009
+#define EFI_HOB_TYPE_LOAD_PEIM_UNUSED     0x000A
+#define EFI_HOB_TYPE_UEFI_CAPSULE         0x000B
+#define EFI_HOB_TYPE_UNUSED               0xFFFE
+#define EFI_HOB_TYPE_END_OF_HOB_LIST      0xFFFF
+
+///
+/// Describes the format and size of the data inside the HOB.
+/// All HOBs must contain this generic HOB header.
+///
+typedef struct {
+  ///
+  /// Identifies the HOB data structure type.
+  ///
+  UINT16    HobType;
+  ///
+  /// The length in bytes of the HOB.
+  ///
+  UINT16    HobLength;
+  ///
+  /// This field must always be set to zero.
+  ///
+  UINT32    Reserved;
+} EFI_HOB_GENERIC_HEADER;
+
+
+///
+/// Value of version  in EFI_HOB_HANDOFF_INFO_TABLE.
+///
+#define EFI_HOB_HANDOFF_TABLE_VERSION 0x0009
+
+///
+/// Contains general state information used by the HOB producer phase.
+/// This HOB must be the first one in the HOB list.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_HANDOFF.
+  ///
+  EFI_HOB_GENERIC_HEADER  Header;
+  ///
+  /// The version number pertaining to the PHIT HOB definition.
+  /// This value is four bytes in length to provide an 8-byte aligned entry
+  /// when it is combined with the 4-byte BootMode.
+  ///
+  UINT32                  Version;
+  ///
+  /// The system boot mode as determined during the HOB producer phase.
+  ///
+  EFI_BOOT_MODE           BootMode;
+  ///
+  /// The highest address location of memory that is allocated for use by the HOB producer
+  /// phase. This address must be 4-KB aligned to meet page restrictions of UEFI.
+  ///
+  EFI_PHYSICAL_ADDRESS    EfiMemoryTop;
+  ///
+  /// The lowest address location of memory that is allocated for use by the HOB producer phase.
+  ///
+  EFI_PHYSICAL_ADDRESS    EfiMemoryBottom;
+  ///
+  /// The highest address location of free memory that is currently available
+  /// for use by the HOB producer phase.
+  ///
+  EFI_PHYSICAL_ADDRESS    EfiFreeMemoryTop;
+  ///
+  /// The lowest address location of free memory that is available for use by the HOB producer phase.
+  ///
+  EFI_PHYSICAL_ADDRESS    EfiFreeMemoryBottom;
+  ///
+  /// The end of the HOB list.
+  ///
+  EFI_PHYSICAL_ADDRESS    EfiEndOfHobList;
+} EFI_HOB_HANDOFF_INFO_TABLE;
+
+///
+/// EFI_HOB_MEMORY_ALLOCATION_HEADER describes the
+/// various attributes of the logical memory allocation. The type field will be used for
+/// subsequent inclusion in the UEFI memory map.
+///
+typedef struct {
+  ///
+  /// A GUID that defines the memory allocation region's type and purpose, as well as
+  /// other fields within the memory allocation HOB. This GUID is used to define the
+  /// additional data within the HOB that may be present for the memory allocation HOB.
+  /// Type EFI_GUID is defined in InstallProtocolInterface() in the UEFI 2.0
+  /// specification.
+  ///
+  EFI_GUID              Name;
+
+  ///
+  /// The base address of memory allocated by this HOB. Type
+  /// EFI_PHYSICAL_ADDRESS is defined in AllocatePages() in the UEFI 2.0
+  /// specification.
+  ///
+  EFI_PHYSICAL_ADDRESS  MemoryBaseAddress;
+
+  ///
+  /// The length in bytes of memory allocated by this HOB.
+  ///
+  UINT64                MemoryLength;
+
+  ///
+  /// Defines the type of memory allocated by this HOB. The memory type definition
+  /// follows the EFI_MEMORY_TYPE definition. Type EFI_MEMORY_TYPE is defined
+  /// in AllocatePages() in the UEFI 2.0 specification.
+  ///
+  EFI_MEMORY_TYPE       MemoryType;
+
+  ///
+  /// Padding for Itanium processor family
+  ///
+  UINT8                 Reserved[4];
+} EFI_HOB_MEMORY_ALLOCATION_HEADER;
+
+///
+/// Describes all memory ranges used during the HOB producer
+/// phase that exist outside the HOB list. This HOB type
+/// describes how memory is used, not the physical attributes of memory.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
+  ///
+  EFI_HOB_GENERIC_HEADER            Header;
+  ///
+  /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
+  /// various attributes of the logical memory allocation.
+  ///
+  EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
+  //
+  // Additional data pertaining to the "Name" Guid memory
+  // may go here.
+  //
+} EFI_HOB_MEMORY_ALLOCATION;
+
+
+///
+/// Describes the memory stack that is produced by the HOB producer
+/// phase and upon which all post-memory-installed executable
+/// content in the HOB producer phase is executing.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
+  ///
+  EFI_HOB_GENERIC_HEADER            Header;
+  ///
+  /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
+  /// various attributes of the logical memory allocation.
+  ///
+  EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
+} EFI_HOB_MEMORY_ALLOCATION_STACK;
+
+///
+/// Defines the location of the boot-strap
+/// processor (BSP) BSPStore ("Backing Store Pointer Store").
+/// This HOB is valid for the Itanium processor family only
+/// register overflow store.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
+  ///
+  EFI_HOB_GENERIC_HEADER            Header;
+  ///
+  /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
+  /// various attributes of the logical memory allocation.
+  ///
+  EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
+} EFI_HOB_MEMORY_ALLOCATION_BSP_STORE;
+
+///
+/// Defines the location and entry point of the HOB consumer phase.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
+  ///
+  EFI_HOB_GENERIC_HEADER            Header;
+  ///
+  /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
+  /// various attributes of the logical memory allocation.
+  ///
+  EFI_HOB_MEMORY_ALLOCATION_HEADER  MemoryAllocationHeader;
+  ///
+  /// The GUID specifying the values of the firmware file system name
+  /// that contains the HOB consumer phase component.
+  ///
+  EFI_GUID                          ModuleName;
+  ///
+  /// The address of the memory-mapped firmware volume
+  /// that contains the HOB consumer phase firmware file.
+  ///
+  EFI_PHYSICAL_ADDRESS              EntryPoint;
+} EFI_HOB_MEMORY_ALLOCATION_MODULE;
+
+///
+/// The resource type.
+///
+typedef UINT32 EFI_RESOURCE_TYPE;
+
+//
+// Value of ResourceType in EFI_HOB_RESOURCE_DESCRIPTOR.
+//
+#define EFI_RESOURCE_SYSTEM_MEMORY          0x00000000
+#define EFI_RESOURCE_MEMORY_MAPPED_IO       0x00000001
+#define EFI_RESOURCE_IO                     0x00000002
+#define EFI_RESOURCE_FIRMWARE_DEVICE        0x00000003
+#define EFI_RESOURCE_MEMORY_MAPPED_IO_PORT  0x00000004
+#define EFI_RESOURCE_MEMORY_RESERVED        0x00000005
+#define EFI_RESOURCE_IO_RESERVED            0x00000006
+#define EFI_RESOURCE_MAX_MEMORY_TYPE        0x00000007
+
+///
+/// A type of recount attribute type.
+///
+typedef UINT32 EFI_RESOURCE_ATTRIBUTE_TYPE;
+
+//
+// These types can be ORed together as needed.
+//
+// The following attributes are used to describe settings
+//
+#define EFI_RESOURCE_ATTRIBUTE_PRESENT                  0x00000001
+#define EFI_RESOURCE_ATTRIBUTE_INITIALIZED              0x00000002
+#define EFI_RESOURCE_ATTRIBUTE_TESTED                   0x00000004
+#define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED           0x00000080
+//
+// This is typically used as memory cacheability attribute today.
+// NOTE: Since PI spec 1.4, please use EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTED
+// as Physical write protected attribute, and EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED
+// means Memory cacheability attribute: The memory supports being programmed with
+// a writeprotected cacheable attribute.
+//
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED          0x00000100
+#define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED      0x00000200
+#define EFI_RESOURCE_ATTRIBUTE_PERSISTENT               0x00800000
+//
+// The rest of the attributes are used to describe capabilities
+//
+#define EFI_RESOURCE_ATTRIBUTE_SINGLE_BIT_ECC           0x00000008
+#define EFI_RESOURCE_ATTRIBUTE_MULTIPLE_BIT_ECC         0x00000010
+#define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_1           0x00000020
+#define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_2           0x00000040
+#define EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE              0x00000400
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE        0x00000800
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE  0x00001000
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE     0x00002000
+#define EFI_RESOURCE_ATTRIBUTE_16_BIT_IO                0x00004000
+#define EFI_RESOURCE_ATTRIBUTE_32_BIT_IO                0x00008000
+#define EFI_RESOURCE_ATTRIBUTE_64_BIT_IO                0x00010000
+#define EFI_RESOURCE_ATTRIBUTE_UNCACHED_EXPORTED        0x00020000
+#define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTABLE         0x00100000
+//
+// This is typically used as memory cacheability attribute today.
+// NOTE: Since PI spec 1.4, please use EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTABLE
+// as Memory capability attribute: The memory supports being protected from processor
+// writes, and EFI_RESOURCE_ATTRIBUTE_WRITE_PROTEC TABLE means Memory cacheability attribute:
+// The memory supports being programmed with a writeprotected cacheable attribute.
+//
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTABLE        0x00200000
+#define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTABLE    0x00400000
+#define EFI_RESOURCE_ATTRIBUTE_PERSISTABLE              0x01000000
+
+#define EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTED      0x00040000
+#define EFI_RESOURCE_ATTRIBUTE_READ_ONLY_PROTECTABLE    0x00080000
+
+//
+// Physical memory relative reliability attribute. This
+// memory provides higher reliability relative to other
+// memory in the system. If all memory has the same
+// reliability, then this bit is not used.
+//
+#define EFI_RESOURCE_ATTRIBUTE_MORE_RELIABLE            0x02000000
+
+///
+/// Describes the resource properties of all fixed,
+/// nonrelocatable resource ranges found on the processor
+/// host bus during the HOB producer phase.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
+  ///
+  EFI_HOB_GENERIC_HEADER      Header;
+  ///
+  /// A GUID representing the owner of the resource. This GUID is used by HOB
+  /// consumer phase components to correlate device ownership of a resource.
+  ///
+  EFI_GUID                    Owner;
+  ///
+  /// The resource type enumeration as defined by EFI_RESOURCE_TYPE.
+  ///
+  EFI_RESOURCE_TYPE           ResourceType;
+  ///
+  /// Resource attributes as defined by EFI_RESOURCE_ATTRIBUTE_TYPE.
+  ///
+  EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute;
+  ///
+  /// The physical start address of the resource region.
+  ///
+  EFI_PHYSICAL_ADDRESS        PhysicalStart;
+  ///
+  /// The number of bytes of the resource region.
+  ///
+  UINT64                      ResourceLength;
+} EFI_HOB_RESOURCE_DESCRIPTOR;
+
+///
+/// Allows writers of executable content in the HOB producer phase to
+/// maintain and manage HOBs with specific GUID.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION.
+  ///
+  EFI_HOB_GENERIC_HEADER      Header;
+  ///
+  /// A GUID that defines the contents of this HOB.
+  ///
+  EFI_GUID                    Name;
+  //
+  // Guid specific data goes here
+  //
+} EFI_HOB_GUID_TYPE;
+
+///
+/// Details the location of firmware volumes that contain firmware files.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV.
+  ///
+  EFI_HOB_GENERIC_HEADER Header;
+  ///
+  /// The physical memory-mapped base address of the firmware volume.
+  ///
+  EFI_PHYSICAL_ADDRESS   BaseAddress;
+  ///
+  /// The length in bytes of the firmware volume.
+  ///
+  UINT64                 Length;
+} EFI_HOB_FIRMWARE_VOLUME;
+
+///
+/// Details the location of a firmware volume that was extracted
+/// from a file within another firmware volume.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_FV2.
+  ///
+  EFI_HOB_GENERIC_HEADER  Header;
+  ///
+  /// The physical memory-mapped base address of the firmware volume.
+  ///
+  EFI_PHYSICAL_ADDRESS    BaseAddress;
+  ///
+  /// The length in bytes of the firmware volume.
+  ///
+  UINT64                  Length;
+  ///
+  /// The name of the firmware volume.
+  ///
+  EFI_GUID                FvName;
+  ///
+  /// The name of the firmware file that contained this firmware volume.
+  ///
+  EFI_GUID                FileName;
+} EFI_HOB_FIRMWARE_VOLUME2;
+
+
+///
+/// Describes processor information, such as address space and I/O space capabilities.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_CPU.
+  ///
+  EFI_HOB_GENERIC_HEADER  Header;
+  ///
+  /// Identifies the maximum physical memory addressability of the processor.
+  ///
+  UINT8                   SizeOfMemorySpace;
+  ///
+  /// Identifies the maximum physical I/O addressability of the processor.
+  ///
+  UINT8                   SizeOfIoSpace;
+  ///
+  /// This field will always be set to zero.
+  ///
+  UINT8                   Reserved[6];
+} EFI_HOB_CPU;
+
+
+///
+/// Describes pool memory allocations.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_POOL.
+  ///
+  EFI_HOB_GENERIC_HEADER  Header;
+} EFI_HOB_MEMORY_POOL;
+
+///
+/// Each UEFI capsule HOB details the location of a UEFI capsule. It includes a base address and length
+/// which is based upon memory blocks with a EFI_CAPSULE_HEADER and the associated
+/// CapsuleImageSize-based payloads. These HOB's shall be created by the PEI PI firmware
+/// sometime after the UEFI UpdateCapsule service invocation with the
+/// CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag set in the EFI_CAPSULE_HEADER.
+///
+typedef struct {
+  ///
+  /// The HOB generic header where Header.HobType = EFI_HOB_TYPE_UEFI_CAPSULE.
+  ///
+  EFI_HOB_GENERIC_HEADER Header;
+
+  ///
+  /// The physical memory-mapped base address of an UEFI capsule. This value is set to
+  /// point to the base of the contiguous memory of the UEFI capsule.
+  /// The length of the contiguous memory in bytes.
+  ///
+  EFI_PHYSICAL_ADDRESS   BaseAddress;
+  UINT64                 Length;
+} EFI_HOB_UEFI_CAPSULE;
+
+///
+/// Union of all the possible HOB Types.
+///
+typedef union {
+  EFI_HOB_GENERIC_HEADER              *Header;
+  EFI_HOB_HANDOFF_INFO_TABLE          *HandoffInformationTable;
+  EFI_HOB_MEMORY_ALLOCATION           *MemoryAllocation;
+  EFI_HOB_MEMORY_ALLOCATION_BSP_STORE *MemoryAllocationBspStore;
+  EFI_HOB_MEMORY_ALLOCATION_STACK     *MemoryAllocationStack;
+  EFI_HOB_MEMORY_ALLOCATION_MODULE    *MemoryAllocationModule;
+  EFI_HOB_RESOURCE_DESCRIPTOR         *ResourceDescriptor;
+  EFI_HOB_GUID_TYPE                   *Guid;
+  EFI_HOB_FIRMWARE_VOLUME             *FirmwareVolume;
+  EFI_HOB_FIRMWARE_VOLUME2            *FirmwareVolume2;
+  EFI_HOB_CPU                         *Cpu;
+  EFI_HOB_MEMORY_POOL                 *Pool;
+  EFI_HOB_UEFI_CAPSULE                *Capsule;
+  UINT8                               *Raw;
+} EFI_PEI_HOB_POINTERS;
+
+
+#endif
diff --git a/MdePkg/Include/Pi/PiI2c.h b/MdePkg/Include/Pi/PiI2c.h
new file mode 100644
index 000000000000..4aa55f5e3e6d
--- /dev/null
+++ b/MdePkg/Include/Pi/PiI2c.h
@@ -0,0 +1,307 @@
+/** @file
+  Include file matches things in PI.
+
+Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  PI Version 1.3
+
+**/
+
+#ifndef __PI_I2C_H__
+#define __PI_I2C_H__
+
+///
+/// A 10-bit slave address is or'ed with the following value enabling the
+/// I2C protocol stack to address the duplicated address space between 0
+//  and 127 in 10-bit mode.
+///
+#define I2C_ADDRESSING_10_BIT     0x80000000
+
+///
+/// I2C controller capabilities
+///
+/// The EFI_I2C_CONTROLLER_CAPABILITIES specifies the capabilities of the
+/// I2C host controller.  The StructureSizeInBytes enables variations of
+/// this structure to be identified if there is need to extend this
+/// structure in the future.
+///
+typedef struct {
+  ///
+  /// Length of this data structure in bytes
+  ///
+  UINT32 StructureSizeInBytes;
+
+  ///
+  /// The maximum number of bytes the I2C host controller is able to
+  /// receive from the I2C bus.
+  ///
+  UINT32 MaximumReceiveBytes;
+
+  ///
+  /// The maximum number of bytes the I2C host controller is able to send
+  /// on the I2C  bus.
+  ///
+  UINT32 MaximumTransmitBytes;
+
+  ///
+  /// The maximum number of bytes in the I2C bus transaction.
+  ///
+  UINT32 MaximumTotalBytes;
+} EFI_I2C_CONTROLLER_CAPABILITIES;
+
+///
+/// I2C device description
+///
+/// The EFI_I2C_ENUMERATE_PROTOCOL uses the EFI_I2C_DEVICE to describe
+/// the platform specific details associated with an I2C device.  This
+/// description is passed to the I2C bus driver during enumeration where
+/// it is made available to the third party I2C device driver via the
+/// EFI_I2C_IO_PROTOCOL.
+///
+typedef struct {
+  ///
+  /// Unique value assigned by the silicon manufacture or the third
+  /// party I2C driver writer for the I2C part.  This value logically
+  /// combines both the manufacture name and the I2C part number into
+  /// a single value specified as a GUID.
+  ///
+  CONST EFI_GUID *DeviceGuid;
+
+  ///
+  /// Unique ID of the I2C part within the system
+  ///
+  UINT32 DeviceIndex;
+
+  ///
+  /// Hardware revision - ACPI _HRV value.  See the Advanced
+  /// Configuration and Power Interface Specification, Revision 5.0
+  /// for the field format and the Plug and play support for I2C
+  /// web-page for restriction on values.
+  ///
+  /// http://www.acpi.info/spec.htm
+  /// http://msdn.microsoft.com/en-us/library/windows/hardware/jj131711(v=vs.85).aspx
+  ///
+  UINT32 HardwareRevision;
+
+  ///
+  /// I2C bus configuration for the I2C device
+  ///
+  UINT32 I2cBusConfiguration;
+
+  ///
+  /// Number of slave addresses for the I2C device.
+  ///
+  UINT32 SlaveAddressCount;
+
+  ///
+  /// Pointer to the array of slave addresses for the I2C device.
+  ///
+  CONST UINT32 *SlaveAddressArray;
+} EFI_I2C_DEVICE;
+
+///
+/// Define the I2C flags
+///
+/// I2C read operation when set
+#define I2C_FLAG_READ               0x00000001
+
+///
+/// Define the flags for SMBus operation
+///
+/// The following flags are also present in only the first I2C operation
+/// and are ignored when present in other operations.  These flags
+/// describe a particular SMB transaction as shown in the following table.
+///
+
+/// SMBus operation
+#define I2C_FLAG_SMBUS_OPERATION    0x00010000
+
+/// SMBus block operation
+///   The flag I2C_FLAG_SMBUS_BLOCK causes the I2C master protocol to update
+///   the LengthInBytes field of the operation in the request packet with
+///   the actual number of bytes read or written.  These values are only
+///   valid when the entire I2C transaction is successful.
+///   This flag also changes the LengthInBytes meaning to be: A maximum
+///   of LengthInBytes is to be read from the device.  The first byte
+///   read contains the number of bytes remaining to be read, plus an
+///   optional PEC value.
+#define I2C_FLAG_SMBUS_BLOCK        0x00020000
+
+/// SMBus process call operation
+#define I2C_FLAG_SMBUS_PROCESS_CALL 0x00040000
+
+/// SMBus use packet error code (PEC)
+///   Note that the I2C master protocol may clear the I2C_FLAG_SMBUS_PEC bit
+///   to indicate that the PEC value was checked by the hardware and is
+///   not appended to the returned read data.
+///
+#define I2C_FLAG_SMBUS_PEC          0x00080000
+
+//----------------------------------------------------------------------
+///
+/// QuickRead:          OperationCount=1,
+///                     LengthInBytes=0,   Flags=I2C_FLAG_READ
+/// QuickWrite:         OperationCount=1,
+///                     LengthInBytes=0,   Flags=0
+///
+///
+/// ReceiveByte:        OperationCount=1,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_READ
+/// ReceiveByte+PEC:    OperationCount=1,
+///                     LengthInBytes=2,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_READ
+///                                            | I2C_FLAG_SMBUS_PEC
+///
+///
+/// SendByte:           OperationCount=1,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+/// SendByte+PEC:       OperationCount=1,
+///                     LengthInBytes=2,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PEC
+///
+///
+/// ReadDataByte:       OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                     LengthInBytes=1,   Flags=I2C_FLAG_READ
+/// ReadDataByte+PEC:   OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PEC
+///                     LengthInBytes=2,   Flags=I2C_FLAG_READ
+///
+///
+/// WriteDataByte:      OperationCount=1,
+///                     LengthInBytes=2,   Flags=I2C_FLAG_SMBUS_OPERATION
+/// WriteDataByte+PEC:  OperationCount=1,
+///                     LengthInBytes=3,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PEC
+///
+///
+/// ReadDataWord:       OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                     LengthInBytes=2,   Flags=I2C_FLAG_READ
+/// ReadDataWord+PEC:   OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PEC
+///                     LengthInBytes=3,   Flags=I2C_FLAG_READ
+///
+///
+/// WriteDataWord:      OperationCount=1,
+///                     LengthInBytes=3,   Flags=I2C_FLAG_SMBUS_OPERATION
+/// WriteDataWord+PEC:  OperationCount=1,
+///                     LengthInBytes=4,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PEC
+///
+///
+/// ReadBlock:          OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_BLOCK
+///                     LengthInBytes=33,  Flags=I2C_FLAG_READ
+/// ReadBlock+PEC:      OperationCount=2,
+///                     LengthInBytes=1,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_BLOCK
+///                                            | I2C_FLAG_SMBUS_PEC
+///                     LengthInBytes=34,  Flags=I2C_FLAG_READ
+///
+///
+/// WriteBlock:         OperationCount=1,
+///                     LengthInBytes=N+2, Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_BLOCK
+/// WriteBlock+PEC:     OperationCount=1,
+///                     LengthInBytes=N+3, Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_BLOCK
+///                                            | I2C_FLAG_SMBUS_PEC
+///
+///
+/// ProcessCall:        OperationCount=2,
+///                     LengthInBytes=3,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PROCESS_CALL
+///                     LengthInBytes=2,   Flags=I2C_FLAG_READ
+/// ProcessCall+PEC:    OperationCount=2,
+///                     LengthInBytes=3,   Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PROCESS_CALL
+///                                            | I2C_FLAG_SMBUS_PEC
+///                     LengthInBytes=3,   Flags=I2C_FLAG_READ
+///
+///
+/// BlkProcessCall:     OperationCount=2,
+///                     LengthInBytes=N+2, Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PROCESS_CALL
+///                                            | I2C_FLAG_SMBUS_BLOCK
+///                     LengthInBytes=33,  Flags=I2C_FLAG_READ
+/// BlkProcessCall+PEC: OperationCount=2,
+///                     LengthInBytes=N+2, Flags=I2C_FLAG_SMBUS_OPERATION
+///                                            | I2C_FLAG_SMBUS_PROCESS_CALL
+///                                            | I2C_FLAG_SMBUS_BLOCK
+///                                            | I2C_FLAG_SMBUS_PEC
+///                     LengthInBytes=34,  Flags=I2C_FLAG_READ
+///
+//----------------------------------------------------------------------
+
+///
+/// I2C device operation
+///
+/// The EFI_I2C_OPERATION describes a subset of an I2C transaction in which
+/// the I2C controller is either sending or receiving bytes from the bus.
+/// Some transactions will consist of a single operation while others will
+/// be two or more.
+///
+/// Note: Some I2C controllers do not support read or write ping (address
+/// only) operation and will return EFI_UNSUPPORTED status when these
+/// operations are requested.
+///
+/// Note: I2C controllers which do not support complex transactions requiring
+/// multiple repeated start bits return EFI_UNSUPPORTED without processing
+/// any of the transaction.
+///
+typedef struct {
+  ///
+  /// Flags to qualify the I2C operation.
+  ///
+  UINT32 Flags;
+
+  ///
+  /// Number of bytes to send to or receive from the I2C device.  A ping
+  /// (address only byte/bytes)  is indicated by setting the LengthInBytes
+  /// to zero.
+  ///
+  UINT32 LengthInBytes;
+
+  ///
+  /// Pointer to a buffer containing the data to send or to receive from
+  /// the I2C device.  The Buffer must be at least LengthInBytes in size.
+  ///
+  UINT8 *Buffer;
+} EFI_I2C_OPERATION;
+
+///
+/// I2C device request
+///
+/// The EFI_I2C_REQUEST_PACKET describes a single I2C transaction.  The
+/// transaction starts with a start bit followed by the first operation
+/// in the operation array.  Subsequent operations are separated with
+/// repeated start bits and the last operation is followed by a stop bit
+/// which concludes the transaction.  Each operation is described by one
+/// of the elements in the Operation array.
+///
+typedef struct {
+  ///
+  /// Number of elements in the operation array
+  ///
+  UINTN OperationCount;
+
+  ///
+  /// Description of the I2C operation
+  ///
+  EFI_I2C_OPERATION Operation [1];
+} EFI_I2C_REQUEST_PACKET;
+
+#endif  //  __PI_I2C_H__
diff --git a/MdePkg/Include/Pi/PiMultiPhase.h b/MdePkg/Include/Pi/PiMultiPhase.h
new file mode 100644
index 000000000000..3561254b337f
--- /dev/null
+++ b/MdePkg/Include/Pi/PiMultiPhase.h
@@ -0,0 +1,179 @@
+/** @file
+  Include file matches things in PI for multiple module types.
+
+Copyright (c) 2006 - 2015, 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.             
+
+  @par Revision Reference:
+  These elements are defined in UEFI Platform Initialization Specification 1.2.
+
+**/
+
+#ifndef __PI_MULTIPHASE_H__
+#define __PI_MULTIPHASE_H__
+
+#include <Pi/PiFirmwareVolume.h>
+#include <Pi/PiFirmwareFile.h>
+#include <Pi/PiBootMode.h>
+#include <Pi/PiHob.h>
+#include <Pi/PiDependency.h>
+#include <Pi/PiStatusCode.h>
+#include <Pi/PiS3BootScript.h>
+
+/**
+  Produces an error code in the range reserved for use by the Platform Initialization
+  Architecture Specification.
+
+  The supported 32-bit range is 0xA0000000-0xBFFFFFFF 
+  The supported 64-bit range is 0xA000000000000000-0xBFFFFFFFFFFFFFFF 
+
+  @param  StatusCode    The status code value to convert into a warning code.  
+                        StatusCode must be in the range 0x00000000..0x1FFFFFFF.
+
+  @return The value specified by StatusCode in the PI reserved range.
+
+**/
+#define DXE_ERROR(StatusCode)  (MAX_BIT | (MAX_BIT >> 2) | StatusCode)
+
+///
+/// If this value is returned by an EFI image, then the image should be unloaded.
+///
+#define EFI_REQUEST_UNLOAD_IMAGE  DXE_ERROR (1)
+
+///
+/// If this value is returned by an API, it means the capability is not yet 
+/// installed/available/ready to use.
+///
+#define EFI_NOT_AVAILABLE_YET     DXE_ERROR (2)
+
+///
+/// Success and warning codes reserved for use by PI.
+/// Supported 32-bit range is 0x20000000-0x3fffffff.
+/// Supported 64-bit range is 0x2000000000000000-0x3fffffffffffffff.
+///
+#define PI_ENCODE_WARNING(a)                ((MAX_BIT >> 2) | (a))
+
+///
+/// Error codes reserved for use by PI.
+/// Supported 32-bit range is 0xa0000000-0xbfffffff.
+/// Supported 64-bit range is 0xa000000000000000-0xbfffffffffffffff.
+///
+#define PI_ENCODE_ERROR(a)                  (MAX_BIT | (MAX_BIT >> 2) | (a))
+
+/// 
+/// Return status codes defined in SMM CIS.
+/// 
+#define EFI_INTERRUPT_PENDING               PI_ENCODE_ERROR (0)
+
+#define EFI_WARN_INTERRUPT_SOURCE_PENDING   PI_ENCODE_WARNING (0)
+#define EFI_WARN_INTERRUPT_SOURCE_QUIESCED  PI_ENCODE_WARNING (1)
+
+///
+/// Bitmask of values for Authentication Status.
+/// Authentication Status is returned from EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL 
+/// and the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
+///
+/// xx00 Image was not signed.
+/// xxx1 Platform security policy override. Assumes the same meaning as 0010 (the image was signed, the
+///      signature was tested, and the signature passed authentication test).
+/// 0010 Image was signed, the signature was tested, and the signature passed authentication test.
+/// 0110 Image was signed and the signature was not tested.
+/// 1010 Image was signed, the signature was tested, and the signature failed the authentication test.
+///
+///@{
+#define EFI_AUTH_STATUS_PLATFORM_OVERRIDE   0x01
+#define EFI_AUTH_STATUS_IMAGE_SIGNED        0x02
+#define EFI_AUTH_STATUS_NOT_TESTED          0x04
+#define EFI_AUTH_STATUS_TEST_FAILED         0x08
+#define EFI_AUTH_STATUS_ALL                 0x0f
+///@}
+
+///
+/// SMRAM states and capabilities
+///
+#define EFI_SMRAM_OPEN                  0x00000001
+#define EFI_SMRAM_CLOSED                0x00000002
+#define EFI_SMRAM_LOCKED                0x00000004
+#define EFI_CACHEABLE                   0x00000008
+#define EFI_ALLOCATED                   0x00000010
+#define EFI_NEEDS_TESTING               0x00000020
+#define EFI_NEEDS_ECC_INITIALIZATION    0x00000040
+
+///
+/// Structure describing a SMRAM region and its accessibility attributes.
+///
+typedef struct {
+  ///
+  /// Designates the physical address of the SMRAM in memory. This view of memory is 
+  /// the same as seen by I/O-based agents, for example, but it may not be the address seen 
+  /// by the processors.
+  ///
+  EFI_PHYSICAL_ADDRESS  PhysicalStart;
+  ///
+  /// Designates the address of the SMRAM, as seen by software executing on the 
+  /// processors. This address may or may not match PhysicalStart.
+  ///
+  EFI_PHYSICAL_ADDRESS  CpuStart;       
+  ///
+  /// Describes the number of bytes in the SMRAM region.
+  ///
+  UINT64                PhysicalSize;
+  ///
+  /// Describes the accessibility attributes of the SMRAM.  These attributes include the 
+  /// hardware state (e.g., Open/Closed/Locked), capability (e.g., cacheable), logical 
+  /// allocation (e.g., allocated), and pre-use initialization (e.g., needs testing/ECC 
+  /// initialization).
+  ///
+  UINT64                RegionState;
+} EFI_SMRAM_DESCRIPTOR;
+
+typedef enum {
+  EFI_PCD_TYPE_8,
+  EFI_PCD_TYPE_16,
+  EFI_PCD_TYPE_32,
+  EFI_PCD_TYPE_64,
+  EFI_PCD_TYPE_BOOL,
+  EFI_PCD_TYPE_PTR
+} EFI_PCD_TYPE;
+
+typedef struct {
+  ///
+  /// The returned information associated with the requested TokenNumber. If
+  /// TokenNumber is 0, then PcdType is set to EFI_PCD_TYPE_8.
+  ///
+  EFI_PCD_TYPE      PcdType;
+  ///
+  /// The size of the data in bytes associated with the TokenNumber specified. If
+  /// TokenNumber is 0, then PcdSize is set 0.
+  ///
+  UINTN             PcdSize;
+  ///
+  /// The null-terminated ASCII string associated with a given token. If the
+  /// TokenNumber specified was 0, then this field corresponds to the null-terminated
+  /// ASCII string associated with the token's namespace Guid. If NULL, there is no
+  /// name associated with this request.
+  ///
+  CHAR8             *PcdName;
+} EFI_PCD_INFO;
+
+/**
+  The function prototype for invoking a function on an Application Processor.
+
+  This definition is used by the UEFI MP Serices Protocol, and the
+  PI SMM System Table.
+
+  @param[in,out] Buffer  The pointer to private data buffer.
+**/
+typedef
+VOID
+(EFIAPI *EFI_AP_PROCEDURE)(
+  IN OUT VOID  *Buffer
+  );
+
+#endif
diff --git a/MdePkg/Include/Pi/PiPeiCis.h b/MdePkg/Include/Pi/PiPeiCis.h
new file mode 100644
index 000000000000..3963aa030d27
--- /dev/null
+++ b/MdePkg/Include/Pi/PiPeiCis.h
@@ -0,0 +1,1042 @@
+/** @file
+  PI PEI master include file. This file should match the PI spec.
+
+Copyright (c) 2006 - 2016, 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.             
+
+  @par Revision Reference:
+  PI Version 1.4a.
+
+**/
+
+#ifndef __PI_PEICIS_H__
+#define __PI_PEICIS_H__
+
+#include <Uefi/UefiMultiPhase.h>
+#include <Pi/PiMultiPhase.h>
+
+///
+/// The handles of EFI FV.
+/// 
+typedef VOID    *EFI_PEI_FV_HANDLE;
+
+///
+/// The handles of EFI FFS.
+/// 
+typedef VOID    *EFI_PEI_FILE_HANDLE;
+
+///
+/// Declare the forward reference data structure for EFI_PEI_SERVICE.
+/// 
+typedef struct _EFI_PEI_SERVICES          EFI_PEI_SERVICES;
+
+///
+/// Declare the forward reference data structure for EFI_PEI_NOTIFY_DESCRIPTOR.
+/// 
+typedef struct _EFI_PEI_NOTIFY_DESCRIPTOR EFI_PEI_NOTIFY_DESCRIPTOR;
+
+
+#include <Ppi/CpuIo.h>
+#include <Ppi/PciCfg2.h>
+
+
+/**
+  The PEI Dispatcher will invoke each PEIM one time.  During this pass, the PEI 
+  Dispatcher will pass control to the PEIM at the AddressOfEntryPoint in the PE Header. 
+
+  @param  FileHandle       Pointer to the FFS file header.
+  @param  PeiServices      Describes the list of possible PEI Services.
+
+  @retval EFI_SUCCESS      The PEI completed successfully.
+  @retval !EFI_SUCCESS     There is error in PEIM.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEIM_ENTRY_POINT2)(
+  IN EFI_PEI_FILE_HANDLE             FileHandle,
+  IN CONST EFI_PEI_SERVICES          **PeiServices
+  );
+
+/**
+  Entry point of the notification callback function itself within the PEIM.
+
+  @param  PeiServices      Indirect reference to the PEI Services Table.
+  @param  NotifyDescriptor Address of the notification descriptor data structure.
+  @param  Ppi              Address of the PPI that was installed.
+
+  @return Status of the notification.
+          The status code returned from this function is ignored.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEIM_NOTIFY_ENTRY_POINT)(
+  IN EFI_PEI_SERVICES           **PeiServices,
+  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
+  IN VOID                       *Ppi
+  );
+
+//
+// PEI Ppi Services List Descriptors
+//
+#define EFI_PEI_PPI_DESCRIPTOR_PIC              0x00000001
+#define EFI_PEI_PPI_DESCRIPTOR_PPI              0x00000010
+#define EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK  0x00000020
+#define EFI_PEI_PPI_DESCRIPTOR_NOTIFY_DISPATCH  0x00000040
+#define EFI_PEI_PPI_DESCRIPTOR_NOTIFY_TYPES     0x00000060
+#define EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST   0x80000000
+
+///
+/// The data structure through which a PEIM describes available services to the PEI Foundation.
+/// 
+typedef struct {
+  ///
+  /// This field is a set of flags describing the characteristics of this imported table entry.
+  /// All flags are defined as EFI_PEI_PPI_DESCRIPTOR_***, which can also be combined into one.
+  ///
+  UINTN     Flags;
+  ///
+  /// The address of the EFI_GUID that names the interface.
+  ///
+  EFI_GUID  *Guid;
+  ///
+  /// A pointer to the PPI. It contains the information necessary to install a service.
+  ///
+  VOID      *Ppi;
+} EFI_PEI_PPI_DESCRIPTOR;
+
+/// 
+/// The data structure in a given PEIM that tells the PEI 
+/// Foundation where to invoke the notification service.
+/// 
+struct _EFI_PEI_NOTIFY_DESCRIPTOR {
+  ///
+  /// Details if the type of notification are callback or dispatch.
+  ///
+  UINTN                       Flags;
+  ///
+  /// The address of the EFI_GUID that names the interface.
+  ///
+  EFI_GUID                    *Guid;
+  ///
+  /// Address of the notification callback function itself within the PEIM.
+  ///
+  EFI_PEIM_NOTIFY_ENTRY_POINT Notify;
+};
+
+///
+/// This data structure is the means by which callable services are installed and
+/// notifications are registered in the PEI phase.
+///
+typedef union {
+  ///
+  /// The typedef structure of the notification descriptor.
+  ///
+  EFI_PEI_NOTIFY_DESCRIPTOR   Notify;
+  ///
+  /// The typedef structure of the PPI descriptor.
+  ///
+  EFI_PEI_PPI_DESCRIPTOR      Ppi;
+} EFI_PEI_DESCRIPTOR;
+
+/**
+  This service is the first one provided by the PEI Foundation.  This function 
+  installs an interface in the PEI PPI database by GUID.  The purpose of the 
+  service is to publish an interface that other parties can use to call 
+  additional PEIMs.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table
+                           published by the PEI Foundation.
+  @param  PpiList          A pointer to the list of interfaces that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The PpiList pointer is NULL or Any of the PEI PPI 
+                                descriptors in the list do not have the 
+                                EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_INSTALL_PPI)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN CONST EFI_PEI_PPI_DESCRIPTOR      *PpiList
+  );
+
+/**
+  This function reinstalls an interface in the PEI PPI database by GUID. 
+  The purpose of the service is to publish an interface that other parties 
+  can use to replace a same-named interface in the protocol database 
+  with a different interface. 
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table
+                           published by the PEI Foundation.
+  @param  OldPpi           A pointer to the former PPI in the database.
+  @param  NewPpi           A pointer to the new interfaces that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The PpiList pointer is NULL or Any of the PEI PPI descriptors in the 
+                                list do not have the EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+  @retval EFI_NOT_FOUND         The PPI for which the reinstallation was requested has not been installed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_REINSTALL_PPI)(
+  IN CONST EFI_PEI_SERVICES                **PeiServices,
+  IN CONST EFI_PEI_PPI_DESCRIPTOR          *OldPpi,
+  IN CONST EFI_PEI_PPI_DESCRIPTOR          *NewPpi
+  );
+
+/**
+  This function locates an interface in the PEI PPI database by GUID. 
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES published by the PEI Foundation.
+  @param  Guid             A pointer to the GUID whose corresponding interface needs to be found.
+  @param  Instance         The N-th instance of the interface that is required.
+  @param  PpiDescriptor    A pointer to instance of the EFI_PEI_PPI_DESCRIPTOR.
+  @param  Ppi              A pointer to the instance of the interface.
+
+  @retval EFI_SUCCESS           The interface was successfully returned.
+  @retval EFI_NOT_FOUND         The PPI descriptor is not found in the database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_LOCATE_PPI)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN CONST EFI_GUID                    *Guid,
+  IN UINTN                             Instance,
+  IN OUT   EFI_PEI_PPI_DESCRIPTOR      **PpiDescriptor OPTIONAL,
+  IN OUT   VOID                        **Ppi
+  );
+
+/**
+  This function installs a notification service to be called back when a 
+  given interface is installed or reinstalled.  The purpose of the service 
+  is to publish an interface that other parties can use to call additional PPIs 
+  that may materialize later.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
+  @param  NotifyList       A pointer to the list of notification interfaces that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The PpiList pointer is NULL, or any of the PEI PPI descriptors in the 
+                                list do not have the EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_NOTIFY_PPI)(
+  IN CONST EFI_PEI_SERVICES                **PeiServices,
+  IN CONST EFI_PEI_NOTIFY_DESCRIPTOR       *NotifyList
+  );
+
+/**
+  This function returns the present value of the boot mode.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  BootMode         A pointer to contain the value of the boot mode.
+
+  @retval EFI_SUCCESS           The boot mode returned successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_BOOT_MODE)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  OUT EFI_BOOT_MODE                    *BootMode
+  );
+
+/**
+  This function sets the value of the boot mode.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
+  @param  BootMode         The value of the boot mode to set.
+
+  @retval EFI_SUCCESS           The boot mode returned successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SET_BOOT_MODE)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN EFI_BOOT_MODE                     BootMode
+  );
+
+/**
+  This function returns the pointer to the list of Hand-Off Blocks (HOBs) in memory. 
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
+  @param  HobList          A pointer to the list of HOBs that the PEI Foundation will initialize
+
+  @retval EFI_SUCCESS           The list was successfully returned.
+  @retval EFI_NOT_AVAILABLE_YET The HOB list is not yet published.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_HOB_LIST)(
+  IN CONST EFI_PEI_SERVICES        **PeiServices,
+  OUT VOID                         **HobList
+  );
+
+/**
+  This service, published by the PEI Foundation, abstracts the creation of a Hand-Off Block's (HOB's) headers.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  Type             The type of HOB to be installed.
+  @param  Length           The length of the HOB to be added.
+  @param  Hob              The address of a pointer that will contain the HOB header.
+
+  @retval EFI_SUCCESS           The HOB was successfully created.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_CREATE_HOB)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN UINT16                            Type,
+  IN UINT16                            Length,
+  IN OUT VOID                          **Hob
+  );
+
+/**
+  The purpose of the service is to abstract the capability of the PEI 
+  Foundation to discover instances of firmware volumes in the system. 
+
+  This service enables PEIMs to discover additional firmware volumes. The PEI Foundation uses this
+  service to abstract the locations and formats of various firmware volumes. These volumes include
+  the Boot Firmware Volume and any other volumes exposed by EFI_PEI_FV_PPI. The service
+  returns a volume handle of type EFI_PEI_FV_HANDLE, which must be unique within the system.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  Instance         This instance of the firmware volume to find.
+                           The value 0 is the Boot Firmware Volume (BFV).
+  @param  VolumeHandle     On exit, points to the next volumn handle or NULL if it does not exist.
+
+  @retval EFI_SUCCESS           The volume was found.
+  @retval EFI_NOT_FOUND         The volume was not found.
+  @retval EFI_INVALID_PARAMETER VolumeHandle is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_FIND_NEXT_VOLUME2)(
+  IN CONST EFI_PEI_SERVICES                **PeiServices,
+  IN UINTN                                 Instance,
+  OUT EFI_PEI_FV_HANDLE                    *VolumeHandle
+  );
+
+/**
+  Searches for the next matching file in the firmware volume.
+
+  This service enables PEIMs to discover firmware files within a specified volume.
+  To find the first instance of a firmware file, pass a FileHandle value of NULL into the service.
+  The service returns a file handle of type EFI_PEI_FILE_HANDLE, which must be unique within
+  the system.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  SearchType       A filter to find files only of this type.
+  @param  FvHandle         Handle of firmware volume in which to search.
+  @param  FileHandle       On entry, points to the current handle from which to begin searching
+                           or NULL to start at the beginning of the firmware volume.
+                           On exit, points the file handle of the next file in the volume or NULL
+                           if there are no more files.
+
+  @retval EFI_SUCCESS      The file was found.
+  @retval EFI_NOT_FOUND    The file was not found.
+  @retval EFI_NOT_FOUND    The header checksum was not zero.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_FIND_NEXT_FILE2)(
+  IN CONST EFI_PEI_SERVICES                **PeiServices,
+  IN EFI_FV_FILETYPE                       SearchType,
+  IN CONST EFI_PEI_FV_HANDLE               FvHandle,
+  IN OUT EFI_PEI_FILE_HANDLE               *FileHandle
+  );
+
+/**
+  Searches for the next matching section within the specified file.
+
+  This service enables PEI modules to discover the first section of a given type within a valid file.
+  This service will search within encapsulation sections (compression and GUIDed) as well. It will
+  search inside of a GUIDed section or a compressed section, but may not, for example, search a
+  GUIDed section inside a GUIDes section.
+  This service will not search within compression sections or GUIDed sections that require
+  extraction if memory is not present.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  SectionType      The value of the section type to find.
+  @param  FileHandle       Handle of the firmware file to search.
+  @param  SectionData      A pointer to the discovered section, if successful.
+
+  @retval EFI_SUCCESS      The section was found.
+  @retval EFI_NOT_FOUND    The section was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_FIND_SECTION_DATA2)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN EFI_SECTION_TYPE                  SectionType,
+  IN EFI_PEI_FILE_HANDLE               FileHandle,
+  OUT VOID                             **SectionData
+  );
+
+/**
+  Searches for the next matching section within the specified file.
+
+  This service enables PEI modules to discover the section of a given type within a valid file.
+  This service will search within encapsulation sections (compression and GUIDed) as well. It will
+  search inside of a GUIDed section or a compressed section, but may not, for example, search a
+  GUIDed section inside a GUIDes section.
+  This service will not search within compression sections or GUIDed sections that require
+  extraction if memory is not present.
+
+  @param  PeiServices           An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  SectionType           The value of the section type to find.
+  @param  SectionInstance       Section instance to find.
+  @param  FileHandle            Handle of the firmware file to search.
+  @param  SectionData           A pointer to the discovered section, if successful.
+  @param  AuthenticationStatus  A pointer to the authentication status for this section.
+
+  @retval EFI_SUCCESS      The section was found.
+  @retval EFI_NOT_FOUND    The section was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_FIND_SECTION_DATA3)(
+  IN CONST EFI_PEI_SERVICES            **PeiServices,
+  IN EFI_SECTION_TYPE                  SectionType,
+  IN UINTN                             SectionInstance,
+  IN EFI_PEI_FILE_HANDLE               FileHandle,
+  OUT VOID                             **SectionData,
+  OUT UINT32                           *AuthenticationStatus
+  );
+
+/**
+  This function registers the found memory configuration with the PEI Foundation.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  MemoryBegin      The value of a region of installed memory.
+  @param  MemoryLength     The corresponding length of a region of installed memory.
+
+  @retval EFI_SUCCESS           The region was successfully installed in a HOB.
+  @retval EFI_INVALID_PARAMETER MemoryBegin and MemoryLength are illegal for this system.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_INSTALL_PEI_MEMORY)(
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS       MemoryBegin,
+  IN UINT64                     MemoryLength
+  );
+
+/**
+  The purpose of the service is to publish an interface that allows 
+  PEIMs to allocate memory ranges that are managed by the PEI Foundation.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  MemoryType       The type of memory to allocate.
+  @param  Pages            The number of contiguous 4 KB pages to allocate.
+  @param  Memory           A pointer to a physical address. On output, the address is set to the base 
+                           of the page range that was allocated.
+
+  @retval EFI_SUCCESS           The memory range was successfully allocated.
+  @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
+  @retval EFI_INVALID_PARAMETER The type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode, 
+                                EfiRuntimeServicesData, EfiBootServicesCode, EfiBootServicesData,
+                                EfiACPIReclaimMemory, EfiReservedMemoryType, or EfiACPIMemoryNVS.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_ALLOCATE_PAGES)(
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN EFI_MEMORY_TYPE            MemoryType,
+  IN UINTN                      Pages,
+  OUT EFI_PHYSICAL_ADDRESS      *Memory
+  );
+
+/**
+  The purpose of this service is to publish an interface that 
+  allows PEIMs to allocate memory ranges that are managed by the PEI Foundation.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  Size             The number of bytes to allocate from the pool.
+  @param  Buffer           If the call succeeds, a pointer to a pointer to the allocated buffer; undefined otherwise.
+
+  @retval EFI_SUCCESS           The allocation was successful.
+  @retval EFI_OUT_OF_RESOURCES  There is not enough heap to allocate the requested size.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_ALLOCATE_POOL)(
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN UINTN                      Size,
+  OUT VOID                      **Buffer
+  );
+
+/**
+  This service copies the contents of one buffer to another buffer.
+
+  @param  Destination      The pointer to the destination buffer of the memory copy.
+  @param  Source           The pointer to the source buffer of the memory copy.
+  @param  Length           The number of bytes to copy from Source to Destination.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_COPY_MEM)(
+  IN VOID                       *Destination,
+  IN VOID                       *Source,
+  IN UINTN                      Length
+  );
+
+/**
+  The service fills a buffer with a specified value.
+
+  @param  Buffer           The pointer to the buffer to fill.
+  @param  Size             The number of bytes in Buffer to fill.
+  @param  Value            The value to fill Buffer with.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_SET_MEM)(
+  IN VOID                       *Buffer,
+  IN UINTN                      Size,
+  IN UINT8                      Value
+  );
+
+/**
+  This service publishes an interface that allows PEIMs to report status codes.
+
+  ReportStatusCode() is called by PEIMs that wish to report status information on their
+  progress. The principal use model is for a PEIM to emit one of the standard 32-bit error codes. This
+  will allow a platform owner to ascertain the state of the system, especially under conditions where
+  the full consoles might not have been installed.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  Type             Indicates the type of status code being reported.
+  @param  Value            Describes the current status of a hardware or
+                           software entity. This includes information about the class and
+                           subclass that is used to classify the entity as well as an operation.
+                           For progress codes, the operation is the current activity.
+                           For error codes, it is the exception.For debug codes,it is not defined at this time.
+  @param  Instance         The enumeration of a hardware or software entity within
+                           the system. A system may contain multiple entities that match a class/subclass
+                           pairing. The instance differentiates between them. An instance of 0 indicates
+                           that instance information is unavailable, not meaningful, or not relevant.
+                           Valid instance numbers start with 1.
+  @param  CallerId         This optional parameter may be used to identify the caller.
+                           This parameter allows the status code driver to apply different rules to
+                           different callers.
+  @param  Data             This optional parameter may be used to pass additional data.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_NOT_AVAILABLE_YET No progress code provider has installed an interface in the system.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_REPORT_STATUS_CODE)(
+  IN CONST EFI_PEI_SERVICES         **PeiServices,
+  IN EFI_STATUS_CODE_TYPE           Type,
+  IN EFI_STATUS_CODE_VALUE          Value,
+  IN UINT32                         Instance,
+  IN CONST EFI_GUID                 *CallerId OPTIONAL,
+  IN CONST EFI_STATUS_CODE_DATA     *Data OPTIONAL
+  );
+
+/**
+  Resets the entire platform.
+
+  This service resets the entire platform, including all processors
+  and devices, and reboots the system.
+  This service will never return EFI_SUCCESS.  
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES
+                           table published by the PEI Foundation.
+
+  @retval EFI_NOT_AVAILABLE_YET The service has not been installed yet.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_RESET_SYSTEM)(
+  IN CONST EFI_PEI_SERVICES   **PeiServices
+  );
+
+/**
+  Resets the entire platform.
+
+  @param[in] ResetType      The type of reset to perform.
+  @param[in] ResetStatus    The status code for the reset.
+  @param[in] DataSize       The size, in bytes, of WatchdogData.
+  @param[in] ResetData      For a ResetType of EfiResetCold, EfiResetWarm, or EfiResetShutdown
+                            the data buffer starts with a Null-terminated string, optionally
+                            followed by additional binary data. The string is a description
+                            that the caller may use to further indicate the reason for the
+                            system reset. ResetData is only valid if ResetStatus is something
+                            other than EFI_SUCCESS unless the ResetType is EfiResetPlatformSpecific
+                            where a minimum amount of ResetData is always required.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_RESET2_SYSTEM) (
+  IN EFI_RESET_TYPE     ResetType,
+  IN EFI_STATUS         ResetStatus,
+  IN UINTN              DataSize,
+  IN VOID               *ResetData OPTIONAL
+  );
+
+/**
+  Find a file within a volume by its name.
+
+  This service searches for files with a specific name, within
+  either the specified firmware volume or all firmware volumes.
+  The service returns a file handle of type EFI_PEI_FILE_HANDLE,
+  which must be unique within the system.
+
+  @param FileName       A pointer to the name of the file to
+                        find within the firmware volume.
+  @param VolumeHandle   The firmware volume to search.
+  @param FileHandle     Upon exit, points to the found file's
+                        handle or NULL if it could not be found.
+
+  @retval EFI_SUCCESS             The file was found.
+  @retval EFI_NOT_FOUND           The file was not found.
+  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or
+                                  FileName was NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_FIND_BY_NAME)(
+  IN  CONST  EFI_GUID            *FileName,
+  IN  EFI_PEI_FV_HANDLE          VolumeHandle,
+  OUT EFI_PEI_FILE_HANDLE        *FileHandle
+  );
+
+///
+/// The information of the FV file.
+///
+typedef struct {
+  ///
+  /// Name of the file.
+  ///
+  EFI_GUID                FileName;
+  ///
+  /// File type.
+  ///
+  EFI_FV_FILETYPE         FileType;
+  ///
+  /// Attributes of the file.
+  ///
+  EFI_FV_FILE_ATTRIBUTES  FileAttributes;
+  ///
+  /// Points to the file's data (not the header).
+  /// Not valid if EFI_FV_FILE_ATTRIB_MEMORY_MAPPED
+  /// is zero.
+  ///
+  VOID                    *Buffer;
+  ///
+  /// Size of the file's data.
+  ///
+  UINT32                  BufferSize;
+} EFI_FV_FILE_INFO;
+
+///
+/// The information with authentication status of the FV file.
+///
+typedef struct {
+  ///
+  /// Name of the file.
+  ///
+  EFI_GUID                FileName;
+  ///
+  /// File type.
+  ///
+  EFI_FV_FILETYPE         FileType;
+  ///
+  /// Attributes of the file.
+  ///
+  EFI_FV_FILE_ATTRIBUTES  FileAttributes;
+  ///
+  /// Points to the file's data (not the header).
+  /// Not valid if EFI_FV_FILE_ATTRIB_MEMORY_MAPPED
+  /// is zero.
+  ///
+  VOID                    *Buffer;
+  ///
+  /// Size of the file's data.
+  ///
+  UINT32                  BufferSize;
+  ///
+  /// Authentication status for this file.
+  ///
+  UINT32                  AuthenticationStatus;
+} EFI_FV_FILE_INFO2;
+
+/**
+  Returns information about a specific file.
+
+  This function returns information about a specific file,
+  including its file name, type, attributes, starting address and
+  size. If the firmware volume is not memory mapped, then the
+  Buffer member will be NULL.
+
+  @param FileHandle   The handle of the file.
+  @param FileInfo     Upon exit, points to the file's
+                      information.
+
+  @retval EFI_SUCCESS             File information was returned.
+  @retval EFI_INVALID_PARAMETER   FileHandle does not
+                                  represent a valid file.
+  @retval EFI_INVALID_PARAMETER   FileInfo is NULL.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_GET_FILE_INFO)(
+  IN  EFI_PEI_FILE_HANDLE         FileHandle,
+  OUT EFI_FV_FILE_INFO            *FileInfo
+  );
+
+/**
+  Returns information about a specific file.
+
+  This function returns information about a specific file,
+  including its file name, type, attributes, starting address, size and authentication status.
+  If the firmware volume is not memory mapped, then the Buffer member will be NULL.
+
+  @param FileHandle   The handle of the file.
+  @param FileInfo     Upon exit, points to the file's
+                      information.
+
+  @retval EFI_SUCCESS             File information was returned.
+  @retval EFI_INVALID_PARAMETER   FileHandle does not
+                                  represent a valid file.
+  @retval EFI_INVALID_PARAMETER   FileInfo is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_GET_FILE_INFO2)(
+  IN  EFI_PEI_FILE_HANDLE         FileHandle,
+  OUT EFI_FV_FILE_INFO2           *FileInfo
+  );
+
+///
+/// The information of the FV volume.
+///
+typedef struct {
+  ///
+  /// Attributes of the firmware volume.
+  ///
+  EFI_FVB_ATTRIBUTES_2  FvAttributes;
+  ///
+  /// Format of the firmware volume.
+  ///
+  EFI_GUID              FvFormat;
+  ///
+  /// Name of the firmware volume.
+  ///
+  EFI_GUID              FvName;
+  ///
+  /// Points to the first byte of the firmware
+  /// volume, if bit EFI_FVB_MEMORY_MAPPED is
+  /// set in FvAttributes.
+  ///
+  VOID                  *FvStart;
+  ///
+  /// Size of the firmware volume.
+  ///
+  UINT64                FvSize;
+} EFI_FV_INFO;
+
+/**
+  Returns information about the specified volume.
+
+  This function returns information about a specific firmware
+  volume, including its name, type, attributes, starting address
+  and size.
+
+  @param VolumeHandle   Handle of the volume.
+  @param VolumeInfo     Upon exit, points to the volume's information.
+
+  @retval EFI_SUCCESS             The volume information returned.
+  @retval EFI_INVALID_PARAMETER   If VolumeHandle does not represent a valid volume.
+  @retval EFI_INVALID_PARAMETER   If VolumeHandle is NULL.
+  @retval EFI_SUCCESS             Information was successfully returned.
+  @retval EFI_INVALID_PARAMETER   The volume designated by the VolumeHandle is not available.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FFS_GET_VOLUME_INFO)(
+  IN  EFI_PEI_FV_HANDLE       VolumeHandle,
+  OUT EFI_FV_INFO             *VolumeInfo
+  );
+
+/**
+  Register a PEIM so that it will be shadowed and called again.
+
+  This service registers a file handle so that after memory is
+  available, the PEIM will be re-loaded into permanent memory and
+  re-initialized. The PEIM registered this way will always be
+  initialized twice. The first time, this function call will
+  return EFI_SUCCESS. The second time, this function call will
+  return EFI_ALREADY_STARTED. Depending on the order in which
+  PEIMs are dispatched, the PEIM making this call may be
+  initialized after permanent memory is installed, even the first
+  time.
+
+  @param  FileHandle            PEIM's file handle. Must be the currently
+                                executing PEIM.
+  
+  @retval EFI_SUCCESS           The PEIM was successfully registered for
+                                shadowing.
+  @retval EFI_ALREADY_STARTED   The PEIM was previously
+                                registered for shadowing.
+  @retval EFI_NOT_FOUND         The FileHandle does not refer to a
+                                valid file handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_REGISTER_FOR_SHADOW)(
+  IN  EFI_PEI_FILE_HANDLE FileHandle
+  );
+
+
+//
+// PEI Specification Revision information
+//
+#define PEI_SPECIFICATION_MAJOR_REVISION  1
+#define PEI_SPECIFICATION_MINOR_REVISION  40
+///
+/// Specification inconsistency here: 
+/// In the PI1.0 spec, PEI_SERVICES_SIGNATURE is defined as 0x5652455320494550. But 
+/// to pass a multiple tool chain, it appends an ULL.
+///
+//
+// PEI Services Table
+//
+#define PEI_SERVICES_SIGNATURE  0x5652455320494550ULL
+///
+/// Specification inconsistency here: 
+/// In the PI1.0 specification, there is a typo error in PEI_SERVICES_REVISION. In the specification the defintion is 
+/// #define ((PEI_SPECIFICATION_MAJOR_REVISION<<16) |(PEI_SPECIFICATION_MINOR_REVISION))
+/// and it should be as follows:
+///
+#define PEI_SERVICES_REVISION   ((PEI_SPECIFICATION_MAJOR_REVISION<<16) | (PEI_SPECIFICATION_MINOR_REVISION))
+
+/// 
+/// EFI_PEI_SERVICES is a collection of functions whose implementation is provided by the PEI
+/// Foundation. These services fall into various classes, including the following:
+/// - Managing the boot mode
+/// - Allocating both early and permanent memory
+/// - Supporting the Firmware File System (FFS)
+/// - Abstracting the PPI database abstraction
+/// - Creating Hand-Off Blocks (HOBs).
+///
+struct _EFI_PEI_SERVICES {
+  ///
+  /// The table header for the PEI Services Table.
+  ///
+  EFI_TABLE_HEADER                Hdr;
+
+  //
+  // PPI Functions
+  //
+  EFI_PEI_INSTALL_PPI             InstallPpi;
+  EFI_PEI_REINSTALL_PPI           ReInstallPpi;
+  EFI_PEI_LOCATE_PPI              LocatePpi;
+  EFI_PEI_NOTIFY_PPI              NotifyPpi;
+
+  //
+  // Boot Mode Functions
+  //
+  EFI_PEI_GET_BOOT_MODE           GetBootMode;
+  EFI_PEI_SET_BOOT_MODE           SetBootMode;
+
+  //
+  // HOB Functions
+  //
+  EFI_PEI_GET_HOB_LIST            GetHobList;
+  EFI_PEI_CREATE_HOB              CreateHob;
+
+  //
+  // Firmware Volume Functions
+  //
+  EFI_PEI_FFS_FIND_NEXT_VOLUME2   FfsFindNextVolume;
+  EFI_PEI_FFS_FIND_NEXT_FILE2     FfsFindNextFile;
+  EFI_PEI_FFS_FIND_SECTION_DATA2  FfsFindSectionData;
+
+  //
+  // PEI Memory Functions
+  //
+  EFI_PEI_INSTALL_PEI_MEMORY      InstallPeiMemory;
+  EFI_PEI_ALLOCATE_PAGES          AllocatePages;
+  EFI_PEI_ALLOCATE_POOL           AllocatePool;
+  EFI_PEI_COPY_MEM                CopyMem;
+  EFI_PEI_SET_MEM                 SetMem;
+
+  //
+  // Status Code
+  //
+  EFI_PEI_REPORT_STATUS_CODE      ReportStatusCode;
+
+  //
+  // Reset
+  //
+  EFI_PEI_RESET_SYSTEM            ResetSystem;
+
+  //
+  // (the following interfaces are installed by publishing PEIM)
+  // I/O Abstractions
+  //
+  EFI_PEI_CPU_IO_PPI              *CpuIo;
+  EFI_PEI_PCI_CFG2_PPI            *PciCfg;
+
+  //
+  // Future Installed Services
+  //
+  EFI_PEI_FFS_FIND_BY_NAME        FfsFindFileByName;
+  EFI_PEI_FFS_GET_FILE_INFO       FfsGetFileInfo;
+  EFI_PEI_FFS_GET_VOLUME_INFO     FfsGetVolumeInfo;
+  EFI_PEI_REGISTER_FOR_SHADOW     RegisterForShadow;
+  EFI_PEI_FFS_FIND_SECTION_DATA3  FindSectionData3;
+  EFI_PEI_FFS_GET_FILE_INFO2      FfsGetFileInfo2;
+  EFI_PEI_RESET2_SYSTEM           ResetSystem2;
+};
+
+
+///
+/// EFI_SEC_PEI_HAND_OFF structure holds information about
+/// PEI core's operating environment, such as the size of location of
+/// temporary RAM, the stack location and BFV location.
+/// 
+typedef struct _EFI_SEC_PEI_HAND_OFF {
+  ///
+  /// Size of the data structure.
+  /// 
+  UINT16  DataSize;
+
+  ///
+  /// Points to the first byte of the boot firmware volume, 
+  /// which the PEI Dispatcher should search for 
+  /// PEI modules.
+  /// 
+  VOID    *BootFirmwareVolumeBase;
+
+  ///
+  /// Size of the boot firmware volume, in bytes.
+  /// 
+  UINTN   BootFirmwareVolumeSize;
+
+  ///
+  /// Points to the first byte of the temporary RAM.
+  /// 
+  VOID    *TemporaryRamBase;
+
+  ///
+  /// Size of the temporary RAM, in bytes.
+  /// 
+  UINTN   TemporaryRamSize;
+
+  ///
+  /// Points to the first byte of the temporary RAM 
+  /// available for use by the PEI Foundation. The area 
+  /// described by PeiTemporaryRamBase and PeiTemporaryRamSize 
+  /// must not extend outside beyond the area described by
+  /// TemporaryRamBase & TemporaryRamSize. This area should not
+  /// overlap with the area reported by StackBase and 
+  /// StackSize.
+  ///
+  VOID    *PeiTemporaryRamBase;
+
+  ///
+  /// The size of the available temporary RAM available for 
+  /// use by the PEI Foundation, in bytes.
+  /// 
+  UINTN   PeiTemporaryRamSize;
+
+  ///
+  /// Points to the first byte of the stack. 
+  /// This are may be part of the memory described by 
+  /// TemporaryRamBase and TemporaryRamSize 
+  /// or may be an entirely separate area.
+  /// 
+  VOID    *StackBase;
+
+  ///
+  /// Size of the stack, in bytes.
+  /// 
+  UINTN   StackSize;
+} EFI_SEC_PEI_HAND_OFF;
+
+
+/**
+  The entry point of PEI Foundation.
+
+  This function is the entry point for the PEI Foundation, which
+  allows the SEC phase to pass information about the stack,
+  temporary RAM and the Boot Firmware Volume. In addition, it also
+  allows the SEC phase to pass services and data forward for use
+  during the PEI phase in the form of one or more PPIs. There is
+  no limit to the number of additional PPIs that can be passed
+  from SEC into the PEI Foundation. As part of its initialization
+  phase, the PEI Foundation will add these SEC-hosted PPIs to its
+  PPI database such that both the PEI Foundation and any modules
+  can leverage the associated service calls and/or code in these
+  early PPIs.
+
+  @param SecCoreData    Points to a data structure containing
+                        information about the PEI core's
+                        operating environment, such as the size
+                        and location of temporary RAM, the stack
+                        location and the BFV location.
+
+  @param PpiList        Points to a list of one or more PPI
+                        descriptors to be installed initially by
+                        the PEI core. An empty PPI list consists
+                        of a single descriptor with the end-tag
+                        EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                        As part of its initialization phase, the
+                        PEI Foundation will add these SEC-hosted
+                        PPIs to its PPI database such that both
+                        the PEI Foundation and any modules can
+                        leverage the associated service calls
+                        and/or code in these early PPIs.
+
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CORE_ENTRY_POINT)(
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList
+);
+
+#endif
diff --git a/MdePkg/Include/Pi/PiS3BootScript.h b/MdePkg/Include/Pi/PiS3BootScript.h
new file mode 100644
index 000000000000..466f084ee0e5
--- /dev/null
+++ b/MdePkg/Include/Pi/PiS3BootScript.h
@@ -0,0 +1,59 @@
+/** @file
+  This file contains the boot script defintions that are shared between the 
+  Boot Script Executor PPI and the Boot Script Save Protocol.
+
+  Copyright (c) 2009, 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 _PI_S3_BOOT_SCRIPT_H_
+#define _PI_S3_BOOT_SCRIPT_H_
+
+//*******************************************
+// EFI Boot Script Opcode definitions
+//*******************************************
+#define EFI_BOOT_SCRIPT_IO_WRITE_OPCODE                 0x00
+#define EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE            0x01
+#define EFI_BOOT_SCRIPT_MEM_WRITE_OPCODE                0x02
+#define EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE           0x03
+#define EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE         0x04
+#define EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE    0x05
+#define EFI_BOOT_SCRIPT_SMBUS_EXECUTE_OPCODE            0x06
+#define EFI_BOOT_SCRIPT_STALL_OPCODE                    0x07
+#define EFI_BOOT_SCRIPT_DISPATCH_OPCODE                 0x08
+#define EFI_BOOT_SCRIPT_DISPATCH_2_OPCODE               0x09
+#define EFI_BOOT_SCRIPT_INFORMATION_OPCODE              0x0A
+#define EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE        0x0B
+#define EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE   0x0C
+#define EFI_BOOT_SCRIPT_IO_POLL_OPCODE                  0x0D
+#define EFI_BOOT_SCRIPT_MEM_POLL_OPCODE                 0x0E
+#define EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE          0x0F
+#define EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE         0x10
+
+//*******************************************
+// EFI_BOOT_SCRIPT_WIDTH
+//*******************************************
+typedef enum {
+  EfiBootScriptWidthUint8,
+  EfiBootScriptWidthUint16,
+  EfiBootScriptWidthUint32,
+  EfiBootScriptWidthUint64,
+  EfiBootScriptWidthFifoUint8,
+  EfiBootScriptWidthFifoUint16,
+  EfiBootScriptWidthFifoUint32,
+  EfiBootScriptWidthFifoUint64,
+  EfiBootScriptWidthFillUint8,
+  EfiBootScriptWidthFillUint16,
+  EfiBootScriptWidthFillUint32,
+  EfiBootScriptWidthFillUint64,
+  EfiBootScriptWidthMaximum
+} EFI_BOOT_SCRIPT_WIDTH;
+
+#endif
diff --git a/MdePkg/Include/Pi/PiSmmCis.h b/MdePkg/Include/Pi/PiSmmCis.h
new file mode 100644
index 000000000000..7e8cd5f54500
--- /dev/null
+++ b/MdePkg/Include/Pi/PiSmmCis.h
@@ -0,0 +1,351 @@
+/** @file
+  Common definitions in the Platform Initialization Specification version 1.4a
+  VOLUME 4 System Management Mode Core Interface version.
+
+  Copyright (c) 2009 - 2016, 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 _PI_SMMCIS_H_
+#define _PI_SMMCIS_H_
+
+#include <Pi/PiMultiPhase.h>
+#include <Protocol/SmmCpuIo2.h>
+
+typedef struct _EFI_SMM_SYSTEM_TABLE2  EFI_SMM_SYSTEM_TABLE2;
+
+///
+/// The System Management System Table (SMST) signature
+///
+#define SMM_SMST_SIGNATURE            SIGNATURE_32 ('S', 'M', 'S', 'T')
+///
+/// The System Management System Table (SMST) revision is 1.4
+///
+#define SMM_SPECIFICATION_MAJOR_REVISION  1
+#define SMM_SPECIFICATION_MINOR_REVISION  40
+#define EFI_SMM_SYSTEM_TABLE2_REVISION    ((SMM_SPECIFICATION_MAJOR_REVISION<<16) | (SMM_SPECIFICATION_MINOR_REVISION))
+
+/**
+  Adds, updates, or removes a configuration table entry from the System Management System Table.
+
+  The SmmInstallConfigurationTable() function is used to maintain the list
+  of configuration tables that are stored in the System Management System
+  Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list
+  must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
+
+  @param[in] SystemTable         A pointer to the SMM System Table (SMST).
+  @param[in] Guid                A pointer to the GUID for the entry to add, update, or remove.
+  @param[in] Table               A pointer to the buffer of the table to add.
+  @param[in] TableSize           The size of the table to install.
+
+  @retval EFI_SUCCESS            The (Guid, Table) pair was added, updated, or removed.
+  @retval EFI_INVALID_PARAMETER  Guid is not valid.
+  @retval EFI_NOT_FOUND          An attempt was made to delete a non-existent entry.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory available to complete the operation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE2)(
+  IN CONST EFI_SMM_SYSTEM_TABLE2  *SystemTable,
+  IN CONST EFI_GUID               *Guid,
+  IN VOID                         *Table,
+  IN UINTN                        TableSize
+  );
+
+/**
+  This service lets the caller to get one distinct application processor (AP) to execute
+  a caller-provided code stream while in SMM.
+
+  @param[in]     Procedure       A pointer to the code stream to be run on the designated
+                                 AP of the system.
+  @param[in]     CpuNumber       The zero-based index of the processor number of the AP
+                                 on which the code stream is supposed to run.
+  @param[in,out] ProcArguments   Allows the caller to pass a list of parameters to the code
+                                 that is run by the AP.
+
+  @retval EFI_SUCCESS            The call was successful and the return parameters are valid.
+  @retval EFI_INVALID_PARAMETER  The input arguments are out of range.
+  @retval EFI_INVALID_PARAMETER  The CPU requested is not available on this SMI invocation.
+  @retval EFI_INVALID_PARAMETER  The CPU cannot support an additional service invocation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_STARTUP_THIS_AP)(
+  IN EFI_AP_PROCEDURE  Procedure,
+  IN UINTN             CpuNumber,
+  IN OUT VOID          *ProcArguments OPTIONAL
+  );
+
+/**
+  Function prototype for protocol install notification.
+
+  @param[in] Protocol   Points to the protocol's unique identifier.
+  @param[in] Interface  Points to the interface instance.
+  @param[in] Handle     The handle on which the interface was installed.
+
+  @return Status Code
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_NOTIFY_FN)(
+  IN CONST EFI_GUID  *Protocol,
+  IN VOID            *Interface,
+  IN EFI_HANDLE      Handle
+  );
+
+/**
+  Register a callback function be called when a particular protocol interface is installed.
+
+  The SmmRegisterProtocolNotify() function creates a registration Function that is to be 
+  called whenever a protocol interface is installed for Protocol by 
+  SmmInstallProtocolInterface().
+  If Function == NULL and Registration is an existing registration, then the callback is unhooked.
+
+  @param[in]  Protocol          The unique ID of the protocol for which the event is to be registered.
+  @param[in]  Function          Points to the notification function.
+  @param[out] Registration      A pointer to a memory location to receive the registration value.
+
+  @retval EFI_SUCCESS           Successfully returned the registration record
+                                that has been added or unhooked.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL or Registration is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Not enough memory resource to finish the request.
+  @retval EFI_NOT_FOUND         If the registration is not found when Function == NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_REGISTER_PROTOCOL_NOTIFY)(
+  IN  CONST EFI_GUID     *Protocol,
+  IN  EFI_SMM_NOTIFY_FN  Function,
+  OUT VOID               **Registration
+  );
+
+/**
+  Manage SMI of a particular type.
+
+  @param[in]     HandlerType     Points to the handler type or NULL for root SMI handlers.
+  @param[in]     Context         Points to an optional context buffer.
+  @param[in,out] CommBuffer      Points to the optional communication buffer.
+  @param[in,out] CommBufferSize  Points to the size of the optional communication buffer.
+
+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING  Interrupt source was processed successfully but not quiesced.
+  @retval EFI_INTERRUPT_PENDING              One or more SMI sources could not be quiesced.
+  @retval EFI_NOT_FOUND                      Interrupt source was not handled or quiesced.
+  @retval EFI_SUCCESS                        Interrupt source was handled and quiesced.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_INTERRUPT_MANAGE)(
+  IN CONST EFI_GUID  *HandlerType,
+  IN CONST VOID      *Context         OPTIONAL,
+  IN OUT VOID        *CommBuffer      OPTIONAL,
+  IN OUT UINTN       *CommBufferSize  OPTIONAL
+  );
+
+/**
+  Main entry point for an SMM handler dispatch or communicate-based callback.
+
+  @param[in]     DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
+  @param[in]     Context         Points to an optional handler context which was specified when the
+                                 handler was registered.
+  @param[in,out] CommBuffer      A pointer to a collection of data in memory that will
+                                 be conveyed from a non-SMM environment into an SMM environment.
+  @param[in,out] CommBufferSize  The size of the CommBuffer.
+
+  @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers 
+                                              should still be called.
+  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should 
+                                              still be called.
+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still 
+                                              be called.
+  @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT2)(
+  IN EFI_HANDLE  DispatchHandle,
+  IN CONST VOID  *Context         OPTIONAL,
+  IN OUT VOID    *CommBuffer      OPTIONAL,
+  IN OUT UINTN   *CommBufferSize  OPTIONAL
+  );
+
+/**
+  Registers a handler to execute within SMM.
+
+  @param[in]  Handler            Handler service function pointer.
+  @param[in]  HandlerType        Points to the handler type or NULL for root SMI handlers.
+  @param[out] DispatchHandle     On return, contains a unique handle which can be used to later
+                                 unregister the handler function.
+
+  @retval EFI_SUCCESS            SMI handler added successfully.
+  @retval EFI_INVALID_PARAMETER  Handler is NULL or DispatchHandle is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_INTERRUPT_REGISTER)(
+  IN  EFI_SMM_HANDLER_ENTRY_POINT2  Handler,
+  IN  CONST EFI_GUID                *HandlerType OPTIONAL,
+  OUT EFI_HANDLE                    *DispatchHandle
+  );
+
+/**
+  Unregister a handler in SMM.
+
+  @param[in] DispatchHandle      The handle that was specified when the handler was registered.
+
+  @retval EFI_SUCCESS            Handler function was successfully unregistered.
+  @retval EFI_INVALID_PARAMETER  DispatchHandle does not refer to a valid handle.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_INTERRUPT_UNREGISTER)(
+  IN EFI_HANDLE  DispatchHandle
+  );
+
+///
+/// Processor information and functionality needed by SMM Foundation.
+///
+typedef struct _EFI_SMM_ENTRY_CONTEXT {
+  EFI_SMM_STARTUP_THIS_AP  SmmStartupThisAp;
+  ///
+  /// A number between zero and the NumberOfCpus field. This field designates which 
+  /// processor is executing the SMM Foundation.
+  ///
+  UINTN                    CurrentlyExecutingCpu;
+  ///
+  /// The number of possible processors in the platform.  This is a 1 based 
+  /// counter.  This does not indicate the number of processors that entered SMM.
+  ///
+  UINTN                    NumberOfCpus;
+  ///
+  /// Points to an array, where each element describes the number of bytes in the 
+  /// corresponding save state specified by CpuSaveState. There are always 
+  /// NumberOfCpus entries in the array. 
+  ///
+  UINTN                    *CpuSaveStateSize;
+  ///
+  /// Points to an array, where each element is a pointer to a CPU save state. The 
+  /// corresponding element in CpuSaveStateSize specifies the number of bytes in the 
+  /// save state area. There are always NumberOfCpus entries in the array.
+  ///
+  VOID                     **CpuSaveState;
+} EFI_SMM_ENTRY_CONTEXT;
+
+/**
+  This function is the main entry point to the SMM Foundation.
+
+  @param[in] SmmEntryContext  Processor information and functionality needed by SMM Foundation.
+**/
+typedef
+VOID
+(EFIAPI *EFI_SMM_ENTRY_POINT)(
+  IN CONST EFI_SMM_ENTRY_CONTEXT  *SmmEntryContext
+  );
+
+///
+/// System Management System Table (SMST)
+///
+/// The System Management System Table (SMST) is a table that contains a collection of common 
+/// services for managing SMRAM allocation and providing basic I/O services. These services are 
+/// intended for both preboot and runtime usage.
+///
+struct _EFI_SMM_SYSTEM_TABLE2 {
+  ///
+  /// The table header for the SMST.
+  ///
+  EFI_TABLE_HEADER                     Hdr;
+  ///
+  /// A pointer to a NULL-terminated Unicode string containing the vendor name.
+  /// It is permissible for this pointer to be NULL.
+  ///
+  CHAR16                               *SmmFirmwareVendor;
+  ///
+  /// The particular revision of the firmware.
+  ///
+  UINT32                               SmmFirmwareRevision;
+
+  EFI_SMM_INSTALL_CONFIGURATION_TABLE2 SmmInstallConfigurationTable;
+
+  ///
+  /// I/O Service
+  ///
+  EFI_SMM_CPU_IO2_PROTOCOL             SmmIo;
+
+  ///
+  /// Runtime memory services
+  ///
+  EFI_ALLOCATE_POOL                    SmmAllocatePool;
+  EFI_FREE_POOL                        SmmFreePool;
+  EFI_ALLOCATE_PAGES                   SmmAllocatePages;
+  EFI_FREE_PAGES                       SmmFreePages;
+
+  ///
+  /// MP service
+  ///
+  EFI_SMM_STARTUP_THIS_AP              SmmStartupThisAp;
+
+  ///
+  /// CPU information records
+  ///
+
+  ///
+  /// A number between zero and and the NumberOfCpus field. This field designates 
+  /// which processor is executing the SMM infrastructure.
+  ///
+  UINTN                                CurrentlyExecutingCpu;
+  ///
+  /// The number of possible processors in the platform.  This is a 1 based counter.
+  ///
+  UINTN                                NumberOfCpus;
+  ///
+  /// Points to an array, where each element describes the number of bytes in the 
+  /// corresponding save state specified by CpuSaveState. There are always 
+  /// NumberOfCpus entries in the array. 
+  ///
+  UINTN                                *CpuSaveStateSize;
+  ///
+  /// Points to an array, where each element is a pointer to a CPU save state. The 
+  /// corresponding element in CpuSaveStateSize specifies the number of bytes in the 
+  /// save state area. There are always NumberOfCpus entries in the array.
+  ///
+  VOID                                 **CpuSaveState;
+
+  ///
+  /// Extensibility table
+  ///
+
+  ///
+  /// The number of UEFI Configuration Tables in the buffer SmmConfigurationTable.
+  ///
+  UINTN                                NumberOfTableEntries;
+  ///
+  /// A pointer to the UEFI Configuration Tables. The number of entries in the table is 
+  /// NumberOfTableEntries. 
+  ///
+  EFI_CONFIGURATION_TABLE              *SmmConfigurationTable;
+
+  ///
+  /// Protocol services
+  ///
+  EFI_INSTALL_PROTOCOL_INTERFACE       SmmInstallProtocolInterface;
+  EFI_UNINSTALL_PROTOCOL_INTERFACE     SmmUninstallProtocolInterface;
+  EFI_HANDLE_PROTOCOL                  SmmHandleProtocol;
+  EFI_SMM_REGISTER_PROTOCOL_NOTIFY     SmmRegisterProtocolNotify;
+  EFI_LOCATE_HANDLE                    SmmLocateHandle;
+  EFI_LOCATE_PROTOCOL                  SmmLocateProtocol;
+
+  ///
+  /// SMI Management functions
+  ///
+  EFI_SMM_INTERRUPT_MANAGE             SmiManage;
+  EFI_SMM_INTERRUPT_REGISTER           SmiHandlerRegister;
+  EFI_SMM_INTERRUPT_UNREGISTER         SmiHandlerUnRegister;
+};
+
+#endif
diff --git a/MdePkg/Include/Pi/PiSmmCommunicationAcpiTable.h b/MdePkg/Include/Pi/PiSmmCommunicationAcpiTable.h
new file mode 100644
index 000000000000..a683299b6abb
--- /dev/null
+++ b/MdePkg/Include/Pi/PiSmmCommunicationAcpiTable.h
@@ -0,0 +1,20 @@
+/** @file
+  PI SMM Communication ACPI Table Definition.
+
+Copyright (c) 2011, 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 __PI_SMM_COMMUNICATION_ACPI_TABLE__
+#define __PI_SMM_COMMUNICATION_ACPI_TABLE__
+
+#include <Uefi/UefiAcpiDataTable.h>
+
+#endif
diff --git a/MdePkg/Include/Pi/PiStatusCode.h b/MdePkg/Include/Pi/PiStatusCode.h
new file mode 100644
index 000000000000..adb70ca2050f
--- /dev/null
+++ b/MdePkg/Include/Pi/PiStatusCode.h
@@ -0,0 +1,1199 @@
+/** @file
+  StatusCode related definitions in PI.
+
+Copyright (c) 2009 - 2013, 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.             
+
+  @par Revision Reference:
+  These status codes are defined in UEFI Platform Initialization Specification 1.2, 
+  Volume 3: Shared Architectural Elements.
+
+**/
+
+#ifndef __PI_STATUS_CODE_H__
+#define __PI_STATUS_CODE_H__
+
+//
+// Required for IA32, X64, IPF, ARM and EBC defines for CPU exception types
+//
+#include <Protocol/DebugSupport.h>
+
+///
+/// Status Code Type Definition.
+///
+typedef UINT32  EFI_STATUS_CODE_TYPE;
+
+///
+/// A Status Code Type is made up of the code type and severity.
+/// All values masked by EFI_STATUS_CODE_RESERVED_MASK are
+/// reserved for use by this specification.
+///
+///@{
+#define EFI_STATUS_CODE_TYPE_MASK     0x000000FF
+#define EFI_STATUS_CODE_SEVERITY_MASK 0xFF000000
+#define EFI_STATUS_CODE_RESERVED_MASK 0x00FFFF00
+///@}
+
+///
+/// Definition of code types. All other values masked by
+/// EFI_STATUS_CODE_TYPE_MASK are reserved for use by
+/// this specification.
+///
+///@{
+#define EFI_PROGRESS_CODE             0x00000001
+#define EFI_ERROR_CODE                0x00000002
+#define EFI_DEBUG_CODE                0x00000003
+///@}
+
+///
+/// Definitions of severities, all other values masked by
+/// EFI_STATUS_CODE_SEVERITY_MASK are reserved for use by
+/// this specification.
+/// Uncontained errors are major errors that could not contained
+/// to the specific component that is reporting the error.
+/// For example, if a memory error was not detected early enough,
+/// the bad data could be consumed by other drivers.
+///
+///@{
+#define EFI_ERROR_MINOR               0x40000000
+#define EFI_ERROR_MAJOR               0x80000000
+#define EFI_ERROR_UNRECOVERED         0x90000000
+#define EFI_ERROR_UNCONTAINED         0xa0000000
+///@}
+
+///
+/// Status Code Value Definition.
+///
+typedef UINT32 EFI_STATUS_CODE_VALUE;
+
+///
+/// A Status Code Value is made up of the class, subclass, and
+/// an operation.
+///
+///@{
+#define EFI_STATUS_CODE_CLASS_MASK      0xFF000000
+#define EFI_STATUS_CODE_SUBCLASS_MASK   0x00FF0000
+#define EFI_STATUS_CODE_OPERATION_MASK  0x0000FFFF
+///@}
+
+///
+/// Definition of Status Code extended data header.
+/// The data will follow HeaderSize bytes from the beginning of
+/// the structure and is Size bytes long.
+///
+typedef struct {
+  ///
+  /// The size of the structure. This is specified to enable future expansion.
+  ///
+  UINT16    HeaderSize;
+  ///
+  /// The size of the data in bytes. This does not include the size of the header structure.
+  ///
+  UINT16    Size;
+  ///
+  /// The GUID defining the type of the data.
+  ///
+  EFI_GUID  Type;
+} EFI_STATUS_CODE_DATA;
+
+///
+/// General partitioning scheme for Progress and Error Codes are:
+///   - 0x0000-0x0FFF    Shared by all sub-classes in a given class.
+///   - 0x1000-0x7FFF    Subclass Specific.
+///   - 0x8000-0xFFFF    OEM specific.
+///@{
+#define EFI_SUBCLASS_SPECIFIC 0x1000
+#define EFI_OEM_SPECIFIC      0x8000
+///@}
+
+///
+/// Debug Code definitions for all classes and subclass.
+/// Only one debug code is defined at this point and should
+/// be used for anything that is sent to the debug stream.
+///
+///@{
+#define EFI_DC_UNSPECIFIED  0x0
+///@}
+
+///
+/// Class definitions.
+/// Values of 4-127 are reserved for future use by this specification.
+/// Values in the range 127-255 are reserved for OEM use.
+///
+///@{
+#define EFI_COMPUTING_UNIT  0x00000000
+#define EFI_PERIPHERAL      0x01000000
+#define EFI_IO_BUS          0x02000000
+#define EFI_SOFTWARE        0x03000000
+///@}
+
+/// 
+/// Computing Unit Subclass definitions.
+/// Values of 8-127 are reserved for future use by this specification.
+/// Values of 128-255 are reserved for OEM use.
+///
+///@{
+#define EFI_COMPUTING_UNIT_UNSPECIFIED        (EFI_COMPUTING_UNIT | 0x00000000)
+#define EFI_COMPUTING_UNIT_HOST_PROCESSOR     (EFI_COMPUTING_UNIT | 0x00010000)
+#define EFI_COMPUTING_UNIT_FIRMWARE_PROCESSOR (EFI_COMPUTING_UNIT | 0x00020000)
+#define EFI_COMPUTING_UNIT_IO_PROCESSOR       (EFI_COMPUTING_UNIT | 0x00030000)
+#define EFI_COMPUTING_UNIT_CACHE              (EFI_COMPUTING_UNIT | 0x00040000)
+#define EFI_COMPUTING_UNIT_MEMORY             (EFI_COMPUTING_UNIT | 0x00050000)
+#define EFI_COMPUTING_UNIT_CHIPSET            (EFI_COMPUTING_UNIT | 0x00060000)
+///@}
+
+///
+/// Computing Unit Class Progress Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_CU_PC_INIT_BEGIN  0x00000000
+#define EFI_CU_PC_INIT_END    0x00000001
+///@}
+
+//
+// Computing Unit Unspecified Subclass Progress Code definitions.
+//
+
+///
+/// Computing Unit Host Processor Subclass Progress Code definitions.
+///@{
+#define EFI_CU_HP_PC_POWER_ON_INIT          (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_HP_PC_CACHE_INIT             (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_HP_PC_RAM_INIT               (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_CU_HP_PC_MEMORY_CONTROLLER_INIT (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_CU_HP_PC_IO_INIT                (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_CU_HP_PC_BSP_SELECT             (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_CU_HP_PC_BSP_RESELECT           (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_CU_HP_PC_AP_INIT                (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_CU_HP_PC_SMM_INIT               (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+///@}
+
+//
+// Computing Unit Firmware Processor Subclass Progress Code definitions.
+//
+
+//
+// Computing Unit IO Processor Subclass Progress Code definitions.
+//
+
+///
+/// Computing Unit Cache Subclass Progress Code definitions.
+///
+///@{
+#define EFI_CU_CACHE_PC_PRESENCE_DETECT (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_CACHE_PC_CONFIGURATION   (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+///
+/// Computing Unit Memory Subclass Progress Code definitions.
+///
+///@{
+#define EFI_CU_MEMORY_PC_SPD_READ         (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_MEMORY_PC_PRESENCE_DETECT  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_MEMORY_PC_TIMING           (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_CU_MEMORY_PC_CONFIGURING      (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_CU_MEMORY_PC_OPTIMIZING       (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_CU_MEMORY_PC_INIT             (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_CU_MEMORY_PC_TEST             (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+///@}
+
+//
+// Computing Unit Chipset Subclass Progress Code definitions.
+//
+
+///
+/// South Bridge initialization prior to memory detection.
+///
+#define EFI_CHIPSET_PC_PEI_CAR_SB_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000000)
+
+///
+/// North Bridge initialization prior to memory detection.
+///
+#define EFI_CHIPSET_PC_PEI_CAR_NB_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000001)
+
+///
+/// South Bridge initialization after memory detection.
+///
+#define EFI_CHIPSET_PC_PEI_MEM_SB_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000002)
+
+///
+/// North Bridge initialization after memory detection.
+///
+#define EFI_CHIPSET_PC_PEI_MEM_NB_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000003)
+
+///
+/// PCI Host Bridge DXE initialization.
+///
+#define EFI_CHIPSET_PC_DXE_HB_INIT          (EFI_SUBCLASS_SPECIFIC|0x00000004)
+
+///
+/// North Bridge DXE initialization.
+///
+#define EFI_CHIPSET_PC_DXE_NB_INIT          (EFI_SUBCLASS_SPECIFIC|0x00000005)
+
+///
+/// North Bridge specific SMM initialization in DXE.
+///
+#define EFI_CHIPSET_PC_DXE_NB_SMM_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000006)
+
+///
+/// Initialization of the South Bridge specific UEFI Runtime Services.
+///
+#define EFI_CHIPSET_PC_DXE_SB_RT_INIT       (EFI_SUBCLASS_SPECIFIC|0x00000007)
+
+///
+/// South Bridge DXE initialization
+///
+#define EFI_CHIPSET_PC_DXE_SB_INIT          (EFI_SUBCLASS_SPECIFIC|0x00000008)
+
+///
+/// South Bridge specific SMM initialization in DXE.
+///
+#define EFI_CHIPSET_PC_DXE_SB_SMM_INIT      (EFI_SUBCLASS_SPECIFIC|0x00000009)
+
+///
+/// Initialization of the South Bridge devices.
+///
+#define EFI_CHIPSET_PC_DXE_SB_DEVICES_INIT  (EFI_SUBCLASS_SPECIFIC|0x0000000a)
+
+///
+/// Computing Unit Class Error Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_CU_EC_NON_SPECIFIC    0x00000000
+#define EFI_CU_EC_DISABLED        0x00000001
+#define EFI_CU_EC_NOT_SUPPORTED   0x00000002
+#define EFI_CU_EC_NOT_DETECTED    0x00000003
+#define EFI_CU_EC_NOT_CONFIGURED  0x00000004
+///@}
+
+//
+// Computing Unit Unspecified Subclass Error Code definitions.
+//
+
+///
+/// Computing Unit Host Processor Subclass Error Code definitions.
+///
+///@{
+#define EFI_CU_HP_EC_INVALID_TYPE         (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_HP_EC_INVALID_SPEED        (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_HP_EC_MISMATCH             (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_CU_HP_EC_TIMER_EXPIRED        (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_CU_HP_EC_SELF_TEST            (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_CU_HP_EC_INTERNAL             (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_CU_HP_EC_THERMAL              (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_CU_HP_EC_LOW_VOLTAGE          (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_CU_HP_EC_HIGH_VOLTAGE         (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_CU_HP_EC_CACHE                (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_CU_HP_EC_MICROCODE_UPDATE     (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+#define EFI_CU_HP_EC_CORRECTABLE          (EFI_SUBCLASS_SPECIFIC | 0x0000000B)
+#define EFI_CU_HP_EC_UNCORRECTABLE        (EFI_SUBCLASS_SPECIFIC | 0x0000000C)
+#define EFI_CU_HP_EC_NO_MICROCODE_UPDATE  (EFI_SUBCLASS_SPECIFIC | 0x0000000D)
+///@}
+
+///
+/// Computing Unit Firmware Processor Subclass Error Code definitions.
+///
+///@{
+#define EFI_CU_FP_EC_HARD_FAIL  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_FP_EC_SOFT_FAIL  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_FP_EC_COMM_ERROR (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+//
+// Computing Unit IO Processor Subclass Error Code definitions.
+//
+
+///
+/// Computing Unit Cache Subclass Error Code definitions.
+///
+///@{
+#define EFI_CU_CACHE_EC_INVALID_TYPE  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_CACHE_EC_INVALID_SPEED (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_CACHE_EC_INVALID_SIZE  (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_CU_CACHE_EC_MISMATCH      (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+///@}
+
+///
+/// Computing Unit Memory Subclass Error Code definitions.
+///
+///@{
+#define EFI_CU_MEMORY_EC_INVALID_TYPE   (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CU_MEMORY_EC_INVALID_SPEED  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CU_MEMORY_EC_CORRECTABLE    (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_CU_MEMORY_EC_UNCORRECTABLE  (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_CU_MEMORY_EC_SPD_FAIL       (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_CU_MEMORY_EC_INVALID_SIZE   (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_CU_MEMORY_EC_MISMATCH       (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_CU_MEMORY_EC_S3_RESUME_FAIL (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_CU_MEMORY_EC_UPDATE_FAIL    (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_CU_MEMORY_EC_NONE_DETECTED  (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_CU_MEMORY_EC_NONE_USEFUL    (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+///@}
+
+///
+/// Computing Unit Chipset Subclass Error Code definitions.
+///
+///@{
+#define EFI_CHIPSET_EC_BAD_BATTERY      (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_CHIPSET_EC_DXE_NB_ERROR     (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_CHIPSET_EC_DXE_SB_ERROR     (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+///
+/// Peripheral Subclass definitions.
+/// Values of 12-127 are reserved for future use by this specification.
+/// Values of 128-255 are reserved for OEM use.
+///
+///@{
+#define EFI_PERIPHERAL_UNSPECIFIED      (EFI_PERIPHERAL | 0x00000000)
+#define EFI_PERIPHERAL_KEYBOARD         (EFI_PERIPHERAL | 0x00010000)
+#define EFI_PERIPHERAL_MOUSE            (EFI_PERIPHERAL | 0x00020000)
+#define EFI_PERIPHERAL_LOCAL_CONSOLE    (EFI_PERIPHERAL | 0x00030000)
+#define EFI_PERIPHERAL_REMOTE_CONSOLE   (EFI_PERIPHERAL | 0x00040000)
+#define EFI_PERIPHERAL_SERIAL_PORT      (EFI_PERIPHERAL | 0x00050000)
+#define EFI_PERIPHERAL_PARALLEL_PORT    (EFI_PERIPHERAL | 0x00060000)
+#define EFI_PERIPHERAL_FIXED_MEDIA      (EFI_PERIPHERAL | 0x00070000)
+#define EFI_PERIPHERAL_REMOVABLE_MEDIA  (EFI_PERIPHERAL | 0x00080000)
+#define EFI_PERIPHERAL_AUDIO_INPUT      (EFI_PERIPHERAL | 0x00090000)
+#define EFI_PERIPHERAL_AUDIO_OUTPUT     (EFI_PERIPHERAL | 0x000A0000)
+#define EFI_PERIPHERAL_LCD_DEVICE       (EFI_PERIPHERAL | 0x000B0000)
+#define EFI_PERIPHERAL_NETWORK          (EFI_PERIPHERAL | 0x000C0000)
+///@}
+
+///
+/// Peripheral Class Progress Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_P_PC_INIT             0x00000000
+#define EFI_P_PC_RESET            0x00000001
+#define EFI_P_PC_DISABLE          0x00000002
+#define EFI_P_PC_PRESENCE_DETECT  0x00000003
+#define EFI_P_PC_ENABLE           0x00000004
+#define EFI_P_PC_RECONFIG         0x00000005
+#define EFI_P_PC_DETECTED         0x00000006
+///@}
+
+//
+// Peripheral Class Unspecified Subclass Progress Code definitions.
+//
+
+///
+/// Peripheral Class Keyboard Subclass Progress Code definitions.
+///
+///@{
+#define EFI_P_KEYBOARD_PC_CLEAR_BUFFER  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_P_KEYBOARD_PC_SELF_TEST     (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+///
+/// Peripheral Class Mouse Subclass Progress Code definitions.
+///
+///@{
+#define EFI_P_MOUSE_PC_SELF_TEST  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+///@}
+
+//
+// Peripheral Class Local Console Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Remote Console Subclass Progress Code definitions.
+//
+
+///
+/// Peripheral Class Serial Port Subclass Progress Code definitions.
+///
+///@{
+#define EFI_P_SERIAL_PORT_PC_CLEAR_BUFFER (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+///@}
+
+//
+// Peripheral Class Parallel Port Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Fixed Media Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Removable Media Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Audio Input Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Audio Output Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class LCD Device Subclass Progress Code definitions.
+//
+
+//
+// Peripheral Class Network Subclass Progress Code definitions.
+//
+
+///
+/// Peripheral Class Error Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_P_EC_NON_SPECIFIC       0x00000000
+#define EFI_P_EC_DISABLED           0x00000001
+#define EFI_P_EC_NOT_SUPPORTED      0x00000002
+#define EFI_P_EC_NOT_DETECTED       0x00000003
+#define EFI_P_EC_NOT_CONFIGURED     0x00000004
+#define EFI_P_EC_INTERFACE_ERROR    0x00000005
+#define EFI_P_EC_CONTROLLER_ERROR   0x00000006
+#define EFI_P_EC_INPUT_ERROR        0x00000007
+#define EFI_P_EC_OUTPUT_ERROR       0x00000008
+#define EFI_P_EC_RESOURCE_CONFLICT  0x00000009
+///@}
+
+//
+// Peripheral Class Unspecified Subclass Error Code definitions.
+//
+
+///
+/// Peripheral Class Keyboard Subclass Error Code definitions.
+///
+///@{
+#define EFI_P_KEYBOARD_EC_LOCKED    (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_P_KEYBOARD_EC_STUCK_KEY (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+///
+/// Peripheral Class Mouse Subclass Error Code definitions.
+///
+///@{
+#define EFI_P_MOUSE_EC_LOCKED (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+///@}
+
+//
+// Peripheral Class Local Console Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Remote Console Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Serial Port Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Parallel Port Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Fixed Media Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Removable Media Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Audio Input Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Audio Output Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class LCD Device Subclass Error Code definitions.
+//
+
+//
+// Peripheral Class Network Subclass Error Code definitions.
+//
+
+///
+/// IO Bus Subclass definitions.
+/// Values of 14-127 are reserved for future use by this specification.
+/// Values of 128-255 are reserved for OEM use.
+///
+///@{
+#define EFI_IO_BUS_UNSPECIFIED  (EFI_IO_BUS | 0x00000000)
+#define EFI_IO_BUS_PCI          (EFI_IO_BUS | 0x00010000)
+#define EFI_IO_BUS_USB          (EFI_IO_BUS | 0x00020000)
+#define EFI_IO_BUS_IBA          (EFI_IO_BUS | 0x00030000)
+#define EFI_IO_BUS_AGP          (EFI_IO_BUS | 0x00040000)
+#define EFI_IO_BUS_PC_CARD      (EFI_IO_BUS | 0x00050000)
+#define EFI_IO_BUS_LPC          (EFI_IO_BUS | 0x00060000)
+#define EFI_IO_BUS_SCSI         (EFI_IO_BUS | 0x00070000)
+#define EFI_IO_BUS_ATA_ATAPI    (EFI_IO_BUS | 0x00080000)
+#define EFI_IO_BUS_FC           (EFI_IO_BUS | 0x00090000)
+#define EFI_IO_BUS_IP_NETWORK   (EFI_IO_BUS | 0x000A0000)
+#define EFI_IO_BUS_SMBUS        (EFI_IO_BUS | 0x000B0000)
+#define EFI_IO_BUS_I2C          (EFI_IO_BUS | 0x000C0000)
+///@}
+
+///
+/// IO Bus Class Progress Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_IOB_PC_INIT     0x00000000
+#define EFI_IOB_PC_RESET    0x00000001
+#define EFI_IOB_PC_DISABLE  0x00000002
+#define EFI_IOB_PC_DETECT   0x00000003
+#define EFI_IOB_PC_ENABLE   0x00000004
+#define EFI_IOB_PC_RECONFIG 0x00000005
+#define EFI_IOB_PC_HOTPLUG  0x00000006
+///@}
+
+//
+// IO Bus Class Unspecified Subclass Progress Code definitions.
+//
+
+///
+/// IO Bus Class PCI Subclass Progress Code definitions.
+///
+///@{
+#define EFI_IOB_PCI_BUS_ENUM   (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_IOB_PCI_RES_ALLOC  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_IOB_PCI_HPC_INIT   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+//
+// IO Bus Class USB Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class IBA Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class AGP Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class PC Card Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class LPC Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class SCSI Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class ATA/ATAPI Subclass Progress Code definitions.
+//
+#define EFI_IOB_ATA_BUS_SMART_ENABLE          (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_IOB_ATA_BUS_SMART_DISABLE         (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_IOB_ATA_BUS_SMART_OVERTHRESHOLD   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_IOB_ATA_BUS_SMART_UNDERTHRESHOLD  (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+//
+// IO Bus Class FC Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class IP Network Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class SMBUS Subclass Progress Code definitions.
+//
+
+//
+// IO Bus Class I2C Subclass Progress Code definitions.
+//
+
+///
+/// IO Bus Class Error Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_IOB_EC_NON_SPECIFIC       0x00000000
+#define EFI_IOB_EC_DISABLED           0x00000001
+#define EFI_IOB_EC_NOT_SUPPORTED      0x00000002
+#define EFI_IOB_EC_NOT_DETECTED       0x00000003
+#define EFI_IOB_EC_NOT_CONFIGURED     0x00000004
+#define EFI_IOB_EC_INTERFACE_ERROR    0x00000005
+#define EFI_IOB_EC_CONTROLLER_ERROR   0x00000006
+#define EFI_IOB_EC_READ_ERROR         0x00000007
+#define EFI_IOB_EC_WRITE_ERROR        0x00000008
+#define EFI_IOB_EC_RESOURCE_CONFLICT  0x00000009
+///@}
+
+//
+// IO Bus Class Unspecified Subclass Error Code definitions.
+//
+
+///
+/// IO Bus Class PCI Subclass Error Code definitions.
+///
+///@{
+#define EFI_IOB_PCI_EC_PERR (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_IOB_PCI_EC_SERR (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+//
+// IO Bus Class USB Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class IBA Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class AGP Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class PC Card Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class LPC Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class SCSI Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class ATA/ATAPI Subclass Error Code definitions.
+//
+#define EFI_IOB_ATA_BUS_SMART_NOTSUPPORTED  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_IOB_ATA_BUS_SMART_DISABLED      (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+
+//
+// IO Bus Class FC Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class IP Network Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class SMBUS Subclass Error Code definitions.
+//
+
+//
+// IO Bus Class I2C Subclass Error Code definitions.
+//
+
+///
+/// Software Subclass definitions.
+/// Values of 14-127 are reserved for future use by this specification.
+/// Values of 128-255 are reserved for OEM use.
+///
+///@{
+#define EFI_SOFTWARE_UNSPECIFIED          (EFI_SOFTWARE | 0x00000000)
+#define EFI_SOFTWARE_SEC                  (EFI_SOFTWARE | 0x00010000)
+#define EFI_SOFTWARE_PEI_CORE             (EFI_SOFTWARE | 0x00020000)
+#define EFI_SOFTWARE_PEI_MODULE           (EFI_SOFTWARE | 0x00030000)
+#define EFI_SOFTWARE_DXE_CORE             (EFI_SOFTWARE | 0x00040000)
+#define EFI_SOFTWARE_DXE_BS_DRIVER        (EFI_SOFTWARE | 0x00050000)
+#define EFI_SOFTWARE_DXE_RT_DRIVER        (EFI_SOFTWARE | 0x00060000)
+#define EFI_SOFTWARE_SMM_DRIVER           (EFI_SOFTWARE | 0x00070000)
+#define EFI_SOFTWARE_EFI_APPLICATION      (EFI_SOFTWARE | 0x00080000)
+#define EFI_SOFTWARE_EFI_OS_LOADER        (EFI_SOFTWARE | 0x00090000)
+#define EFI_SOFTWARE_RT                   (EFI_SOFTWARE | 0x000A0000)
+#define EFI_SOFTWARE_AL                   (EFI_SOFTWARE | 0x000B0000)
+#define EFI_SOFTWARE_EBC_EXCEPTION        (EFI_SOFTWARE | 0x000C0000)
+#define EFI_SOFTWARE_IA32_EXCEPTION       (EFI_SOFTWARE | 0x000D0000)
+#define EFI_SOFTWARE_IPF_EXCEPTION        (EFI_SOFTWARE | 0x000E0000)
+#define EFI_SOFTWARE_PEI_SERVICE          (EFI_SOFTWARE | 0x000F0000)
+#define EFI_SOFTWARE_EFI_BOOT_SERVICE     (EFI_SOFTWARE | 0x00100000)
+#define EFI_SOFTWARE_EFI_RUNTIME_SERVICE  (EFI_SOFTWARE | 0x00110000)
+#define EFI_SOFTWARE_EFI_DXE_SERVICE      (EFI_SOFTWARE | 0x00120000)
+#define EFI_SOFTWARE_X64_EXCEPTION        (EFI_SOFTWARE | 0x00130000)
+#define EFI_SOFTWARE_ARM_EXCEPTION        (EFI_SOFTWARE | 0x00140000)
+
+///@}
+
+///
+/// Software Class Progress Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_SW_PC_INIT                0x00000000
+#define EFI_SW_PC_LOAD                0x00000001
+#define EFI_SW_PC_INIT_BEGIN          0x00000002
+#define EFI_SW_PC_INIT_END            0x00000003
+#define EFI_SW_PC_AUTHENTICATE_BEGIN  0x00000004
+#define EFI_SW_PC_AUTHENTICATE_END    0x00000005
+#define EFI_SW_PC_INPUT_WAIT          0x00000006
+#define EFI_SW_PC_USER_SETUP          0x00000007
+///@}
+
+//
+// Software Class Unspecified Subclass Progress Code definitions.
+//
+
+///
+/// Software Class SEC Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_SEC_PC_ENTRY_POINT     (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_SEC_PC_HANDOFF_TO_NEXT (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+///
+/// Software Class PEI Core Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_PEI_CORE_PC_ENTRY_POINT      (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PEI_CORE_PC_HANDOFF_TO_NEXT  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_PEI_CORE_PC_RETURN_TO_LAST   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+///
+/// Software Class PEI Module Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_PEI_PC_RECOVERY_BEGIN  (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PEI_PC_CAPSULE_LOAD    (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_PEI_PC_CAPSULE_START   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_PEI_PC_RECOVERY_USER   (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_PEI_PC_RECOVERY_AUTO   (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_PEI_PC_S3_BOOT_SCRIPT  (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_PEI_PC_OS_WAKE         (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+///@}
+
+///
+/// Software Class DXE Core Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_DXE_CORE_PC_ENTRY_POINT      (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_DXE_CORE_PC_RETURN_TO_LAST   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_DXE_CORE_PC_START_DRIVER     (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_DXE_CORE_PC_ARCH_READY       (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+///@}
+
+///
+/// Software Class DXE BS Driver Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_DXE_BS_PC_LEGACY_OPROM_INIT            (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_DXE_BS_PC_READY_TO_BOOT_EVENT          (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_DXE_BS_PC_LEGACY_BOOT_EVENT            (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_DXE_BS_PC_EXIT_BOOT_SERVICES_EVENT     (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_DXE_BS_PC_VIRTUAL_ADDRESS_CHANGE_EVENT (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+///@}
+
+//
+// Software Class SMM Driver Subclass Progress Code definitions.
+//
+
+//
+// Software Class EFI Application Subclass Progress Code definitions.
+//
+
+//
+// Software Class EFI OS Loader Subclass Progress Code definitions.
+//
+
+///
+/// Software Class EFI RT Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_RT_PC_ENTRY_POINT      (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_RT_PC_HANDOFF_TO_NEXT  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_RT_PC_RETURN_TO_LAST   (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+//
+// Software Class X64 Exception Subclass Progress Code definitions.
+//
+
+//
+// Software Class ARM Exception Subclass Progress Code definitions.
+//
+
+//
+// Software Class EBC Exception Subclass Progress Code definitions.
+//
+
+//
+// Software Class IA32 Exception Subclass Progress Code definitions.
+//
+
+//
+// Software Class X64 Exception Subclass Progress Code definitions.
+//
+
+//
+// Software Class IPF Exception Subclass Progress Code definitions.
+//
+
+///
+/// Software Class PEI Services Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_PS_PC_INSTALL_PPI              (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PS_PC_REINSTALL_PPI            (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_PS_PC_LOCATE_PPI               (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_PS_PC_NOTIFY_PPI               (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_PS_PC_GET_BOOT_MODE            (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_PS_PC_SET_BOOT_MODE            (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_PS_PC_GET_HOB_LIST             (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_SW_PS_PC_CREATE_HOB               (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_SW_PS_PC_FFS_FIND_NEXT_VOLUME     (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_SW_PS_PC_FFS_FIND_NEXT_FILE       (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_SW_PS_PC_FFS_FIND_SECTION_DATA    (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+#define EFI_SW_PS_PC_INSTALL_PEI_MEMORY       (EFI_SUBCLASS_SPECIFIC | 0x0000000B)
+#define EFI_SW_PS_PC_ALLOCATE_PAGES           (EFI_SUBCLASS_SPECIFIC | 0x0000000C)
+#define EFI_SW_PS_PC_ALLOCATE_POOL            (EFI_SUBCLASS_SPECIFIC | 0x0000000D)
+#define EFI_SW_PS_PC_COPY_MEM                 (EFI_SUBCLASS_SPECIFIC | 0x0000000E)
+#define EFI_SW_PS_PC_SET_MEM                  (EFI_SUBCLASS_SPECIFIC | 0x0000000F)
+#define EFI_SW_PS_PC_RESET_SYSTEM             (EFI_SUBCLASS_SPECIFIC | 0x00000010)
+#define EFI_SW_PS_PC_FFS_FIND_FILE_BY_NAME    (EFI_SUBCLASS_SPECIFIC | 0x00000013)
+#define EFI_SW_PS_PC_FFS_GET_FILE_INFO        (EFI_SUBCLASS_SPECIFIC | 0x00000014)
+#define EFI_SW_PS_PC_FFS_GET_VOLUME_INFO      (EFI_SUBCLASS_SPECIFIC | 0x00000015)
+#define EFI_SW_PS_PC_FFS_REGISTER_FOR_SHADOW  (EFI_SUBCLASS_SPECIFIC | 0x00000016)
+///@}
+
+///
+/// Software Class EFI Boot Services Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_BS_PC_RAISE_TPL                      (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_BS_PC_RESTORE_TPL                    (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_BS_PC_ALLOCATE_PAGES                 (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_BS_PC_FREE_PAGES                     (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_BS_PC_GET_MEMORY_MAP                 (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_BS_PC_ALLOCATE_POOL                  (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_BS_PC_FREE_POOL                      (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_SW_BS_PC_CREATE_EVENT                   (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_SW_BS_PC_SET_TIMER                      (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_SW_BS_PC_WAIT_FOR_EVENT                 (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_SW_BS_PC_SIGNAL_EVENT                   (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+#define EFI_SW_BS_PC_CLOSE_EVENT                    (EFI_SUBCLASS_SPECIFIC | 0x0000000B)
+#define EFI_SW_BS_PC_CHECK_EVENT                    (EFI_SUBCLASS_SPECIFIC | 0x0000000C)
+#define EFI_SW_BS_PC_INSTALL_PROTOCOL_INTERFACE     (EFI_SUBCLASS_SPECIFIC | 0x0000000D)
+#define EFI_SW_BS_PC_REINSTALL_PROTOCOL_INTERFACE   (EFI_SUBCLASS_SPECIFIC | 0x0000000E)
+#define EFI_SW_BS_PC_UNINSTALL_PROTOCOL_INTERFACE   (EFI_SUBCLASS_SPECIFIC | 0x0000000F)
+#define EFI_SW_BS_PC_HANDLE_PROTOCOL                (EFI_SUBCLASS_SPECIFIC | 0x00000010)
+#define EFI_SW_BS_PC_PC_HANDLE_PROTOCOL             (EFI_SUBCLASS_SPECIFIC | 0x00000011)
+#define EFI_SW_BS_PC_REGISTER_PROTOCOL_NOTIFY       (EFI_SUBCLASS_SPECIFIC | 0x00000012)
+#define EFI_SW_BS_PC_LOCATE_HANDLE                  (EFI_SUBCLASS_SPECIFIC | 0x00000013)
+#define EFI_SW_BS_PC_INSTALL_CONFIGURATION_TABLE    (EFI_SUBCLASS_SPECIFIC | 0x00000014)
+#define EFI_SW_BS_PC_LOAD_IMAGE                     (EFI_SUBCLASS_SPECIFIC | 0x00000015)
+#define EFI_SW_BS_PC_START_IMAGE                    (EFI_SUBCLASS_SPECIFIC | 0x00000016)
+#define EFI_SW_BS_PC_EXIT                           (EFI_SUBCLASS_SPECIFIC | 0x00000017)
+#define EFI_SW_BS_PC_UNLOAD_IMAGE                   (EFI_SUBCLASS_SPECIFIC | 0x00000018)
+#define EFI_SW_BS_PC_EXIT_BOOT_SERVICES             (EFI_SUBCLASS_SPECIFIC | 0x00000019)
+#define EFI_SW_BS_PC_GET_NEXT_MONOTONIC_COUNT       (EFI_SUBCLASS_SPECIFIC | 0x0000001A)
+#define EFI_SW_BS_PC_STALL                          (EFI_SUBCLASS_SPECIFIC | 0x0000001B)
+#define EFI_SW_BS_PC_SET_WATCHDOG_TIMER             (EFI_SUBCLASS_SPECIFIC | 0x0000001C)
+#define EFI_SW_BS_PC_CONNECT_CONTROLLER             (EFI_SUBCLASS_SPECIFIC | 0x0000001D)
+#define EFI_SW_BS_PC_DISCONNECT_CONTROLLER          (EFI_SUBCLASS_SPECIFIC | 0x0000001E)
+#define EFI_SW_BS_PC_OPEN_PROTOCOL                  (EFI_SUBCLASS_SPECIFIC | 0x0000001F)
+#define EFI_SW_BS_PC_CLOSE_PROTOCOL                 (EFI_SUBCLASS_SPECIFIC | 0x00000020)
+#define EFI_SW_BS_PC_OPEN_PROTOCOL_INFORMATION      (EFI_SUBCLASS_SPECIFIC | 0x00000021)
+#define EFI_SW_BS_PC_PROTOCOLS_PER_HANDLE           (EFI_SUBCLASS_SPECIFIC | 0x00000022)
+#define EFI_SW_BS_PC_LOCATE_HANDLE_BUFFER           (EFI_SUBCLASS_SPECIFIC | 0x00000023)
+#define EFI_SW_BS_PC_LOCATE_PROTOCOL                (EFI_SUBCLASS_SPECIFIC | 0x00000024)
+#define EFI_SW_BS_PC_INSTALL_MULTIPLE_INTERFACES    (EFI_SUBCLASS_SPECIFIC | 0x00000025)
+#define EFI_SW_BS_PC_UNINSTALL_MULTIPLE_INTERFACES  (EFI_SUBCLASS_SPECIFIC | 0x00000026)
+#define EFI_SW_BS_PC_CALCULATE_CRC_32               (EFI_SUBCLASS_SPECIFIC | 0x00000027)
+#define EFI_SW_BS_PC_COPY_MEM                       (EFI_SUBCLASS_SPECIFIC | 0x00000028)
+#define EFI_SW_BS_PC_SET_MEM                        (EFI_SUBCLASS_SPECIFIC | 0x00000029)
+#define EFI_SW_BS_PC_CREATE_EVENT_EX                (EFI_SUBCLASS_SPECIFIC | 0x0000002A)
+///@}
+
+///
+/// Software Class EFI Runtime Services Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_RS_PC_GET_TIME                       (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_RS_PC_SET_TIME                       (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_RS_PC_GET_WAKEUP_TIME                (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_RS_PC_SET_WAKEUP_TIME                (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_RS_PC_SET_VIRTUAL_ADDRESS_MAP        (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_RS_PC_CONVERT_POINTER                (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_RS_PC_GET_VARIABLE                   (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_SW_RS_PC_GET_NEXT_VARIABLE_NAME         (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_SW_RS_PC_SET_VARIABLE                   (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_SW_RS_PC_GET_NEXT_HIGH_MONOTONIC_COUNT  (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_SW_RS_PC_RESET_SYSTEM                   (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+#define EFI_SW_RS_PC_UPDATE_CAPSULE                 (EFI_SUBCLASS_SPECIFIC | 0x0000000B)
+#define EFI_SW_RS_PC_QUERY_CAPSULE_CAPABILITIES     (EFI_SUBCLASS_SPECIFIC | 0x0000000C)
+#define EFI_SW_RS_PC_QUERY_VARIABLE_INFO            (EFI_SUBCLASS_SPECIFIC | 0x0000000D)
+///@}
+
+///
+/// Software Class EFI DXE Services Subclass Progress Code definitions
+///
+///@{
+#define EFI_SW_DS_PC_ADD_MEMORY_SPACE             (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_DS_PC_ALLOCATE_MEMORY_SPACE        (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_DS_PC_FREE_MEMORY_SPACE            (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_DS_PC_REMOVE_MEMORY_SPACE          (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_DS_PC_GET_MEMORY_SPACE_DESCRIPTOR  (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_DS_PC_SET_MEMORY_SPACE_ATTRIBUTES  (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_DS_PC_GET_MEMORY_SPACE_MAP         (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_SW_DS_PC_ADD_IO_SPACE                 (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+#define EFI_SW_DS_PC_ALLOCATE_IO_SPACE            (EFI_SUBCLASS_SPECIFIC | 0x00000008)
+#define EFI_SW_DS_PC_FREE_IO_SPACE                (EFI_SUBCLASS_SPECIFIC | 0x00000009)
+#define EFI_SW_DS_PC_REMOVE_IO_SPACE              (EFI_SUBCLASS_SPECIFIC | 0x0000000A)
+#define EFI_SW_DS_PC_GET_IO_SPACE_DESCRIPTOR      (EFI_SUBCLASS_SPECIFIC | 0x0000000B)
+#define EFI_SW_DS_PC_GET_IO_SPACE_MAP             (EFI_SUBCLASS_SPECIFIC | 0x0000000C)
+#define EFI_SW_DS_PC_DISPATCH                     (EFI_SUBCLASS_SPECIFIC | 0x0000000D)
+#define EFI_SW_DS_PC_SCHEDULE                     (EFI_SUBCLASS_SPECIFIC | 0x0000000E)
+#define EFI_SW_DS_PC_TRUST                        (EFI_SUBCLASS_SPECIFIC | 0x0000000F)
+#define EFI_SW_DS_PC_PROCESS_FIRMWARE_VOLUME      (EFI_SUBCLASS_SPECIFIC | 0x00000010)
+///@}
+
+///
+/// Software Class Error Code definitions.
+/// These are shared by all subclasses.
+///
+///@{
+#define EFI_SW_EC_NON_SPECIFIC            0x00000000
+#define EFI_SW_EC_LOAD_ERROR              0x00000001
+#define EFI_SW_EC_INVALID_PARAMETER       0x00000002
+#define EFI_SW_EC_UNSUPPORTED             0x00000003
+#define EFI_SW_EC_INVALID_BUFFER          0x00000004
+#define EFI_SW_EC_OUT_OF_RESOURCES        0x00000005
+#define EFI_SW_EC_ABORTED                 0x00000006
+#define EFI_SW_EC_ILLEGAL_SOFTWARE_STATE  0x00000007
+#define EFI_SW_EC_ILLEGAL_HARDWARE_STATE  0x00000008
+#define EFI_SW_EC_START_ERROR             0x00000009
+#define EFI_SW_EC_BAD_DATE_TIME           0x0000000A
+#define EFI_SW_EC_CFG_INVALID             0x0000000B
+#define EFI_SW_EC_CFG_CLR_REQUEST         0x0000000C
+#define EFI_SW_EC_CFG_DEFAULT             0x0000000D
+#define EFI_SW_EC_PWD_INVALID             0x0000000E
+#define EFI_SW_EC_PWD_CLR_REQUEST         0x0000000F
+#define EFI_SW_EC_PWD_CLEARED             0x00000010
+#define EFI_SW_EC_EVENT_LOG_FULL          0x00000011
+///@}
+
+//
+// Software Class Unspecified Subclass Error Code definitions.
+//
+
+//
+// Software Class SEC Subclass Error Code definitions.
+//
+
+///
+/// Software Class PEI Core Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_PEI_CORE_EC_DXE_CORRUPT           (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PEI_CORE_EC_DXEIPL_NOT_FOUND      (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_PEI_CORE_EC_MEMORY_NOT_INSTALLED  (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+///@}
+
+///
+/// Software Class PEI Module Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_PEI_EC_NO_RECOVERY_CAPSULE          (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PEI_EC_INVALID_CAPSULE_DESCRIPTOR   (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_PEI_EC_S3_RESUME_PPI_NOT_FOUND      (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_PEI_EC_S3_BOOT_SCRIPT_ERROR         (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_PEI_EC_S3_OS_WAKE_ERROR             (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_PEI_EC_S3_RESUME_FAILED             (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_PEI_EC_RECOVERY_PPI_NOT_FOUND       (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+#define EFI_SW_PEI_EC_RECOVERY_FAILED              (EFI_SUBCLASS_SPECIFIC | 0x00000007)
+///@}
+
+///
+/// Software Class DXE Foundation Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_DXE_CORE_EC_NO_ARCH                (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+///@}
+
+
+///
+/// Software Class DXE Boot Service Driver Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_DXE_BS_EC_LEGACY_OPROM_NO_SPACE   (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_DXE_BS_EC_INVALID_PASSWORD        (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_DXE_BS_EC_BOOT_OPTION_LOAD_ERROR  (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_DXE_BS_EC_BOOT_OPTION_FAILED      (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_DXE_BS_EC_INVALID_IDE_PASSWORD    (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+///@}
+
+//
+// Software Class DXE Runtime Service Driver Subclass Error Code definitions.
+//
+
+//
+// Software Class SMM Driver Subclass Error Code definitions.
+//
+
+//
+// Software Class EFI Application Subclass Error Code definitions.
+//
+
+//
+// Software Class EFI OS Loader Subclass Error Code definitions.
+//
+
+//
+// Software Class EFI RT Subclass Error Code definitions.
+//
+
+//
+// Software Class EFI AL Subclass Error Code definitions.
+//
+
+///
+/// Software Class EBC Exception Subclass Error Code definitions.
+/// These exceptions are derived from the debug protocol definitions in the EFI
+/// specification.
+///
+///@{
+#define EFI_SW_EC_EBC_UNDEFINED             0x00000000
+#define EFI_SW_EC_EBC_DIVIDE_ERROR          EXCEPT_EBC_DIVIDE_ERROR
+#define EFI_SW_EC_EBC_DEBUG                 EXCEPT_EBC_DEBUG
+#define EFI_SW_EC_EBC_BREAKPOINT            EXCEPT_EBC_BREAKPOINT
+#define EFI_SW_EC_EBC_OVERFLOW              EXCEPT_EBC_OVERFLOW
+#define EFI_SW_EC_EBC_INVALID_OPCODE        EXCEPT_EBC_INVALID_OPCODE
+#define EFI_SW_EC_EBC_STACK_FAULT           EXCEPT_EBC_STACK_FAULT
+#define EFI_SW_EC_EBC_ALIGNMENT_CHECK       EXCEPT_EBC_ALIGNMENT_CHECK
+#define EFI_SW_EC_EBC_INSTRUCTION_ENCODING  EXCEPT_EBC_INSTRUCTION_ENCODING
+#define EFI_SW_EC_EBC_BAD_BREAK             EXCEPT_EBC_BAD_BREAK
+#define EFI_SW_EC_EBC_STEP                  EXCEPT_EBC_STEP
+///@}
+
+///
+/// Software Class IA32 Exception Subclass Error Code definitions.
+/// These exceptions are derived from the debug protocol definitions in the EFI
+/// specification.
+///
+///@{
+#define EFI_SW_EC_IA32_DIVIDE_ERROR     EXCEPT_IA32_DIVIDE_ERROR
+#define EFI_SW_EC_IA32_DEBUG            EXCEPT_IA32_DEBUG
+#define EFI_SW_EC_IA32_NMI              EXCEPT_IA32_NMI
+#define EFI_SW_EC_IA32_BREAKPOINT       EXCEPT_IA32_BREAKPOINT
+#define EFI_SW_EC_IA32_OVERFLOW         EXCEPT_IA32_OVERFLOW
+#define EFI_SW_EC_IA32_BOUND            EXCEPT_IA32_BOUND
+#define EFI_SW_EC_IA32_INVALID_OPCODE   EXCEPT_IA32_INVALID_OPCODE
+#define EFI_SW_EC_IA32_DOUBLE_FAULT     EXCEPT_IA32_DOUBLE_FAULT
+#define EFI_SW_EC_IA32_INVALID_TSS      EXCEPT_IA32_INVALID_TSS
+#define EFI_SW_EC_IA32_SEG_NOT_PRESENT  EXCEPT_IA32_SEG_NOT_PRESENT
+#define EFI_SW_EC_IA32_STACK_FAULT      EXCEPT_IA32_STACK_FAULT
+#define EFI_SW_EC_IA32_GP_FAULT         EXCEPT_IA32_GP_FAULT
+#define EFI_SW_EC_IA32_PAGE_FAULT       EXCEPT_IA32_PAGE_FAULT
+#define EFI_SW_EC_IA32_FP_ERROR         EXCEPT_IA32_FP_ERROR
+#define EFI_SW_EC_IA32_ALIGNMENT_CHECK  EXCEPT_IA32_ALIGNMENT_CHECK
+#define EFI_SW_EC_IA32_MACHINE_CHECK    EXCEPT_IA32_MACHINE_CHECK
+#define EFI_SW_EC_IA32_SIMD             EXCEPT_IA32_SIMD
+///@}
+
+///
+/// Software Class IPF Exception Subclass Error Code definitions.
+/// These exceptions are derived from the debug protocol definitions in the EFI
+/// specification.
+///
+///@{
+#define EFI_SW_EC_IPF_ALT_DTLB            EXCEPT_IPF_ALT_DTLB
+#define EFI_SW_EC_IPF_DNESTED_TLB         EXCEPT_IPF_DNESTED_TLB
+#define EFI_SW_EC_IPF_BREAKPOINT          EXCEPT_IPF_BREAKPOINT
+#define EFI_SW_EC_IPF_EXTERNAL_INTERRUPT  EXCEPT_IPF_EXTERNAL_INTERRUPT
+#define EFI_SW_EC_IPF_GEN_EXCEPT          EXCEPT_IPF_GEN_EXCEPT
+#define EFI_SW_EC_IPF_NAT_CONSUMPTION     EXCEPT_IPF_NAT_CONSUMPTION
+#define EFI_SW_EC_IPF_DEBUG_EXCEPT        EXCEPT_IPF_DEBUG_EXCEPT
+#define EFI_SW_EC_IPF_UNALIGNED_ACCESS    EXCEPT_IPF_UNALIGNED_ACCESS
+#define EFI_SW_EC_IPF_FP_FAULT            EXCEPT_IPF_FP_FAULT
+#define EFI_SW_EC_IPF_FP_TRAP             EXCEPT_IPF_FP_TRAP
+#define EFI_SW_EC_IPF_TAKEN_BRANCH        EXCEPT_IPF_TAKEN_BRANCH
+#define EFI_SW_EC_IPF_SINGLE_STEP         EXCEPT_IPF_SINGLE_STEP
+///@}
+
+///
+/// Software Class PEI Service Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_PS_EC_RESET_NOT_AVAILABLE     (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_PS_EC_MEMORY_INSTALLED_TWICE  (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+///@}
+
+//
+// Software Class EFI Boot Service Subclass Error Code definitions.
+//
+
+//
+// Software Class EFI Runtime Service Subclass Error Code definitions.
+//
+
+///
+/// Software Class EFI DXE Service Subclass Error Code definitions.
+///
+///@{
+#define EFI_SW_DXE_BS_PC_BEGIN_CONNECTING_DRIVERS   (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+#define EFI_SW_DXE_BS_PC_VERIFYING_PASSWORD         (EFI_SUBCLASS_SPECIFIC | 0x00000006)
+///@}
+
+///
+/// Software Class DXE RT Driver Subclass Progress Code definitions.
+///
+///@{
+#define EFI_SW_DXE_RT_PC_S0                         (EFI_SUBCLASS_SPECIFIC | 0x00000000)
+#define EFI_SW_DXE_RT_PC_S1                         (EFI_SUBCLASS_SPECIFIC | 0x00000001)
+#define EFI_SW_DXE_RT_PC_S2                         (EFI_SUBCLASS_SPECIFIC | 0x00000002)
+#define EFI_SW_DXE_RT_PC_S3                         (EFI_SUBCLASS_SPECIFIC | 0x00000003)
+#define EFI_SW_DXE_RT_PC_S4                         (EFI_SUBCLASS_SPECIFIC | 0x00000004)
+#define EFI_SW_DXE_RT_PC_S5                         (EFI_SUBCLASS_SPECIFIC | 0x00000005)
+///@}
+
+///
+/// Software Class X64 Exception Subclass Error Code definitions.
+/// These exceptions are derived from the debug protocol
+/// definitions in the EFI specification.
+///
+///@{
+#define EFI_SW_EC_X64_DIVIDE_ERROR                   EXCEPT_X64_DIVIDE_ERROR
+#define EFI_SW_EC_X64_DEBUG                          EXCEPT_X64_DEBUG
+#define EFI_SW_EC_X64_NMI                            EXCEPT_X64_NMI
+#define EFI_SW_EC_X64_BREAKPOINT                     EXCEPT_X64_BREAKPOINT
+#define EFI_SW_EC_X64_OVERFLOW                       EXCEPT_X64_OVERFLOW
+#define EFI_SW_EC_X64_BOUND                          EXCEPT_X64_BOUND
+#define EFI_SW_EC_X64_INVALID_OPCODE                 EXCEPT_X64_INVALID_OPCODE
+#define EFI_SW_EC_X64_DOUBLE_FAULT                   EXCEPT_X64_DOUBLE_FAULT
+#define EFI_SW_EC_X64_INVALID_TSS                    EXCEPT_X64_INVALID_TSS
+#define EFI_SW_EC_X64_SEG_NOT_PRESENT                EXCEPT_X64_SEG_NOT_PRESENT
+#define EFI_SW_EC_X64_STACK_FAULT                    EXCEPT_X64_STACK_FAULT
+#define EFI_SW_EC_X64_GP_FAULT                       EXCEPT_X64_GP_FAULT
+#define EFI_SW_EC_X64_PAGE_FAULT                     EXCEPT_X64_PAGE_FAULT
+#define EFI_SW_EC_X64_FP_ERROR                       EXCEPT_X64_FP_ERROR
+#define EFI_SW_EC_X64_ALIGNMENT_CHECK                EXCEPT_X64_ALIGNMENT_CHECK
+#define EFI_SW_EC_X64_MACHINE_CHECK                  EXCEPT_X64_MACHINE_CHECK
+#define EFI_SW_EC_X64_SIMD                           EXCEPT_X64_SIMD
+///@}
+
+///
+/// Software Class ARM Exception Subclass Error Code definitions.
+/// These exceptions are derived from the debug protocol
+/// definitions in the EFI specification.
+///
+///@{
+#define EFI_SW_EC_ARM_RESET                          EXCEPT_ARM_RESET 
+#define EFI_SW_EC_ARM_UNDEFINED_INSTRUCTION          EXCEPT_ARM_UNDEFINED_INSTRUCTION 
+#define EFI_SW_EC_ARM_SOFTWARE_INTERRUPT             EXCEPT_ARM_SOFTWARE_INTERRUPT 
+#define EFI_SW_EC_ARM_PREFETCH_ABORT                 EXCEPT_ARM_PREFETCH_ABORT
+#define EFI_SW_EC_ARM_DATA_ABORT                     EXCEPT_ARM_DATA_ABORT
+#define EFI_SW_EC_ARM_RESERVED                       EXCEPT_ARM_RESERVED
+#define EFI_SW_EC_ARM_IRQ                            EXCEPT_ARM_IRQ
+#define EFI_SW_EC_ARM_FIQ                            EXCEPT_ARM_FIQ
+///@}
+
+#endif
diff --git a/MdePkg/Include/PiDxe.h b/MdePkg/Include/PiDxe.h
new file mode 100644
index 000000000000..57ac130d4522
--- /dev/null
+++ b/MdePkg/Include/PiDxe.h
@@ -0,0 +1,25 @@
+/** @file
+
+  Root include file for Mde Package DXE_CORE, DXE, RUNTIME, SMM, SAL type modules.
+
+Copyright (c) 2006 - 2010, 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 __PI_DXE_H__
+#define __PI_DXE_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Uefi/UefiSpec.h>
+
+#include <Pi/PiDxeCis.h>
+
+#endif
+
diff --git a/MdePkg/Include/PiPei.h b/MdePkg/Include/PiPei.h
new file mode 100644
index 000000000000..d35341251e63
--- /dev/null
+++ b/MdePkg/Include/PiPei.h
@@ -0,0 +1,27 @@
+/** @file
+
+  Root include file for Mde Package SEC, PEIM, PEI_CORE type modules.
+
+  This is the include file for any module of type PEIM. PEIM
+  modules only use types defined via this include file and can
+  be ported easily to any environment. 
+
+Copyright (c) 2006 - 2010, 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 __PI_PEI_H__
+#define __PI_PEI_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Pi/PiPeiCis.h>
+
+#endif
+
diff --git a/MdePkg/Include/PiSmm.h b/MdePkg/Include/PiSmm.h
new file mode 100644
index 000000000000..bc7129ac5062
--- /dev/null
+++ b/MdePkg/Include/PiSmm.h
@@ -0,0 +1,26 @@
+/** @file
+
+  Root include file for Mde Package SMM modules.
+
+Copyright (c) 2009 - 2011, 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 __PI_SMM_H__
+#define __PI_SMM_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Uefi/UefiSpec.h>
+
+#include <Pi/PiSmmCis.h>
+#include <Pi/PiSmmCommunicationAcpiTable.h>
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/BlockIo.h b/MdePkg/Include/Ppi/BlockIo.h
new file mode 100644
index 000000000000..7331855f5742
--- /dev/null
+++ b/MdePkg/Include/Ppi/BlockIo.h
@@ -0,0 +1,238 @@
+/** @file
+  Provides the services required to access a block I/O device during PEI recovery 
+  boot mode.
+
+  The Recovery Module PPI and the Device Recovery Module PPI are device neutral. 
+  This PPI is device specific and addresses the most common form of recovery 
+  media-block I/O devices such as legacy floppy, CD-ROM, or IDE devices.
+
+  The Recovery Block I/O PPI is used to access block devices. Because the Recovery 
+  Block I/O PPIs that are provided by the PEI ATAPI driver and PEI legacy floppy 
+  driver are the same, here we define a set of general PPIs for both drivers to use.
+  
+Copyright (c) 2007 - 2015, 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.
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Volume 1: 
+  Pre-EFI Initalization Core Interface.
+
+**/
+
+#ifndef _PEI_BLOCK_IO_H_
+#define _PEI_BLOCK_IO_H_
+
+///
+/// Global ID for EFI_PEI_RECOVERY_BLOCK_IO_PPI
+///
+#define EFI_PEI_RECOVERY_BLOCK_IO_PPI_GUID \
+  { \
+    0x695d8aa1, 0x42ee, 0x4c46, { 0x80, 0x5c, 0x6e, 0xa6, 0xbc, 0xe7, 0x99, 0xe3 } \
+  }
+
+///
+/// The forward declaration for EFI_PEI_RECOVERY_BLOCK_IO_PPI.
+///
+typedef struct _EFI_PEI_RECOVERY_BLOCK_IO_PPI  EFI_PEI_RECOVERY_BLOCK_IO_PPI;
+
+///
+/// All blocks on the recovery device are addressed with a 64-bit Logical Block Address (LBA).
+///
+typedef UINT64  EFI_PEI_LBA;
+
+///
+/// EFI_PEI_BLOCK_DEVICE_TYPE
+///
+typedef enum {
+  LegacyFloppy  = 0,   ///< The recovery device is a floppy. 
+  IdeCDROM      = 1,   ///< The recovery device is an IDE CD-ROM
+  IdeLS120      = 2,   ///< The recovery device is an IDE LS-120
+  UsbMassStorage= 3,   ///< The recovery device is a USB Mass Storage device
+  SD            = 4,   ///< The recovery device is a Secure Digital device
+  EMMC          = 5,   ///< The recovery device is a eMMC device
+  UfsDevice     = 6,   ///< The recovery device is a Universal Flash Storage device
+  MaxDeviceType
+} EFI_PEI_BLOCK_DEVICE_TYPE;
+
+///
+/// Specification inconsistency here: 
+/// PEI_BLOCK_IO_MEDIA has been changed to EFI_PEI_BLOCK_IO_MEDIA.
+/// Inconsistency exists in UEFI Platform Initialization Specification 1.2 
+/// Volume 1: Pre-EFI Initalization Core Interface, where all referrences to 
+/// this structure name are with the "EFI_" prefix, except for the definition 
+/// which is without "EFI_".  So the name of PEI_BLOCK_IO_MEDIA is taken as the 
+/// exception, and EFI_PEI_BLOCK_IO_MEDIA is used to comply with most of 
+/// the specification.
+///
+typedef struct {
+  ///
+  /// The type of media device being referenced by DeviceIndex. 
+  ///
+  EFI_PEI_BLOCK_DEVICE_TYPE  DeviceType;
+  ///
+  /// A flag that indicates if media is present. This flag is always set for 
+  /// nonremovable media devices.
+  ///
+  BOOLEAN                    MediaPresent;
+  ///
+  /// The last logical block that the device supports.
+  ///
+  UINTN                      LastBlock;
+  ///
+  /// The size of a logical block in bytes.
+  ///
+  UINTN                      BlockSize;
+} EFI_PEI_BLOCK_IO_MEDIA;
+
+/**
+  Gets the count of block I/O devices that one specific block driver detects.
+
+  This function is used for getting the count of block I/O devices that one 
+  specific block driver detects.  To the PEI ATAPI driver, it returns the number
+  of all the detected ATAPI devices it detects during the enumeration process. 
+  To the PEI legacy floppy driver, it returns the number of all the legacy 
+  devices it finds during its enumeration process. If no device is detected, 
+  then the function will return zero.  
+  
+  @param[in]  PeiServices          General-purpose services that are available 
+                                   to every PEIM.
+  @param[in]  This                 Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI 
+                                   instance.
+  @param[out] NumberBlockDevices   The number of block I/O devices discovered.
+
+  @retval     EFI_SUCCESS          The operation performed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_NUMBER_BLOCK_DEVICES)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
+  OUT UINTN                          *NumberBlockDevices
+  );
+
+/**
+  Gets a block device's media information.
+
+  This function will provide the caller with the specified block device's media 
+  information. If the media changes, calling this function will update the media 
+  information accordingly.
+
+  @param[in]  PeiServices   General-purpose services that are available to every
+                            PEIM
+  @param[in]  This          Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.
+  @param[in]  DeviceIndex   Specifies the block device to which the function wants 
+                            to talk. Because the driver that implements Block I/O 
+                            PPIs will manage multiple block devices, the PPIs that 
+                            want to talk to a single device must specify the 
+                            device index that was assigned during the enumeration
+                            process. This index is a number from one to 
+                            NumberBlockDevices.
+  @param[out] MediaInfo     The media information of the specified block media.  
+                            The caller is responsible for the ownership of this 
+                            data structure.
+
+  @par Note: 
+      The MediaInfo structure describes an enumeration of possible block device 
+      types.  This enumeration exists because no device paths are actually passed 
+      across interfaces that describe the type or class of hardware that is publishing 
+      the block I/O interface. This enumeration will allow for policy decisions
+      in the Recovery PEIM, such as "Try to recover from legacy floppy first, 
+      LS-120 second, CD-ROM third." If there are multiple partitions abstracted 
+      by a given device type, they should be reported in ascending order; this 
+      order also applies to nested partitions, such as legacy MBR, where the 
+      outermost partitions would have precedence in the reporting order. The 
+      same logic applies to systems such as IDE that have precedence relationships 
+      like "Master/Slave" or "Primary/Secondary". The master device should be 
+      reported first, the slave second.
+  
+  @retval EFI_SUCCESS        Media information about the specified block device 
+                             was obtained successfully.
+  @retval EFI_DEVICE_ERROR   Cannot get the media information due to a hardware 
+                             error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_DEVICE_MEDIA_INFORMATION)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
+  IN  UINTN                          DeviceIndex,
+  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
+  );
+
+/**
+  Reads the requested number of blocks from the specified block device.
+
+  The function reads the requested number of blocks from the device. All the 
+  blocks are read, or an error is returned. If there is no media in the device,
+  the function returns EFI_NO_MEDIA.
+
+  @param[in]  PeiServices   General-purpose services that are available to 
+                            every PEIM.
+  @param[in]  This          Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.
+  @param[in]  DeviceIndex   Specifies the block device to which the function wants 
+                            to talk. Because the driver that implements Block I/O 
+                            PPIs will manage multiple block devices, PPIs that 
+                            want to talk to a single device must specify the device 
+                            index that was assigned during the enumeration process. 
+                            This index is a number from one to NumberBlockDevices.
+  @param[in]  StartLBA      The starting logical block address (LBA) to read from
+                            on the device
+  @param[in]  BufferSize    The size of the Buffer in bytes. This number must be
+                            a multiple of the intrinsic block size of the device.
+  @param[out] Buffer        A pointer to the destination buffer for the data.
+                            The caller is responsible for the ownership of the 
+                            buffer.
+                         
+  @retval EFI_SUCCESS             The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR        The device reported an error while attempting 
+                                  to perform the read operation.
+  @retval EFI_INVALID_PARAMETER   The read request contains LBAs that are not 
+                                  valid, or the buffer is not properly aligned.
+  @retval EFI_NO_MEDIA            There is no media in the device.
+  @retval EFI_BAD_BUFFER_SIZE     The BufferSize parameter is not a multiple of
+                                  the intrinsic block size of the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_READ_BLOCKS)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
+  IN  UINTN                          DeviceIndex,
+  IN  EFI_PEI_LBA                    StartLBA,
+  IN  UINTN                          BufferSize,
+  OUT VOID                           *Buffer
+  );
+
+///
+///  EFI_PEI_RECOVERY_BLOCK_IO_PPI provides the services that are required
+///  to access a block I/O device during PEI recovery boot mode.
+///
+struct _EFI_PEI_RECOVERY_BLOCK_IO_PPI {
+  ///
+  /// Gets the number of block I/O devices that the specific block driver manages.
+  ///
+  EFI_PEI_GET_NUMBER_BLOCK_DEVICES      GetNumberOfBlockDevices;
+  
+  ///
+  /// Gets the specified media information.
+  ///
+  EFI_PEI_GET_DEVICE_MEDIA_INFORMATION  GetBlockDeviceMediaInfo;
+  
+  ///
+  /// Reads the requested number of blocks from the specified block device.
+  ///
+  EFI_PEI_READ_BLOCKS                   ReadBlocks;
+};
+
+extern EFI_GUID gEfiPeiVirtualBlockIoPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/BlockIo2.h b/MdePkg/Include/Ppi/BlockIo2.h
new file mode 100644
index 000000000000..c76b7033e65d
--- /dev/null
+++ b/MdePkg/Include/Ppi/BlockIo2.h
@@ -0,0 +1,223 @@
+/** @file
+  Provides the services required to access a block I/O 2 device during PEI recovery
+  boot mode.
+
+Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.4 Volume 1:
+  Pre-EFI Initalization Core Interface.
+
+**/
+
+#ifndef _PEI_BLOCK_IO2_H_
+#define _PEI_BLOCK_IO2_H_
+
+#include <Ppi/BlockIo.h>
+#include <Protocol/DevicePath.h>
+
+///
+/// Global ID for EFI_PEI_RECOVERY_BLOCK_IO2_PPI
+///
+#define EFI_PEI_RECOVERY_BLOCK_IO2_PPI_GUID \
+  { \
+    0x26cc0fad, 0xbeb3, 0x478a, { 0x91, 0xb2, 0xc, 0x18, 0x8f, 0x72, 0x61, 0x98 } \
+  }
+
+///
+/// The forward declaration for EFI_PEI_RECOVERY_BLOCK_IO_PPI.
+///
+typedef struct _EFI_PEI_RECOVERY_BLOCK_IO2_PPI  EFI_PEI_RECOVERY_BLOCK_IO2_PPI;
+
+#define EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION 0x00010000
+
+typedef struct {
+  ///
+  /// A type of interface that the device being referenced by DeviceIndex is
+  /// attached to. This field re-uses Messaging Device Path Node sub-type values
+  /// as defined by Section 9.3.5 Messaging Device Path of UEFI Specification.
+  /// When more than one sub-type is associated with the interface, sub-type with
+  /// the smallest number must be used.
+  ///
+  UINT8                      InterfaceType;
+  ///
+  /// A flag that indicates if media is removable.
+  ///
+  BOOLEAN                    RemovableMedia;
+  ///
+  /// A flag that indicates if media is present. This flag is always set for
+  /// non-removable media devices.
+  ///
+  BOOLEAN                    MediaPresent;
+  ///
+  /// A flag that indicates if media is read-only.
+  ///
+  BOOLEAN                    ReadOnly;
+  ///
+  /// The size of a logical block in bytes.
+  ///
+  UINT32                     BlockSize;
+  ///
+  /// The last logical block that the device supports.
+  ///
+  EFI_PEI_LBA                LastBlock;
+} EFI_PEI_BLOCK_IO2_MEDIA;
+
+/**
+  Gets the count of block I/O devices that one specific block driver detects.
+
+  This function is used for getting the count of block I/O devices that one
+  specific block driver detects.  To the PEI ATAPI driver, it returns the number
+  of all the detected ATAPI devices it detects during the enumeration process.
+  To the PEI legacy floppy driver, it returns the number of all the legacy
+  devices it finds during its enumeration process. If no device is detected,
+  then the function will return zero.
+
+  @param[in]  PeiServices          General-purpose services that are available
+                                   to every PEIM.
+  @param[in]  This                 Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI
+                                   instance.
+  @param[out] NumberBlockDevices   The number of block I/O devices discovered.
+
+  @retval     EFI_SUCCESS          The operation performed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_NUMBER_BLOCK_DEVICES2)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
+  OUT UINTN                          *NumberBlockDevices
+  );
+
+/**
+  Gets a block device's media information.
+
+  This function will provide the caller with the specified block device's media
+  information. If the media changes, calling this function will update the media
+  information accordingly.
+
+  @param[in]  PeiServices   General-purpose services that are available to every
+                            PEIM
+  @param[in]  This          Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance.
+  @param[in]  DeviceIndex   Specifies the block device to which the function wants
+                            to talk. Because the driver that implements Block I/O
+                            PPIs will manage multiple block devices, the PPIs that
+                            want to talk to a single device must specify the
+                            device index that was assigned during the enumeration
+                            process. This index is a number from one to
+                            NumberBlockDevices.
+  @param[out] MediaInfo     The media information of the specified block media.
+                            The caller is responsible for the ownership of this
+                            data structure.
+
+  @par Note:
+      The MediaInfo structure describes an enumeration of possible block device
+      types.  This enumeration exists because no device paths are actually passed
+      across interfaces that describe the type or class of hardware that is publishing
+      the block I/O interface. This enumeration will allow for policy decisions
+      in the Recovery PEIM, such as "Try to recover from legacy floppy first,
+      LS-120 second, CD-ROM third." If there are multiple partitions abstracted
+      by a given device type, they should be reported in ascending order; this
+      order also applies to nested partitions, such as legacy MBR, where the
+      outermost partitions would have precedence in the reporting order. The
+      same logic applies to systems such as IDE that have precedence relationships
+      like "Master/Slave" or "Primary/Secondary". The master device should be
+      reported first, the slave second.
+
+  @retval EFI_SUCCESS        Media information about the specified block device
+                             was obtained successfully.
+  @retval EFI_DEVICE_ERROR   Cannot get the media information due to a hardware
+                             error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_DEVICE_MEDIA_INFORMATION2)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
+  IN  UINTN                          DeviceIndex,
+  OUT EFI_PEI_BLOCK_IO2_MEDIA        *MediaInfo
+  );
+
+/**
+  Reads the requested number of blocks from the specified block device.
+
+  The function reads the requested number of blocks from the device. All the
+  blocks are read, or an error is returned. If there is no media in the device,
+  the function returns EFI_NO_MEDIA.
+
+  @param[in]  PeiServices   General-purpose services that are available to
+                            every PEIM.
+  @param[in]  This          Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance.
+  @param[in]  DeviceIndex   Specifies the block device to which the function wants
+                            to talk. Because the driver that implements Block I/O
+                            PPIs will manage multiple block devices, PPIs that
+                            want to talk to a single device must specify the device
+                            index that was assigned during the enumeration process.
+                            This index is a number from one to NumberBlockDevices.
+  @param[in]  StartLBA      The starting logical block address (LBA) to read from
+                            on the device
+  @param[in]  BufferSize    The size of the Buffer in bytes. This number must be
+                            a multiple of the intrinsic block size of the device.
+  @param[out] Buffer        A pointer to the destination buffer for the data.
+                            The caller is responsible for the ownership of the
+                            buffer.
+
+  @retval EFI_SUCCESS             The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR        The device reported an error while attempting
+                                  to perform the read operation.
+  @retval EFI_INVALID_PARAMETER   The read request contains LBAs that are not
+                                  valid, or the buffer is not properly aligned.
+  @retval EFI_NO_MEDIA            There is no media in the device.
+  @retval EFI_BAD_BUFFER_SIZE     The BufferSize parameter is not a multiple of
+                                  the intrinsic block size of the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_READ_BLOCKS2)(
+  IN  EFI_PEI_SERVICES               **PeiServices,
+  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
+  IN  UINTN                          DeviceIndex,
+  IN  EFI_PEI_LBA                    StartLBA,
+  IN  UINTN                          BufferSize,
+  OUT VOID                           *Buffer
+  );
+
+///
+///  EFI_PEI_RECOVERY_BLOCK_IO_PPI provides the services that are required
+///  to access a block I/O device during PEI recovery boot mode.
+///
+struct _EFI_PEI_RECOVERY_BLOCK_IO2_PPI {
+  ///
+  /// The revision to which the interface adheres.
+  /// All future revisions must be backwards compatible.
+  ///
+  UINT64                                 Revision;
+  ///
+  /// Gets the number of block I/O devices that the specific block driver manages.
+  ///
+  EFI_PEI_GET_NUMBER_BLOCK_DEVICES2      GetNumberOfBlockDevices;
+
+  ///
+  /// Gets the specified media information.
+  ///
+  EFI_PEI_GET_DEVICE_MEDIA_INFORMATION2  GetBlockDeviceMediaInfo;
+
+  ///
+  /// Reads the requested number of blocks from the specified block device.
+  ///
+  EFI_PEI_READ_BLOCKS2                   ReadBlocks;
+};
+
+extern EFI_GUID gEfiPeiVirtualBlockIo2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/BootInRecoveryMode.h b/MdePkg/Include/Ppi/BootInRecoveryMode.h
new file mode 100644
index 000000000000..8671d5141d80
--- /dev/null
+++ b/MdePkg/Include/Ppi/BootInRecoveryMode.h
@@ -0,0 +1,30 @@
+/** @file
+  This PPI is installed by the platform PEIM to designate that a recovery boot 
+  is in progress.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __BOOT_IN_RECOVERY_MODE_PPI_H__
+#define __BOOT_IN_RECOVERY_MODE_PPI_H__
+
+#define EFI_PEI_BOOT_IN_RECOVERY_MODE_PPI \
+  { \
+    0x17ee496a, 0xd8e4, 0x4b9a, {0x94, 0xd1, 0xce, 0x82, 0x72, 0x30, 0x8, 0x50 } \
+  }
+
+
+extern EFI_GUID gEfiPeiBootInRecoveryModePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Capsule.h b/MdePkg/Include/Ppi/Capsule.h
new file mode 100644
index 000000000000..2cc64c514243
--- /dev/null
+++ b/MdePkg/Include/Ppi/Capsule.h
@@ -0,0 +1,136 @@
+/** @file
+  Defines the APIs that enable PEI services to work with 
+  the underlying capsule capabilities of the platform.
+
+Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.4.
+
+**/
+
+#ifndef _PEI_CAPSULE_PPI_H_
+#define _PEI_CAPSULE_PPI_H_
+
+///
+/// Global ID for the EFI_PEI_CAPSULE_PPI.
+///
+#define EFI_PEI_CAPSULE_PPI_GUID \
+  { \
+    0x3acf33ee, 0xd892, 0x40f4, {0xa2, 0xfc, 0x38, 0x54, 0xd2, 0xe1, 0x32, 0x3d } \
+  }
+
+///
+/// Forward declaration for the EFI_PEI_CAPSULE_PPI.
+///
+typedef struct _EFI_PEI_CAPSULE_PPI EFI_PEI_CAPSULE_PPI;
+
+///
+/// Keep name backwards compatible before PI Version 1.4
+///
+typedef struct _EFI_PEI_CAPSULE_PPI PEI_CAPSULE_PPI;
+
+/**
+  Upon determining that there is a capsule to operate on, this service 
+  will use a series of EFI_CAPSULE_BLOCK_DESCRIPTOR entries to determine 
+  the current location of the various capsule fragments and coalesce them 
+  into a contiguous region of system memory.   
+
+  @param[in]  PeiServices   Pointer to the PEI Services Table.
+  @param[out] MemoryBase    Pointer to the base of a block of memory into which the buffers will be coalesced.
+                            On output, this variable will hold the base address 
+                            of a coalesced capsule.
+  @param[out] MemorySize    Size of the memory region pointed to by MemoryBase.
+                            On output, this variable will contain the size of the
+                            coalesced capsule.
+
+  @retval EFI_NOT_FOUND          If: boot modecould not be determined, or the 
+                                 boot mode is not flash-update, or the capsule descriptors were not found. 
+  @retval EFI_BUFFER_TOO_SMALL   The capsule could not be coalesced in the provided memory region. 
+  @retval EFI_SUCCESS            There was no capsule, or the capsule was processed successfully. 
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_CAPSULE_COALESCE)(
+  IN EFI_PEI_SERVICES  **PeiServices,
+  IN OUT VOID          **MemoryBase,
+  IN OUT UINTN         *MemSize
+  );
+
+/**
+  Determine if a capsule needs to be processed. 
+  The means by which the presence of a capsule is determined is platform
+  specific. For example, an implementation could be driven by the presence 
+  of a Capsule EFI Variable containing a list of EFI_CAPSULE_BLOCK_DESCRIPTOR 
+  entries. If present, return EFI_SUCCESS, otherwise return EFI_NOT_FOUND.
+    
+  @param[in] PeiServices   Pointer to the PEI Services Table.
+
+  @retval EFI_SUCCESS     If a capsule is available.
+  @retval EFI_NOT_FOUND   No capsule detected.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_CAPSULE_CHECK_CAPSULE_UPDATE)(
+  IN EFI_PEI_SERVICES  **PeiServices
+  );
+
+/**
+  The Capsule PPI service that gets called after memory is available. The
+  capsule coalesce function, which must be called first, returns a base
+  address and size. Once the memory init PEIM has discovered memory, 
+  it should call this function and pass in the base address and size 
+  returned by the Coalesce() function. Then this function can create a 
+  capsule HOB and return.
+
+  @par Notes:
+    This function assumes it will not be called until the
+    actual capsule update.
+
+  @param[in] PeiServices   Pointer to the PEI Services Table.
+  @param[in] CapsuleBase   Address returned by the capsule coalesce function. 
+  @param[in] CapsuleSize   Value returned by the capsule coalesce function.
+
+  @retval EFI_VOLUME_CORRUPTED   CapsuleBase does not appear to point to a
+                                 coalesced capsule.
+  @retval EFI_SUCCESS            Capsule HOB was created successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_CAPSULE_CREATE_STATE)(
+  IN EFI_PEI_SERVICES  **PeiServices,
+  IN VOID              *CapsuleBase,
+  IN UINTN             CapsuleSize  
+  );
+
+///
+/// This PPI provides several services in PEI to work with the underlying
+/// capsule capabilities of the platform.  These services include the ability 
+/// for PEI to coalesce a capsule from a scattered set of memory locations 
+/// into a contiguous space in memory, detect if a capsule is present for
+/// processing, and once memory is available, create a HOB for the capsule.
+///
+struct _EFI_PEI_CAPSULE_PPI {
+  EFI_PEI_CAPSULE_COALESCE              Coalesce;
+  EFI_PEI_CAPSULE_CHECK_CAPSULE_UPDATE  CheckCapsuleUpdate;
+  EFI_PEI_CAPSULE_CREATE_STATE          CreateState;
+};
+
+///
+/// Keep name backwards compatible before PI Version 1.4
+///
+extern EFI_GUID gPeiCapsulePpiGuid;
+
+extern EFI_GUID gEfiPeiCapsulePpiGuid;
+
+#endif // #ifndef _PEI_CAPSULE_PPI_H_
diff --git a/MdePkg/Include/Ppi/CpuIo.h b/MdePkg/Include/Ppi/CpuIo.h
new file mode 100644
index 000000000000..410a75b27b08
--- /dev/null
+++ b/MdePkg/Include/Ppi/CpuIo.h
@@ -0,0 +1,428 @@
+/** @file
+  This PPI provides a set of memory and I/O-based services. 
+  The perspective of the services is that of the processor, not the bus or system.
+
+Copyright (c) 2006 - 2010, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+  
+**/
+
+#ifndef __PEI_CPUIO_PPI_H__
+#define __PEI_CPUIO_PPI_H__
+
+#define EFI_PEI_CPU_IO_PPI_INSTALLED_GUID \
+  { 0xe6af1f7b, 0xfc3f, 0x46da, {0xa8, 0x28, 0xa3, 0xb4, 0x57, 0xa4, 0x42, 0x82 } }
+
+typedef struct _EFI_PEI_CPU_IO_PPI  EFI_PEI_CPU_IO_PPI;
+
+///
+/// EFI_PEI_CPU_IO_PPI_WIDTH.
+///
+typedef enum {
+  EfiPeiCpuIoWidthUint8,
+  EfiPeiCpuIoWidthUint16,
+  EfiPeiCpuIoWidthUint32,
+  EfiPeiCpuIoWidthUint64,
+  EfiPeiCpuIoWidthFifoUint8,
+  EfiPeiCpuIoWidthFifoUint16,
+  EfiPeiCpuIoWidthFifoUint32,
+  EfiPeiCpuIoWidthFifoUint64,
+  EfiPeiCpuIoWidthFillUint8,
+  EfiPeiCpuIoWidthFillUint16,
+  EfiPeiCpuIoWidthFillUint32,
+  EfiPeiCpuIoWidthFillUint64,
+  EfiPeiCpuIoWidthMaximum
+} EFI_PEI_CPU_IO_PPI_WIDTH;
+
+/**
+  Memory-based access services and I/O-based access services.
+
+  @param[in]      PeiServices  An indirect pointer to the PEI Services Table
+                               published by the PEI Foundation.
+  @param[in]      This         The pointer to local data for the interface.
+  @param[in]      Width        The width of the access. Enumerated in bytes.
+  @param[in]      Address      The physical address of the access.
+  @param[in]      Count        The number of accesses to perform.
+  @param[in, out] Buffer       A pointer to the buffer of data.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_NOT_YET_AVAILABLE  The service has not been installed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_MEM)(
+  IN     CONST EFI_PEI_SERVICES    **PeiServices,
+  IN     CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN     EFI_PEI_CPU_IO_PPI_WIDTH  Width,
+  IN     UINT64                    Address,
+  IN     UINTN                     Count,
+  IN OUT VOID                      *Buffer
+  );
+
+///
+/// EFI_PEI_CPU_IO_PPI_ACCESS
+///
+typedef struct {
+  ///
+  /// This service provides the various modalities of memory and I/O read.
+  ///
+  EFI_PEI_CPU_IO_PPI_IO_MEM  Read;
+  ///
+  /// This service provides the various modalities of memory and I/O write.
+  ///
+  EFI_PEI_CPU_IO_PPI_IO_MEM  Write;
+} EFI_PEI_CPU_IO_PPI_ACCESS;
+
+/**
+  8-bit I/O read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  An 8-bit value returned from the I/O space.
+
+**/
+typedef
+UINT8
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_READ8)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  16-bit I/O read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 16-bit value returned from the I/O space.
+
+**/
+typedef
+UINT16
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_READ16)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  32-bit I/O read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 32-bit value returned from the I/O space.
+
+**/
+typedef
+UINT32
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_READ32)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  64-bit I/O read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 64-bit value returned from the I/O space.
+
+**/
+typedef
+UINT64
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_READ64)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  8-bit I/O write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_WRITE8)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT8                     Data
+  );
+
+/**
+  16-bit I/O write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_WRITE16)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT16                    Data
+  );
+
+/**
+  32-bit I/O write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_WRITE32)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT32                    Data
+  );
+
+/**
+  64-bit I/O write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_IO_WRITE64)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT64                    Data
+  );
+
+/**
+  8-bit memory read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  An 8-bit value returned from the memory space.
+
+**/
+typedef
+UINT8
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_READ8)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  16-bit memory read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 16-bit value returned from the memory space.
+
+**/
+typedef
+UINT16
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_READ16)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  32-bit memory read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 32-bit value returned from the memory space.
+
+**/
+typedef
+UINT32
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_READ32)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  64-bit memory read operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+
+  @return  A 64-bit value returned from the memory space.
+
+**/
+typedef
+UINT64
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_READ64)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address
+  );
+
+/**
+  8-bit memory write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_WRITE8)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT8                     Data
+  );
+
+/**
+  16-bit memory write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_WRITE16)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT16                    Data
+  );
+
+/**
+  32-bit memory write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_WRITE32)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT32                    Data
+  );
+
+/**
+  64-bit memory write operations.
+
+  @param[in] PeiServices  An indirect pointer to the PEI Services Table published 
+                          by the PEI Foundation.
+  @param[in] This         The pointer to local data for the interface.
+  @param[in] Address      The physical address of the access.
+  @param[in] Data         The data to write.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_CPU_IO_PPI_MEM_WRITE64)(
+  IN  CONST EFI_PEI_SERVICES    **PeiServices,
+  IN  CONST EFI_PEI_CPU_IO_PPI  *This,
+  IN  UINT64                    Address,
+  IN  UINT64                    Data
+  );
+
+///
+/// EFI_PEI_CPU_IO_PPI provides a set of memory and I/O-based services.
+/// The perspective of the services is that of the processor, not that of the 
+/// bus or system.
+///
+struct _EFI_PEI_CPU_IO_PPI {
+  ///
+  /// Collection of memory-access services.
+  ///
+  EFI_PEI_CPU_IO_PPI_ACCESS       Mem;
+  ///
+  /// Collection of I/O-access services.
+  ///
+  EFI_PEI_CPU_IO_PPI_ACCESS       Io;
+
+  EFI_PEI_CPU_IO_PPI_IO_READ8     IoRead8;
+  EFI_PEI_CPU_IO_PPI_IO_READ16    IoRead16;
+  EFI_PEI_CPU_IO_PPI_IO_READ32    IoRead32;
+  EFI_PEI_CPU_IO_PPI_IO_READ64    IoRead64;
+
+  EFI_PEI_CPU_IO_PPI_IO_WRITE8    IoWrite8;
+  EFI_PEI_CPU_IO_PPI_IO_WRITE16   IoWrite16;
+  EFI_PEI_CPU_IO_PPI_IO_WRITE32   IoWrite32;
+  EFI_PEI_CPU_IO_PPI_IO_WRITE64   IoWrite64;
+
+  EFI_PEI_CPU_IO_PPI_MEM_READ8    MemRead8;
+  EFI_PEI_CPU_IO_PPI_MEM_READ16   MemRead16;
+  EFI_PEI_CPU_IO_PPI_MEM_READ32   MemRead32;
+  EFI_PEI_CPU_IO_PPI_MEM_READ64   MemRead64;
+
+  EFI_PEI_CPU_IO_PPI_MEM_WRITE8   MemWrite8;
+  EFI_PEI_CPU_IO_PPI_MEM_WRITE16  MemWrite16;
+  EFI_PEI_CPU_IO_PPI_MEM_WRITE32  MemWrite32;
+  EFI_PEI_CPU_IO_PPI_MEM_WRITE64  MemWrite64;
+};
+
+extern EFI_GUID gEfiPeiCpuIoPpiInstalledGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Decompress.h b/MdePkg/Include/Ppi/Decompress.h
new file mode 100644
index 000000000000..49678e9dbe08
--- /dev/null
+++ b/MdePkg/Include/Ppi/Decompress.h
@@ -0,0 +1,74 @@
+/** @file
+  Provides decompression services to the PEI Foundatoin.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __DECOMPRESS_PPI_H__
+#define __DECOMPRESS_PPI_H__
+
+#define EFI_PEI_DECOMPRESS_PPI_GUID \
+  { 0x1a36e4e7, 0xfab6, 0x476a, { 0x8e, 0x75, 0x69, 0x5a, 0x5, 0x76, 0xfd, 0xd7 } }
+
+typedef struct _EFI_PEI_DECOMPRESS_PPI  EFI_PEI_DECOMPRESS_PPI;
+
+/** 
+  Decompress a single compression section in a firmware file.
+                                                               
+  Decompresses the data in a compressed section and returns it
+  as a series of standard PI Firmware File Sections. The
+  required memory is allocated from permanent memory.
+
+  @param This                   Points to this instance of the
+                                EFI_PEI_DECOMPRESS_PEI PPI.
+  @param InputSection           Points to the compressed section.
+  @param OutputBuffer           Holds the returned pointer to the
+                                decompressed sections.
+  @param OutputSize             Holds the returned size of the decompress
+                                section streams.
+
+  @retval EFI_SUCCESS           The section was decompressed
+                                successfully. OutputBuffer contains the
+                                resulting data and OutputSize contains
+                                the resulting size.
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate sufficient
+                                memory to hold the decompressed data.
+  @retval EFI_UNSUPPORTED       The compression type specified
+                                in the compression header is unsupported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_DECOMPRESS_DECOMPRESS)(
+  IN  CONST EFI_PEI_DECOMPRESS_PPI  *This,
+  IN  CONST EFI_COMPRESSION_SECTION *InputSection,
+  OUT VOID                           **OutputBuffer,
+  OUT UINTN                          *OutputSize
+);
+
+
+///
+/// This PPI's single member function decompresses a compression
+/// encapsulated section. It is used by the PEI Foundation to
+/// process sectioned files. Prior to the installation of this PPI,
+/// compression sections will be ignored.
+///
+struct _EFI_PEI_DECOMPRESS_PPI {
+  EFI_PEI_DECOMPRESS_DECOMPRESS Decompress;
+};
+
+
+extern EFI_GUID   gEfiPeiDecompressPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/DeviceRecoveryModule.h b/MdePkg/Include/Ppi/DeviceRecoveryModule.h
new file mode 100644
index 000000000000..6f3a2174ca85
--- /dev/null
+++ b/MdePkg/Include/Ppi/DeviceRecoveryModule.h
@@ -0,0 +1,144 @@
+/** @file
+  This file declares the Device Recovery Module PPI.
+
+  The interface of this PPI does the following:
+    - Reports the number of recovery DXE capsules that exist on the associated device(s)
+    - Finds the requested firmware binary capsule
+    - Loads that capsule into memory
+
+  A device can be either a group of devices, such as a block device, or an individual device.
+  The module determines the internal search order, with capsule number 1 as the highest load
+  priority and number N as the lowest priority.
+
+  Copyright (c) 2007 - 2011, 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.
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Volume 1: 
+  Pre-EFI Initalization Core Interface
+
+**/
+
+#ifndef _PEI_DEVICE_RECOVERY_MODULE_PPI_H_
+#define _PEI_DEVICE_RECOVERY_MODULE_PPI_H_
+
+#define EFI_PEI_DEVICE_RECOVERY_MODULE_PPI_GUID \
+  { \
+    0x0DE2CE25, 0x446A, 0x45a7, {0xBF, 0xC9, 0x37, 0xDA, 0x26, 0x34, 0x4B, 0x37 } \
+  }
+
+typedef struct _EFI_PEI_DEVICE_RECOVERY_MODULE_PPI EFI_PEI_DEVICE_RECOVERY_MODULE_PPI;
+
+/**
+  Returns the number of DXE capsules residing on the device.
+
+  This function searches for DXE capsules from the associated device and returns
+  the number and maximum size in bytes of the capsules discovered. Entry 1 is 
+  assumed to be the highest load priority and entry N is assumed to be the lowest 
+  priority.
+
+  @param[in]  PeiServices              General-purpose services that are available 
+                                       to every PEIM
+  @param[in]  This                     Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                       instance.
+  @param[out] NumberRecoveryCapsules   Pointer to a caller-allocated UINTN. On 
+                                       output, *NumberRecoveryCapsules contains 
+                                       the number of recovery capsule images 
+                                       available for retrieval from this PEIM 
+                                       instance.
+
+  @retval EFI_SUCCESS        One or more capsules were discovered.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A recovery DXE capsule cannot be found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_DEVICE_GET_NUMBER_RECOVERY_CAPSULE)(
+  IN  EFI_PEI_SERVICES                    **PeiServices,
+  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
+  OUT UINTN                               *NumberRecoveryCapsules
+  );
+
+/**
+  Returns the size and type of the requested recovery capsule.
+
+  This function gets the size and type of the capsule specified by CapsuleInstance.
+
+  @param[in]  PeiServices       General-purpose services that are available to every PEIM
+  @param[in]  This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI 
+                                instance.
+  @param[in]  CapsuleInstance   Specifies for which capsule instance to retrieve 
+                                the information.  This parameter must be between 
+                                one and the value returned by GetNumberRecoveryCapsules() 
+                                in NumberRecoveryCapsules.
+  @param[out] Size              A pointer to a caller-allocated UINTN in which 
+                                the size of the requested recovery module is 
+                                returned.
+  @param[out] CapsuleType       A pointer to a caller-allocated EFI_GUID in which 
+                                the type of the requested recovery capsule is 
+                                returned.  The semantic meaning of the value 
+                                returned is defined by the implementation.
+
+  @retval EFI_SUCCESS        One or more capsules were discovered.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A recovery DXE capsule cannot be found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_DEVICE_GET_RECOVERY_CAPSULE_INFO)(
+  IN  EFI_PEI_SERVICES                    **PeiServices,
+  IN  EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
+  IN  UINTN                               CapsuleInstance,
+  OUT UINTN                               *Size,
+  OUT EFI_GUID                            *CapsuleType
+  );
+
+/**
+  Loads a DXE capsule from some media into memory.
+
+  This function, by whatever mechanism, retrieves a DXE capsule from some device
+  and loads it into memory. Note that the published interface is device neutral.
+
+  @param[in]     PeiServices       General-purpose services that are available 
+                                   to every PEIM
+  @param[in]     This              Indicates the EFI_PEI_DEVICE_RECOVERY_MODULE_PPI
+                                   instance.
+  @param[in]     CapsuleInstance   Specifies which capsule instance to retrieve.
+  @param[out]    Buffer            Specifies a caller-allocated buffer in which 
+                                   the requested recovery capsule will be returned.
+
+  @retval EFI_SUCCESS        The capsule was loaded correctly.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A requested recovery DXE capsule cannot be found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_DEVICE_LOAD_RECOVERY_CAPSULE)(
+  IN     EFI_PEI_SERVICES                    **PeiServices,
+  IN     EFI_PEI_DEVICE_RECOVERY_MODULE_PPI  *This,
+  IN     UINTN                               CapsuleInstance,
+  OUT    VOID                                *Buffer
+  );
+
+///
+/// Presents a standard interface to EFI_PEI_DEVICE_RECOVERY_MODULE_PPI,
+/// regardless of the underlying device(s).
+///
+struct _EFI_PEI_DEVICE_RECOVERY_MODULE_PPI {
+  EFI_PEI_DEVICE_GET_NUMBER_RECOVERY_CAPSULE  GetNumberRecoveryCapsules;    ///< Returns the number of DXE capsules residing on the device.
+  EFI_PEI_DEVICE_GET_RECOVERY_CAPSULE_INFO    GetRecoveryCapsuleInfo;       ///< Returns the size and type of the requested recovery capsule.
+  EFI_PEI_DEVICE_LOAD_RECOVERY_CAPSULE        LoadRecoveryCapsule;          ///< Loads a DXE capsule from some media into memory.
+};
+
+extern EFI_GUID gEfiPeiDeviceRecoveryModulePpiGuid;
+
+#endif  /* _PEI_DEVICE_RECOVERY_MODULE_PPI_H_ */
diff --git a/MdePkg/Include/Ppi/DxeIpl.h b/MdePkg/Include/Ppi/DxeIpl.h
new file mode 100644
index 000000000000..3d3d1f3c4db1
--- /dev/null
+++ b/MdePkg/Include/Ppi/DxeIpl.h
@@ -0,0 +1,72 @@
+/** @file
+  This file declares DXE Initial Program Load PPI.
+  When the PEI core is done it calls the DXE IPL PPI to load the DXE Foundation.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __DXE_IPL_H__
+#define __DXE_IPL_H__
+
+#define EFI_DXE_IPL_PPI_GUID \
+  { \
+    0xae8ce5d, 0xe448, 0x4437, {0xa8, 0xd7, 0xeb, 0xf5, 0xf1, 0x94, 0xf7, 0x31 } \
+  }
+
+typedef struct _EFI_DXE_IPL_PPI EFI_DXE_IPL_PPI;
+
+/**
+  The architectural PPI that the PEI Foundation invokes when 
+  there are no additional PEIMs to invoke.
+
+  This function is invoked by the PEI Foundation.
+  The PEI Foundation will invoke this service when there are
+  no additional PEIMs to invoke in the system.
+  If this PPI does not exist, it is an error condition and
+  an ill-formed firmware set. The DXE IPL PPI should never
+  return after having been invoked by the PEI Foundation.
+  The DXE IPL PPI can do many things internally, including the following:
+    - Invoke the DXE entry point from a firmware volume
+    - Invoke the recovery processing modules
+    - Invoke the S3 resume modules
+
+  @param  This           Pointer to the DXE IPL PPI instance
+  @param  PeiServices    Pointer to the PEI Services Table.
+  @param  HobList        Pointer to the list of Hand-Off Block (HOB) entries.
+
+  @retval EFI_SUCCESS    Upon this return code, the PEI Foundation should enter
+                         some exception handling.Under normal circumstances, 
+                         the DXE IPL PPI should not return.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DXE_IPL_ENTRY)(
+  IN CONST EFI_DXE_IPL_PPI        *This,
+  IN EFI_PEI_SERVICES             **PeiServices,
+  IN EFI_PEI_HOB_POINTERS         HobList
+  );
+
+///
+/// Final service to be invoked by the PEI Foundation.
+/// The DXE IPL PPI is responsible for locating and loading the DXE Foundation.
+/// The DXE IPL PPI may use PEI services to locate and load the DXE Foundation.
+///
+struct _EFI_DXE_IPL_PPI {
+  EFI_DXE_IPL_ENTRY Entry;
+};
+
+extern EFI_GUID gEfiDxeIplPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/EndOfPeiPhase.h b/MdePkg/Include/Ppi/EndOfPeiPhase.h
new file mode 100644
index 000000000000..b123c79dcd9f
--- /dev/null
+++ b/MdePkg/Include/Ppi/EndOfPeiPhase.h
@@ -0,0 +1,31 @@
+/** @file
+  This PPI will be installed at the end of PEI for all boot paths, including 
+  normal, recovery, and S3. It allows for PEIMs to possibly quiesce hardware, 
+  build handoff information for the next phase of execution, 
+  or provide some terminal processing behavior.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __END_OF_PEI_PHASE_PPI_H__
+#define __END_OF_PEI_PHASE_PPI_H__
+
+#define EFI_PEI_END_OF_PEI_PHASE_PPI_GUID \
+  { \
+    0x605EA650, 0xC65C, 0x42e1, {0xBA, 0x80, 0x91, 0xA5, 0x2A, 0xB6, 0x18, 0xC6 } \
+  }
+
+extern EFI_GUID gEfiEndOfPeiSignalPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/FirmwareVolume.h b/MdePkg/Include/Ppi/FirmwareVolume.h
new file mode 100644
index 000000000000..37eaa2129e8f
--- /dev/null
+++ b/MdePkg/Include/Ppi/FirmwareVolume.h
@@ -0,0 +1,294 @@
+/** @file
+  This file provides functions for accessing a memory-mapped firmware volume of a specific format.
+
+  Copyright (c) 2006 - 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is from PI Version 1.0 errata.
+
+**/
+
+#ifndef __FIRMWARE_VOLUME_PPI_H__
+#define __FIRMWARE_VOLUME_PPI_H__
+
+///
+/// The GUID for this PPI is the same as the firmware volume format GUID.
+/// The FV format can be EFI_FIRMWARE_FILE_SYSTEM2_GUID or the GUID for a user-defined
+/// format. The EFI_FIRMWARE_FILE_SYSTEM2_GUID is the PI Firmware Volume format.
+/// 
+typedef struct _EFI_PEI_FIRMWARE_VOLUME_PPI   EFI_PEI_FIRMWARE_VOLUME_PPI;
+
+
+/**
+  Process a firmware volume and create a volume handle.
+
+  Create a volume handle from the information in the buffer. For
+  memory-mapped firmware volumes, Buffer and BufferSize refer to
+  the start of the firmware volume and the firmware volume size.
+  For non memory-mapped firmware volumes, this points to a
+  buffer which contains the necessary information for creating
+  the firmware volume handle. Normally, these values are derived
+  from the EFI_FIRMWARE_VOLUME_INFO_PPI.
+  
+  
+  @param This                   Points to this instance of the
+                                EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param Buffer                 Points to the start of the buffer.
+  @param BufferSize             Size of the buffer.
+  @param FvHandle               Points to the returned firmware volume
+                                handle. The firmware volume handle must
+                                be unique within the system. 
+
+  @retval EFI_SUCCESS           Firmware volume handle created.
+  @retval EFI_VOLUME_CORRUPTED  Volume was corrupt.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_PROCESS_FV)(
+  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI *This,
+  IN  VOID                               *Buffer,
+  IN  UINTN                              BufferSize,
+  OUT EFI_PEI_FV_HANDLE                  *FvHandle
+);
+
+/**
+  Finds the next file of the specified type.
+
+  This service enables PEI modules to discover additional firmware files. 
+  The FileHandle must be unique within the system.
+
+  @param This           Points to this instance of the
+                        EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param SearchType     A filter to find only files of this type. Type
+                        EFI_FV_FILETYPE_ALL causes no filtering to be
+                        done.
+  @param FvHandle       Handle of firmware volume in which to
+                        search.
+  @param FileHandle     Points to the current handle from which to
+                        begin searching or NULL to start at the
+                        beginning of the firmware volume. Updated
+                        upon return to reflect the file found.
+
+  @retval EFI_SUCCESS   The file was found.
+  @retval EFI_NOT_FOUND The file was not found. FileHandle contains NULL.
+
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_FIND_FILE_TYPE)( 
+  IN     CONST EFI_PEI_FIRMWARE_VOLUME_PPI   *This, 
+  IN     EFI_FV_FILETYPE                     SearchType, 
+  IN     EFI_PEI_FV_HANDLE                   FvHandle,
+  IN OUT EFI_PEI_FILE_HANDLE                 *FileHandle 
+);
+
+
+/**
+  Find a file within a volume by its name. 
+  
+  This service searches for files with a specific name, within
+  either the specified firmware volume or all firmware volumes.
+
+  @param This                   Points to this instance of the
+                                EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param FileName               A pointer to the name of the file to find
+                                within the firmware volume.
+  @param FvHandle               Upon entry, the pointer to the firmware
+                                volume to search or NULL if all firmware
+                                volumes should be searched. Upon exit, the
+                                actual firmware volume in which the file was
+                                found.
+  @param FileHandle             Upon exit, points to the found file's
+                                handle or NULL if it could not be found.
+
+  @retval EFI_SUCCESS           File was found.
+  @retval EFI_NOT_FOUND         File was not found.
+  @retval EFI_INVALID_PARAMETER FvHandle or FileHandle or
+                                FileName was NULL.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_FIND_FILE_NAME)(
+  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI *This,
+  IN  CONST  EFI_GUID                    *FileName,
+  IN  EFI_PEI_FV_HANDLE                  *FvHandle,
+  OUT EFI_PEI_FILE_HANDLE                *FileHandle
+);
+
+
+/**
+  Returns information about a specific file.
+
+  This function returns information about a specific
+  file, including its file name, type, attributes, starting
+  address and size. 
+   
+  @param This                     Points to this instance of the
+                                  EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param FileHandle               Handle of the file.
+  @param FileInfo                 Upon exit, points to the file's
+                                  information.
+
+  @retval EFI_SUCCESS             File information returned.
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+  
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_GET_FILE_INFO)(
+  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI   *This, 
+  IN  EFI_PEI_FILE_HANDLE                 FileHandle, 
+  OUT EFI_FV_FILE_INFO                    *FileInfo
+);
+
+/**
+  Returns information about a specific file.
+
+  This function returns information about a specific
+  file, including its file name, type, attributes, starting
+  address, size and authentication status. 
+
+  @param This                     Points to this instance of the
+                                  EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param FileHandle               Handle of the file.
+  @param FileInfo                 Upon exit, points to the file's
+                                  information.
+
+  @retval EFI_SUCCESS             File information returned.
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_GET_FILE_INFO2)(
+  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI   *This, 
+  IN  EFI_PEI_FILE_HANDLE                 FileHandle,
+  OUT EFI_FV_FILE_INFO2                   *FileInfo
+);
+
+/**
+  This function returns information about the firmware volume.
+  
+  @param This                     Points to this instance of the
+                                  EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param FvHandle                 Handle to the firmware handle.
+  @param VolumeInfo               Points to the returned firmware volume
+                                  information.
+
+  @retval EFI_SUCCESS             Information returned successfully.
+  @retval EFI_INVALID_PARAMETER   FvHandle does not indicate a valid
+                                  firmware volume or VolumeInfo is NULL.
+
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_GET_INFO)(
+  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI   *This, 
+  IN  EFI_PEI_FV_HANDLE                    FvHandle, 
+  OUT EFI_FV_INFO                          *VolumeInfo
+);
+
+/**
+  Find the next matching section in the firmware file.
+  
+  This service enables PEI modules to discover sections
+  of a given type within a valid file.
+  
+  @param This             Points to this instance of the
+                          EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param SearchType       A filter to find only sections of this
+                          type.
+  @param FileHandle       Handle of firmware file in which to
+                          search.
+  @param SectionData      Updated upon  return to point to the
+                          section found.
+  
+  @retval EFI_SUCCESS     Section was found.
+  @retval EFI_NOT_FOUND   Section of the specified type was not
+                          found. SectionData contains NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_FIND_SECTION)(
+  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI    *This,
+  IN  EFI_SECTION_TYPE                     SearchType,
+  IN  EFI_PEI_FILE_HANDLE                  FileHandle,
+  OUT VOID                                 **SectionData
+);
+
+/**
+  Find the next matching section in the firmware file.
+
+  This service enables PEI modules to discover sections
+  of a given instance and type within a valid file.
+
+  @param This                   Points to this instance of the
+                                EFI_PEI_FIRMWARE_VOLUME_PPI.
+  @param SearchType             A filter to find only sections of this
+                                type.
+  @param SearchInstance         A filter to find the specific instance
+                                of sections.
+  @param FileHandle             Handle of firmware file in which to
+                                search.
+  @param SectionData            Updated upon return to point to the
+                                section found.
+  @param AuthenticationStatus   Updated upon return to point to the
+                                authentication status for this section.
+
+  @retval EFI_SUCCESS     Section was found.
+  @retval EFI_NOT_FOUND   Section of the specified type was not
+                          found. SectionData contains NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FV_FIND_SECTION2)(
+  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI    *This,
+  IN  EFI_SECTION_TYPE                     SearchType,
+  IN  UINTN                                SearchInstance,
+  IN  EFI_PEI_FILE_HANDLE                  FileHandle,
+  OUT VOID                                 **SectionData,
+  OUT UINT32                               *AuthenticationStatus
+);
+
+#define EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE SIGNATURE_32 ('P', 'F', 'V', 'P')
+#define EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION 0x00010030
+
+///
+/// This PPI provides functions for accessing a memory-mapped firmware volume of a specific format.
+///
+struct _EFI_PEI_FIRMWARE_VOLUME_PPI {
+  EFI_PEI_FV_PROCESS_FV       ProcessVolume;
+  EFI_PEI_FV_FIND_FILE_TYPE   FindFileByType;
+  EFI_PEI_FV_FIND_FILE_NAME   FindFileByName;
+  EFI_PEI_FV_GET_FILE_INFO    GetFileInfo;
+  EFI_PEI_FV_GET_INFO         GetVolumeInfo;
+  EFI_PEI_FV_FIND_SECTION     FindSectionByType;
+  EFI_PEI_FV_GET_FILE_INFO2   GetFileInfo2;
+  EFI_PEI_FV_FIND_SECTION2    FindSectionByType2;
+  ///
+  /// Signature is used to keep backward-compatibility, set to {'P','F','V','P'}.
+  ///
+  UINT32                      Signature;
+  ///
+  /// Revision for further extension.
+  ///
+  UINT32                      Revision;
+};
+
+extern EFI_GUID gEfiPeiFirmwareVolumePpiGuid;
+
+#endif 
diff --git a/MdePkg/Include/Ppi/FirmwareVolumeInfo.h b/MdePkg/Include/Ppi/FirmwareVolumeInfo.h
new file mode 100644
index 000000000000..b26685519ed3
--- /dev/null
+++ b/MdePkg/Include/Ppi/FirmwareVolumeInfo.h
@@ -0,0 +1,68 @@
+/** @file
+  This file provides location and format of a firmware volume.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __EFI_PEI_FIRMWARE_VOLUME_INFO_H__
+#define __EFI_PEI_FIRMWARE_VOLUME_INFO_H__
+
+
+
+#define EFI_PEI_FIRMWARE_VOLUME_INFO_PPI_GUID \
+{ 0x49edb1c1, 0xbf21, 0x4761, { 0xbb, 0x12, 0xeb, 0x0, 0x31, 0xaa, 0xbb, 0x39 } }
+
+typedef struct _EFI_PEI_FIRMWARE_VOLUME_INFO_PPI  EFI_PEI_FIRMWARE_VOLUME_INFO_PPI;
+
+///
+///  This PPI describes the location and format of a firmware volume. 
+///  The FvFormat can be EFI_FIRMWARE_FILE_SYSTEM2_GUID or the GUID for 
+///  a user-defined format. The  EFI_FIRMWARE_FILE_SYSTEM2_GUID is 
+///  the PI Firmware Volume format.
+///
+struct _EFI_PEI_FIRMWARE_VOLUME_INFO_PPI {
+  ///
+  /// Unique identifier of the format of the memory-mapped firmware volume.
+  ///
+  EFI_GUID  FvFormat;
+  ///
+  /// Points to a buffer which allows the EFI_PEI_FIRMWARE_VOLUME_PPI to process
+  /// the volume. The format of this buffer is specific to the FvFormat.
+  /// For memory-mapped firmware volumes, this typically points to the first byte
+  /// of the firmware volume.
+  ///
+  VOID      *FvInfo;
+  ///
+  /// Size of the data provided by FvInfo. For memory-mapped firmware volumes,
+  /// this is typically the size of the firmware volume.
+  ///
+  UINT32    FvInfoSize;
+  ///
+  /// If the firmware volume originally came from a firmware file, then these
+  /// point to the parent firmware volume name and firmware volume file.
+  /// If it did not originally come from a firmware file, these should be NULL.
+  ///
+  EFI_GUID  *ParentFvName;
+  ///
+  /// If the firmware volume originally came from a firmware file, then these
+  /// point to the parent firmware volume name and firmware volume file.
+  /// If it did not originally come from a firmware file, these should be NULL.
+  ///
+  EFI_GUID  *ParentFileName;
+};
+
+extern EFI_GUID gEfiPeiFirmwareVolumeInfoPpiGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/FirmwareVolumeInfo2.h b/MdePkg/Include/Ppi/FirmwareVolumeInfo2.h
new file mode 100644
index 000000000000..4e2259299a0e
--- /dev/null
+++ b/MdePkg/Include/Ppi/FirmwareVolumeInfo2.h
@@ -0,0 +1,72 @@
+/** @file
+  This file provides location, format and authentication status of a firmware volume.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.3 errata.
+
+**/
+
+#ifndef __EFI_PEI_FIRMWARE_VOLUME_INFO2_H__
+#define __EFI_PEI_FIRMWARE_VOLUME_INFO2_H__
+
+
+
+#define EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI_GUID \
+{ 0xea7ca24b, 0xded5, 0x4dad, { 0xa3, 0x89, 0xbf, 0x82, 0x7e, 0x8f, 0x9b, 0x38 } }
+
+typedef struct _EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI  EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI;
+
+///
+///  This PPI describes the location and format of a firmware volume. 
+///  The FvFormat can be EFI_FIRMWARE_FILE_SYSTEM2_GUID or the GUID for 
+///  a user-defined format. The  EFI_FIRMWARE_FILE_SYSTEM2_GUID is 
+///  the PI Firmware Volume format.
+///
+struct _EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI {
+  ///
+  /// Unique identifier of the format of the memory-mapped firmware volume.
+  ///
+  EFI_GUID  FvFormat;
+  ///
+  /// Points to a buffer which allows the EFI_PEI_FIRMWARE_VOLUME_PPI to process
+  /// the volume. The format of this buffer is specific to the FvFormat.
+  /// For memory-mapped firmware volumes, this typically points to the first byte
+  /// of the firmware volume.
+  ///
+  VOID      *FvInfo;
+  ///
+  /// Size of the data provided by FvInfo. For memory-mapped firmware volumes,
+  /// this is typically the size of the firmware volume.
+  ///
+  UINT32    FvInfoSize;
+  ///
+  /// If the firmware volume originally came from a firmware file, then these
+  /// point to the parent firmware volume name and firmware volume file.
+  /// If it did not originally come from a firmware file, these should be NULL.
+  ///
+  EFI_GUID  *ParentFvName;
+  ///
+  /// If the firmware volume originally came from a firmware file, then these
+  /// point to the parent firmware volume name and firmware volume file.
+  /// If it did not originally come from a firmware file, these should be NULL.
+  ///
+  EFI_GUID  *ParentFileName;
+  ///
+  /// Authentication Status.
+  ///
+  UINT32    AuthenticationStatus;
+};
+
+extern EFI_GUID gEfiPeiFirmwareVolumeInfo2PpiGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/Graphics.h b/MdePkg/Include/Ppi/Graphics.h
new file mode 100644
index 000000000000..3ae6bef9dfef
--- /dev/null
+++ b/MdePkg/Include/Ppi/Graphics.h
@@ -0,0 +1,85 @@
+/** @file
+  This file declares Graphics PPI.
+  This PPI is the main interface exposed by the Graphics PEIM to be used by the
+  other firmware modules.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.4.
+
+**/
+
+#ifndef __PEI_GRAPHICS_PPI_H__
+#define __PEI_GRAPHICS_PPI_H__
+
+#include <Protocol/GraphicsOutput.h>
+
+#define EFI_PEI_GRAPHICS_PPI_GUID \
+  { \
+    0x6ecd1463, 0x4a4a, 0x461b, { 0xaf, 0x5f, 0x5a, 0x33, 0xe3, 0xb2, 0x16, 0x2b } \
+  }
+
+typedef struct _EFI_PEI_GRAPHICS_PPI EFI_PEI_GRAPHICS_PPI;
+
+/**
+  The GraphicsPpiInit initializes the graphics subsystem in phases.
+
+  @param[in] GraphicsPolicyPtr    GraphicsPolicyPtr points to a configuration data
+                                  block of policy settings required by Graphics PEIM.
+
+  @retval EFI_SUCCESS             The invocation was successful.
+  @retval EFI_INVALID_PARAMETER   The phase parameter is not valid.
+  @retval EFI_NOT_ABORTED         The stages was not called in the proper order.
+  @retval EFI_NOT_FOUND           The PeiGraphicsPlatformPolicyPpi is not located.
+  @retval EFI_DEVICE_ERROR        The initialization failed due to device error.
+  @retval EFI_NOT_READY           The previous init stage is still in progress and not
+                                  ready for the current initialization phase yet. The
+                                  platform code should call this again sometime later.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GRAPHICS_INIT) (
+  IN VOID                            *GraphicsPolicyPtr
+  );
+
+/**
+  The GraphicsPpiGetMode returns the mode information supported by the Graphics PEI
+  Module.
+
+  @param[in, out] Mode            Pointer to EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE data.
+
+  @retval EFI_SUCCESS             Valid mode information was returned.
+  @retval EFI_INVALID_PARAMETER   The Mode parameter is not valid.
+  @retval EFI_DEVICE_ERROR        A hardware error occurred trying to retrieve the video
+                                  mode.
+  @retval EFI_NOT_READY           The Graphics Initialization is not competed and Mode
+                                  information is not yet available.The platform code
+                                  should call this again after the Graphics
+                                  initialization is done.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GRAPHICS_GET_MODE) (
+  IN OUT EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE  *Mode
+  );
+
+///
+/// This PPI is the main interface exposed by the Graphics PEIM to be used by the other
+/// firmware modules.
+///
+struct _EFI_PEI_GRAPHICS_PPI {
+  EFI_PEI_GRAPHICS_INIT              GraphicsPpiInit;
+  EFI_PEI_GRAPHICS_GET_MODE          GraphicsPpiGetMode;
+};
+
+extern EFI_GUID gEfiPeiGraphicsPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/GuidedSectionExtraction.h b/MdePkg/Include/Ppi/GuidedSectionExtraction.h
new file mode 100644
index 000000000000..6eb16daa9543
--- /dev/null
+++ b/MdePkg/Include/Ppi/GuidedSectionExtraction.h
@@ -0,0 +1,104 @@
+/** @file
+  If a GUID-defined section is encountered when doing section extraction, 
+  the PEI Foundation or the EFI_PEI_FILE_LOADER_PPI instance 
+  calls the appropriate instance of the GUIDed Section Extraction PPI 
+  to extract the section stream contained therein. 
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __EFI_GUIDED_SECTION_EXTRACTION_PPI_H__
+#define __EFI_GUIDED_SECTION_EXTRACTION_PPI_H__
+
+//
+// Typically, protocol interface structures are identified 
+// by associating them with a GUID. Each instance of 
+// a protocol with a given GUID must have 
+// the same interface structure. While all instances of 
+// the GUIDed Section Extraction PPI must have 
+// the same interface structure, they do not all have 
+// te same GUID. The GUID that is associated with 
+// an instance of the GUIDed Section Extraction Protocol 
+// is used to correlate it with the GUIDed section type 
+// that it is intended to process.
+//
+
+
+typedef struct _EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI   EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI;
+
+
+/**
+  Processes the input section and returns the data contained therein 
+  along with the authentication status.
+
+  The ExtractSection() function processes the input section and
+  returns a pointer to the section contents. If the section being
+  extracted does not require processing (if the section
+  GuidedSectionHeader.Attributes has the
+  EFI_GUIDED_SECTION_PROCESSING_REQUIRED field cleared), then
+  OutputBuffer is just updated to point to the start of the
+  section's contents. Otherwise, *Buffer must be allocated
+  from PEI permanent memory.
+
+  @param This                   Indicates the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
+                                instance.
+  @param InputSection           Buffer containing the input GUIDed section to be
+                                processed.
+  @param OutputBuffer           *OutputBuffer is allocated from PEI permanent memory
+                                and contains the new section stream.
+  @param OutputSize             A pointer to a caller-allocated UINTN in which
+                                the size of *OutputBuffer allocation is stored.
+                                If the function returns anything other than
+                                EFI_SUCCESS, the value of *OutputSize is undefined.
+  @param AuthenticationStatus   A pointer to a caller-allocated UINT32 that indicates
+                                the authentication status of the output buffer.
+                                If the input section's
+                                GuidedSectionHeader.Attributes field has the
+                                EFI_GUIDED_SECTION_AUTH_STATUS_VALID bit as clear,
+                                *AuthenticationStatus must return zero. These bits
+                                reflect the status of the extraction operation.
+                                If the function returns anything other than EFI_SUCCESS,
+                                the value of *AuthenticationStatus is undefined.
+  
+  @retval EFI_SUCCESS           The InputSection was successfully processed and the
+                                section contents were returned.
+  @retval EFI_OUT_OF_RESOURCES  The system has insufficient resources to process the request.
+  @retval EFI_INVALID_PARAMETER The GUID in InputSection does not match this instance of the
+                                GUIDed Section Extraction PPI.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_EXTRACT_GUIDED_SECTION)(
+  IN  CONST  EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *This,
+  IN  CONST  VOID                                  *InputSection,
+  OUT VOID                                         **OutputBuffer,
+  OUT UINTN                                        *OutputSize,
+  OUT UINT32                                       *AuthenticationStatus
+);
+
+///
+/// If a GUID-defined section is encountered when doing section extraction,
+/// the PEI Foundation or the EFI_PEI_FILE_LOADER_PPI instance
+/// calls the appropriate instance of the GUIDed Section
+/// Extraction PPI to extract the section stream contained
+/// therein.
+///  
+struct _EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI {
+  EFI_PEI_EXTRACT_GUIDED_SECTION ExtractSection;
+};
+
+
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/I2cMaster.h b/MdePkg/Include/Ppi/I2cMaster.h
new file mode 100644
index 000000000000..acc4405f746e
--- /dev/null
+++ b/MdePkg/Include/Ppi/I2cMaster.h
@@ -0,0 +1,108 @@
+/** @file
+  This PPI manipulates the I2C host controller to perform transactions as a master 
+  on the I2C bus using the current state of any switches or multiplexers in the I2C bus.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.3.
+
+**/
+
+#ifndef __I2C_MASTER_PPI_H__
+#define __I2C_MASTER_PPI_H__
+
+#include <Pi/PiI2c.h>
+
+#define EFI_PEI_I2C_MASTER_PPI_GUID \
+  { 0xb3bfab9b, 0x9f9c, 0x4e8b, { 0xad, 0x37, 0x7f, 0x8c, 0x51, 0xfc, 0x62, 0x80 }}
+
+typedef struct _EFI_PEI_I2C_MASTER_PPI EFI_PEI_I2C_MASTER_PPI;
+
+/**
+  Set the frequency for the I2C clock line.
+  
+  @param This                   Pointer to an EFI_PEI_I2C_MASTER_PPI structure.
+  @param BusClockHertz          Pointer to the requested I2C bus clock frequency in Hertz.
+                                Upon return this value contains the actual frequency 
+                                in use by the I2C controller.
+
+  @retval EFI_SUCCESS           The bus frequency was set successfully.
+  @retval EFI_INVALID_PARAMETER BusClockHertz is NULL
+  @retval EFI_UNSUPPORTED       The controller does not support this frequency.
+   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_I2C_MASTER_PPI_SET_BUS_FREQUENCY) (
+  IN EFI_PEI_I2C_MASTER_PPI   *This,
+  IN UINTN                    *BusClockHertz
+  );
+
+/**
+  Reset the I2C controller and configure it for use.
+  
+  @param  This                  Pointer to an EFI_PEI_I2C_MASTER_PPI structure.
+
+  @retval EFI_SUCCESS           The reset completed successfully.
+  @retval EFI_DEVICE_ERROR      The reset operation failed.
+   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_I2C_MASTER_PPI_RESET) (
+  IN CONST EFI_PEI_I2C_MASTER_PPI  *This
+  );
+
+/**
+  Start an I2C transaction on the host controller.
+  
+  @param  This                   Pointer to an EFI_PEI_I2C_MASTER_PPI structure.
+  @param  SlaveAddress           Address of the device on the I2C bus.
+                                 Set the I2C_ADDRESSING_10_BIT when using 10-bit addresses, 
+                                 clear this bit for 7-bit addressing.
+                                 Bits 0-6 are used for 7-bit I2C slave addresses and 
+                                 bits 0-9 are used for 10-bit I2C slave addresses.
+  @param  RequestPacket          Pointer to an EFI_I2C_REQUEST_PACKET structure describing the I2C transaction.
+
+  @retval EFI_SUCCESS	           The transaction completed successfully.
+  @retval EFI_BAD_BUFFER_SIZE	   The RequestPacket->LengthInBytes value is too large.
+  @retval EFI_DEVICE_ERROR	     There was an I2C error (NACK) during the transaction.
+  @retval EFI_INVALID_PARAMETER	 RequestPacket is NULL
+  @retval EFI_NO_RESPONSE	       The I2C device is not responding to the slave address.
+                                 EFI_DEVICE_ERROR will be returned if the controller cannot distinguish when the NACK occurred.
+  @retval EFI_NOT_FOUND	         Reserved bit set in the SlaveAddress parameter
+  @retval EFI_OUT_OF_RESOURCES	 Insufficient memory for I2C transaction
+  @retval EFI_UNSUPPORTED	       The controller does not support the requested transaction.
+   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_I2C_MASTER_PPI_START_REQUEST) (
+  IN CONST EFI_PEI_I2C_MASTER_PPI     *This,
+  IN UINTN                            SlaveAddress,
+  IN EFI_I2C_REQUEST_PACKET           *RequestPacket
+  );
+
+///
+/// This PPI manipulates the I2C host controller to perform transactions as a master on the I2C bus
+/// using the current state of any switches or multiplexers in the I2C bus.
+///
+struct _EFI_PEI_I2C_MASTER_PPI {
+  EFI_PEI_I2C_MASTER_PPI_SET_BUS_FREQUENCY   SetBusFrequency;
+  EFI_PEI_I2C_MASTER_PPI_RESET               Reset;
+  EFI_PEI_I2C_MASTER_PPI_START_REQUEST       StartRequest;
+  CONST EFI_I2C_CONTROLLER_CAPABILITIES      *I2cControllerCapabilities;
+  EFI_GUID                                   Identifier;
+};
+
+extern EFI_GUID gEfiPeiI2cMasterPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/IsaHc.h b/MdePkg/Include/Ppi/IsaHc.h
new file mode 100644
index 000000000000..16be828ec509
--- /dev/null
+++ b/MdePkg/Include/Ppi/IsaHc.h
@@ -0,0 +1,119 @@
+/** @file
+  This PPI opens or closes an I/O aperture in a ISA HOST controller.
+
+  Copyright (c) 2015, 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.             
+
+  @par Revision Reference:
+  This PPI is from PI Version 1.2.1.
+
+**/
+
+#ifndef __ISA_HC_PPI_H__
+#define __ISA_HC_PPI_H__
+
+#define EFI_ISA_HC_PPI_GUID \
+  { \
+    0x8d48bd70, 0xc8a3, 0x4c06, {0x90, 0x1b, 0x74, 0x79, 0x46, 0xaa, 0xc3, 0x58} \
+  }
+
+typedef struct _EFI_ISA_HC_PPI EFI_ISA_HC_PPI;
+typedef struct _EFI_ISA_HC_PPI *PEFI_ISA_HC_PPI;
+
+/**
+  Open I/O aperture.
+
+  This function opens an I/O aperture in a ISA Host Controller for the I/O
+  addresses specified by IoAddress to IoAddress + IoLength - 1. It is possible
+  that more than one caller may be assigned to the same aperture.
+  It may be possible that a single hardware aperture may be used for more than
+  one device. This function tracks the number of times that each aperture is 
+  referenced, and doesa not close the hardware aperture (via CloseIoAperture())
+  until there are no more references to it.
+ 
+  @param This             A pointer to this instance of the EFI_ISA_HC_PPI.
+  @param IoAddress        An unsigned integer that specifies the first byte of
+                          the I/O space required.
+  @param IoLength         An unsigned integer that specifies the number of
+                          bytes of the I/O space required.
+  @param IoApertureHandle A pointer to the returned I/O aperture handle.
+                          This value can be used on subsequent calls to CloseIoAperture().
+
+  @retval EFI_SUCCESS          The I/O aperture was opened successfully.
+  @retval EFI_UNSUPPORTED      The ISA Host Controller is a subtractive-decode controller.
+  @retval EFI_OUT_OF_RESOURCES There is no available I/O aperture.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_ISA_HC_OPEN_IO) (
+  IN CONST EFI_ISA_HC_PPI   *This,
+  IN UINT16                 IoAddress,
+  IN UINT16                 IoLength,
+  OUT UINT64                *IoApertureHandle
+  );
+
+/**
+  Close I/O aperture.
+
+  This function closes a previously opened I/O aperture handle. If there are no
+  more I/O aperture handles that refer to the hardware I/O aperture resource,
+  then the hardware I/O aperture is closed.
+  It may be possible that a single hardware aperture may be used for more than
+  one device. This function tracks the number of times that each aperture is
+  referenced, and does not close the hardware aperture (via CloseIoAperture())
+  until there are no more references to it.
+
+  @param This             A pointer to this instance of the EFI_ISA_HC_PPI.
+  @param IoApertureHandle The I/O aperture handle previously returned from a
+                          call to OpenIoAperture().
+
+  @retval EFI_SUCCESS   The I/O aperture was closed successfully.
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_ISA_HC_CLOSE_IO) (
+  IN CONST EFI_ISA_HC_PPI     *This,
+  IN UINT64                   IoApertureHandle
+  );
+
+///
+/// This PPI provides functions for opening or closing an I/O aperture.
+///
+struct _EFI_ISA_HC_PPI {
+  ///
+  /// An unsigned integer that specifies the version of the PPI structure.
+  ///
+  UINT32                  Version;
+  ///
+  /// The address of the ISA/LPC Bridge device.
+  /// For PCI, this is the segment, bus, device and function of the a ISA/LPC
+  /// Bridge device.
+  ///
+  /// If bits 24-31 are 0, then the definition is:
+  /// Bits 0:2   - Function
+  /// Bits 3-7   - Device
+  /// Bits 8:15  - Bus
+  /// Bits 16-23 - Segment
+  /// Bits 24-31 - Bus Type
+  /// If bits 24-31 are 0xff, then the definition is platform-specific.
+  ///
+  UINT32                  Address;
+  ///
+  /// Opens an aperture on a positive-decode ISA Host Controller.
+  ///
+  EFI_PEI_ISA_HC_OPEN_IO  OpenIoAperture;
+  ///
+  /// Closes an aperture on a positive-decode ISA Host Controller.
+  ///
+  EFI_PEI_ISA_HC_CLOSE_IO CloseIoAperture;
+};
+
+extern EFI_GUID gEfiIsaHcPpiGuid;
+
+#endif 
diff --git a/MdePkg/Include/Ppi/LoadFile.h b/MdePkg/Include/Ppi/LoadFile.h
new file mode 100644
index 000000000000..243976c3c406
--- /dev/null
+++ b/MdePkg/Include/Ppi/LoadFile.h
@@ -0,0 +1,77 @@
+/** @file
+  Load image file from fv to memory. 
+
+  Copyright (c) 2006 - 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __LOAD_FILE_PPI_H__
+#define __LOAD_FILE_PPI_H__
+
+#define EFI_PEI_LOAD_FILE_PPI_GUID \
+  { 0xb9e0abfe, 0x5979, 0x4914, { 0x97, 0x7f, 0x6d, 0xee, 0x78, 0xc2, 0x78, 0xa6 } }
+
+
+typedef struct _EFI_PEI_LOAD_FILE_PPI EFI_PEI_LOAD_FILE_PPI;
+
+/**
+  Loads a PEIM into memory for subsequent execution.
+
+  This service is the single member function of EFI_LOAD_FILE_PPI.
+  This service separates image loading and relocating from the PEI Foundation.
+  
+  @param This                   Interface pointer that implements
+                                the Load File PPI instance.
+  @param FileHandle             File handle of the file to load.
+  @param ImageAddress           Pointer to the address of the loaded image.
+  @param ImageSize              Pointer to the size of the loaded image.
+  @param EntryPoint             Pointer to the entry point of the image.
+  @param AuthenticationState    On exit, points to the attestation
+                                authentication state of the image
+                                or 0 if no attestation was performed.
+
+  @retval EFI_SUCCESS           The image was loaded successfully.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory.
+  @retval EFI_LOAD_ERROR        There was no supported image in the file.
+  @retval EFI_INVALID_PARAMETER FileHandle was not a valid firmware file handle.
+  @retval EFI_INVALID_PARAMETER EntryPoint was NULL.
+  @retval EFI_UNSUPPORTED       An image requires relocations or is not
+                                memory mapped.
+  @retval EFI_WARN_BUFFER_TOO_SMALL 
+                                There is not enough heap to allocate the requested size.
+                                This will not prevent the XIP image from being invoked.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_LOAD_FILE)(
+  IN  CONST  EFI_PEI_LOAD_FILE_PPI   *This,
+  IN  EFI_PEI_FILE_HANDLE            FileHandle,
+  OUT EFI_PHYSICAL_ADDRESS           *ImageAddress,
+  OUT UINT64                         *ImageSize,
+  OUT EFI_PHYSICAL_ADDRESS           *EntryPoint,
+  OUT UINT32                         *AuthenticationState
+);
+
+///
+/// This PPI is a pointer to the Load File service.
+/// This service will be published by a PEIM. The PEI Foundation
+/// will use this service to launch the known PEI module images.
+///
+struct _EFI_PEI_LOAD_FILE_PPI {
+  EFI_PEI_LOAD_FILE LoadFile;
+};
+
+extern EFI_GUID gEfiPeiLoadFilePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/LoadImage.h b/MdePkg/Include/Ppi/LoadImage.h
new file mode 100644
index 000000000000..59966e068ff1
--- /dev/null
+++ b/MdePkg/Include/Ppi/LoadImage.h
@@ -0,0 +1,52 @@
+/** @file
+  The file describes the PPI which notifies other drivers 
+  of the PEIM being initialized by the PEI Dispatcher.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __LOADED_IMAGE_PPI_H__
+#define __LOADED_IMAGE_PPI_H__
+
+#define EFI_PEI_LOADED_IMAGE_PPI_GUID \
+  { 0xc1fcd448, 0x6300, 0x4458, { 0xb8, 0x64, 0x28, 0xdf, 0x1, 0x53, 0x64, 0xbc } }
+
+
+typedef struct _EFI_PEI_LOADED_IMAGE_PPI  EFI_PEI_LOADED_IMAGE_PPI;
+
+///
+/// This interface is installed by the PEI Dispatcher after the image has been
+/// loaded and after all security checks have been performed, 
+/// to notify other PEIMs of the files which are being loaded.
+///
+struct _EFI_PEI_LOADED_IMAGE_PPI {
+  ///
+  /// Address of the image at the address where it will be executed.
+  ///
+  EFI_PHYSICAL_ADDRESS  ImageAddress;
+  ///
+  /// Size of the image as it will be executed.
+  ///
+  UINT64                ImageSize;
+  ///
+  /// File handle from which the image was loaded.
+  /// Can be NULL, indicating the image was not loaded from a handle.
+  ///
+  EFI_PEI_FILE_HANDLE   FileHandle;
+};
+
+
+extern EFI_GUID gEfiPeiLoadedImagePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/MasterBootMode.h b/MdePkg/Include/Ppi/MasterBootMode.h
new file mode 100644
index 000000000000..2d071fa3342b
--- /dev/null
+++ b/MdePkg/Include/Ppi/MasterBootMode.h
@@ -0,0 +1,32 @@
+/** @file
+  This file declares Boot Mode PPI.
+
+  The Master Boot Mode PPI is installed by a PEIM to signal that a final 
+  boot has been determined and set. This signal is useful in that PEIMs 
+  with boot-mode-specific behavior can put this PPI in their dependency expression.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __MASTER_BOOT_MODE_PPI_H__
+#define __MASTER_BOOT_MODE_PPI_H__
+
+#define EFI_PEI_MASTER_BOOT_MODE_PEIM_PPI \
+  { \
+    0x7408d748, 0xfc8c, 0x4ee6, {0x92, 0x88, 0xc4, 0xbe, 0xc0, 0x92, 0xa4, 0x10 } \
+  }
+
+extern EFI_GUID gEfiPeiMasterBootModePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/MemoryDiscovered.h b/MdePkg/Include/Ppi/MemoryDiscovered.h
new file mode 100644
index 000000000000..df7a3d81b615
--- /dev/null
+++ b/MdePkg/Include/Ppi/MemoryDiscovered.h
@@ -0,0 +1,32 @@
+/** @file
+  This file declares Memory Discovered PPI.
+
+  This PPI is published by the PEI Foundation when the main memory is installed. 
+  It is essentially a PPI with no associated interface. Its purpose is to be used
+  as a signal for other PEIMs who can register for a notification on its installation. 
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __PEI_MEMORY_DISCOVERED_PPI_H__
+#define __PEI_MEMORY_DISCOVERED_PPI_H__
+
+#define EFI_PEI_PERMANENT_MEMORY_INSTALLED_PPI_GUID \
+  { \
+    0xf894643d, 0xc449, 0x42d1, {0x8e, 0xa8, 0x85, 0xbd, 0xd8, 0xc6, 0x5b, 0xde } \
+  }
+
+extern EFI_GUID gEfiPeiMemoryDiscoveredPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/MpServices.h b/MdePkg/Include/Ppi/MpServices.h
new file mode 100644
index 000000000000..fce4d2dbb81c
--- /dev/null
+++ b/MdePkg/Include/Ppi/MpServices.h
@@ -0,0 +1,283 @@
+/** @file
+  This file declares UEFI PI Multi-processor PPI.
+  This PPI is installed by some platform or chipset-specific PEIM that abstracts
+  handling multiprocessor support.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.4.
+
+**/
+
+#ifndef __PEI_MP_SERVICES_PPI_H__
+#define __PEI_MP_SERVICES_PPI_H__
+
+#include <Protocol/MpService.h>
+
+#define EFI_PEI_MP_SERVICES_PPI_GUID \
+  { \
+    0xee16160a, 0xe8be, 0x47a6, { 0x82, 0xa, 0xc6, 0x90, 0xd, 0xb0, 0x25, 0xa } \
+  }
+
+typedef struct _EFI_PEI_MP_SERVICES_PPI  EFI_PEI_MP_SERVICES_PPI ;
+
+/**
+  Get the number of CPU's.
+
+  @param[in]  PeiServices         An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in]  This                Pointer to this instance of the PPI.
+  @param[out] NumberOfProcessors  Pointer to the total number of logical processors in
+                                  the system, including the BSP and disabled APs.
+  @param[out] NumberOfEnabledProcessors
+                                  Number of processors in the system that are enabled.
+
+  @retval EFI_SUCCESS             The number of logical processors and enabled
+                                  logical processors was retrieved.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_INVALID_PARAMETER   NumberOfProcessors is NULL.
+                                  NumberOfEnabledProcessors is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_GET_NUMBER_OF_PROCESSORS) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  OUT UINTN                       *NumberOfProcessors,
+  OUT UINTN                       *NumberOfEnabledProcessors
+  );
+
+/**
+  Get information on a specific CPU.
+
+  @param[in]  PeiServices         An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in]  This                Pointer to this instance of the PPI.
+  @param[in]  ProcessorNumber     Pointer to the total number of logical processors in
+                                  the system, including the BSP and disabled APs.
+  @param[out] ProcessorInfoBuffer Number of processors in the system that are enabled.
+
+  @retval EFI_SUCCESS             Processor information was returned.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_INVALID_PARAMETER   ProcessorInfoBuffer is NULL.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist in the platform.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_GET_PROCESSOR_INFO) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  IN  UINTN                       ProcessorNumber,
+  OUT EFI_PROCESSOR_INFORMATION   *ProcessorInfoBuffer
+  );
+
+/**
+  Activate all of the application proessors.
+
+  @param[in] PeiServices          An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in] This                 A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
+  @param[in] Procedure            A pointer to the function to be run on enabled APs of
+                                  the system.
+  @param[in] SingleThread         If TRUE, then all the enabled APs execute the function
+                                  specified by Procedure one by one, in ascending order
+                                  of processor handle number. If FALSE, then all the
+                                  enabled APs execute the function specified by Procedure
+                                  simultaneously.
+  @param[in] TimeoutInMicroSeconds
+                                  Indicates the time limit in microseconds for APs to
+                                  return from Procedure, for blocking mode only. Zero
+                                  means infinity. If the timeout expires before all APs
+                                  return from Procedure, then Procedure on the failed APs
+                                  is terminated. All enabled APs are available for next
+                                  function assigned by EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
+                                  or EFI_PEI_MP_SERVICES_PPI.StartupThisAP(). If the
+                                  timeout expires in blocking mode, BSP returns
+                                  EFI_TIMEOUT.
+  @param[in] ProcedureArgument    The parameter passed into Procedure for all APs.
+
+  @retval EFI_SUCCESS             In blocking mode, all APs have finished before the
+                                  timeout expired.
+  @retval EFI_DEVICE_ERROR        Caller processor is AP.
+  @retval EFI_NOT_STARTED         No enabled APs exist in the system.
+  @retval EFI_NOT_READY           Any enabled APs are busy.
+  @retval EFI_TIMEOUT             In blocking mode, the timeout expired before all
+                                  enabled APs have finished.
+  @retval EFI_INVALID_PARAMETER   Procedure is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_STARTUP_ALL_APS) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  IN  EFI_AP_PROCEDURE            Procedure,
+  IN  BOOLEAN                     SingleThread,
+  IN  UINTN                       TimeoutInMicroSeconds,
+  IN  VOID                        *ProcedureArgument      OPTIONAL
+  );
+
+/**
+  Activate a specific application processor.
+
+  @param[in] PeiServices          An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in] This                 A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
+  @param[in] Procedure            A pointer to the function to be run on enabled APs of
+                                  the system.
+  @param[in] ProcessorNumber      The handle number of the AP. The range is from 0 to the
+                                  total number of logical processors minus 1. The total
+                                  number of logical processors can be retrieved by
+                                  EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
+  @param[in] TimeoutInMicroSeconds
+                                  Indicates the time limit in microseconds for APs to
+                                  return from Procedure, for blocking mode only. Zero
+                                  means infinity. If the timeout expires before all APs
+                                  return from Procedure, then Procedure on the failed APs
+                                  is terminated. All enabled APs are available for next
+                                  function assigned by EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
+                                  or EFI_PEI_MP_SERVICES_PPI.StartupThisAP(). If the
+                                  timeout expires in blocking mode, BSP returns
+                                  EFI_TIMEOUT.
+  @param[in] ProcedureArgument    The parameter passed into Procedure for all APs.
+
+  @retval EFI_SUCCESS             In blocking mode, specified AP finished before the
+                                  timeout expires.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_TIMEOUT             In blocking mode, the timeout expired before the
+                                  specified AP has finished.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP or disabled AP.
+  @retval EFI_INVALID_PARAMETER   Procedure is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_STARTUP_THIS_AP) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  IN  EFI_AP_PROCEDURE            Procedure,
+  IN  UINTN                       ProcessorNumber,
+  IN  UINTN                       TimeoutInMicroseconds,
+  IN  VOID                        *ProcedureArgument      OPTIONAL
+  );
+
+/**
+  Switch the boot strap processor.
+
+  @param[in] PeiServices          An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in] This                 A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
+  @param[in] ProcessorNumber      The handle number of the AP. The range is from 0 to the
+                                  total number of logical processors minus 1. The total
+                                  number of logical processors can be retrieved by
+                                  EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
+  @param[in] EnableOldBSP         If TRUE, then the old BSP will be listed as an enabled
+                                  AP. Otherwise, it will be disabled.
+
+  @retval EFI_SUCCESS             BSP successfully switched.
+  @retval EFI_UNSUPPORTED         Switching the BSP cannot be completed prior to this
+                                  service returning.
+  @retval EFI_UNSUPPORTED         Switching the BSP is not supported.
+  @retval EFI_SUCCESS             The calling processor is an AP.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the current BSP or a disabled
+                                  AP.
+  @retval EFI_NOT_READY           The specified AP is busy.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_SWITCH_BSP) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  IN  UINTN                       ProcessorNumber,
+  IN  BOOLEAN                     EnableOldBSP
+  );
+
+/**
+  Enable or disable an application processor.
+
+  @param[in] PeiServices          An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in] This                 A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
+  @param[in] ProcessorNumber      The handle number of the AP. The range is from 0 to the
+                                  total number of logical processors minus 1. The total
+                                  number of logical processors can be retrieved by
+                                  EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
+  @param[in] EnableAP             Specifies the new state for the processor for enabled,
+                                  FALSE for disabled.
+  @param[in] HealthFlag           If not NULL, a pointer to a value that specifies the
+                                  new health status of the AP. This flag corresponds to
+                                  StatusFlag defined in EFI_PEI_MP_SERVICES_PPI.GetProcessorInfo().
+                                  Only the PROCESSOR_HEALTH_STATUS_BIT is used. All other
+                                  bits are ignored. If it is NULL, this parameter is
+                                  ignored.
+
+  @retval EFI_SUCCESS             The specified AP was enabled or disabled successfully.
+  @retval EFI_UNSUPPORTED         Enabling or disabling an AP cannot be completed prior
+                                  to this service returning.
+  @retval EFI_UNSUPPORTED         Enabling or disabling an AP is not supported.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_NOT_FOUND           Processor with the handle specified by ProcessorNumber
+                                  does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_ENABLEDISABLEAP) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  IN  UINTN                       ProcessorNumber,
+  IN  BOOLEAN                     EnableAP,
+  IN  UINT32                      *HealthFlag      OPTIONAL
+  );
+
+/**
+  Identify the currently executing processor.
+
+  @param[in]  PeiServices         An indirect pointer to the PEI Services Table
+                                  published by the PEI Foundation.
+  @param[in]  This                A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
+  @param[out] ProcessorNumber     The handle number of the AP. The range is from 0 to the
+                                  total number of logical processors minus 1. The total
+                                  number of logical processors can be retrieved by
+                                  EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
+
+  @retval EFI_SUCCESS             The current processor handle number was returned in
+                                  ProcessorNumber.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_MP_SERVICES_WHOAMI) (
+  IN  CONST EFI_PEI_SERVICES      **PeiServices,
+  IN  EFI_PEI_MP_SERVICES_PPI     *This,
+  OUT UINTN                       *ProcessorNumber
+  );
+
+///
+/// This PPI is installed by some platform or chipset-specific PEIM that abstracts
+/// handling multiprocessor support.
+///
+struct _EFI_PEI_MP_SERVICES_PPI {
+  EFI_PEI_MP_SERVICES_GET_NUMBER_OF_PROCESSORS   GetNumberOfProcessors;
+  EFI_PEI_MP_SERVICES_GET_PROCESSOR_INFO         GetProcessorInfo;
+  EFI_PEI_MP_SERVICES_STARTUP_ALL_APS            StartupAllAPs;
+  EFI_PEI_MP_SERVICES_STARTUP_THIS_AP            StartupThisAP;
+  EFI_PEI_MP_SERVICES_SWITCH_BSP                 SwitchBSP;
+  EFI_PEI_MP_SERVICES_ENABLEDISABLEAP            EnableDisableAP;
+  EFI_PEI_MP_SERVICES_WHOAMI                     WhoAmI;
+};
+
+extern EFI_GUID gEfiPeiMpServicesPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Pcd.h b/MdePkg/Include/Ppi/Pcd.h
new file mode 100644
index 000000000000..05b59048d6ae
--- /dev/null
+++ b/MdePkg/Include/Ppi/Pcd.h
@@ -0,0 +1,860 @@
+/** @file
+  Native Platform Configuration Database (PCD) PPI
+  
+  Different with the EFI_PCD_PPI defined in PI 1.2 specification, the native
+  PCD PPI provide interfaces for dynamic and dynamic-ex type PCD. 
+  The interfaces for dynamic type PCD do not require the token space guid as parameter,
+  but interfaces for dynamic-ex type PCD require token space guid as parameter.
+
+Copyright (c) 2006 - 2013, 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 __PCD_PPI_H__
+#define __PCD_PPI_H__
+
+#define PCD_PPI_GUID \
+  { 0x6e81c58, 0x4ad7, 0x44bc, { 0x83, 0x90, 0xf1, 0x2, 0x65, 0xf7, 0x24, 0x80 } }
+
+#define PCD_INVALID_TOKEN_NUMBER ((UINTN) 0)
+
+
+/**
+  Sets the SKU value for subsequent calls to set or get PCD token values.
+
+  SetSku() sets the SKU Id to be used for subsequent calls to set or get PCD values. 
+  SetSku() is normally called only once by the system.
+
+  For each item (token), the database can hold a single value that applies to all SKUs, 
+  or multiple values, where each value is associated with a specific SKU Id. Items with multiple, 
+  SKU-specific values are called SKU enabled. 
+  
+  The SKU Id of zero is reserved as a default. The valid SkuId range is 1 to 255.  
+  For tokens that are not SKU enabled, the system ignores any set SKU Id and works with the 
+  single value for that token. For SKU-enabled tokens, the system will use the SKU Id set by the 
+  last call to SetSku(). If no SKU Id is set or the currently set SKU Id isn't valid for the specified token, 
+  the system uses the default SKU Id. If the system attempts to use the default SKU Id and no value has been 
+  set for that Id, the results are unpredictable.
+
+  @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and 
+              set values associated with a PCD token.
+
+  @retval VOID
+
+**/
+typedef 
+VOID
+(EFIAPI *PCD_PPI_SET_SKU)(
+  IN  UINTN          SkuId
+  );
+
+
+
+/**
+  Retrieves an 8-bit value for a given PCD token.
+
+  Retrieves the current byte-sized value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT8 value.
+  
+**/
+typedef
+UINT8
+(EFIAPI *PCD_PPI_GET8)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 16-bit value for a given PCD token.
+
+  Retrieves the current 16-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT16 value.
+  
+**/
+typedef
+UINT16
+(EFIAPI *PCD_PPI_GET16)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 32-bit value for a given PCD token.
+
+  Retrieves the current 32-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT32 value.
+  
+**/
+typedef
+UINT32
+(EFIAPI *PCD_PPI_GET32)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 64-bit value for a given PCD token.
+
+  Retrieves the current 64-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT64 value.
+  
+**/
+typedef
+UINT64
+(EFIAPI *PCD_PPI_GET64)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a pointer to a value for a given PCD token.
+
+  Retrieves the current pointer to the buffer for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The pointer to the buffer to be retrived.
+  
+**/
+typedef
+VOID *
+(EFIAPI *PCD_PPI_GET_POINTER)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a Boolean value for a given PCD token.
+
+  Retrieves the current boolean value for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The Boolean value.
+  
+**/
+typedef
+BOOLEAN
+(EFIAPI *PCD_PPI_GET_BOOLEAN)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves the size of the value for a given PCD token.
+
+  Retrieves the current size of a particular PCD token.  
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size of the value for the PCD token.
+  
+**/
+typedef
+UINTN
+(EFIAPI *PCD_PPI_GET_SIZE)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves an 8-bit value for a given PCD token and token space.
+
+  Retrieves the 8-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 8-bit value for the PCD token.
+  
+**/
+typedef
+UINT8
+(EFIAPI *PCD_PPI_GET_EX_8)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 16-bit value for a given PCD token and token space.
+
+  Retrieves the 16-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 16-bit value for the PCD token.
+  
+**/
+typedef
+UINT16
+(EFIAPI *PCD_PPI_GET_EX_16)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 32-bit value for a given PCD token and token space.
+
+  Retrieves the 32-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 32-bit value for the PCD token.
+  
+**/
+typedef
+UINT32
+(EFIAPI *PCD_PPI_GET_EX_32)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 64-bit value for a given PCD token and token space.
+
+  Retrieves the 64-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 64-bit value for the PCD token.
+  
+**/
+typedef
+UINT64
+(EFIAPI *PCD_PPI_GET_EX_64)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves a pointer to a value for a given PCD token and token space.
+
+  Retrieves the current pointer to the buffer for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The pointer to the buffer to be retrived.
+  
+**/
+typedef
+VOID *
+(EFIAPI *PCD_PPI_GET_EX_POINTER)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves an Boolean value for a given PCD token and token space.
+
+  Retrieves the Boolean value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size Boolean value for the PCD token.
+  
+**/
+typedef
+BOOLEAN
+(EFIAPI *PCD_PPI_GET_EX_BOOLEAN)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Retrieves the size of the value for a given PCD token and token space.
+
+  Retrieves the current size of a particular PCD token.  
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size of the value for the PCD token.
+  
+**/
+typedef
+UINTN
+(EFIAPI *PCD_PPI_GET_EX_SIZE)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber
+  );
+
+
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET8)(
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  );
+
+
+
+/**
+  Sets a 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET16)(
+  IN UINTN              TokenNumber,
+  IN UINT16             Value
+  );
+
+
+
+/**
+  Sets a 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET32)(
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  );
+
+
+
+/**
+  Sets a 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET64)(
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  );
+
+/**
+  Sets a value of a specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]      TokenNumber  The PCD token number. 
+  @param[in, out] SizeOfValue  A pointer to the length of the value being set for the PCD token.  
+                               On input, if the SizeOfValue is greater than the maximum size supported 
+                               for this TokenNumber then the output value of SizeOfValue will reflect 
+                               the maximum size supported for this TokenNumber.
+  @param[in]      Buffer       The buffer to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_POINTER)(
+  IN        UINTN             TokenNumber,
+  IN OUT    UINTN             *SizeOfValue,
+  IN        VOID              *Buffer
+  );
+
+/**
+  Sets an Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_BOOLEAN)(
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  );
+
+
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_8)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber,
+  IN       UINT8       Value
+  );
+
+
+
+/**
+  Sets a 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_16)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber,
+  IN       UINT16      Value
+  );
+
+
+
+/**
+  Sets a 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_32)(
+  IN CONST EFI_GUID    *Guid,
+  IN       UINTN       TokenNumber,
+  IN       UINT32      Value
+  );
+
+
+
+/**
+  Sets a 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_64)(
+  IN CONST EFI_GUID     *Guid,
+  IN       UINTN        TokenNumber,
+  IN       UINT64       Value
+  );
+
+
+
+/**
+  Sets a value of a specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]      Guid         The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]      TokenNumber  The PCD token number. 
+  @param[in, out] SizeOfValue  A pointer to the length of the value being set for the PCD token.  
+                               On input, if the SizeOfValue is greater than the maximum size supported 
+                               for this TokenNumber then the output value of SizeOfValue will reflect 
+                               the maximum size supported for this TokenNumber.
+  @param[in]      Buffer       The buffer to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_POINTER)(
+  IN CONST EFI_GUID          *Guid,
+  IN       UINTN             TokenNumber,
+  IN OUT   UINTN             *SizeOfValue,
+  IN       VOID              *Buffer
+  );
+
+/**
+  Sets an Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS           The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                being set was incompatible with a call to this function.  
+                                Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND         The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_SET_EX_BOOLEAN)(
+  IN CONST EFI_GUID          *Guid,
+  IN       UINTN             TokenNumber,
+  IN       BOOLEAN           Value
+  );
+
+
+
+/**
+  Callback on SET function prototype definition.
+
+  This notification function serves two purposes. Firstly, it notifies the module 
+  which did the registration that the value of this PCD token has been set. Secondly, 
+  it provides a mechanism for the module which did the registration to intercept the set 
+  operation and override the value been set if necessary. After the invocation of the 
+  callback function, TokenData will be used by PCD service PEIM to modify the internal data 
+  in PCD database.
+
+  @param[in]      CallBackGuid  The PCD token GUID being set.
+  @param[in]      CallBackToken The PCD token number being set.
+  @param[in, out] TokenData     A pointer to the token data being set.
+  @param[in]      TokenDataSize The size, in bytes, of the data being set.
+
+  @retval VOID
+
+**/
+typedef
+VOID
+(EFIAPI *PCD_PPI_CALLBACK)(
+  IN CONST EFI_GUID         *CallBackGuid, OPTIONAL
+  IN       UINTN            CallBackToken,
+  IN OUT   VOID             *TokenData,
+  IN       UINTN            TokenDataSize
+  );
+
+
+
+/**
+  Specifies a function to be called anytime the value of a designated token is changed.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Guid The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  CallBackFunction The function prototype called when the value associated with the CallBackToken is set.  
+
+  @retval EFI_SUCCESS  The PCD service has successfully established a call event 
+                        for the CallBackToken requested.
+  @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_CALLBACK_ONSET)(
+  IN  CONST EFI_GUID               *Guid, OPTIONAL
+  IN        UINTN                  TokenNumber,
+  IN        PCD_PPI_CALLBACK       CallBackFunction
+  );
+
+
+
+/**
+  Cancels a previously set callback function for a particular PCD token number.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Guid The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  CallBackFunction The function prototype called when the value associated with the CallBackToken is set.  
+
+  @retval EFI_SUCCESS  The PCD service has successfully established a call event 
+                        for the CallBackToken requested.
+  @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_CANCEL_CALLBACK)(
+  IN  CONST EFI_GUID                *Guid, OPTIONAL
+  IN        UINTN                   TokenNumber,
+  IN        PCD_PPI_CALLBACK        CallBackFunction
+  );
+
+
+
+/**
+  Retrieves the next valid token number in a given namespace.  
+  
+  This is useful since the PCD infrastructure contains a sparse list of token numbers, 
+  and one cannot a priori know what token numbers are valid in the database. 
+  
+  If TokenNumber is 0 and Guid is not NULL, then the first token from the token space specified by Guid is returned.  
+  If TokenNumber is not 0 and Guid is not NULL, then the next token in the token space specified by Guid is returned.  
+  If TokenNumber is 0 and Guid is NULL, then the first token in the default token space is returned.  
+  If TokenNumber is not 0 and Guid is NULL, then the next token in the default token space is returned.  
+  The token numbers in the default token space may not be related to token numbers in token spaces that are named by Guid.  
+  If the next token number can be retrieved, then it is returned in TokenNumber, and EFI_SUCCESS is returned.  
+  If TokenNumber represents the last token number in the token space specified by Guid, then EFI_NOT_FOUND is returned.  
+  If TokenNumber is not present in the token space specified by Guid, then EFI_NOT_FOUND is returned.
+
+
+  @param[in]       Guid        The 128-bit unique value that designates the namespace from which to extract the value.  
+                               This is an optional parameter that may be NULL.  If this parameter is NULL, then a request 
+                               is being made to retrieve tokens from the default token space.
+  @param[in, out]  TokenNumber A pointer to the PCD token number to use to find the subsequent token number.
+                   
+  @retval EFI_SUCCESS   The PCD service has retrieved the next valid token number.
+  @retval EFI_NOT_FOUND The PCD service could not find data from the requested token number.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *PCD_PPI_GET_NEXT_TOKEN)(
+  IN CONST EFI_GUID           *Guid, OPTIONAL
+  IN OUT   UINTN              *TokenNumber
+  );
+
+
+
+/**
+  Retrieves the next valid PCD token namespace for a given namespace.
+
+  Gets the next valid token namespace for a given namespace. This is useful to traverse the valid
+  token namespaces on a platform.
+
+  @param[in, out]   Guid    An indirect pointer to EFI_GUID. On input it designates a known token
+                            namespace from which the search will start. On output, it designates the next valid
+                            token namespace on the platform. If *Guid is NULL, then the GUID of the first token
+                            space of the current platform is returned. If the search cannot locate the next valid
+                            token namespace, an error is returned and the value of *Guid is undefined.
+ 
+  @retval  EFI_SUCCESS      The PCD service retrieved the value requested.
+  @retval  EFI_NOT_FOUND    The PCD service could not find the next valid token namespace.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PPI_GET_NEXT_TOKENSPACE)(
+  IN OUT CONST EFI_GUID         **Guid
+  );
+
+
+
+///
+/// This service abstracts the ability to set/get Platform Configuration Database (PCD).
+///
+typedef struct {
+  PCD_PPI_SET_SKU              SetSku;
+
+  PCD_PPI_GET8                 Get8;
+  PCD_PPI_GET16                Get16;
+  PCD_PPI_GET32                Get32;
+  PCD_PPI_GET64                Get64;
+  PCD_PPI_GET_POINTER          GetPtr;
+  PCD_PPI_GET_BOOLEAN          GetBool;
+  PCD_PPI_GET_SIZE             GetSize;
+
+  PCD_PPI_GET_EX_8             Get8Ex;
+  PCD_PPI_GET_EX_16            Get16Ex;
+  PCD_PPI_GET_EX_32            Get32Ex;
+  PCD_PPI_GET_EX_64            Get64Ex;
+  PCD_PPI_GET_EX_POINTER       GetPtrEx;
+  PCD_PPI_GET_EX_BOOLEAN       GetBoolEx;
+  PCD_PPI_GET_EX_SIZE          GetSizeEx;
+
+  PCD_PPI_SET8                 Set8;
+  PCD_PPI_SET16                Set16;
+  PCD_PPI_SET32                Set32;
+  PCD_PPI_SET64                Set64;
+  PCD_PPI_SET_POINTER          SetPtr;
+  PCD_PPI_SET_BOOLEAN          SetBool;
+
+  PCD_PPI_SET_EX_8             Set8Ex;
+  PCD_PPI_SET_EX_16            Set16Ex;
+  PCD_PPI_SET_EX_32            Set32Ex;
+  PCD_PPI_SET_EX_64            Set64Ex;
+  PCD_PPI_SET_EX_POINTER       SetPtrEx;
+  PCD_PPI_SET_EX_BOOLEAN       SetBoolEx;
+
+  PCD_PPI_CALLBACK_ONSET       CallbackOnSet;
+  PCD_PPI_CANCEL_CALLBACK      CancelCallback;
+  PCD_PPI_GET_NEXT_TOKEN       GetNextToken;
+  PCD_PPI_GET_NEXT_TOKENSPACE  GetNextTokenSpace;
+} PCD_PPI;
+
+
+extern EFI_GUID gPcdPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/PcdInfo.h b/MdePkg/Include/Ppi/PcdInfo.h
new file mode 100644
index 000000000000..a06fff13fc76
--- /dev/null
+++ b/MdePkg/Include/Ppi/PcdInfo.h
@@ -0,0 +1,105 @@
+/** @file
+  Native Platform Configuration Database (PCD) INFO PPI
+
+  The PPI that provides additional information about items that reside in the PCD database.
+  
+  Different with the EFI_GET_PCD_INFO_PPI defined in PI 1.2.1 specification,
+  the native PCD INFO PPI provide interfaces for dynamic and dynamic-ex type PCD. 
+  The interfaces for dynamic type PCD do not require the token space guid as parameter,
+  but interfaces for dynamic-ex type PCD require token space guid as parameter.
+
+  Copyright (c) 2013, 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 __PCD_INFO_PPI_H__
+#define __PCD_INFO_PPI_H__
+
+extern EFI_GUID gGetPcdInfoPpiGuid;
+
+#define GET_PCD_INFO_PPI_GUID \
+  { 0x4d8b155b, 0xc059, 0x4c8f, { 0x89, 0x26,  0x6, 0xfd, 0x43, 0x31, 0xdb, 0x8a } }
+
+///
+/// The forward declaration for GET_PCD_INFO_PPI.
+///
+typedef struct _GET_PCD_INFO_PPI  GET_PCD_INFO_PPI;
+
+/**
+  Retrieve additional information associated with a PCD token in the default token space.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *GET_PCD_INFO_PPI_GET_INFO) (
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *GET_PCD_INFO_PPI_GET_INFO_EX) (
+  IN CONST  EFI_GUID        *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+typedef
+UINTN
+(EFIAPI *GET_PCD_INFO_PPI_GET_SKU) (
+  VOID
+);
+
+///
+/// This is the PCD service to use when querying for some additional data that can be contained in the
+/// PCD database.
+///
+struct _GET_PCD_INFO_PPI {
+  ///
+  /// Retrieve additional information associated with a PCD.
+  ///
+  GET_PCD_INFO_PPI_GET_INFO             GetInfo;
+  GET_PCD_INFO_PPI_GET_INFO_EX          GetInfoEx;
+  ///
+  /// Retrieve the currently set SKU Id.
+  ///
+  GET_PCD_INFO_PPI_GET_SKU              GetSku;
+};
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/PciCfg2.h b/MdePkg/Include/Ppi/PciCfg2.h
new file mode 100644
index 000000000000..ea9547875476
--- /dev/null
+++ b/MdePkg/Include/Ppi/PciCfg2.h
@@ -0,0 +1,184 @@
+/** @file
+  This file declares PciCfg2 PPI.
+
+  This ppi Provides platform or chipset-specific access to 
+  the PCI configuration space for a specific PCI segment.
+
+  Copyright (c) 2006 - 2011, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __PEI_PCI_CFG2_H__
+#define __PEI_PCI_CFG2_H__
+
+#include <Library/BaseLib.h>
+
+#define EFI_PEI_PCI_CFG2_PPI_GUID \
+  { 0x57a449a, 0x1fdc, 0x4c06, { 0xbf, 0xc9, 0xf5, 0x3f, 0x6a, 0x99, 0xbb, 0x92 } }
+
+typedef struct _EFI_PEI_PCI_CFG2_PPI   EFI_PEI_PCI_CFG2_PPI;
+
+#define EFI_PEI_PCI_CFG_ADDRESS(bus,dev,func,reg) \
+  (UINT64) ( \
+  (((UINTN) bus) << 24) | \
+  (((UINTN) dev) << 16) | \
+  (((UINTN) func) << 8) | \
+  (((UINTN) (reg)) < 256 ? ((UINTN) (reg)) : (UINT64) (LShiftU64 ((UINT64) (reg), 32))))
+
+///
+/// EFI_PEI_PCI_CFG_PPI_WIDTH
+///
+typedef enum {
+  ///
+  ///  8-bit access
+  ///
+  EfiPeiPciCfgWidthUint8  = 0,
+  ///
+  /// 16-bit access
+  ///
+  EfiPeiPciCfgWidthUint16 = 1,
+  ///
+  /// 32-bit access
+  ///
+  EfiPeiPciCfgWidthUint32 = 2,
+  ///
+  /// 64-bit access
+  ///
+  EfiPeiPciCfgWidthUint64 = 3,
+  EfiPeiPciCfgWidthMaximum
+} EFI_PEI_PCI_CFG_PPI_WIDTH;
+
+///
+/// EFI_PEI_PCI_CFG_PPI_PCI_ADDRESS
+///
+typedef struct {
+  ///
+  /// 8-bit register offset within the PCI configuration space for a given device's function
+  /// space.
+  ///
+  UINT8   Register;
+  ///
+  /// Only the 3 least-significant bits are used to encode one of 8 possible functions within a
+  /// given device.
+  ///
+  UINT8   Function;
+  ///
+  /// Only the 5 least-significant bits are used to encode one of 32 possible devices.
+  ///
+  UINT8   Device;
+  ///
+  /// 8-bit value to encode between 0 and 255 buses.
+  ///
+  UINT8   Bus;
+  ///
+  /// Register number in PCI configuration space. If this field is zero, then Register is used
+  /// for the register number. If this field is non-zero, then Register is ignored and this field
+  /// is used for the register number.
+  ///
+  UINT32  ExtendedRegister;
+} EFI_PEI_PCI_CFG_PPI_PCI_ADDRESS;
+
+/**
+  Reads from or write to a given location in the PCI configuration space.
+
+  @param  PeiServices     An indirect pointer to the PEI Services Table published by the PEI Foundation.
+
+  @param  This            Pointer to local data for the interface.
+
+  @param  Width           The width of the access. Enumerated in bytes.
+                          See EFI_PEI_PCI_CFG_PPI_WIDTH above.
+
+  @param  Address         The physical address of the access. The format of
+                          the address is described by EFI_PEI_PCI_CFG_PPI_PCI_ADDRESS.
+
+  @param  Buffer          A pointer to the buffer of data..
+
+
+  @retval EFI_SUCCESS           The function completed successfully.
+
+  @retval EFI_DEVICE_ERROR      There was a problem with the transaction.
+
+  @retval EFI_DEVICE_NOT_READY  The device is not capable of supporting the operation at this
+                                time.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCI_CFG2_PPI_IO)(
+  IN CONST  EFI_PEI_SERVICES          **PeiServices,
+  IN CONST  EFI_PEI_PCI_CFG2_PPI      *This,
+  IN        EFI_PEI_PCI_CFG_PPI_WIDTH Width,
+  IN        UINT64                    Address,
+  IN OUT    VOID                      *Buffer
+);
+
+
+/**
+  Performs a read-modify-write operation on the contents 
+  from a given location in the PCI configuration space.
+
+  @param  PeiServices     An indirect pointer to the PEI Services Table
+                          published by the PEI Foundation.
+
+  @param  This            Pointer to local data for the interface.
+
+  @param  Width           The width of the access. Enumerated in bytes. Type
+                          EFI_PEI_PCI_CFG_PPI_WIDTH is defined in Read().
+
+  @param  Address         The physical address of the access.
+
+  @param  SetBits         Points to value to bitwise-OR with the read configuration value.
+
+                          The size of the value is determined by Width.
+
+  @param  ClearBits       Points to the value to negate and bitwise-AND with the read configuration value.
+                          The size of the value is determined by Width.
+
+
+  @retval EFI_SUCCESS           The function completed successfully.
+
+  @retval EFI_DEVICE_ERROR      There was a problem with the transaction.
+
+  @retval EFI_DEVICE_NOT_READY  The device is not capable of supporting
+                                the operation at this time.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCI_CFG2_PPI_RW)(
+  IN CONST  EFI_PEI_SERVICES          **PeiServices,
+  IN CONST  EFI_PEI_PCI_CFG2_PPI      *This,
+  IN        EFI_PEI_PCI_CFG_PPI_WIDTH Width,
+  IN        UINT64                    Address,
+  IN        VOID                      *SetBits,
+  IN        VOID                      *ClearBits
+);
+
+///
+/// The EFI_PEI_PCI_CFG_PPI interfaces are used to abstract accesses to PCI
+/// controllers behind a PCI root bridge controller.
+///
+struct _EFI_PEI_PCI_CFG2_PPI {
+  EFI_PEI_PCI_CFG2_PPI_IO  Read;
+  EFI_PEI_PCI_CFG2_PPI_IO  Write;
+  EFI_PEI_PCI_CFG2_PPI_RW  Modify;
+  ///
+  /// The PCI bus segment which the specified functions will access.
+  ///
+  UINT16                  Segment;
+};
+
+
+extern EFI_GUID gEfiPciCfg2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/PiPcd.h b/MdePkg/Include/Ppi/PiPcd.h
new file mode 100644
index 000000000000..41b0c2e18a93
--- /dev/null
+++ b/MdePkg/Include/Ppi/PiPcd.h
@@ -0,0 +1,432 @@
+/** @file
+  Platform Configuration Database (PCD) PPI defined in PI 1.2 Vol3
+
+  A platform database that contains a variety of current platform settings or
+  directives that can be accessed by a driver or application.
+  PI PCD ppi only provide the accessing interfaces for Dynamic-Ex type PCD.
+
+  This is the base PCD service API that provides an abstraction for accessing configuration content in
+  the platform. It a seamless mechanism for extracting information regardless of where the
+  information is stored (such as in Read-only data, or an EFI Variable).
+  This protocol allows access to data through size-granular APIs and provides a mechanism for a
+  firmware component to monitor specific settings and be alerted when a setting is changed.
+
+  Copyright (c) 2009 - 2013, 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.
+
+  @par Revision Reference:
+  PI Version 1.2 Vol 3.
+**/
+
+#ifndef __PI_PCD_PPI_H__
+#define __PI_PCD_PPI_H__
+
+extern EFI_GUID gEfiPeiPcdPpiGuid;
+
+#define EFI_PEI_PCD_PPI_GUID \
+  { 0x1f34d25, 0x4de2, 0x23ad, { 0x3f, 0xf3, 0x36, 0x35, 0x3f, 0xf3, 0x23, 0xf1 } }
+
+#define EFI_PCD_INVALID_TOKEN_NUMBER ((UINTN) 0)
+
+/**
+  SetSku() sets the SKU Id to be used for subsequent calls to set or get PCD values. SetSku() is
+  normally called only once by the system.
+  For each item (token), the database can hold a single value that applies to all SKUs, or multiple
+  values, where each value is associated with a specific SKU Id. Items with multiple, SKU-specific
+  values are called SKU enabled.
+  The SKU Id of zero is reserved as a default. The valid SkuId range is 1 to 255. For tokens that are
+  not SKU enabled, the system ignores any set SKU Id and works with the single value for that token.
+  For SKU-enabled tokens, the system will use the SKU Id set by the last call to SetSku(). If no
+  SKU Id is set or the currently set SKU Id isn't valid for the specified token, the system uses the
+  default SKU Id. If the system attempts to use the default SKU Id and no value has been set for that
+  Id, the results are unpredictable.
+
+  @param[in]    SkuId   The SKU value to set.
+**/
+typedef
+VOID
+(EFIAPI *EFI_PEI_PCD_PPI_SET_SKU)(
+  IN UINTN SkuId
+);
+
+/**
+  Retrieves the current byte-sized value for a PCD token number. If the TokenNumber is invalid,
+  the results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return 8-bit value for a given PCD token.
+**/
+typedef
+UINT8
+(EFIAPI *EFI_PEI_PCD_PPI_GET_8)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current word-sized value for a PCD token number. If the TokenNumber is invalid,
+  the results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return 16-bit value for a given PCD token.
+**/
+typedef
+UINT16
+(EFIAPI *EFI_PEI_PCD_PPI_GET_16)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current 32-bit value for a PCD token number. If the TokenNumber is invalid, the
+  results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return 32-bit value for a given PCD token.
+**/
+typedef
+UINT32
+(EFIAPI *EFI_PEI_PCD_PPI_GET_32)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current 64-bit value for a PCD token number. If the TokenNumber is invalid, the
+  results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return 64-bit value for a given PCD token.
+**/
+typedef
+UINT64
+(EFIAPI *EFI_PEI_PCD_PPI_GET_64)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current pointer to the value for a PCD token number. There should not be any
+  alignment assumptions about the pointer that is returned by this function call. If the TokenNumber
+  is invalid, the results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+**/
+typedef
+VOID *
+(EFIAPI *EFI_PEI_PCD_PPI_GET_POINTER)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current Boolean-sized value for a PCD token number. If the TokenNumber is
+  invalid, the results are unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return Boolean value for a given PCD token.
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_PEI_PCD_PPI_GET_BOOLEAN)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current size of a particular PCD token. If the TokenNumber is invalid, the results are
+  unpredictable.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+
+  @return the size of the value for a given PCD token.
+**/
+typedef
+UINTN
+(EFIAPI *EFI_PEI_PCD_PPI_GET_SIZE)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    Value         The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_8)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT8     Value
+);
+
+/**
+  Sets an 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    Value         The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_16)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT16    Value
+);
+
+/**
+  Sets an 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    Value         The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_32)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT32    Value
+);
+
+/**
+  Sets an 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    Value         The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_64)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT64    Value
+);
+
+/**
+  Sets a value of the specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    SizeOfValue   The length of the value being set for the PCD token. If too large of a length is
+                              specified, upon return from this function the value of SizeOfValue will reflect the
+                              maximum size for the PCD token.
+  @param[in]    Buffer        A pointer to the buffer containing the value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_POINTER)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN OUT    UINTN     *SizeOfValue,
+  IN        VOID      *Buffer
+);
+
+/**
+  Sets a Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   The PCD token number.
+  @param[in]    Value         The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_SET_BOOLEAN)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        BOOLEAN   Value
+);
+
+typedef
+VOID
+(EFIAPI *EFI_PEI_PCD_PPI_CALLBACK)(
+  IN     EFI_GUID *Guid     OPTIONAL,
+  IN     UINTN    CallBackToken,
+  IN OUT VOID     *TokenData,
+  IN     UINTN    TokenDatSize
+);
+
+/**
+  Specifies a function to be called anytime the value of a designated token is changed.
+
+  @param[in]    Guid              The 128-bit unique value that designates which namespace to monitor. If NULL, use
+                                  the standard platform namespace.
+  @param[in]    CallBackToken     The PCD token number to monitor.
+  @param[in]    CallBackFunction  The function prototype that will be called when the value associated with the
+                                  CallBackToken is set.
+
+  @retval EFI_SUCCESS     The PCD service has successfully established a call event for the
+                          CallBackToken requested.
+  @retval EFI_NOT_FOUND   The PCD service could not find the referenced token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_CALLBACK_ON_SET)(
+  IN CONST  EFI_GUID                  *Guid   OPTIONAL,
+  IN        UINTN                     CallBackToken,
+  IN        EFI_PEI_PCD_PPI_CALLBACK  CallBackFunction
+);
+
+/**
+  Cancels a previously set callback function for a particular PCD token number.
+
+  @param[in]  Guid              The 128-bit unique value that designates which namespace to monitor. If NULL, use
+                                the standard platform namespace.
+  @param[in]  CallBackToken     The PCD token number to cancel monitoring.
+  @param[in]  CallBackFunction  The function prototype that was originally passed to the CallBackOnSet function.
+
+  @retval     EFI_SUCCESS       The PCD service has cancelled the call event associated with the
+                                CallBackToken.
+  @retval     EFI_INVALID_PARAMETER   The PCD service did not match the CallBackFunction to one
+                                      that is currently being monitored.
+  @retval     EFI_NOT_FOUND     The PCD service could not find data the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_CANCEL_CALLBACK)(
+  IN CONST  EFI_GUID                  *Guid   OPTIONAL,
+  IN        UINTN                     CallBackToken,
+  IN        EFI_PEI_PCD_PPI_CALLBACK  CallBackFunction
+);
+
+/**
+  Retrieves the next valid PCD token for a given namespace.
+
+  This provides a means by which to get the next valid token number in a given namespace. This is
+  useful since the PCD infrastructure has a sparse list of token numbers in it, and one cannot a priori
+  know what token numbers are valid in the database.
+
+  @param[in]    Guid          The 128-bit unique value that designates which namespace to extract the value from.
+  @param[in]    TokenNumber   A pointer to the PCD token number to use to find the subsequent token number. To
+                              retrieve the "first" token, have the pointer reference a TokenNumber value of 0.
+
+  @retval   EFI_SUCCESS       The PCD service has retrieved the value requested.
+  @retval   EFI_NOT_FOUND     The PCD service could not find data from the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_GET_NEXT_TOKEN)(
+  IN CONST  EFI_GUID      *Guid     OPTIONAL,
+  IN        UINTN         *TokenNumber
+);
+
+/**
+  Retrieves the next valid PCD token namespace for a given namespace.
+
+  Gets the next valid token namespace for a given namespace. This is useful to traverse the valid
+  token namespaces on a platform.
+
+  @param[in, out]   Guid    An indirect pointer to EFI_GUID. On input it designates a known token
+                            namespace from which the search will start. On output, it designates the next valid
+                            token namespace on the platform. If *Guid is NULL, then the GUID of the first token
+                            space of the current platform is returned. If the search cannot locate the next valid
+                            token namespace, an error is returned and the value of *Guid is undefined.
+
+  @retval  EFI_SUCCESS      The PCD service retrieved the value requested.
+  @retval  EFI_NOT_FOUND    The PCD service could not find the next valid token namespace.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_PCD_PPI_GET_NEXT_TOKEN_SPACE)(
+  IN OUT CONST EFI_GUID     **Guid
+);
+
+typedef struct {
+  EFI_PEI_PCD_PPI_SET_SKU               SetSku;
+  EFI_PEI_PCD_PPI_GET_8                 Get8;
+  EFI_PEI_PCD_PPI_GET_16                Get16;
+  EFI_PEI_PCD_PPI_GET_32                Get32;
+  EFI_PEI_PCD_PPI_GET_64                Get64;
+  EFI_PEI_PCD_PPI_GET_POINTER           GetPtr;
+  EFI_PEI_PCD_PPI_GET_BOOLEAN           GetBool;
+  EFI_PEI_PCD_PPI_GET_SIZE              GetSize;
+  EFI_PEI_PCD_PPI_SET_8                 Set8;
+  EFI_PEI_PCD_PPI_SET_16                Set16;
+  EFI_PEI_PCD_PPI_SET_32                Set32;
+  EFI_PEI_PCD_PPI_SET_64                Set64;
+  EFI_PEI_PCD_PPI_SET_POINTER           SetPtr;
+  EFI_PEI_PCD_PPI_SET_BOOLEAN           SetBool;
+  EFI_PEI_PCD_PPI_CALLBACK_ON_SET       CallbackOnSet;
+  EFI_PEI_PCD_PPI_CANCEL_CALLBACK       CancelCallback;
+  EFI_PEI_PCD_PPI_GET_NEXT_TOKEN        GetNextToken;
+  EFI_PEI_PCD_PPI_GET_NEXT_TOKEN_SPACE  GetNextTokenSpace;
+} EFI_PEI_PCD_PPI;
+
+#endif
diff --git a/MdePkg/Include/Ppi/PiPcdInfo.h b/MdePkg/Include/Ppi/PiPcdInfo.h
new file mode 100644
index 000000000000..20571f891b7a
--- /dev/null
+++ b/MdePkg/Include/Ppi/PiPcdInfo.h
@@ -0,0 +1,82 @@
+/** @file
+  Platform Configuration Database (PCD) Info Ppi defined in PI 1.2.1 Vol3.
+
+  The PPI that provides additional information about items that reside in the PCD database.
+
+  Copyright (c) 2013, 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.
+
+  @par Revision Reference:
+  PI Version 1.2.1 Vol 3.
+**/
+
+#ifndef __PI_PCD_INFO_PPI_H__
+#define __PI_PCD_INFO_PPI_H__
+
+extern EFI_GUID gEfiGetPcdInfoPpiGuid;
+
+#define EFI_GET_PCD_INFO_PPI_GUID \
+  { 0xa60c6b59, 0xe459, 0x425d, { 0x9c, 0x69,  0xb, 0xcc, 0x9c, 0xb2, 0x7d, 0x81 } }
+
+///
+/// The forward declaration for EFI_GET_PCD_INFO_PPI.
+///
+typedef struct _EFI_GET_PCD_INFO_PPI  EFI_GET_PCD_INFO_PPI;
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_PCD_INFO_PPI_GET_INFO) (
+  IN CONST  EFI_GUID        *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+typedef
+UINTN
+(EFIAPI *EFI_GET_PCD_INFO_PPI_GET_SKU) (
+  VOID
+);
+
+///
+/// This is the PCD service to use when querying for some additional data that can be contained in the
+/// PCD database.
+///
+struct _EFI_GET_PCD_INFO_PPI {
+  ///
+  /// Retrieve additional information associated with a PCD.
+  ///
+  EFI_GET_PCD_INFO_PPI_GET_INFO         GetInfo;
+  ///
+  /// Retrieve the currently set SKU Id.
+  ///
+  EFI_GET_PCD_INFO_PPI_GET_SKU          GetSku;
+};
+
+#endif
+
diff --git a/MdePkg/Include/Ppi/ReadOnlyVariable2.h b/MdePkg/Include/Ppi/ReadOnlyVariable2.h
new file mode 100644
index 000000000000..6caee568263a
--- /dev/null
+++ b/MdePkg/Include/Ppi/ReadOnlyVariable2.h
@@ -0,0 +1,116 @@
+/** @file
+  This file declares Read-only Variable Service2 PPI.
+  This ppi permits read-only access to the UEFI variable store during the PEI phase.
+
+Copyright (c) 2006 - 2010, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __PEI_READ_ONLY_VARIABLE2_PPI_H__
+#define __PEI_READ_ONLY_VARIABLE2_PPI_H__
+
+#define EFI_PEI_READ_ONLY_VARIABLE2_PPI_GUID \
+  { 0x2ab86ef5, 0xecb5, 0x4134, { 0xb5, 0x56, 0x38, 0x54, 0xca, 0x1f, 0xe1, 0xb4 } }
+
+
+typedef struct _EFI_PEI_READ_ONLY_VARIABLE2_PPI  EFI_PEI_READ_ONLY_VARIABLE2_PPI;
+
+/**
+  This service retrieves a variable's value using its name and GUID.
+
+  Read the specified variable from the UEFI variable store. If the Data 
+  buffer is too small to hold the contents of the variable, 
+  the error EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the
+  required buffer size to obtain the data.
+
+  @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
+  @param  VariableName          A pointer to a null-terminated string that is the variable's name.
+  @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of
+                                VariableGuid and VariableName must be unique.
+  @param  Attributes            If non-NULL, on return, points to the variable's attributes.
+  @param  DataSize              On entry, points to the size in bytes of the Data buffer.
+                                On return, points to the size of the data returned in Data.
+  @param  Data                  Points to the buffer which will hold the returned variable value.
+
+  @retval EFI_SUCCESS           The variable was read successfully.
+  @retval EFI_NOT_FOUND         The variable could not be found.
+  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data. 
+                                DataSize is updated with the size required for 
+                                the specified variable.
+  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
+  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_VARIABLE2)(
+  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
+  IN CONST  CHAR16                          *VariableName,
+  IN CONST  EFI_GUID                        *VariableGuid,
+  OUT       UINT32                          *Attributes,
+  IN OUT    UINTN                           *DataSize,
+  OUT       VOID                            *Data
+  );
+
+
+/**
+  Return the next variable name and GUID.
+
+  This function is called multiple times to retrieve the VariableName 
+  and VariableGuid of all variables currently available in the system. 
+  On each call, the previous results are passed into the interface, 
+  and, on return, the interface returns the data for the next 
+  interface. When the entire variable list has been returned, 
+  EFI_NOT_FOUND is returned.
+
+  @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
+
+  @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.
+                            On return, the size of the variable name buffer.
+  @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.
+                            On return, points to the next variable's null-terminated name string.
+
+  @param  VariableGuid      On entry, a pointer to an EFI_GUID that is the variable's GUID. 
+                            On return, a pointer to the next variable's GUID.
+
+  @retval EFI_SUCCESS           The variable was read successfully.
+  @retval EFI_NOT_FOUND         The variable could not be found.
+  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting
+                                data. VariableNameSize is updated with the size
+                                required for the specified variable.
+  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
+                                VariableNameSize is NULL.
+  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_GET_NEXT_VARIABLE_NAME2)(
+  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
+  IN OUT    UINTN                           *VariableNameSize,
+  IN OUT    CHAR16                          *VariableName,
+  IN OUT    EFI_GUID                        *VariableGuid
+  );
+
+///
+/// This PPI provides a lightweight, read-only variant of the full EFI 
+/// variable services. 
+///
+struct _EFI_PEI_READ_ONLY_VARIABLE2_PPI {
+  EFI_PEI_GET_VARIABLE2           GetVariable;
+  EFI_PEI_GET_NEXT_VARIABLE_NAME2 NextVariableName;
+};
+
+extern EFI_GUID gEfiPeiReadOnlyVariable2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/RecoveryModule.h b/MdePkg/Include/Ppi/RecoveryModule.h
new file mode 100644
index 000000000000..2987facca8e7
--- /dev/null
+++ b/MdePkg/Include/Ppi/RecoveryModule.h
@@ -0,0 +1,87 @@
+/** @file
+  This file declares Recovery Module PPI.  This PPI is used to find and load the
+  recovery files.
+
+  A module that produces this PPI has many roles and is responsible for the following:
+    -# Calling the driver recovery PPI EFI_PEI_DEVICE_RECOVERY_MODULE_PPI.
+       GetNumberRecoveryCapsules() to determine if one or more DXE recovery 
+       entities exist.
+    -# If no capsules exist, then performing appropriate error handling.
+    -# Allocating a buffer of MaxRecoveryCapsuleSize as determined by
+       EFI_PEI_DEVICE_RECOVERY_MODULE_PPI.GetRecoveryCapsuleInfo() or
+       larger.
+    -# Determining the policy in which DXE recovery capsules are loaded.
+    -# Calling the driver recovery PPI EFI_PEI_DEVICE_RECOVERY_MODULE_PPI.
+       LoadRecoveryCapsule() for capsule number x.
+    -# If the load failed, performing appropriate error handling.
+    -# Performing security checks for a loaded DXE recovery capsule.
+    -# If the security checks failed, then logging the failure in a data HOB.
+    -# If the security checks failed, then determining the next 
+       EFI_PEI_DEVICE_RECOVERY_MODULE_PPI.LoadRecoveryCapsule()capsule number; 
+       otherwise, go to step 11.
+    -# If more DXE recovery capsules exist, then go to step 5; otherwise, perform 
+       error handling.
+    -# Decomposing the capsule loaded by EFI_PEI_DEVICE_RECOVERY_MODULE_PPI.
+       LoadRecoveryCapsule() into its components. It is assumed that the path 
+       parameters are redundant for recovery and Setup parameters are either 
+       redundant or canned.
+    -# Invalidating all HOB entries for updateable firmware volume entries. 
+       This invalidation prevents possible errant drivers from being executed.
+    -# Updating the HOB table with the recovery DXE firmware volume information 
+       generated from the capsule decomposition.
+    -# Returning to the PEI Dispatcher.  
+  
+  Copyright (c) 2007 - 2011, 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.
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Errata B Volume 1: 
+  Pre-EFI Initalization Core Interface
+
+**/
+
+#ifndef __PEI_RECOVERY_MODULE_PPI_H__
+#define __PEI_RECOVERY_MODULE_PPI_H__
+
+#define EFI_PEI_RECOVERY_MODULE_PPI_GUID \
+  { \
+    0xFB6D9542, 0x612D, 0x4f45, {0x87, 0x2F, 0x5C, 0xFF, 0x52, 0xE9, 0x3D, 0xCF } \
+  }
+
+typedef struct _EFI_PEI_RECOVERY_MODULE_PPI EFI_PEI_RECOVERY_MODULE_PPI;
+
+/**
+  Loads a DXE capsule from some media into memory and updates the HOB table
+  with the DXE firmware volume information.
+
+  @param  PeiServices   General-purpose services that are available to every PEIM.
+  @param  This          Indicates the EFI_PEI_RECOVERY_MODULE_PPI instance.
+
+  @retval EFI_SUCCESS        The capsule was loaded correctly.
+  @retval EFI_DEVICE_ERROR   A device error occurred.
+  @retval EFI_NOT_FOUND      A recovery DXE capsule cannot be found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_LOAD_RECOVERY_CAPSULE)(
+  IN EFI_PEI_SERVICES             **PeiServices,
+  IN EFI_PEI_RECOVERY_MODULE_PPI  *This
+  );
+
+///
+///  Finds and loads the recovery files.
+///
+struct _EFI_PEI_RECOVERY_MODULE_PPI {
+  EFI_PEI_LOAD_RECOVERY_CAPSULE LoadRecoveryCapsule;  ///< Loads a DXE binary capsule into memory.
+};
+
+extern EFI_GUID gEfiPeiRecoveryModulePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/ReportStatusCodeHandler.h b/MdePkg/Include/Ppi/ReportStatusCodeHandler.h
new file mode 100644
index 000000000000..40dfd2f72d22
--- /dev/null
+++ b/MdePkg/Include/Ppi/ReportStatusCodeHandler.h
@@ -0,0 +1,82 @@
+/** @file
+  This PPI provides registering and unregistering services to status code consumers.
+  
+  Copyright (c) 2007 - 2009, 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 __REPORT_STATUS_CODE_HANDLER_PPI_H__
+#define __REPORT_STATUS_CODE_HANDLER_PPI_H__
+
+#define EFI_PEI_RSC_HANDLER_PPI_GUID \
+  { \
+    0x65d394, 0x9951, 0x4144, {0x82, 0xa3, 0xa, 0xfc, 0x85, 0x79, 0xc2, 0x51} \
+  }
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_RSC_HANDLER_CALLBACK)(
+  IN CONST  EFI_PEI_SERVICES        **PeiServices,
+  IN        EFI_STATUS_CODE_TYPE    Type,
+  IN        EFI_STATUS_CODE_VALUE   Value,
+  IN        UINT32                  Instance,
+  IN CONST  EFI_GUID                *CallerId,
+  IN CONST  EFI_STATUS_CODE_DATA    *Data
+);
+
+/**
+  Register the callback function for ReportStatusCode() notification.
+  
+  When this function is called the function pointer is added to an internal list and any future calls to
+  ReportStatusCode() will be forwarded to the Callback function.
+
+  @param[in] Callback           A pointer to a function of type EFI_PEI_RSC_HANDLER_CALLBACK that is called
+                                when a call to ReportStatusCode() occurs.
+                        
+  @retval EFI_SUCCESS           Function was successfully registered.
+  @retval EFI_INVALID_PARAMETER The callback function was NULL.
+  @retval EFI_OUT_OF_RESOURCES  The internal buffer ran out of space. No more functions can be
+                                registered.
+  @retval EFI_ALREADY_STARTED   The function was already registered. It can't be registered again.
+                        
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_RSC_HANDLER_REGISTER)(
+  IN EFI_PEI_RSC_HANDLER_CALLBACK Callback
+);
+
+/**
+  Remove a previously registered callback function from the notification list.
+  
+  ReportStatusCode() messages will no longer be forwarded to the Callback function.
+  
+  @param[in] Callback           A pointer to a function of type EFI_PEI_RSC_HANDLER_CALLBACK that is to be
+                                unregistered.
+
+  @retval EFI_SUCCESS           The function was successfully unregistered.
+  @retval EFI_INVALID_PARAMETER The callback function was NULL.
+  @retval EFI_NOT_FOUND         The callback function was not found to be unregistered.
+                        
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_RSC_HANDLER_UNREGISTER)(
+  IN EFI_PEI_RSC_HANDLER_CALLBACK Callback
+);
+
+typedef struct _EFI_PEI_RSC_HANDLER_PPI {
+  EFI_PEI_RSC_HANDLER_REGISTER Register;
+  EFI_PEI_RSC_HANDLER_UNREGISTER Unregister;
+} EFI_PEI_RSC_HANDLER_PPI;
+
+extern EFI_GUID gEfiPeiRscHandlerPpiGuid;
+
+#endif // __REPORT_STATUS_CODE_HANDLER_PPI_H__
diff --git a/MdePkg/Include/Ppi/Reset.h b/MdePkg/Include/Ppi/Reset.h
new file mode 100644
index 000000000000..9cafbdcdc511
--- /dev/null
+++ b/MdePkg/Include/Ppi/Reset.h
@@ -0,0 +1,44 @@
+/** @file
+  This file declares Reset PPI used to reset the platform.
+  
+  This PPI is installed by some platform- or chipset-specific PEIM that 
+  abstracts the Reset Service to other agents.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __RESET_PPI_H__
+#define __RESET_PPI_H__
+
+#define EFI_PEI_RESET_PPI_GUID \
+  { \
+    0xef398d58, 0x9dfd, 0x4103, {0xbf, 0x94, 0x78, 0xc6, 0xf4, 0xfe, 0x71, 0x2f } \
+  }
+
+//
+// EFI_PEI_RESET_PPI.ResetSystem() is equivalent to the
+// PEI Service ResetSystem().
+// It is introduced in PIPeiCis.h. 
+//
+
+///
+/// This PPI provides provide a simple reset service. 
+///
+typedef struct {
+  EFI_PEI_RESET_SYSTEM  ResetSystem;
+} EFI_PEI_RESET_PPI;
+
+extern EFI_GUID gEfiPeiResetPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Reset2.h b/MdePkg/Include/Ppi/Reset2.h
new file mode 100644
index 000000000000..8834ba8500c1
--- /dev/null
+++ b/MdePkg/Include/Ppi/Reset2.h
@@ -0,0 +1,38 @@
+/** @file
+  This file declares Reset2 PPI used to reset the platform.
+
+  This PPI is installed by some platform- or chipset-specific PEIM that
+  abstracts the Reset Service to other agents.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.4.
+
+**/
+
+#ifndef __RESET2_PPI_H__
+#define __RESET2_PPI_H__
+
+#define EFI_PEI_RESET2_PPI_GUID \
+  { \
+    0x6cc45765, 0xcce4, 0x42fd, {0xbc, 0x56, 0x1, 0x1a, 0xaa, 0xc6, 0xc9, 0xa8 } \
+  }
+
+///
+/// This PPI provides provide a simple reset service.
+///
+typedef struct _EFI_PEI_RESET2_PPI {
+  EFI_PEI_RESET2_SYSTEM ResetSystem;
+} EFI_PEI_RESET2_PPI;
+
+extern EFI_GUID gEfiPeiReset2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/S3Resume2.h b/MdePkg/Include/Ppi/S3Resume2.h
new file mode 100644
index 000000000000..2645c22975bc
--- /dev/null
+++ b/MdePkg/Include/Ppi/S3Resume2.h
@@ -0,0 +1,92 @@
+/** @file
+  This PPI produces functions to interpret and execute the PI boot script table.
+  
+  This PPI is published by a PEIM and provides for the restoration of the platform's
+  configuration when resuming from the ACPI S3 power state. The ability to execute 
+  the boot script may depend on the availability of other PPIs. For example, if 
+  the boot script includes an SMBus command, this PEIM looks for the relevant PPI 
+  that is able to execute that command.  
+  
+  Copyright (c) 2010, 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.
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Volume 5: 
+  Standards
+
+**/
+
+#ifndef __PEI_S3_RESUME_PPI_H__
+#define __PEI_S3_RESUME_PPI_H__
+
+///
+/// Global ID for EFI_PEI_S3_RESUME2_PPI
+///
+#define EFI_PEI_S3_RESUME2_PPI_GUID \
+  { \
+    0x6D582DBC, 0xDB85, 0x4514, {0x8F, 0xCC, 0x5A, 0xDF, 0x62, 0x27, 0xB1, 0x47 } \
+  }
+
+///
+/// Forward declaration for EFI_PEI_S3_RESUME_PPI
+///
+typedef struct _EFI_PEI_S3_RESUME2_PPI  EFI_PEI_S3_RESUME2_PPI;
+
+/**
+  Restores the platform to its preboot configuration for an S3 resume and
+  jumps to the OS waking vector.
+
+  This function will restore the platform to its pre-boot configuration that was 
+  pre-stored in the boot script table and transfer control to OS waking vector.
+  Upon invocation, this function is responsible for locating the following 
+  information before jumping to OS waking vector:
+    - ACPI tables
+    - boot script table
+    - any other information that it needs
+    
+  The S3RestoreConfig() function then executes the pre-stored boot script table 
+  and transitions the platform to the pre-boot state. The boot script is recorded 
+  during regular boot using the EFI_S3_SAVE_STATE_PROTOCOL.Write() and
+  EFI_S3_SMM_SAVE_STATE_PROTOCOL.Write() functions.  Finally, this function 
+  transfers control to the OS waking vector. If the OS supports only a real-mode 
+  waking vector, this function will switch from flat mode to real mode before 
+  jumping to the waking vector.  If all platform pre-boot configurations are 
+  successfully restored and all other necessary information is ready, this 
+  function will never return and instead will directly jump to the OS waking 
+  vector. If this function returns, it indicates that the attempt to resume 
+  from the ACPI S3 sleep state failed.  
+  
+  @param[in] This   Pointer to this instance of the PEI_S3_RESUME_PPI
+
+  @retval EFI_ABORTED     Execution of the S3 resume boot script table failed.
+  @retval EFI_NOT_FOUND   Some necessary information that is used for the S3 
+                          resume boot path could not be located.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_S3_RESUME_PPI_RESTORE_CONFIG2)(
+  IN EFI_PEI_S3_RESUME2_PPI  *This
+  );
+
+/**
+  EFI_PEI_S3_RESUME2_PPI accomplishes the firmware S3 resume boot
+  path and transfers control to OS.
+**/
+struct _EFI_PEI_S3_RESUME2_PPI {
+  ///
+  /// Restores the platform to its preboot configuration for an S3 resume and
+  /// jumps to the OS waking vector.
+  ///
+  EFI_PEI_S3_RESUME_PPI_RESTORE_CONFIG2  S3RestoreConfig2;
+};
+
+extern EFI_GUID gEfiPeiS3Resume2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/SecPlatformInformation.h b/MdePkg/Include/Ppi/SecPlatformInformation.h
new file mode 100644
index 000000000000..eaf73ce9cf1b
--- /dev/null
+++ b/MdePkg/Include/Ppi/SecPlatformInformation.h
@@ -0,0 +1,188 @@
+/** @file
+  This file declares Sec Platform Information PPI.
+
+  This service is the primary handoff state into the PEI Foundation.
+  The Security (SEC) component creates the early, transitory memory
+  environment and also encapsulates knowledge of at least the
+  location of the Boot Firmware Volume (BFV).
+
+Copyright (c) 2006 - 2015, 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.
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __SEC_PLATFORM_INFORMATION_PPI_H__
+#define __SEC_PLATFORM_INFORMATION_PPI_H__
+
+#include <Pi/PiPeiCis.h>
+
+#define EFI_SEC_PLATFORM_INFORMATION_GUID \
+  { \
+    0x6f8c2b35, 0xfef4, 0x448d, {0x82, 0x56, 0xe1, 0x1b, 0x19, 0xd6, 0x10, 0x77 } \
+  }
+
+typedef struct _EFI_SEC_PLATFORM_INFORMATION_PPI EFI_SEC_PLATFORM_INFORMATION_PPI;
+
+
+///
+/// EFI_HEALTH_FLAGS
+/// Contains information generated by microcode, hardware, and/or the Itanium
+/// processor PAL code about the state of the processor upon reset.
+///
+typedef union {
+  struct {
+    ///
+    /// A 2-bit field indicating self-test state after reset.
+    ///
+    UINT32   Status                   : 2;
+    ///
+    /// A 1-bit field indicating whether testing has occurred.
+    /// If this field is zero, the processor has not been tested,
+    /// and no further fields in the self-test State parameter are valid.
+    ///
+    UINT32   Tested                   : 1;
+    ///
+    /// Reserved 13 bits.
+    ///
+    UINT32   Reserved1                :13;
+    ///
+    /// A 1-bit field. If set to 1, this indicates that virtual
+    /// memory features are not available.
+    ///
+    UINT32   VirtualMemoryUnavailable : 1;
+    ///
+    /// A 1-bit field. If set to 1, this indicates that IA-32 execution
+    /// is not available.
+    ///
+    UINT32   Ia32ExecutionUnavailable : 1;
+    ///
+    /// A 1-bit field. If set to 1, this indicates that the floating
+    /// point unit is not available.
+    ///
+    UINT32   FloatingPointUnavailable : 1;
+    ///
+    /// A 1-bit field. If set to 1, this indicates miscellaneous
+    /// functional failure other than vm, ia, or fp.
+    /// The test status field provides additional information on
+    /// test failures when the State field returns a value of
+    /// performance restricted or functionally restricted.
+    /// The value returned is implementation dependent.
+    ///
+    UINT32   MiscFeaturesUnavailable  : 1;
+    ///
+    /// Reserved 12 bits.
+    ///
+    UINT32   Reserved2                :12;
+  } Bits;
+  UINT32     Uint32;
+} EFI_HEALTH_FLAGS;
+
+#define NORMAL_BOOT_CALL    0x0
+#define RECOVERY_CHECK_CALL 0x3
+
+typedef EFI_HEALTH_FLAGS X64_HANDOFF_STATUS;
+typedef EFI_HEALTH_FLAGS IA32_HANDOFF_STATUS;
+///
+/// The hand-off status structure for Itanium architecture.
+///
+typedef struct {
+  ///
+  /// SALE_ENTRY state : 3 = Recovery_Check
+  /// and 0 = RESET or Normal_Boot phase.
+  ///
+  UINT8 BootPhase;
+  ///
+  /// Firmware status on entry to SALE.
+  ///
+  UINT8 FWStatus;
+  UINT16 Reserved1;
+  UINT32 Reserved2;
+  ///
+  /// Geographically significant unique processor ID assigned by PAL.
+  ///
+  UINT16 ProcId;
+  UINT16 Reserved3;
+  UINT8  IdMask;
+  UINT8  EidMask;
+  UINT16 Reserved4;
+  ///
+  /// Address to make PAL calls.
+  ///
+  UINT64 PalCallAddress;
+  ///
+  /// If the entry state is RECOVERY_CHECK, this contains the PAL_RESET
+  /// return address, and if entry state is RESET, this contains
+  /// address for PAL_authentication call.
+  ///
+  UINT64 PalSpecialAddress;
+  ///
+  /// GR35 from PALE_EXIT state.
+  ///
+  UINT64 SelfTestStatus;
+  ///
+  /// GR37 from PALE_EXIT state.
+  ///
+  UINT64 SelfTestControl;
+  UINT64 MemoryBufferRequired;
+} ITANIUM_HANDOFF_STATUS;
+
+///
+/// EFI_SEC_PLATFORM_INFORMATION_RECORD.
+///
+typedef union {
+  IA32_HANDOFF_STATUS    IA32HealthFlags;
+  X64_HANDOFF_STATUS     x64HealthFlags;
+  ITANIUM_HANDOFF_STATUS ItaniumHealthFlags;
+} EFI_SEC_PLATFORM_INFORMATION_RECORD;
+
+/**
+  This interface conveys state information out of the Security (SEC) phase into PEI.
+
+  This service is published by the SEC phase. The SEC phase handoff has an optional
+  EFI_PEI_PPI_DESCRIPTOR list as its final argument when control is passed from SEC into the
+  PEI Foundation. As such, if the platform supports the built-in self test (BIST) on IA-32 Intel
+  architecture or the PAL-A handoff state for Itanium architecture, this information is encapsulated
+  into the data structure abstracted by this service. This information is collected for the boot-strap
+  processor (BSP) on IA-32. For Itanium architecture, it is available on all processors that execute
+  the PEI Foundation.
+
+  @param  PeiServices               The pointer to the PEI Services Table.
+  @param  StructureSize             The pointer to the variable describing size of the input buffer.
+  @param  PlatformInformationRecord The pointer to the EFI_SEC_PLATFORM_INFORMATION_RECORD.
+
+  @retval EFI_SUCCESS               The data was successfully returned.
+  @retval EFI_BUFFER_TOO_SMALL      The buffer was too small. The current buffer size needed to
+                                    hold the record is returned in StructureSize.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SEC_PLATFORM_INFORMATION)(
+  IN CONST  EFI_PEI_SERVICES                    **PeiServices,
+  IN OUT    UINT64                              *StructureSize,
+  OUT       EFI_SEC_PLATFORM_INFORMATION_RECORD *PlatformInformationRecord
+);
+
+
+///
+/// This service abstracts platform-specific information. It is necessary
+/// to convey this information to the PEI Foundation so that it can
+/// discover where to begin dispatching PEIMs.
+///
+struct _EFI_SEC_PLATFORM_INFORMATION_PPI {
+  EFI_SEC_PLATFORM_INFORMATION  PlatformInformation;
+};
+
+
+extern EFI_GUID gEfiSecPlatformInformationPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/SecPlatformInformation2.h b/MdePkg/Include/Ppi/SecPlatformInformation2.h
new file mode 100644
index 000000000000..1a6a776169d8
--- /dev/null
+++ b/MdePkg/Include/Ppi/SecPlatformInformation2.h
@@ -0,0 +1,85 @@
+/** @file
+  This file declares Sec Platform Information2 PPI.
+
+  This service is the primary handoff state into the PEI Foundation.
+  This service abstracts platform-specific information for many CPU's.
+
+Copyright (c) 2015 - 2016, 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.
+
+  @par Revision Reference:
+  This PPI is introduced from PI Version 1.4.
+
+**/
+
+#ifndef __SEC_PLATFORM_INFORMATION2_PPI_H__
+#define __SEC_PLATFORM_INFORMATION2_PPI_H__
+
+#include <Ppi/SecPlatformInformation.h>
+
+#define EFI_SEC_PLATFORM_INFORMATION2_GUID \
+  { \
+    0x9e9f374b, 0x8f16, 0x4230, {0x98, 0x24, 0x58, 0x46, 0xee, 0x76, 0x6a, 0x97 } \
+  }
+
+typedef struct _EFI_SEC_PLATFORM_INFORMATION2_PPI EFI_SEC_PLATFORM_INFORMATION2_PPI;
+
+///
+/// EFI_SEC_PLATFORM_INFORMATION_CPU.
+///
+typedef struct {
+  UINT32                               CpuLocation;
+  EFI_SEC_PLATFORM_INFORMATION_RECORD  InfoRecord;
+} EFI_SEC_PLATFORM_INFORMATION_CPU;
+
+///
+/// EFI_SEC_PLATFORM_INFORMATION_RECORD2.
+///
+typedef struct {
+  ///
+  /// The CPU location would be the local APIC ID
+  ///
+  UINT32                               NumberOfCpus;
+  EFI_SEC_PLATFORM_INFORMATION_CPU     CpuInstance[1];
+} EFI_SEC_PLATFORM_INFORMATION_RECORD2;
+
+/**
+  This interface conveys state information out of the Security (SEC) phase into PEI.
+
+  This service is published by the SEC phase.
+
+  @param  PeiServices                The pointer to the PEI Services Table.
+  @param  StructureSize              The pointer to the variable describing size of the input buffer.
+  @param  PlatformInformationRecord2 The pointer to the EFI_SEC_PLATFORM_INFORMATION_RECORD2.
+
+  @retval EFI_SUCCESS                The data was successfully returned.
+  @retval EFI_BUFFER_TOO_SMALL       The buffer was too small. The current buffer size needed to
+                                     hold the record is returned in StructureSize.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SEC_PLATFORM_INFORMATION2)(
+  IN CONST  EFI_PEI_SERVICES                     **PeiServices,
+  IN OUT    UINT64                               *StructureSize,
+  OUT       EFI_SEC_PLATFORM_INFORMATION_RECORD2 *PlatformInformationRecord2
+);
+
+///
+/// This service abstracts platform-specific information for many CPU's.
+/// It is the multi-processor equivalent of PlatformInformation for
+/// implementations that synchronize some, if not all CPU's in the SEC phase.
+///
+struct _EFI_SEC_PLATFORM_INFORMATION2_PPI {
+  EFI_SEC_PLATFORM_INFORMATION2  PlatformInformation2;
+};
+
+extern EFI_GUID gEfiSecPlatformInformation2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Security2.h b/MdePkg/Include/Ppi/Security2.h
new file mode 100644
index 000000000000..026597492151
--- /dev/null
+++ b/MdePkg/Include/Ppi/Security2.h
@@ -0,0 +1,101 @@
+/** @file
+  This file declares Pei Security2 PPI.
+
+  This PPI is installed by some platform PEIM that abstracts the security 
+  policy to the PEI Foundation, namely the case of a PEIM's authentication 
+  state being returned during the PEI section extraction process.
+
+  Copyright (c) 2006 - 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __SECURITY2_PPI_H__
+#define __SECURITY2_PPI_H__
+
+#define EFI_PEI_SECURITY2_PPI_GUID \
+  { 0xdcd0be23, 0x9586, 0x40f4, { 0xb6, 0x43, 0x6, 0x52, 0x2c, 0xed, 0x4e, 0xde } }
+
+
+typedef struct _EFI_PEI_SECURITY2_PPI  EFI_PEI_SECURITY2_PPI;
+
+/**
+  Allows the platform builder to implement a security policy 
+  in response to varying file authentication states.
+
+  This service is published by some platform PEIM. The purpose of
+  this service is to expose a given platform's policy-based
+  response to the PEI Foundation. For example, if there is a PEIM
+  in a GUIDed encapsulation section and the extraction of the PEI
+  file section yields an authentication failure, there is no a
+  priori policy in the PEI Foundation. Specifically, this
+  situation leads to the question whether PEIMs that are either
+  not in GUIDed sections or are in sections whose authentication
+  fails should still be executed.
+
+  @param PeiServices             An indirect pointer to the PEI Services
+                                 Table published by the PEI Foundation.
+  @param This                    Interface pointer that implements the
+                                 particular EFI_PEI_SECURITY2_PPI instance.
+  @param AuthenticationStatus    Authentication status of the file.
+                                 xx00 Image was not signed.
+                                 xxx1 Platform security policy override. 
+                                      Assumes same meaning as 0010 (the image was signed, the
+                                      signature was tested, and the signature passed authentication test).
+                                 0010 Image was signed, the signature was tested, 
+                                      and the signature passed authentication test.
+                                 0110 Image was signed and the signature was not tested.
+                                 1010 Image was signed, the signature was tested, 
+                                      and the signature failed the authentication test.
+  @param FvHandle                Handle of the volume in which the file
+                                 resides. This allows different policies
+                                 depending on different firmware volumes.
+  @param FileHandle              Handle of the file under review.
+  @param DeferExecution          Pointer to a variable that alerts the
+                                 PEI Foundation to defer execution of a
+                                 PEIM.
+
+  @retval EFI_SUCCESS            The service performed its action successfully.
+  @retval EFI_SECURITY_VIOLATION The object cannot be trusted.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SECURITY_AUTHENTICATION_STATE)(
+  IN CONST  EFI_PEI_SERVICES      **PeiServices,
+  IN CONST  EFI_PEI_SECURITY2_PPI *This,
+  IN UINT32                       AuthenticationStatus,
+  IN EFI_PEI_FV_HANDLE            FvHandle,
+  IN EFI_PEI_FILE_HANDLE          FileHandle,
+  IN OUT    BOOLEAN               *DeferExecution
+);
+
+///
+/// This PPI is a means by which the platform builder can indicate
+/// a response to a PEIM's authentication state. This can be in
+/// the form of a requirement for the PEI Foundation to skip a
+/// module using the DeferExecution Boolean output in the
+/// AuthenticationState() member function. Alternately, the
+/// Security PPI can invoke something like a cryptographic PPI
+/// that hashes the PEIM contents to log attestations, for which
+/// the FileHandle parameter in AuthenticationState() will be
+/// useful. If this PPI does not exist, PEIMs will be considered
+/// trusted.
+///
+struct _EFI_PEI_SECURITY2_PPI {
+  EFI_PEI_SECURITY_AUTHENTICATION_STATE   AuthenticationState;
+};
+
+
+extern EFI_GUID gEfiPeiSecurity2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Smbus2.h b/MdePkg/Include/Ppi/Smbus2.h
new file mode 100644
index 000000000000..633394faa1a7
--- /dev/null
+++ b/MdePkg/Include/Ppi/Smbus2.h
@@ -0,0 +1,203 @@
+/** @file
+  This file declares Smbus2 PPI.
+  This PPI provides the basic I/O interfaces that a PEIM uses to access its 
+  SMBus controller and the slave devices attached to it.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __PEI_SMBUS2_PPI_H__
+#define __PEI_SMBUS2_PPI_H__
+
+#include <IndustryStandard/SmBus.h>
+
+#define EFI_PEI_SMBUS2_PPI_GUID \
+  { 0x9ca93627, 0xb65b, 0x4324, { 0xa2, 0x2, 0xc0, 0xb4, 0x61, 0x76, 0x45, 0x43 } }
+
+
+typedef struct _EFI_PEI_SMBUS2_PPI EFI_PEI_SMBUS2_PPI;
+
+/**
+  Executes an SMBus operation to an SMBus controller. Returns when either 
+  the command has been executed or an error is encountered in doing the operation.
+
+  @param  This            A pointer to the EFI_PEI_SMBUS2_PPI instance.
+  @param  SlaveAddress    The SMBUS hardware address to which the SMBUS device is preassigned or
+                          allocated.
+  @param  Command         This command is transmitted by the SMBus host controller to the SMBus slave 
+                          device and the interpretation is SMBus slave device specific. 
+                          It can mean the offset to a list of functions inside 
+                          an SMBus slave device. Not all operations or slave devices support
+                          this command's registers.
+  @param  Operation       Signifies which particular SMBus hardware protocol instance that it 
+                          will use to execute the SMBus transactions. 
+                          This SMBus hardware protocol is defined by the System Management Bus (SMBus) 
+                          Specification and is not related to UEFI.
+  @param  PecCheck        Defines if Packet Error Code (PEC) checking is required for this operation.
+  @param  Length          Signifies the number of bytes that this operation will do. 
+                          The maximum number of bytes can be revision specific and operation specific.
+                          This parameter will contain the actual number of bytes that are executed
+                          for this operation. Not all operations require this argument.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave device. 
+                          Not all operations require this argument. 
+                          The length of this buffer is identified by Length.
+
+
+  @retval EFI_SUCCESS           The last data that was returned from the access
+                                matched the poll exit criteria.
+  @retval EFI_CRC_ERROR         The checksum is not correct (PEC is incorrect)
+  @retval EFI_TIMEOUT           Timeout expired before the operation was completed.
+                                Timeout is determined by the SMBus host controller device.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed
+                                due to a lack of resources.
+  @retval EFI_DEVICE_ERROR      The request was not completed because
+                                a failure reflected in the Host Status Register bit.
+  @retval EFI_INVALID_PARAMETER Operation is not defined in EFI_SMBUS_OPERATION.
+                                Or Length/Buffer is NULL for operations except for EfiSmbusQuickRead and
+                                EfiSmbusQuickWrite. Or Length is outside the range of valid values.
+  @retval EFI_UNSUPPORTED       The SMBus operation or PEC is not supported.
+  @retval EFI_BUFFER_TOO_SMALL  Buffer is not sufficient for this operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SMBUS2_PPI_EXECUTE_OPERATION)(
+  IN CONST  EFI_PEI_SMBUS2_PPI        *This,
+  IN        EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
+  IN        EFI_SMBUS_DEVICE_COMMAND  Command,
+  IN        EFI_SMBUS_OPERATION       Operation,
+  IN        BOOLEAN                   PecCheck,
+  IN OUT    UINTN                     *Length,
+  IN OUT    VOID                      *Buffer
+);
+
+/**
+  The ArpDevice() function enumerates the entire bus or enumerates a specific 
+  device that is identified by SmbusUdid. 
+
+  @param  This           A pointer to the EFI_PEI_SMBUS2_PPI instance.
+  @param  ArpAll         A Boolean expression that indicates if the host drivers need
+                         to enumerate all the devices or enumerate only the device that is identified
+                         by SmbusUdid. If ArpAll is TRUE, SmbusUdid and SlaveAddress are optional.
+                         If ArpAll is FALSE, ArpDevice will enumerate SmbusUdid and the address
+                         will be at SlaveAddress.
+  @param  SmbusUdid      The targeted SMBus Unique Device Identifier (UDID).
+                         The UDID may not exist for SMBus devices with fixed addresses.
+  @param  SlaveAddress   The new SMBus address for the slave device for
+                         which the operation is targeted.
+
+  @retval EFI_SUCCESS           The SMBus slave device address was set.
+  @retval EFI_INVALID_PARAMETER SlaveAddress is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed
+                                due to a lack of resources.
+  @retval EFI_TIMEOUT           The SMBus slave device did not respond.
+  @retval EFI_DEVICE_ERROR      The request was not completed because the transaction failed.
+  @retval EFI_UNSUPPORTED       ArpDevice, GetArpMap, and Notify are not implemented by this PEIM.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SMBUS2_PPI_ARP_DEVICE)(
+  IN CONST  EFI_PEI_SMBUS2_PPI        *This,
+  IN        BOOLEAN                   ArpAll,
+  IN        EFI_SMBUS_UDID            *SmbusUdid,   OPTIONAL
+  IN OUT    EFI_SMBUS_DEVICE_ADDRESS  *SlaveAddress OPTIONAL
+);
+
+/**
+  The GetArpMap() function returns the mapping of all the SMBus devices 
+  that are enumerated by the SMBus host driver. 
+
+  @param  This           A pointer to the EFI_PEI_SMBUS2_PPI instance.
+  @param  Length         Size of the buffer that contains the SMBus device map.
+  @param  SmbusDeviceMap The pointer to the device map as enumerated
+                         by the SMBus controller driver.
+
+  @retval EFI_SUCCESS           The device map was returned correctly in the buffer.
+  @retval EFI_UNSUPPORTED       ArpDevice, GetArpMap, and Notify are not implemented by this PEIM.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SMBUS2_PPI_GET_ARP_MAP)(
+  IN CONST  EFI_PEI_SMBUS2_PPI    *This,
+  IN OUT    UINTN                 *Length,
+  IN OUT    EFI_SMBUS_DEVICE_MAP  **SmbusDeviceMap
+);
+
+/**
+  CallBack function can be registered in EFI_PEI_SMBUS2_PPI_NOTIFY.
+
+  @param  This           A pointer to the EFI_PEI_SMBUS2_PPI instance.
+  @param  SlaveAddress   The SMBUS hardware address to which the SMBUS
+                         device is preassigned or allocated.
+  @param  Data           Data of the SMBus host notify command that
+                         the caller wants to be called.
+
+  @retval EFI_SUCCESS           NotifyFunction has been registered.
+  @retval EFI_UNSUPPORTED       ArpDevice, GetArpMap, and Notify are not
+                                implemented by this PEIM.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SMBUS_NOTIFY2_FUNCTION)(
+  IN CONST  EFI_PEI_SMBUS2_PPI        *SmbusPpi,
+  IN        EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
+  IN        UINTN                     Data
+);
+
+/**
+  The Notify() function registers all the callback functions to allow the 
+  bus driver to call these functions when the SlaveAddress/Data pair happens.
+
+  @param  This           A pointer to the EFI_PEI_SMBUS2_PPI instance.
+  @param  SlaveAddress   Address that the host controller detects as
+                         sending a message and calls all the registered functions.
+  @param  Data           Data that the host controller detects as sending a message
+                         and calls all the registered functions.
+  @param  NotifyFunction The function to call when the bus driver
+                         detects the SlaveAddress and Data pair.
+
+  @retval EFI_SUCCESS     NotifyFunction has been registered.
+  @retval EFI_UNSUPPORTED ArpDevice, GetArpMap, and Notify are not
+                          implemented by this PEIM.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SMBUS2_PPI_NOTIFY)(
+  IN CONST EFI_PEI_SMBUS2_PPI              *This,
+  IN       EFI_SMBUS_DEVICE_ADDRESS        SlaveAddress,
+  IN       UINTN                           Data,
+  IN       EFI_PEI_SMBUS_NOTIFY2_FUNCTION  NotifyFunction
+);
+
+///
+///  Provides the basic I/O interfaces that a PEIM uses to access 
+///  its SMBus controller and the slave devices attached to it.
+///
+struct _EFI_PEI_SMBUS2_PPI {
+  EFI_PEI_SMBUS2_PPI_EXECUTE_OPERATION  Execute;
+  EFI_PEI_SMBUS2_PPI_ARP_DEVICE         ArpDevice;
+  EFI_PEI_SMBUS2_PPI_GET_ARP_MAP        GetArpMap;
+  EFI_PEI_SMBUS2_PPI_NOTIFY             Notify;
+  ///
+  /// Identifier which uniquely identifies this SMBus controller in a system.
+  ///
+  EFI_GUID                              Identifier;
+};
+
+extern EFI_GUID gEfiPeiSmbus2PpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/Stall.h b/MdePkg/Include/Ppi/Stall.h
new file mode 100644
index 000000000000..94a68c2e392b
--- /dev/null
+++ b/MdePkg/Include/Ppi/Stall.h
@@ -0,0 +1,62 @@
+/** @file
+  This file declares Stall PPI.
+
+  This ppi abstracts the blocking stall service to other agents.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __STALL_PPI_H__
+#define __STALL_PPI_H__
+
+#define EFI_PEI_STALL_PPI_GUID \
+  { 0x1f4c6f90, 0xb06b, 0x48d8, {0xa2, 0x01, 0xba, 0xe5, 0xf1, 0xcd, 0x7d, 0x56 } }
+
+typedef struct _EFI_PEI_STALL_PPI EFI_PEI_STALL_PPI;
+
+/**
+  The Stall() function provides a blocking stall for at least the number 
+  of microseconds stipulated in the final argument of the API.
+
+  @param  PeiServices    An indirect pointer to the PEI Services Table
+                         published by the PEI Foundation.
+  @param  This           Pointer to the local data for the interface.
+  @param  Microseconds   Number of microseconds for which to stall.
+
+  @retval EFI_SUCCESS    The service provided at least the required delay.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_STALL)(
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN CONST EFI_PEI_STALL_PPI    *This,
+  IN UINTN                      Microseconds
+  );
+
+///
+/// This service provides a simple, blocking stall with platform-specific resolution. 
+///
+struct _EFI_PEI_STALL_PPI {
+  ///
+  /// The resolution in microseconds of the stall services.
+  ///
+  UINTN          Resolution;
+
+  EFI_PEI_STALL  Stall;
+};
+
+extern EFI_GUID gEfiPeiStallPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/StatusCode.h b/MdePkg/Include/Ppi/StatusCode.h
new file mode 100644
index 000000000000..30a53304fdc8
--- /dev/null
+++ b/MdePkg/Include/Ppi/StatusCode.h
@@ -0,0 +1,41 @@
+/** @file
+  This file declares Status Code PPI.
+  This ppi provides a service that allows PEIMs to report status codes.
+
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __STATUS_CODE_PPI_H__
+#define __STATUS_CODE_PPI_H__
+
+#define EFI_PEI_REPORT_PROGRESS_CODE_PPI_GUID \
+  { 0x229832d3, 0x7a30, 0x4b36, {0xb8, 0x27, 0xf4, 0xc, 0xb7, 0xd4, 0x54, 0x36 } }
+
+//
+// EFI_PEI_PROGRESS_CODE_PPI.ReportStatusCode() is equivalent to the
+// PEI Service ReportStatusCode().
+// It is introduced in PIPeiCis.h. 
+//
+
+///
+/// This PPI provides the service to report status code.
+/// There can be only one instance of this service in the system.
+///
+typedef struct {
+  EFI_PEI_REPORT_STATUS_CODE  ReportStatusCode;
+} EFI_PEI_PROGRESS_CODE_PPI;
+
+extern EFI_GUID gEfiPeiStatusCodePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/SuperIo.h b/MdePkg/Include/Ppi/SuperIo.h
new file mode 100644
index 000000000000..9f129ffc98e0
--- /dev/null
+++ b/MdePkg/Include/Ppi/SuperIo.h
@@ -0,0 +1,189 @@
+/** @file
+  This PPI provides the super I/O register access functionality.
+
+  Copyright (c) 2015, 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.             
+
+  @par Revision Reference:
+  This PPI is from PI Version 1.2.1.
+
+**/
+
+#ifndef __EFI_SUPER_IO_PPI_H__
+#define __EFI_SUPER_IO_PPI_H__
+
+#include <Protocol/SuperIo.h>
+
+#define EFI_SIO_PPI_GUID \
+  { \
+    0x23a464ad, 0xcb83, 0x48b8, {0x94, 0xab, 0x1a, 0x6f, 0xef, 0xcf, 0xe5, 0x22} \
+  }
+
+typedef struct _EFI_SIO_PPI EFI_SIO_PPI;
+typedef struct _EFI_SIO_PPI *PEFI_SIO_PPI;
+
+typedef UINT16 EFI_SIO_REGISTER;
+#define EFI_SIO_REG(ldn,reg)    (EFI_SIO_REGISTER) (((ldn) << 8) | reg)
+#define EFI_SIO_LDN_GLOBAL      0xFF
+
+/**
+  Read a Super I/O register.
+ 
+  The register is specified as an 8-bit logical device number and an 8-bit
+  register value. The logical device numbers for specific SIO devices can be
+  determined using the Info member of the PPI structure.
+
+  @param PeiServices  A pointer to a pointer to the PEI Services.
+  @param This         A pointer to this instance of the EFI_SIO_PPI.
+  @param ExitCfgMode  A boolean specifying whether the driver should turn on
+                      configuration mode (FALSE) or turn off configuration mode
+                      (TRUE) after completing the read operation. The driver must
+                      track the current state of the configuration mode (if any)
+                      and turn on configuration mode (if necessary) prior to
+                      register access.
+  @param Register     A value specifying the logical device number (bits 15:8) 
+                      and the register to read (bits 7:0). The logical device 
+                      number of EFI_SIO_LDN_GLOBAL indicates that global
+                      registers will be used.
+  @param IoData       A pointer to the returned register value.
+
+  @retval EFI_SUCCESS            Success.
+  @retval EFI_TIMEOUT            The register could not be read in the a reasonable
+                                 amount of time. The exact time is device-specific.
+  @retval EFI_INVALID_PARAMETERS Register was out of range for this device.
+  @retval EFI_INVALID_PARAMETERS IoData was NULL
+  @retval EFI_DEVICE_ERROR       There was a device fault or the device was not present.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SIO_REGISTER_READ)(
+  IN EFI_PEI_SERVICES       **PeiServices,
+  IN CONST EFI_SIO_PPI      *This,
+  IN BOOLEAN                ExitCfgMode,
+  IN EFI_SIO_REGISTER       Register,
+  OUT UINT8                 *IoData
+  );
+
+/**
+  Write a Super I/O register.
+
+  The register is specified as an 8-bit logical device number and an 8-bit register
+  value. The logical device numbers for specific SIO devices can be determined
+  using the Info member of the PPI structure.
+
+  @param PeiServices  A pointer to a pointer to the PEI Services.
+  @param This         A pointer to this instance of the EFI_SIO_PPI.
+  @param ExitCfgMode  A boolean specifying whether the driver should turn on
+                      configuration mode (FALSE) or turn off configuration mode
+                      (TRUE) after completing the read operation. The driver must
+                      track the current state of the configuration mode (if any)
+                      and turn on configuration mode (if necessary) prior to
+                      register access.
+  @param Register     A value specifying the logical device number (bits 15:8) 
+                      and the register to read (bits 7:0). The logical device 
+                      number of EFI_SIO_LDN_GLOBAL indicates that global
+                      registers will be used.
+  @param IoData       A pointer to the returned register value.
+
+  @retval EFI_SUCCESS            Success.
+  @retval EFI_TIMEOUT            The register could not be read in the a reasonable
+                                 amount of time. The exact time is device-specific.
+  @retval EFI_INVALID_PARAMETERS Register was out of range for this device.
+  @retval EFI_INVALID_PARAMETERS IoData was NULL
+  @retval EFI_DEVICE_ERROR       There was a device fault or the device was not present.
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SIO_REGISTER_WRITE)(
+  IN EFI_PEI_SERVICES       **PeiServices,
+  IN CONST EFI_SIO_PPI      *This,
+  IN BOOLEAN                ExitCfgMode,
+  IN EFI_SIO_REGISTER       Register,
+  IN UINT8                  IoData
+  );
+
+/**
+  Provides an interface for a table based programming of the Super I/O registers.
+
+  The Modify() function provides an interface for table based programming of the
+  Super I/O registers. This function can be used to perform programming of
+  multiple Super I/O registers with a single function call. For each table entry,
+  the Register is read, its content is bitwise ANDed with AndMask, and then ORed
+  with OrMask before being written back to the Register. The Super I/O driver
+  must track the current state of the Super I/O and enable the configuration mode
+  of Super I/O if necessary prior to table processing. Once the table is processed,
+  the Super I/O device must be returned to the original state.
+
+  @param PeiServices      A pointer to a pointer to the PEI Services.
+  @param This             A pointer to this instance of the EFI_SIO_PPI.
+  @param Command          A pointer to an array of NumberOfCommands EFI_SIO_REGISTER_MODIFY
+                          structures. Each structure specifies a single Super I/O register
+                          modify operation.
+  @param NumberOfCommands The number of elements in the Command array.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETERS  Command is NULL.
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_SIO_REGISTER_MODIFY)(
+  IN EFI_PEI_SERVICES              **PeiServices,
+  IN CONST EFI_SIO_PPI             *This,
+  IN CONST EFI_SIO_REGISTER_MODIFY *Command,
+  IN UINTN                         NumberOfCommands
+  );
+
+///
+/// Specifies the end of the information list.
+///
+#define EFI_ACPI_PNP_HID_END       EFI_PNP_ID (0x0000)
+
+typedef UINT32                     EFI_ACPI_HID;
+typedef UINT32                     EFI_ACPI_UID;
+#pragma pack(1)
+typedef struct _EFI_SIO_INFO {
+  EFI_ACPI_HID                     Hid;
+  EFI_ACPI_UID                     Uid;
+  UINT8                            Ldn;
+} EFI_SIO_INFO, *PEFI_SIO_INFO;
+#pragma pack()
+
+///
+/// This PPI provides low-level access to Super I/O registers using Read() and
+/// Write(). It also uniquely identifies this Super I/O controller using a GUID
+/// and provides mappings between ACPI style PNP IDs and the logical device numbers.
+/// There is one instance of this PPI per Super I/O device.
+///
+struct _EFI_SIO_PPI {
+  ///
+  /// This function reads a register's value from the Super I/O controller.
+  ///
+  EFI_PEI_SIO_REGISTER_READ   Read;
+  ///
+  /// This function writes a value to a register in the Super I/O controller.
+  ///
+  EFI_PEI_SIO_REGISTER_WRITE  Write;
+  ///
+  /// This function modifies zero or more registers in the Super I/O controller
+  /// using a table.
+  ///
+  EFI_PEI_SIO_REGISTER_MODIFY Modify;
+  ///
+  /// This GUID uniquely identifies the Super I/O controller.
+  ///
+  EFI_GUID                    SioGuid;
+  ///
+  /// This pointer is to an array which maps EISA identifiers to logical devices numbers.
+  ///
+  PEFI_SIO_INFO               Info;
+};
+
+extern EFI_GUID gEfiSioPpiGuid;
+
+#endif 
diff --git a/MdePkg/Include/Ppi/TemporaryRamDone.h b/MdePkg/Include/Ppi/TemporaryRamDone.h
new file mode 100644
index 000000000000..349dac88b52a
--- /dev/null
+++ b/MdePkg/Include/Ppi/TemporaryRamDone.h
@@ -0,0 +1,52 @@
+/** @file
+  This file declares Temporary RAM Done PPI.
+  The PPI that provides a service to disable the use of Temporary RAM.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.2.1.
+
+**/
+
+#ifndef __TEMPORARY_RAM_DONE_H__
+#define __TEMPORARY_RAM_DONE_H__
+
+#define EFI_PEI_TEMPORARY_RAM_DONE_PPI_GUID \
+  { 0xceab683c, 0xec56, 0x4a2d, { 0xa9, 0x6, 0x40, 0x53, 0xfa, 0x4e, 0x9c, 0x16 } }
+
+/**
+  TemporaryRamDone() disables the use of Temporary RAM. If present, this service is invoked
+  by the PEI Foundation after the EFI_PEI_PERMANANT_MEMORY_INSTALLED_PPI is installed.
+
+  @retval EFI_SUCCESS           Use of Temporary RAM was disabled.
+  @retval EFI_INVALID_PARAMETER Temporary RAM could not be disabled.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_PEI_TEMPORARY_RAM_DONE) (
+  VOID
+  );
+
+///
+/// This is an optional PPI that may be produced by SEC or a PEIM. If present, it provide a service to
+/// disable the use of Temporary RAM. This service may only be called by the PEI Foundation after the
+/// transition from Temporary RAM to Permanent RAM is complete. This PPI provides an alternative
+/// to the Temporary RAM Migration PPI for system architectures that allow Temporary RAM and
+/// Permanent RAM to be enabled and accessed at the same time with no side effects.
+///
+typedef struct _EFI_PEI_TEMPORARY_RAM_DONE_PPI {
+  EFI_PEI_TEMPORARY_RAM_DONE TemporaryRamDone;
+} EFI_PEI_TEMPORARY_RAM_DONE_PPI;
+
+extern EFI_GUID gEfiTemporaryRamDonePpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/TemporaryRamSupport.h b/MdePkg/Include/Ppi/TemporaryRamSupport.h
new file mode 100644
index 000000000000..87e5dbd1563d
--- /dev/null
+++ b/MdePkg/Include/Ppi/TemporaryRamSupport.h
@@ -0,0 +1,66 @@
+/** @file
+  This file declares Temporary RAM Support PPI.
+  This Ppi provides the service that migrates temporary RAM into permanent memory.
+
+  Copyright (c) 2006 - 2011, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.0.
+
+**/
+
+#ifndef __TEMPORARY_RAM_SUPPORT_H__
+#define __TEMPORARY_RAM_SUPPORT_H__
+
+///
+/// Note: The GUID name EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI_GUID is different from the current
+///       PI 1.2 spec.
+///
+#define EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI_GUID  \
+  { 0xdbe23aa9, 0xa345, 0x4b97, {0x85, 0xb6, 0xb2, 0x26, 0xf1, 0x61, 0x73, 0x89} }
+
+
+/**
+  This service of the EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI that migrates temporary RAM into
+  permanent memory.
+
+  @param PeiServices            Pointer to the PEI Services Table.
+  @param TemporaryMemoryBase    Source Address in temporary memory from which the SEC or PEIM will copy the
+                                Temporary RAM contents.
+  @param PermanentMemoryBase    Destination Address in permanent memory into which the SEC or PEIM will copy the
+                                Temporary RAM contents.
+  @param CopySize               Amount of memory to migrate from temporary to permanent memory.
+
+  @retval EFI_SUCCESS           The data was successfully returned.
+  @retval EFI_INVALID_PARAMETER PermanentMemoryBase + CopySize > TemporaryMemoryBase when
+                                TemporaryMemoryBase > PermanentMemoryBase.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * TEMPORARY_RAM_MIGRATION)(
+  IN CONST EFI_PEI_SERVICES   **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,
+  IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,
+  IN UINTN                    CopySize
+);
+
+///
+/// This service abstracts the ability to migrate contents of the platform early memory store.
+/// Note: The name EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI is different from the current PI 1.2 spec.
+///       This PPI was optional.
+///
+typedef struct {
+  TEMPORARY_RAM_MIGRATION   TemporaryRamMigration;
+} EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI;
+
+extern EFI_GUID gEfiTemporaryRamSupportPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Ppi/VectorHandoffInfo.h b/MdePkg/Include/Ppi/VectorHandoffInfo.h
new file mode 100644
index 000000000000..fba0856bce0b
--- /dev/null
+++ b/MdePkg/Include/Ppi/VectorHandoffInfo.h
@@ -0,0 +1,75 @@
+/** @file
+  This file declares Vector Handoff Info PPI that describes an array of
+  interrupt and/or exception vectors that are in use and need to persist.
+
+  This is an optional PPI that may be produced by SEC. If present, it provides
+  a description of the interrupt and/or exception vectors that were established
+  in the SEC Phase and need to persist into PEI and DXE. 
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This PPI is introduced in PI Version 1.2.1.
+
+**/
+
+#ifndef __VECTOR_HANDOFF_INFO_H__
+#define __VECTOR_HANDOFF_INFO_H__
+
+///
+/// NOTE: EFI_PEI_VECTOR_HANDOFF_INFO_PPI_GUID can also be used in the PEI Phase
+/// to build a GUIDed HOB that contains an array of EFI_VECTOR_HANDOFF_INFO.
+///
+#define EFI_PEI_VECTOR_HANDOFF_INFO_PPI_GUID \
+  { 0x3cd652b4, 0x6d33, 0x4dce, { 0x89, 0xdb, 0x83, 0xdf, 0x97, 0x66, 0xfc, 0xca }}
+
+///
+/// Vector Handoff Info Attributes
+///@{
+#define EFI_VECTOR_HANDOFF_DO_NOT_HOOK 0x00000000
+#define EFI_VECTOR_HANDOFF_HOOK_BEFORE 0x00000001
+#define EFI_VECTOR_HANDOFF_HOOK_AFTER  0x00000002
+#define EFI_VECTOR_HANDOFF_LAST_ENTRY  0x80000000
+///@}
+
+///
+/// EFI_VECTOR_HANDOFF_INFO entries that describes the interrupt and/or
+/// exception vectors in use in the PEI Phase.
+///
+typedef struct {
+  //
+  // The interrupt or exception vector that is in use and must be preserved.
+  //
+  UINT32    VectorNumber;
+  //
+  // A bitmask that describes the attributes ofthe interrupt or exception vector.
+  //
+  UINT32    Attribute;
+  //
+  // The GUID identifies the party who created the entry. For the 
+  // EFI_VECTOR_HANDOFF_DO_NOT_HOOK case, this establishes the single owner.
+  //
+  EFI_GUID  Owner;
+} EFI_VECTOR_HANDOFF_INFO;
+
+///
+/// Provides a description of the interrupt and/or exception vectors that
+/// were established in the SEC Phase and need to persist into PEI and DXE.  
+///
+typedef struct _EFI_PEI_VECTOR_HANDOFF_INFO_PPI {
+  //
+  // Pointer to an array of interrupt and /or exception vectors.
+  //
+  EFI_VECTOR_HANDOFF_INFO  *Info;
+} EFI_PEI_VECTOR_HANDOFF_INFO_PPI;
+
+extern EFI_GUID gEfiVectorHandoffInfoPpiGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/AbsolutePointer.h b/MdePkg/Include/Protocol/AbsolutePointer.h
new file mode 100644
index 000000000000..42693ab20b65
--- /dev/null
+++ b/MdePkg/Include/Protocol/AbsolutePointer.h
@@ -0,0 +1,205 @@
+/** @file
+  The file provides services that allow information about an
+  absolute pointer device to be retrieved.
+  
+  Copyright (c) 2006 - 2012, 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 __ABSOLUTE_POINTER_H__
+#define __ABSOLUTE_POINTER_H__
+
+
+#define EFI_ABSOLUTE_POINTER_PROTOCOL_GUID \
+  { 0x8D59D32B, 0xC655, 0x4AE9, { 0x9B, 0x15, 0xF2, 0x59, 0x04, 0x99, 0x2A, 0x43 } }
+
+
+typedef struct _EFI_ABSOLUTE_POINTER_PROTOCOL EFI_ABSOLUTE_POINTER_PROTOCOL;
+
+
+//*******************************************************
+// EFI_ABSOLUTE_POINTER_MODE
+//*******************************************************
+
+
+/**
+  The following data values in the EFI_ABSOLUTE_POINTER_MODE
+  interface are read-only and are changed by using the appropriate
+  interface functions.
+**/
+typedef struct {
+  UINT64 AbsoluteMinX; ///< The Absolute Minimum of the device on the x-axis
+  UINT64 AbsoluteMinY; ///< The Absolute Minimum of the device on the y axis.
+  UINT64 AbsoluteMinZ; ///< The Absolute Minimum of the device on the z-axis
+  UINT64 AbsoluteMaxX; ///< The Absolute Maximum of the device on the x-axis. If 0, and the 
+                       ///< AbsoluteMinX is 0, then the pointer device does not support a xaxis
+  UINT64 AbsoluteMaxY; ///< The Absolute Maximum of the device on the y -axis. If 0, and the 
+                       ///< AbsoluteMinX is 0, then the pointer device does not support a yaxis.
+  UINT64 AbsoluteMaxZ; ///< The Absolute Maximum of the device on the z-axis. If 0 , and the 
+                       ///< AbsoluteMinX is 0, then the pointer device does not support a zaxis
+  UINT32 Attributes;   ///< The following bits are set as needed (or'd together) to indicate the 
+                       ///< capabilities of the device supported. The remaining bits are undefined 
+                       ///< and should be 0
+} EFI_ABSOLUTE_POINTER_MODE;
+
+///
+/// If set, indicates this device supports an alternate button input. 
+/// 
+#define EFI_ABSP_SupportsAltActive    0x00000001
+
+///
+/// If set, indicates this device returns pressure data in parameter CurrentZ.
+/// 
+#define EFI_ABSP_SupportsPressureAsZ  0x00000002
+
+
+/**
+  This function resets the pointer device hardware. As part of
+  initialization process, the firmware/device will make a quick
+  but reasonable attempt to verify that the device is
+  functioning. If the ExtendedVerification flag is TRUE the
+  firmware may take an extended amount of time to verify the
+  device is operating on reset. Otherwise the reset operation is
+  to occur as quickly as possible. The hardware verification
+  process is not defined by this specification and is left up to
+  the platform firmware or driver to implement.
+
+  @param This                 A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL
+                              instance.
+
+  @param ExtendedVerification Indicates that the driver may
+                              perform a more exhaustive
+                              verification operation of the
+                              device during reset.
+
+  @retval EFI_SUCCESS       The device was reset.
+  
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ABSOLUTE_POINTER_RESET)(
+  IN EFI_ABSOLUTE_POINTER_PROTOCOL *This,
+  IN BOOLEAN                       ExtendedVerification
+);
+
+///
+/// This bit is set if the touch sensor is active.
+///
+#define EFI_ABSP_TouchActive  0x00000001 
+
+///
+/// This bit is set if the alt sensor, such as pen-side button, is active
+/// 
+#define EFI_ABS_AltActive     0x00000002
+
+
+/**
+  Definition of EFI_ABSOLUTE_POINTER_STATE.
+**/
+typedef struct {
+  ///
+  /// The unsigned position of the activation on the x axis. If the AboluteMinX 
+  /// and the AboluteMaxX fields of the EFI_ABSOLUTE_POINTER_MODE structure are 
+  /// both 0, then this pointer device does not support an x-axis, and this field
+  /// must be ignored.
+  ///
+  UINT64 CurrentX;
+  
+  ///
+  /// The unsigned position of the activation on the y axis. If the AboluteMinY 
+  /// and the AboluteMaxY fields of the EFI_ABSOLUTE_POINTER_MODE structure are 
+  /// both 0, then this pointer device does not support an y-axis, and this field
+  /// must be ignored.  
+  ///
+  UINT64 CurrentY;
+  
+  ///
+  /// The unsigned position of the activation on the z axis, or the pressure 
+  /// measurement. If the AboluteMinZ and the AboluteMaxZ fields of the 
+  /// EFI_ABSOLUTE_POINTER_MODE structure are both 0, then this pointer device 
+  /// does not support an z-axis, and this field must be ignored.  
+  ///
+  UINT64 CurrentZ;
+  
+  ///
+  /// Bits are set to 1 in this structure item to indicate that device buttons are
+  /// active.
+  ///
+  UINT32 ActiveButtons;
+} EFI_ABSOLUTE_POINTER_STATE;
+
+/**
+  The GetState() function retrieves the current state of a pointer
+  device. This includes information on the active state associated
+  with the pointer device and the current position of the axes
+  associated with the pointer device. If the state of the pointer
+  device has not changed since the last call to GetState(), then
+  EFI_NOT_READY is returned. If the state of the pointer device
+  has changed since the last call to GetState(), then the state
+  information is placed in State, and EFI_SUCCESS is returned. If
+  a device error occurs while attempting to retrieve the state
+  information, then EFI_DEVICE_ERROR is returned.
+
+
+  @param This   A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL
+                instance.
+
+  @param State  A pointer to the state information on the
+                pointer device.
+
+  @retval EFI_SUCCESS       The state of the pointer device was
+                            returned in State.
+
+  @retval EFI_NOT_READY     The state of the pointer device has not
+                            changed since the last call to GetState().
+
+  @retval EFI_DEVICE_ERROR  A device error occurred while
+                            attempting to retrieve the pointer
+                            device's current state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ABSOLUTE_POINTER_GET_STATE)(
+  IN      EFI_ABSOLUTE_POINTER_PROTOCOL  *This,
+  IN OUT  EFI_ABSOLUTE_POINTER_STATE     *State
+);
+
+
+///
+/// The EFI_ABSOLUTE_POINTER_PROTOCOL provides a set of services
+/// for a pointer device that can be used as an input device from an
+/// application written to this specification. The services include
+/// the ability to: reset the pointer device, retrieve the state of
+/// the pointer device, and retrieve the capabilities of the pointer
+/// device. The service also provides certain data items describing the device.
+///
+struct _EFI_ABSOLUTE_POINTER_PROTOCOL {
+  EFI_ABSOLUTE_POINTER_RESET      Reset;
+  EFI_ABSOLUTE_POINTER_GET_STATE  GetState;
+  ///
+  /// Event to use with WaitForEvent() to wait for input from the pointer device.  
+  ///
+  EFI_EVENT                       WaitForInput;
+  ///
+  /// Pointer to EFI_ABSOLUTE_POINTER_MODE data.
+  ///
+  EFI_ABSOLUTE_POINTER_MODE       *Mode;
+};
+
+
+extern EFI_GUID gEfiAbsolutePointerProtocolGuid;
+
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/AcpiSystemDescriptionTable.h b/MdePkg/Include/Protocol/AcpiSystemDescriptionTable.h
new file mode 100644
index 000000000000..b98862f6d840
--- /dev/null
+++ b/MdePkg/Include/Protocol/AcpiSystemDescriptionTable.h
@@ -0,0 +1,266 @@
+/** @file
+  This protocol provides services for creating ACPI system description tables.
+  
+  Copyright (c) 2006 - 2015, 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 __ACPI_SYSTEM_DESCRIPTION_TABLE_H___
+#define __ACPI_SYSTEM_DESCRIPTION_TABLE_H___
+
+#define EFI_ACPI_SDT_PROTOCOL_GUID \
+  { 0xeb97088e, 0xcfdf, 0x49c6, { 0xbe, 0x4b, 0xd9, 0x6, 0xa5, 0xb2, 0xe, 0x86 }}
+  
+typedef UINT32  EFI_ACPI_TABLE_VERSION;
+typedef VOID    *EFI_ACPI_HANDLE;
+
+#define EFI_ACPI_TABLE_VERSION_NONE (1 << 0)
+#define EFI_ACPI_TABLE_VERSION_1_0B (1 << 1)
+#define EFI_ACPI_TABLE_VERSION_2_0  (1 << 2)
+#define EFI_ACPI_TABLE_VERSION_3_0  (1 << 3)
+#define EFI_ACPI_TABLE_VERSION_4_0  (1 << 4)
+#define EFI_ACPI_TABLE_VERSION_5_0  (1 << 5)
+  
+typedef UINT32 EFI_ACPI_DATA_TYPE;
+#define EFI_ACPI_DATA_TYPE_NONE         0
+#define EFI_ACPI_DATA_TYPE_OPCODE       1
+#define EFI_ACPI_DATA_TYPE_NAME_STRING  2
+#define EFI_ACPI_DATA_TYPE_OP           3
+#define EFI_ACPI_DATA_TYPE_UINT         4
+#define EFI_ACPI_DATA_TYPE_STRING       5
+#define EFI_ACPI_DATA_TYPE_CHILD        6
+  
+typedef struct {
+  UINT32    Signature;
+  UINT32    Length;
+  UINT8     Revision;
+  UINT8     Checksum;
+  CHAR8     OemId[6];
+  CHAR8     OemTableId[8];
+  UINT32    OemRevision;
+  UINT32    CreatorId;
+  UINT32    CreatorRevision;
+} EFI_ACPI_SDT_HEADER;
+  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_NOTIFICATION_FN)(
+  IN EFI_ACPI_SDT_HEADER    *Table,     ///< A pointer to the ACPI table header.
+  IN EFI_ACPI_TABLE_VERSION Version,    ///< The ACPI table's version.
+  IN UINTN                  TableKey    ///< The table key for this ACPI table.
+);
+  
+/**
+  Returns a requested ACPI table.
+  
+  The GetAcpiTable() function returns a pointer to a buffer containing the ACPI table associated
+  with the Index that was input. The following structures are not considered elements in the list of
+  ACPI tables:
+  - Root System Description Pointer (RSD_PTR)
+  - Root System Description Table (RSDT)
+  - Extended System Description Table (XSDT)
+  Version is updated with a bit map containing all the versions of ACPI of which the table is a
+  member. For tables installed via the EFI_ACPI_TABLE_PROTOCOL.InstallAcpiTable() interface,
+  the function returns the value of EFI_ACPI_STD_PROTOCOL.AcpiVersion.
+  
+  @param[in]    Index       The zero-based index of the table to retrieve.
+  @param[out]   Table       Pointer for returning the table buffer.
+  @param[out]   Version     On return, updated with the ACPI versions to which this table belongs. Type
+                            EFI_ACPI_TABLE_VERSION is defined in "Related Definitions" in the
+                            EFI_ACPI_SDT_PROTOCOL.    
+  @param[out]   TableKey    On return, points to the table key for the specified ACPI system definition table.
+                            This is identical to the table key used in the EFI_ACPI_TABLE_PROTOCOL.
+                            The TableKey can be passed to EFI_ACPI_TABLE_PROTOCOL.UninstallAcpiTable()
+                            to uninstall the table.
+
+  @retval EFI_SUCCESS       The function completed successfully.
+  @retval EFI_NOT_FOUND     The requested index is too large and a table was not found.                                  
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_GET_ACPI_TABLE2)(
+  IN    UINTN                   Index,
+  OUT   EFI_ACPI_SDT_HEADER     **Table,
+  OUT   EFI_ACPI_TABLE_VERSION  *Version,
+  OUT   UINTN                   *TableKey
+);
+
+/**
+  Register or unregister a callback when an ACPI table is installed.
+  
+  This function registers or unregisters a function which will be called whenever a new ACPI table is
+  installed.
+  
+  @param[in]    Register        If TRUE, then the specified function will be registered. If FALSE, then the specified
+                                function will be unregistered.
+  @param[in]    Notification    Points to the callback function to be registered or unregistered.
+  
+  @retval EFI_SUCCESS           Callback successfully registered or unregistered.
+  @retval EFI_INVALID_PARAMETER Notification is NULL
+  @retval EFI_INVALID_PARAMETER Register is FALSE and Notification does not match a known registration function.                        
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_REGISTER_NOTIFY)(
+  IN BOOLEAN                    Register,
+  IN EFI_ACPI_NOTIFICATION_FN   Notification
+);
+
+/**
+  Create a handle from an ACPI opcode
+  
+  @param[in]  Buffer                 Points to the ACPI opcode.
+  @param[out] Handle                 Upon return, holds the handle.
+  
+  @retval   EFI_SUCCESS             Success
+  @retval   EFI_INVALID_PARAMETER   Buffer is NULL or Handle is NULL or Buffer points to an
+                                    invalid opcode.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_OPEN)(
+  IN    VOID            *Buffer,
+  OUT   EFI_ACPI_HANDLE *Handle 
+);
+
+/**
+  Create a handle for the first ACPI opcode in an ACPI system description table.
+  
+  @param[in]    TableKey    The table key for the ACPI table, as returned by GetTable().
+  @param[out]   Handle      On return, points to the newly created ACPI handle.
+
+  @retval EFI_SUCCESS       Handle created successfully.
+  @retval EFI_NOT_FOUND     TableKey does not refer to a valid ACPI table.  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_OPEN_SDT)(
+  IN    UINTN           TableKey,
+  OUT   EFI_ACPI_HANDLE *Handle
+);
+
+/**
+  Close an ACPI handle.
+  
+  @param[in] Handle Returns the handle.
+  
+  @retval EFI_SUCCESS           Success
+  @retval EFI_INVALID_PARAMETER Handle is NULL or does not refer to a valid ACPI object.  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_CLOSE)(
+  IN EFI_ACPI_HANDLE Handle
+);
+
+/**
+  Return the child ACPI objects.
+  
+  @param[in]        ParentHandle    Parent handle.
+  @param[in, out]   Handle          On entry, points to the previously returned handle or NULL to start with the first
+                                    handle. On return, points to the next returned ACPI handle or NULL if there are no
+                                    child objects.
+
+  @retval EFI_SUCCESS               Success
+  @retval EFI_INVALID_PARAMETER     ParentHandle is NULL or does not refer to a valid ACPI object.                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_GET_CHILD)(
+  IN EFI_ACPI_HANDLE        ParentHandle,
+  IN OUT EFI_ACPI_HANDLE    *Handle
+);
+
+/**
+  Retrieve information about an ACPI object.
+  
+  @param[in]    Handle      ACPI object handle.
+  @param[in]    Index       Index of the data to retrieve from the object. In general, indexes read from left-to-right
+                            in the ACPI encoding, with index 0 always being the ACPI opcode.
+  @param[out]   DataType    Points to the returned data type or EFI_ACPI_DATA_TYPE_NONE if no data exists
+                            for the specified index.
+  @param[out]   Data        Upon return, points to the pointer to the data.
+  @param[out]   DataSize    Upon return, points to the size of Data.
+  
+  @retval              
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_GET_OPTION)(
+  IN        EFI_ACPI_HANDLE     Handle,
+  IN        UINTN               Index,
+  OUT       EFI_ACPI_DATA_TYPE  *DataType,
+  OUT CONST VOID                **Data,
+  OUT       UINTN               *DataSize
+);
+
+/**
+  Change information about an ACPI object.
+  
+  @param[in]  Handle    ACPI object handle.
+  @param[in]  Index     Index of the data to retrieve from the object. In general, indexes read from left-to-right
+                        in the ACPI encoding, with index 0 always being the ACPI opcode.
+  @param[in]  Data      Points to the data.
+  @param[in]  DataSize  The size of the Data.
+
+  @retval EFI_SUCCESS           Success
+  @retval EFI_INVALID_PARAMETER Handle is NULL or does not refer to a valid ACPI object.
+  @retval EFI_BAD_BUFFER_SIZE   Data cannot be accommodated in the space occupied by
+                                the option.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_SET_OPTION)(
+  IN        EFI_ACPI_HANDLE Handle,
+  IN        UINTN           Index,
+  IN CONST  VOID            *Data,
+  IN        UINTN           DataSize
+);
+
+/**
+  Returns the handle of the ACPI object representing the specified ACPI path
+  
+  @param[in]    HandleIn    Points to the handle of the object representing the starting point for the path search.
+  @param[in]    AcpiPath    Points to the ACPI path, which conforms to the ACPI encoded path format.
+  @param[out]   HandleOut   On return, points to the ACPI object which represents AcpiPath, relative to
+                            HandleIn.
+                            
+  @retval EFI_SUCCESS           Success
+  @retval EFI_INVALID_PARAMETER HandleIn is NULL or does not refer to a valid ACPI object.                            
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_FIND_PATH)(
+  IN    EFI_ACPI_HANDLE HandleIn,
+  IN    VOID            *AcpiPath,
+  OUT   EFI_ACPI_HANDLE *HandleOut
+);
+
+typedef struct _EFI_ACPI_SDT_PROTOCOL {
+  ///
+  /// A bit map containing all the ACPI versions supported by this protocol.
+  ///
+  EFI_ACPI_TABLE_VERSION    AcpiVersion;
+  EFI_ACPI_GET_ACPI_TABLE2  GetAcpiTable;
+  EFI_ACPI_REGISTER_NOTIFY  RegisterNotify;
+  EFI_ACPI_OPEN             Open;
+  EFI_ACPI_OPEN_SDT         OpenSdt;
+  EFI_ACPI_CLOSE            Close;
+  EFI_ACPI_GET_CHILD        GetChild;
+  EFI_ACPI_GET_OPTION       GetOption;
+  EFI_ACPI_SET_OPTION       SetOption;
+  EFI_ACPI_FIND_PATH        FindPath;
+} EFI_ACPI_SDT_PROTOCOL;
+
+extern EFI_GUID gEfiAcpiSdtProtocolGuid;
+
+#endif // __ACPI_SYSTEM_DESCRIPTION_TABLE_H___
diff --git a/MdePkg/Include/Protocol/AcpiTable.h b/MdePkg/Include/Protocol/AcpiTable.h
new file mode 100644
index 000000000000..c6081823268b
--- /dev/null
+++ b/MdePkg/Include/Protocol/AcpiTable.h
@@ -0,0 +1,127 @@
+/** @file
+  The file provides the protocol to install or remove an ACPI
+  table from a platform. 
+  
+  Copyright (c) 2006 - 2014, 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 __ACPI_TABLE_H___
+#define __ACPI_TABLE_H___
+
+#define EFI_ACPI_TABLE_PROTOCOL_GUID \
+  { 0xffe06bdd, 0x6107, 0x46a6, { 0x7b, 0xb2, 0x5a, 0x9c, 0x7e, 0xc5, 0x27, 0x5c }}
+
+
+typedef struct _EFI_ACPI_TABLE_PROTOCOL EFI_ACPI_TABLE_PROTOCOL;
+
+/**
+
+  The InstallAcpiTable() function allows a caller to install an   
+  ACPI table. When successful, the table will be linked by the   
+  RSDT/XSDT. AcpiTableBuffer specifies the table to be installed.   
+  InstallAcpiTable() will make a copy of the table and insert the   
+  copy into the RSDT/XSDT. InstallAcpiTable() must insert the new   
+  table at the end of the RSDT/XSDT. To prevent namespace   
+  collision, ACPI tables may be created using UEFI ACPI table   
+  format. If this protocol is used to install a table with a
+  signature already present in the system, the new table will not
+  replace the existing table. It is a platform implementation
+  decision to add a new table with a signature matching an
+  existing table or disallow duplicate table signatures and
+  return EFI_ACCESS_DENIED. On successful output, TableKey is   
+  initialized with a unique key. Its value may be used in a   
+  subsequent call to UninstallAcpiTable to remove an ACPI table.   
+  If an EFI application is running at the time of this call, the   
+  relevant EFI_CONFIGURATION_TABLE pointer to the RSDT is no   
+  longer considered valid.   
+
+
+  @param This                 A pointer to a EFI_ACPI_TABLE_PROTOCOL.
+
+  @param AcpiTableBuffer      A pointer to a buffer containing the
+                              ACPI table to be installed.
+
+  @param AcpiTableBufferSize  Specifies the size, in bytes, of
+                              the AcpiTableBuffer buffer.
+
+
+  @param TableKey             Returns a key to refer to the ACPI table.
+  
+  @retval EFI_SUCCESS           The table was successfully inserted
+  
+  @retval EFI_INVALID_PARAMETER Either AcpiTableBuffer is NULL,
+                                TableKey is NULL, or
+                                AcpiTableBufferSize and the size
+                                field embedded in the ACPI table
+                                pointed to by AcpiTableBuffer
+                                are not in sync.
+  
+  @retval EFI_OUT_OF_RESOURCES  Insufficient resources exist to
+                                complete the request.
+  @retval EFI_ACCESS_DENIED     The table signature matches a table already
+                                present in the system and platform policy
+                                does not allow duplicate tables of this type.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_TABLE_INSTALL_ACPI_TABLE)(
+  IN   EFI_ACPI_TABLE_PROTOCOL       *This,
+  IN   VOID                          *AcpiTableBuffer,
+  IN   UINTN                         AcpiTableBufferSize,
+  OUT  UINTN                         *TableKey
+);
+
+
+/**
+  
+  The UninstallAcpiTable() function allows a caller to remove an
+  ACPI table. The routine will remove its reference from the
+  RSDT/XSDT. A table is referenced by the TableKey parameter
+  returned from a prior call to InstallAcpiTable(). If an EFI
+  application is running at the time of this call, the relevant
+  EFI_CONFIGURATION_TABLE pointer to the RSDT is no longer
+  considered valid.
+
+  @param This                   A pointer to a EFI_ACPI_TABLE_PROTOCOL.
+
+  @param TableKey               Specifies the table to uninstall. The key was
+                                returned from InstallAcpiTable().
+
+  @retval EFI_SUCCESS           The table was successfully inserted
+
+  @retval EFI_NOT_FOUND         TableKey does not refer to a valid key
+                                for a table entry.
+
+  @retval EFI_OUT_OF_RESOURCES  Insufficient resources exist to
+                                complete the request.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ACPI_TABLE_UNINSTALL_ACPI_TABLE)(
+  IN  EFI_ACPI_TABLE_PROTOCOL       *This,
+  IN  UINTN                         TableKey
+);
+
+///
+/// The EFI_ACPI_TABLE_PROTOCOL provides the ability for a component
+/// to install and uninstall ACPI tables from a platform.
+///
+struct _EFI_ACPI_TABLE_PROTOCOL {
+  EFI_ACPI_TABLE_INSTALL_ACPI_TABLE   InstallAcpiTable;
+  EFI_ACPI_TABLE_UNINSTALL_ACPI_TABLE UninstallAcpiTable;
+};
+
+extern EFI_GUID gEfiAcpiTableProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/AdapterInformation.h b/MdePkg/Include/Protocol/AdapterInformation.h
new file mode 100644
index 000000000000..92fd11d7706c
--- /dev/null
+++ b/MdePkg/Include/Protocol/AdapterInformation.h
@@ -0,0 +1,241 @@
+/** @file
+  EFI Adapter Information Protocol definition.
+  The EFI Adapter Information Protocol is used to dynamically and quickly discover
+  or set device information for an adapter.
+
+  Copyright (c) 2014 - 2015, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.4
+
+**/
+
+#ifndef __EFI_ADAPTER_INFORMATION_PROTOCOL_H__
+#define __EFI_ADAPTER_INFORMATION_PROTOCOL_H__
+
+
+#define EFI_ADAPTER_INFORMATION_PROTOCOL_GUID \
+  { \
+    0xE5DD1403, 0xD622, 0xC24E, {0x84, 0x88, 0xC7, 0x1B, 0x17, 0xF5, 0xE8, 0x02 } \
+  }
+
+#define EFI_ADAPTER_INFO_MEDIA_STATE_GUID \
+  { \
+    0xD7C74207, 0xA831, 0x4A26, {0xB1, 0xF5, 0xD1, 0x93, 0x06, 0x5C, 0xE8, 0xB6 } \
+  }
+
+#define EFI_ADAPTER_INFO_NETWORK_BOOT_GUID \
+  { \
+    0x1FBD2960, 0x4130, 0x41E5, {0x94, 0xAC, 0xD2, 0xCF, 0x03, 0x7F, 0xB3, 0x7C } \
+  }
+
+#define EFI_ADAPTER_INFO_SAN_MAC_ADDRESS_GUID \
+  { \
+    0x114da5ef, 0x2cf1, 0x4e12, {0x9b, 0xbb, 0xc4, 0x70, 0xb5, 0x52, 0x5, 0xd9 } \
+  }
+
+#define EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT_GUID \
+  { \
+    0x4bd56be3, 0x4975, 0x4d8a, {0xa0, 0xad, 0xc4, 0x91, 0x20, 0x4b, 0x5d, 0x4d} \
+  }
+
+typedef struct _EFI_ADAPTER_INFORMATION_PROTOCOL EFI_ADAPTER_INFORMATION_PROTOCOL;
+
+///
+/// EFI_ADAPTER_INFO_MEDIA_STATE
+///
+typedef struct {
+  ///
+  /// Returns the current media state status. MediaState can have any of the following values: 
+  /// EFI_SUCCESS: There is media attached to the network adapter. EFI_NOT_READY: This detects a bounced state. 
+  /// There was media attached to the network adapter, but it was removed and reattached. EFI_NO_MEDIA: There is 
+  /// not any media attached to the network.
+  ///
+  EFI_STATUS                    MediaState;
+} EFI_ADAPTER_INFO_MEDIA_STATE;
+
+///
+/// EFI_ADAPTER_INFO_NETWORK_BOOT
+///
+typedef struct {
+  ///
+  /// TRUE if the adapter supports booting from iSCSI IPv4 targets.
+  ///
+  BOOLEAN                       iScsiIpv4BootCapablity;
+  ///
+  /// TRUE if the adapter supports booting from iSCSI IPv6 targets.
+  ///
+  BOOLEAN                       iScsiIpv6BootCapablity;
+  ///
+  /// TRUE if the adapter supports booting from FCoE targets.
+  ///
+  BOOLEAN                       FCoeBootCapablity;
+  ///
+  /// TRUE if the adapter supports an offload engine (such as TCP
+  /// Offload Engine (TOE)) for its iSCSI or FCoE boot operations.
+  ///
+  BOOLEAN                       OffloadCapability;
+  ///
+  /// TRUE if the adapter supports multipath I/O (MPIO) for its iSCSI
+  /// boot operations.
+  ///
+  BOOLEAN                       iScsiMpioCapability;
+  ///
+  /// TRUE if the adapter is currently configured to boot from iSCSI
+  /// IPv4 targets.
+  ///
+  BOOLEAN                       iScsiIpv4Boot;
+  ///
+  /// TRUE if the adapter is currently configured to boot from iSCSI
+  /// IPv6 targets.
+  ///
+  BOOLEAN                       iScsiIpv6Boot;
+  ///
+  /// TRUE if the adapter is currently configured to boot from FCoE targets.
+  ///
+  BOOLEAN                       FCoeBoot;
+} EFI_ADAPTER_INFO_NETWORK_BOOT;
+
+///
+/// EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
+///
+typedef struct {
+  ///
+  /// Returns the SAN MAC address for the adapter.For adapters that support today's 802.3 ethernet
+  /// networking and Fibre-Channel Over Ethernet (FCOE), this conveys the FCOE SAN MAC address from the adapter.
+  ///
+  EFI_MAC_ADDRESS                    SanMacAddress;
+} EFI_ADAPTER_INFO_SAN_MAC_ADDRESS;
+
+///
+/// EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT
+///
+typedef struct {
+  ///
+  /// Returns capability of UNDI to support IPv6 traffic.
+  ///
+  BOOLEAN                            Ipv6Support; 
+} EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT;
+
+/**
+  Returns the current state information for the adapter.
+
+  This function returns information of type InformationType from the adapter.
+  If an adapter does not support the requested informational type, then
+  EFI_UNSUPPORTED is returned. 
+
+  @param[in]  This                   A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[in]  InformationType        A pointer to an EFI_GUID that defines the contents of InformationBlock.
+  @param[out] InforamtionBlock       The service returns a pointer to the buffer with the InformationBlock
+                                     structure which contains details about the data specific to InformationType.
+  @param[out] InforamtionBlockSize   The driver returns the size of the InformationBlock in bytes.
+
+  @retval EFI_SUCCESS                The InformationType information was retrieved.
+  @retval EFI_UNSUPPORTED            The InformationType is not known.
+  @retval EFI_DEVICE_ERROR           The device reported an error.
+  @retval EFI_OUT_OF_RESOURCES       The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER      This is NULL. 
+  @retval EFI_INVALID_PARAMETER      InformationBlock is NULL. 
+  @retval EFI_INVALID_PARAMETER      InformationBlockSize is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ADAPTER_INFO_GET_INFO)(
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  IN  EFI_GUID                          *InformationType,
+  OUT VOID                              **InformationBlock,
+  OUT UINTN                             *InformationBlockSize
+  );
+
+/**
+  Sets state information for an adapter.
+
+  This function sends information of type InformationType for an adapter.
+  If an adapter does not support the requested information type, then EFI_UNSUPPORTED
+  is returned.
+
+  @param[in]  This                   A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[in]  InformationType        A pointer to an EFI_GUID that defines the contents of InformationBlock.
+  @param[in]  InforamtionBlock       A pointer to the InformationBlock structure which contains details
+                                     about the data specific to InformationType.
+  @param[in]  InforamtionBlockSize   The size of the InformationBlock in bytes.
+
+  @retval EFI_SUCCESS                The information was received and interpreted successfully.
+  @retval EFI_UNSUPPORTED            The InformationType is not known.
+  @retval EFI_DEVICE_ERROR           The device reported an error.
+  @retval EFI_INVALID_PARAMETER      This is NULL.
+  @retval EFI_INVALID_PARAMETER      InformationBlock is NULL.
+  @retval EFI_WRITE_PROTECTED        The InformationType cannot be modified using EFI_ADAPTER_INFO_SET_INFO().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ADAPTER_INFO_SET_INFO)(
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  IN  EFI_GUID                          *InformationType,
+  IN  VOID                              *InformationBlock,
+  IN  UINTN                             InformationBlockSize
+  );
+
+/**
+  Get a list of supported information types for this instance of the protocol.
+
+  This function returns a list of InformationType GUIDs that are supported on an
+  adapter with this instance of EFI_ADAPTER_INFORMATION_PROTOCOL. The list is returned
+  in InfoTypesBuffer, and the number of GUID pointers in InfoTypesBuffer is returned in
+  InfoTypesBufferCount.
+
+  @param[in]  This                  A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[out] InfoTypesBuffer       A pointer to the array of InformationType GUIDs that are supported
+                                    by This.
+  @param[out] InfoTypesBufferCount  A pointer to the number of GUIDs present in InfoTypesBuffer.
+
+  @retval EFI_SUCCESS               The list of information type GUIDs that are supported on this adapter was
+                                    returned in InfoTypesBuffer. The number of information type GUIDs was
+                                    returned in InfoTypesBufferCount.
+  @retval EFI_INVALID_PARAMETER     This is NULL.
+  @retval EFI_INVALID_PARAMETER     InfoTypesBuffer is NULL.
+  @retval EFI_INVALID_PARAMETER     InfoTypesBufferCount is NULL.
+  @retval EFI_OUT_OF_RESOURCES      There is not enough pool memory to store the results.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ADAPTER_INFO_GET_SUPPORTED_TYPES)(
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  OUT EFI_GUID                          **InfoTypesBuffer,
+  OUT UINTN                             *InfoTypesBufferCount
+  );
+
+///
+/// EFI_ADAPTER_INFORMATION_PROTOCOL
+/// The protocol for adapter provides the following services.
+/// - Gets device state information from adapter.
+/// - Sets device information for adapter.
+/// - Gets a list of supported information types for this instance of the protocol.
+///
+struct _EFI_ADAPTER_INFORMATION_PROTOCOL {
+  EFI_ADAPTER_INFO_GET_INFO              GetInformation;
+  EFI_ADAPTER_INFO_SET_INFO              SetInformation;
+  EFI_ADAPTER_INFO_GET_SUPPORTED_TYPES   GetSupportedTypes;
+};
+
+extern EFI_GUID gEfiAdapterInformationProtocolGuid;
+
+extern EFI_GUID gEfiAdapterInfoMediaStateGuid;
+
+extern EFI_GUID gEfiAdapterInfoNetworkBootGuid;
+
+extern EFI_GUID gEfiAdapterInfoSanMacAddressGuid;
+
+extern EFI_GUID gEfiAdapterInfoUndiIpv6SupportGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Arp.h b/MdePkg/Include/Protocol/Arp.h
new file mode 100644
index 000000000000..0295cc644ddc
--- /dev/null
+++ b/MdePkg/Include/Protocol/Arp.h
@@ -0,0 +1,385 @@
+/** @file  
+  EFI ARP Protocol Definition
+  
+  The EFI ARP Service Binding Protocol is used to locate EFI
+  ARP Protocol drivers to create and destroy child of the
+  driver to communicate with other host using ARP protocol.
+  The EFI ARP Protocol provides services to map IP network
+  address to hardware address used by a data link protocol.
+  
+Copyright (c) 2006 - 2010, 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.             
+
+  @par Revision Reference:          
+  This Protocol was introduced in UEFI Specification 2.0.
+
+**/
+
+#ifndef __EFI_ARP_PROTOCOL_H__
+#define __EFI_ARP_PROTOCOL_H__
+
+#define EFI_ARP_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xf44c00ee, 0x1f2c, 0x4a00, {0xaa, 0x9, 0x1c, 0x9f, 0x3e, 0x8, 0x0, 0xa3 } \
+  }
+
+#define EFI_ARP_PROTOCOL_GUID \
+  { \
+    0xf4b427bb, 0xba21, 0x4f16, {0xbc, 0x4e, 0x43, 0xe4, 0x16, 0xab, 0x61, 0x9c } \
+  }
+
+typedef struct _EFI_ARP_PROTOCOL EFI_ARP_PROTOCOL;
+
+typedef struct {
+  ///
+  /// Length in bytes of this entry.
+  ///
+  UINT32                      Size;
+
+  ///
+  /// Set to TRUE if this entry is a "deny" entry.
+  /// Set to FALSE if this entry is a "normal" entry.
+  ///
+  BOOLEAN                     DenyFlag;
+
+  ///
+  /// Set to TRUE if this entry will not time out.
+  /// Set to FALSE if this entry will time out.
+  ///
+  BOOLEAN                     StaticFlag;
+
+  ///
+  /// 16-bit ARP hardware identifier number.
+  ///
+  UINT16                      HwAddressType;
+
+  ///
+  /// 16-bit protocol type number.
+  ///
+  UINT16                      SwAddressType;
+
+  ///
+  /// The length of the hardware address.
+  ///
+  UINT8                       HwAddressLength;
+
+  ///
+  /// The length of the protocol address.
+  ///
+  UINT8                       SwAddressLength;
+} EFI_ARP_FIND_DATA;
+
+typedef struct {
+  ///
+  /// 16-bit protocol type number in host byte order.
+  ///
+  UINT16                    SwAddressType;
+
+  ///
+  /// The length in bytes of the station's protocol address to register.
+  ///
+  UINT8                     SwAddressLength;
+
+  ///
+  /// The pointer to the first byte of the protocol address to register. For
+  /// example, if SwAddressType is 0x0800 (IP), then
+  /// StationAddress points to the first byte of this station's IP
+  /// address stored in network byte order.
+  ///
+  VOID                      *StationAddress;
+
+  ///
+  /// The timeout value in 100-ns units that is associated with each
+  /// new dynamic ARP cache entry. If it is set to zero, the value is
+  /// implementation-specific.
+  ///
+  UINT32                    EntryTimeOut;
+
+  ///
+  /// The number of retries before a MAC address is resolved. If it is
+  /// set to zero, the value is implementation-specific.
+  ///
+  UINT32                    RetryCount;
+
+  ///
+  /// The timeout value in 100-ns units that is used to wait for the ARP
+  /// reply packet or the timeout value between two retries. Set to zero
+  /// to use implementation-specific value.
+  ///
+  UINT32                    RetryTimeOut;
+} EFI_ARP_CONFIG_DATA;
+
+
+/**
+  This function is used to assign a station address to the ARP cache for this instance
+  of the ARP driver.
+  
+  Each ARP instance has one station address. The EFI_ARP_PROTOCOL driver will 
+  respond to ARP requests that match this registered station address. A call to 
+  this function with the ConfigData field set to NULL will reset this ARP instance.
+  
+  Once a protocol type and station address have been assigned to this ARP instance, 
+  all the following ARP functions will use this information. Attempting to change 
+  the protocol type or station address to a configured ARP instance will result in errors.
+
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+  @param  ConfigData             The pointer to the EFI_ARP_CONFIG_DATA structure.
+
+  @retval EFI_SUCCESS            The new station address was successfully
+                                 registered.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 * This is NULL. 
+                                 * SwAddressLength is zero when ConfigData is not NULL. 
+                                 * StationAddress is NULL when ConfigData is not NULL.
+  @retval EFI_ACCESS_DENIED      The SwAddressType, SwAddressLength, or
+                                 StationAddress is different from the one that is
+                                 already registered.
+  @retval EFI_OUT_OF_RESOURCES   Storage for the new StationAddress could not be
+                                 allocated.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_ARP_CONFIGURE)(
+  IN EFI_ARP_PROTOCOL       *This,
+  IN EFI_ARP_CONFIG_DATA    *ConfigData   OPTIONAL
+  );  
+
+/**
+  This function is used to insert entries into the ARP cache.
+
+  ARP cache entries are typically inserted and updated by network protocol drivers 
+  as network traffic is processed. Most ARP cache entries will time out and be 
+  deleted if the network traffic stops. ARP cache entries that were inserted 
+  by the Add() function may be static (will not time out) or dynamic (will time out).
+  Default ARP cache timeout values are not covered in most network protocol 
+  specifications (although RFC 1122 comes pretty close) and will only be 
+  discussed in general terms in this specification. The timeout values that are 
+  used in the EFI Sample Implementation should be used only as a guideline. 
+  Final product implementations of the EFI network stack should be tuned for 
+  their expected network environments.
+  
+  @param  This                   Pointer to the EFI_ARP_PROTOCOL instance.
+  @param  DenyFlag               Set to TRUE if this entry is a deny entry. Set to
+                                 FALSE if this  entry is a normal entry.
+  @param  TargetSwAddress        Pointer to a protocol address to add (or deny).
+                                 May be set to NULL if DenyFlag is TRUE.
+  @param  TargetHwAddress        Pointer to a hardware address to add (or deny).
+                                 May be set to NULL if DenyFlag is TRUE.
+  @param  TimeoutValue           Time in 100-ns units that this entry will remain
+                                 in the ARP cache. A value of zero means that the
+                                 entry is permanent. A nonzero value will override
+                                 the one given by Configure() if the entry to be
+                                 added is a dynamic entry.
+  @param  Overwrite              If TRUE, the matching cache entry will be
+                                 overwritten with the supplied parameters. If
+                                 FALSE, EFI_ACCESS_DENIED is returned if the
+                                 corresponding cache entry already exists.
+
+  @retval EFI_SUCCESS            The entry has been added or updated.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 * This is NULL. 
+                                 * DenyFlag is FALSE and TargetHwAddress is NULL. 
+                                 * DenyFlag is FALSE and TargetSwAddress is NULL. 
+                                 * TargetHwAddress is NULL and TargetSwAddress is NULL. 
+                                 * Neither TargetSwAddress nor TargetHwAddress are NULL when DenyFlag is
+                                 TRUE.
+  @retval EFI_OUT_OF_RESOURCES   The new ARP cache entry could not be allocated.
+  @retval EFI_ACCESS_DENIED      The ARP cache entry already exists and Overwrite
+                                 is not true.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ARP_ADD)(
+  IN EFI_ARP_PROTOCOL       *This,
+  IN BOOLEAN                DenyFlag,
+  IN VOID                   *TargetSwAddress  OPTIONAL,
+  IN VOID                   *TargetHwAddress  OPTIONAL,
+  IN UINT32                 TimeoutValue,
+  IN BOOLEAN                Overwrite
+  );  
+
+/**
+  This function searches the ARP cache for matching entries and allocates a buffer into
+  which those entries are copied.
+  
+  The first part of the allocated buffer is EFI_ARP_FIND_DATA, following which 
+  are protocol address pairs and hardware address pairs.
+  When finding a specific protocol address (BySwAddress is TRUE and AddressBuffer 
+  is not NULL), the ARP cache timeout for the found entry is reset if Refresh is 
+  set to TRUE. If the found ARP cache entry is a permanent entry, it is not 
+  affected by Refresh.
+  
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+  @param  BySwAddress            Set to TRUE to look for matching software protocol
+                                 addresses. Set to FALSE to look for matching
+                                 hardware protocol addresses.
+  @param  AddressBuffer          The pointer to the address buffer. Set to NULL 
+                                 to match all addresses.
+  @param  EntryLength            The size of an entry in the entries buffer.
+  @param  EntryCount             The number of ARP cache entries that are found by
+                                 the specified criteria.
+  @param  Entries                The pointer to the buffer that will receive the ARP
+                                 cache entries.
+  @param  Refresh                Set to TRUE to refresh the timeout value of the
+                                 matching ARP cache entry.
+
+  @retval EFI_SUCCESS            The requested ARP cache entries were copied into
+                                 the buffer.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 This is NULL. Both EntryCount and EntryLength are
+                                 NULL, when Refresh is FALSE.
+  @retval EFI_NOT_FOUND          No matching entries were found.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_ARP_FIND)(
+  IN EFI_ARP_PROTOCOL       *This,
+  IN BOOLEAN                BySwAddress,
+  IN VOID                   *AddressBuffer    OPTIONAL,
+  OUT UINT32                *EntryLength      OPTIONAL,
+  OUT UINT32                *EntryCount       OPTIONAL,
+  OUT EFI_ARP_FIND_DATA     **Entries         OPTIONAL,
+  IN BOOLEAN                Refresh
+  );  
+
+
+/**
+  This function removes specified ARP cache entries.
+
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+  @param  BySwAddress            Set to TRUE to delete matching protocol addresses.
+                                 Set to FALSE to delete matching hardware
+                                 addresses.
+  @param  AddressBuffer          The pointer to the address buffer that is used as a
+                                 key to look for the cache entry. Set to NULL to
+                                 delete all entries.
+
+  @retval EFI_SUCCESS            The entry was removed from the ARP cache.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_FOUND          The specified deletion key was not found.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ARP_DELETE)(
+  IN EFI_ARP_PROTOCOL       *This,
+  IN BOOLEAN                BySwAddress,
+  IN VOID                   *AddressBuffer   OPTIONAL
+  );  
+
+/**
+  This function delete all dynamic entries from the ARP cache that match the specified
+  software protocol type.
+
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+
+  @retval EFI_SUCCESS            The cache has been flushed.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_FOUND          There are no matching dynamic cache entries.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ARP_FLUSH)(
+  IN EFI_ARP_PROTOCOL       *This
+  );  
+
+/**
+  This function tries to resolve the TargetSwAddress and optionally returns a
+  TargetHwAddress if it already exists in the ARP cache.
+
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+  @param  TargetSwAddress        The pointer to the protocol address to resolve.
+  @param  ResolvedEvent          The pointer to the event that will be signaled when
+                                 the address is resolved or some error occurs.
+  @param  TargetHwAddress        The pointer to the buffer for the resolved hardware
+                                 address in network byte order.
+
+  @retval EFI_SUCCESS            The data is copied from the ARP cache into the
+                                 TargetHwAddress buffer.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 This is NULL. TargetHwAddress is NULL.
+  @retval EFI_ACCESS_DENIED      The requested address is not present in the normal
+                                 ARP cache but is present in the deny address list.
+                                 Outgoing traffic to that address is forbidden.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+  @retval EFI_NOT_READY          The request has been started and is not finished.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ARP_REQUEST)(
+  IN EFI_ARP_PROTOCOL       *This, 
+  IN VOID                   *TargetSwAddress  OPTIONAL,
+  IN EFI_EVENT              ResolvedEvent     OPTIONAL,
+  OUT VOID                  *TargetHwAddress  
+  );  
+
+/**
+  This function aborts the previous ARP request (identified by This, TargetSwAddress
+  and ResolvedEvent) that is issued by EFI_ARP_PROTOCOL.Request().
+  
+  If the request is in the internal ARP request queue, the request is aborted 
+  immediately and its ResolvedEvent is signaled. Only an asynchronous address 
+  request needs to be canceled. If TargeSwAddress and ResolveEvent are both 
+  NULL, all the pending asynchronous requests that have been issued by This 
+  instance will be cancelled and their corresponding events will be signaled.
+  
+  @param  This                   The pointer to the EFI_ARP_PROTOCOL instance.
+  @param  TargetSwAddress        The pointer to the protocol address in previous
+                                 request session.
+  @param  ResolvedEvent          Pointer to the event that is used as the
+                                 notification event in previous request session.
+
+  @retval EFI_SUCCESS            The pending request session(s) is/are aborted and
+                                 corresponding event(s) is/are signaled.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 This is NULL. TargetSwAddress is not NULL and
+                                 ResolvedEvent is NULL. TargetSwAddress is NULL and
+                                 ResolvedEvent is not NULL.
+  @retval EFI_NOT_STARTED        The ARP driver instance has not been configured.
+  @retval EFI_NOT_FOUND          The request is not issued by
+                                 EFI_ARP_PROTOCOL.Request().
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ARP_CANCEL)(
+  IN EFI_ARP_PROTOCOL       *This, 
+  IN VOID                   *TargetSwAddress  OPTIONAL,
+  IN EFI_EVENT              ResolvedEvent     OPTIONAL
+  );  
+
+///
+/// ARP is used to resolve local network protocol addresses into 
+/// network hardware addresses.
+///
+struct _EFI_ARP_PROTOCOL {
+  EFI_ARP_CONFIGURE         Configure;
+  EFI_ARP_ADD               Add;
+  EFI_ARP_FIND              Find;
+  EFI_ARP_DELETE            Delete;
+  EFI_ARP_FLUSH             Flush;
+  EFI_ARP_REQUEST           Request;
+  EFI_ARP_CANCEL            Cancel;
+};
+
+
+extern EFI_GUID gEfiArpServiceBindingProtocolGuid;
+extern EFI_GUID gEfiArpProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/AtaPassThru.h b/MdePkg/Include/Protocol/AtaPassThru.h
new file mode 100644
index 000000000000..1cc596f9e424
--- /dev/null
+++ b/MdePkg/Include/Protocol/AtaPassThru.h
@@ -0,0 +1,471 @@
+/** @file
+  The EFI_ATA_PASS_THRU_PROTOCOL provides information about an ATA controller and the ability
+  to send ATA Command Blocks to any ATA device attached to that ATA controller. The information
+  includes the attributes of the ATA controller.
+
+  Copyright (c) 2009 - 2016, 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 __ATA_PASS_THROUGH_H__
+#define __ATA_PASS_THROUGH_H__
+
+#define EFI_ATA_PASS_THRU_PROTOCOL_GUID \
+  { \
+    0x1d3de7f0, 0x807, 0x424f, {0xaa, 0x69, 0x11, 0xa5, 0x4e, 0x19, 0xa4, 0x6f } \
+  }
+
+typedef struct _EFI_ATA_PASS_THRU_PROTOCOL EFI_ATA_PASS_THRU_PROTOCOL;
+
+typedef struct {
+  UINT32 Attributes;
+  UINT32 IoAlign;
+} EFI_ATA_PASS_THRU_MODE;
+
+///
+/// If this bit is set, then the EFI_ATA_PASS_THRU_PROTOCOL interface is for physical
+/// devices on the ATA controller.
+///
+#define EFI_ATA_PASS_THRU_ATTRIBUTES_PHYSICAL   0x0001
+///
+/// If this bit is set, then the EFI_ATA_PASS_THRU_PROTOCOL interface is for logical
+/// devices on the ATA controller.
+///
+#define EFI_ATA_PASS_THRU_ATTRIBUTES_LOGICAL    0x0002
+///
+/// If this bit is set, then the EFI_ATA_PASS_THRU_PROTOCOL interface supports non blocking
+/// I/O. Every EFI_ATA_PASS_THRU_PROTOCOL must support blocking I/O. The support of non-blocking
+/// I/O is optional.
+///
+#define EFI_ATA_PASS_THRU_ATTRIBUTES_NONBLOCKIO 0x0004
+
+typedef struct _EFI_ATA_COMMAND_BLOCK {
+  UINT8 Reserved1[2];
+  UINT8 AtaCommand;
+  UINT8 AtaFeatures;
+  UINT8 AtaSectorNumber;
+  UINT8 AtaCylinderLow;
+  UINT8 AtaCylinderHigh;
+  UINT8 AtaDeviceHead;
+  UINT8 AtaSectorNumberExp;
+  UINT8 AtaCylinderLowExp;
+  UINT8 AtaCylinderHighExp; 
+  UINT8 AtaFeaturesExp;
+  UINT8 AtaSectorCount;
+  UINT8 AtaSectorCountExp;
+  UINT8 Reserved2[6];
+} EFI_ATA_COMMAND_BLOCK;
+
+typedef struct _EFI_ATA_STATUS_BLOCK {
+  UINT8 Reserved1[2];
+  UINT8 AtaStatus;
+  UINT8 AtaError;
+  UINT8 AtaSectorNumber;
+  UINT8 AtaCylinderLow;
+  UINT8 AtaCylinderHigh;
+  UINT8 AtaDeviceHead;
+  UINT8 AtaSectorNumberExp;
+  UINT8 AtaCylinderLowExp;
+  UINT8 AtaCylinderHighExp; 
+  UINT8 Reserved2;
+  UINT8 AtaSectorCount;
+  UINT8 AtaSectorCountExp;
+  UINT8 Reserved3[6];
+} EFI_ATA_STATUS_BLOCK;
+
+typedef UINT8 EFI_ATA_PASS_THRU_CMD_PROTOCOL;
+
+#define EFI_ATA_PASS_THRU_PROTOCOL_ATA_HARDWARE_RESET 0x00
+#define EFI_ATA_PASS_THRU_PROTOCOL_ATA_SOFTWARE_RESET 0x01
+#define EFI_ATA_PASS_THRU_PROTOCOL_ATA_NON_DATA       0x02
+#define EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN        0x04
+#define EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_OUT       0x05
+#define EFI_ATA_PASS_THRU_PROTOCOL_DMA                0x06
+#define EFI_ATA_PASS_THRU_PROTOCOL_DMA_QUEUED         0x07
+#define EFI_ATA_PASS_THRU_PROTOCOL_DEVICE_DIAGNOSTIC  0x08
+#define EFI_ATA_PASS_THRU_PROTOCOL_DEVICE_RESET       0x09
+#define EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_IN       0x0A
+#define EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_OUT      0x0B
+#define EFI_ATA_PASS_THRU_PROTOCOL_FPDMA              0x0C
+#define EFI_ATA_PASS_THRU_PROTOCOL_RETURN_RESPONSE    0xFF
+
+typedef UINT8 EFI_ATA_PASS_THRU_LENGTH;
+
+#define EFI_ATA_PASS_THRU_LENGTH_BYTES                0x80
+
+
+#define EFI_ATA_PASS_THRU_LENGTH_MASK                 0x70
+#define EFI_ATA_PASS_THRU_LENGTH_NO_DATA_TRANSFER     0x00
+#define EFI_ATA_PASS_THRU_LENGTH_FEATURES             0x10
+#define EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT         0x20
+#define EFI_ATA_PASS_THRU_LENGTH_TPSIU                0x30
+
+#define EFI_ATA_PASS_THRU_LENGTH_COUNT                0x0F
+
+typedef struct {
+  ///
+  /// A pointer to the sense data that was generated by the execution of the ATA
+  /// command. It must be aligned to the boundary specified in the IoAlign field
+  /// in the EFI_ATA_PASS_THRU_MODE structure.
+  ///
+  EFI_ATA_STATUS_BLOCK           *Asb;
+  ///
+  /// A pointer to buffer that contains the Command Data Block to send to the ATA
+  /// device specified by Port and PortMultiplierPort.
+  ///
+  EFI_ATA_COMMAND_BLOCK          *Acb;
+  ///
+  /// The timeout, in 100 ns units, to use for the execution of this ATA command.
+  /// A Timeout value of 0 means that this function will wait indefinitely for the
+  /// ATA command to execute. If Timeout is greater than zero, then this function
+  /// will return EFI_TIMEOUT if the time required to execute the ATA command is
+  /// greater than Timeout.
+  ///
+  UINT64                         Timeout;
+  ///
+  /// A pointer to the data buffer to transfer between the ATA controller and the
+  /// ATA device for read and bidirectional commands. For all write and non data
+  /// commands where InTransferLength is 0 this field is optional and may be NULL.
+  /// If this field is not NULL, then it must be aligned on the boundary specified
+  /// by the IoAlign field in the EFI_ATA_PASS_THRU_MODE structure.
+  ///
+  VOID                           *InDataBuffer;
+  ///
+  /// A pointer to the data buffer to transfer between the ATA controller and the
+  /// ATA device for write or bidirectional commands. For all read and non data
+  /// commands where OutTransferLength is 0 this field is optional and may be NULL.
+  /// If this field is not NULL, then it must be aligned on the boundary specified
+  /// by the IoAlign field in the EFI_ATA_PASS_THRU_MODE structure.
+  ///
+  VOID                           *OutDataBuffer;
+  ///
+  /// On input, the size, in bytes, of InDataBuffer. On output, the number of bytes
+  /// transferred between the ATA controller and the ATA device. If InTransferLength
+  /// is larger than the ATA controller can handle, no data will be transferred,
+  /// InTransferLength will be updated to contain the number of bytes that the ATA
+  /// controller is able to transfer, and EFI_BAD_BUFFER_SIZE will be returned.
+  ///
+  UINT32                         InTransferLength;
+  ///
+  /// On Input, the size, in bytes of OutDataBuffer. On Output, the Number of bytes
+  /// transferred between ATA Controller and the ATA device. If OutTransferLength is
+  /// larger than the ATA controller can handle, no data will be transferred, 
+  /// OutTransferLength will be updated to contain the number of bytes that the ATA
+  /// controller is able to transfer, and EFI_BAD_BUFFER_SIZE will be returned.
+  ///
+  UINT32                         OutTransferLength;
+  ///
+  /// Specifies the protocol used when the ATA device executes the command.
+  ///
+  EFI_ATA_PASS_THRU_CMD_PROTOCOL Protocol;
+  ///
+  /// Specifies the way in which the ATA command length is encoded.
+  ///
+  EFI_ATA_PASS_THRU_LENGTH       Length;
+} EFI_ATA_PASS_THRU_COMMAND_PACKET;
+
+
+/**
+  Sends an ATA command to an ATA device that is attached to the ATA controller. This function
+  supports both blocking I/O and non-blocking I/O. The blocking I/O functionality is required,
+  and the non-blocking I/O functionality is optional.
+
+  @param[in]     This                A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance. 
+  @param[in]     Port                The port number of the ATA device to send the command. 
+  @param[in]     PortMultiplierPort  The port multiplier port number of the ATA device to send the command.
+                                     If there is no port multiplier, then specify 0xFFFF.
+  @param[in,out] Packet              A pointer to the ATA command to send to the ATA device specified by Port
+                                     and PortMultiplierPort.
+  @param[in]     Event               If non-blocking I/O is not supported then Event is ignored, and blocking
+                                     I/O is performed. If Event is NULL, then blocking I/O is performed. If
+                                     Event is not NULL and non blocking I/O is supported, then non-blocking
+                                     I/O is performed, and Event will be signaled when the ATA command completes.
+
+  @retval EFI_SUCCESS                The ATA command was sent by the host. For bi-directional commands, 
+                                     InTransferLength bytes were transferred from InDataBuffer. For write and
+                                     bi-directional commands, OutTransferLength bytes were transferred by OutDataBuffer.
+  @retval EFI_BAD_BUFFER_SIZE        The ATA command was not executed. The number of bytes that could be transferred
+                                     is returned in InTransferLength. For write and bi-directional commands, 
+                                     OutTransferLength bytes were transferred by OutDataBuffer.
+  @retval EFI_NOT_READY              The ATA command could not be sent because there are too many ATA commands
+                                     already queued. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR           A device error occurred while attempting to send the ATA command.
+  @retval EFI_INVALID_PARAMETER      Port, PortMultiplierPort, or the contents of Acb are invalid. The ATA
+                                     command was not sent, so no additional status information is available.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_PASSTHRU)(
+  IN     EFI_ATA_PASS_THRU_PROTOCOL       *This,
+  IN     UINT16                           Port,
+  IN     UINT16                           PortMultiplierPort,
+  IN OUT EFI_ATA_PASS_THRU_COMMAND_PACKET *Packet,
+  IN     EFI_EVENT                        Event OPTIONAL
+  );
+
+/**
+  Used to retrieve the list of legal port numbers for ATA devices on an ATA controller.
+  These can either be the list of ports where ATA devices are actually present or the
+  list of legal port numbers for the ATA controller. Regardless, the caller of this
+  function must probe the port number returned to see if an ATA device is actually
+  present at that location on the ATA controller.
+
+  The GetNextPort() function retrieves the port number on an ATA controller. If on input
+  Port is 0xFFFF, then the port number of the first port on the ATA controller is returned
+  in Port and EFI_SUCCESS is returned.
+
+  If Port is a port number that was returned on a previous call to GetNextPort(), then the
+  port number of the next port on the ATA controller is returned in Port, and EFI_SUCCESS
+  is returned. If Port is not 0xFFFF and Port was not returned on a previous call to
+  GetNextPort(), then EFI_INVALID_PARAMETER is returned.
+
+  If Port is the port number of the last port on the ATA controller, then EFI_NOT_FOUND is
+  returned.
+
+  @param[in]     This           A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance. 
+  @param[in,out] Port           On input, a pointer to the port number on the ATA controller.
+                                On output, a pointer to the next port number on the ATA
+                                controller. An input value of 0xFFFF retrieves the first port
+                                number on the ATA controller.
+
+  @retval EFI_SUCCESS           The next port number on the ATA controller was returned in Port.
+  @retval EFI_NOT_FOUND         There are no more ports on this ATA controller.
+  @retval EFI_INVALID_PARAMETER Port is not 0xFFFF and Port was not returned on a previous call
+                                to GetNextPort().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_GET_NEXT_PORT)(
+  IN EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN OUT UINT16                 *Port
+  );
+
+/**
+  Used to retrieve the list of legal port multiplier port numbers for ATA devices on a port of an ATA 
+  controller. These can either be the list of port multiplier ports where ATA devices are actually 
+  present on port or the list of legal port multiplier ports on that port. Regardless, the caller of this 
+  function must probe the port number and port multiplier port number returned to see if an ATA 
+  device is actually present.
+
+  The GetNextDevice() function retrieves the port multiplier port number of an ATA device 
+  present on a port of an ATA controller.
+  
+  If PortMultiplierPort points to a port multiplier port number value that was returned on a 
+  previous call to GetNextDevice(), then the port multiplier port number of the next ATA device
+  on the port of the ATA controller is returned in PortMultiplierPort, and EFI_SUCCESS is
+  returned.
+  
+  If PortMultiplierPort points to 0xFFFF, then the port multiplier port number of the first 
+  ATA device on port of the ATA controller is returned in PortMultiplierPort and 
+  EFI_SUCCESS is returned.
+  
+  If PortMultiplierPort is not 0xFFFF and the value pointed to by PortMultiplierPort
+  was not returned on a previous call to GetNextDevice(), then EFI_INVALID_PARAMETER
+  is returned.
+  
+  If PortMultiplierPort is the port multiplier port number of the last ATA device on the port of 
+  the ATA controller, then EFI_NOT_FOUND is returned.
+
+  @param[in]     This                A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance.
+  @param[in]     Port                The port number present on the ATA controller.
+  @param[in,out] PortMultiplierPort  On input, a pointer to the port multiplier port number of an
+                                     ATA device present on the ATA controller. 
+                                     If on input a PortMultiplierPort of 0xFFFF is specified, 
+                                     then the port multiplier port number of the first ATA device
+                                     is returned. On output, a pointer to the port multiplier port
+                                     number of the next ATA device present on an ATA controller.
+
+  @retval EFI_SUCCESS                The port multiplier port number of the next ATA device on the port
+                                     of the ATA controller was returned in PortMultiplierPort.
+  @retval EFI_NOT_FOUND              There are no more ATA devices on this port of the ATA controller.
+  @retval EFI_INVALID_PARAMETER      PortMultiplierPort is not 0xFFFF, and PortMultiplierPort was not
+                                     returned on a previous call to GetNextDevice().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_GET_NEXT_DEVICE)(
+  IN EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN UINT16                     Port,
+  IN OUT UINT16                 *PortMultiplierPort
+  );
+
+/**
+  Used to allocate and build a device path node for an ATA device on an ATA controller.
+
+  The BuildDevicePath() function allocates and builds a single device node for the ATA
+  device specified by Port and PortMultiplierPort. If the ATA device specified by Port and
+  PortMultiplierPort is not present on the ATA controller, then EFI_NOT_FOUND is returned.
+  If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned. If there are not enough
+  resources to allocate the device path node, then EFI_OUT_OF_RESOURCES is returned.
+
+  Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of
+  DevicePath are initialized to describe the ATA device specified by Port and PortMultiplierPort,
+  and EFI_SUCCESS is returned.
+
+  @param[in]     This                A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance.
+  @param[in]     Port                Port specifies the port number of the ATA device for which a
+                                     device path node is to be allocated and built.
+  @param[in]     PortMultiplierPort  The port multiplier port number of the ATA device for which a
+                                     device path node is to be allocated and built. If there is no
+                                     port multiplier, then specify 0xFFFF.
+  @param[in,out] DevicePath          A pointer to a single device path node that describes the ATA
+                                     device specified by Port and PortMultiplierPort. This function
+                                     is responsible for allocating the buffer DevicePath with the
+                                     boot service AllocatePool(). It is the caller's responsibility
+                                     to free DevicePath when the caller is finished with DevicePath.
+  @retval EFI_SUCCESS                The device path node that describes the ATA device specified by
+                                     Port and PortMultiplierPort was allocated and returned in DevicePath.
+  @retval EFI_NOT_FOUND              The ATA device specified by Port and PortMultiplierPort does not
+                                     exist on the ATA controller.
+  @retval EFI_INVALID_PARAMETER      DevicePath is NULL.
+  @retval EFI_OUT_OF_RESOURCES       There are not enough resources to allocate DevicePath.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_BUILD_DEVICE_PATH)(
+  IN     EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN     UINT16                     Port,
+  IN     UINT16                     PortMultiplierPort,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL   **DevicePath
+  );
+
+/**
+  Used to translate a device path node to a port number and port multiplier port number.
+
+  The GetDevice() function determines the port and port multiplier port number associated with
+  the ATA device described by DevicePath. If DevicePath is a device path node type that the
+  ATA Pass Thru driver supports, then the ATA Pass Thru driver will attempt to translate the contents 
+  DevicePath into a port number and port multiplier port number.
+
+  If this translation is successful, then that port number and port multiplier port number are returned
+  in Port and PortMultiplierPort, and EFI_SUCCESS is returned.
+
+  If DevicePath, Port, or PortMultiplierPort are NULL, then EFI_INVALID_PARAMETER is returned.
+
+  If DevicePath is not a device path node type that the ATA Pass Thru driver supports, then 
+  EFI_UNSUPPORTED is returned.
+
+  If DevicePath is a device path node type that the ATA Pass Thru driver supports, but there is not 
+  a valid translation from DevicePath to a port number and port multiplier port number, then 
+  EFI_NOT_FOUND is returned.
+
+  @param[in]  This                A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance.
+  @param[in]  DevicePath          A pointer to the device path node that describes an ATA device on the
+                                  ATA controller.
+  @param[out] Port                On return, points to the port number of an ATA device on the ATA controller.
+  @param[out] PortMultiplierPort  On return, points to the port multiplier port number of an ATA device
+                                  on the ATA controller.
+
+  @retval EFI_SUCCESS             DevicePath was successfully translated to a port number and port multiplier
+                                  port number, and they were returned in Port and PortMultiplierPort.
+  @retval EFI_INVALID_PARAMETER   DevicePath is NULL.
+  @retval EFI_INVALID_PARAMETER   Port is NULL.
+  @retval EFI_INVALID_PARAMETER   PortMultiplierPort is NULL.
+  @retval EFI_UNSUPPORTED         This driver does not support the device path node type in DevicePath.
+  @retval EFI_NOT_FOUND           A valid translation from DevicePath to a port number and port multiplier
+                                  port number does not exist.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_GET_DEVICE)(
+  IN  EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN  EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  OUT UINT16                     *Port,
+  OUT UINT16                     *PortMultiplierPort
+  );
+
+/**
+  Resets a specific port on the ATA controller. This operation also resets all the ATA devices
+  connected to the port.
+
+  The ResetChannel() function resets an a specific port on an ATA controller. This operation
+  resets all the ATA devices connected to that port. If this ATA controller does not support
+  a reset port operation, then EFI_UNSUPPORTED is returned.
+
+  If a device error occurs while executing that port reset operation, then EFI_DEVICE_ERROR is
+  returned.
+
+  If a timeout occurs during the execution of the port reset operation, then EFI_TIMEOUT is returned.
+
+  If the port reset operation is completed, then EFI_SUCCESS is returned.
+
+  @param[in]  This          A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance.
+  @param[in]  Port          The port number on the ATA controller.
+
+  @retval EFI_SUCCESS       The ATA controller port was reset.
+  @retval EFI_UNSUPPORTED   The ATA controller does not support a port reset operation.
+  @retval EFI_DEVICE_ERROR  A device error occurred while attempting to reset the ATA port.
+  @retval EFI_TIMEOUT       A timeout occurred while attempting to reset the ATA port.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_RESET_PORT)(
+  IN EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN UINT16                     Port
+  );
+
+/**
+  Resets an ATA device that is connected to an ATA controller.
+
+  The ResetDevice() function resets the ATA device specified by Port and PortMultiplierPort.
+  If this ATA controller does not support a device reset operation, then EFI_UNSUPPORTED is
+  returned.
+
+  If Port or PortMultiplierPort are not in a valid range for this ATA controller, then 
+  EFI_INVALID_PARAMETER is returned.
+
+  If a device error occurs while executing that device reset operation, then EFI_DEVICE_ERROR
+  is returned.
+
+  If a timeout occurs during the execution of the device reset operation, then EFI_TIMEOUT is
+  returned.
+
+  If the device reset operation is completed, then EFI_SUCCESS is returned.
+
+  @param[in] This                A pointer to the EFI_ATA_PASS_THRU_PROTOCOL instance.
+  @param[in] Port                Port represents the port number of the ATA device to be reset.
+  @param[in] PortMultiplierPort  The port multiplier port number of the ATA device to reset.
+                                 If there is no port multiplier, then specify 0xFFFF.
+  @retval EFI_SUCCESS            The ATA device specified by Port and PortMultiplierPort was reset.
+  @retval EFI_UNSUPPORTED        The ATA controller does not support a device reset operation.
+  @retval EFI_INVALID_PARAMETER  Port or PortMultiplierPort are invalid.
+  @retval EFI_DEVICE_ERROR       A device error occurred while attempting to reset the ATA device
+                                 specified by Port and PortMultiplierPort.
+  @retval EFI_TIMEOUT            A timeout occurred while attempting to reset the ATA device
+                                 specified by Port and PortMultiplierPort.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ATA_PASS_THRU_RESET_DEVICE)(
+  IN EFI_ATA_PASS_THRU_PROTOCOL *This,
+  IN UINT16                     Port,
+  IN UINT16                     PortMultiplierPort
+  );
+
+struct _EFI_ATA_PASS_THRU_PROTOCOL {
+  EFI_ATA_PASS_THRU_MODE               *Mode;
+  EFI_ATA_PASS_THRU_PASSTHRU           PassThru;
+  EFI_ATA_PASS_THRU_GET_NEXT_PORT      GetNextPort;
+  EFI_ATA_PASS_THRU_GET_NEXT_DEVICE    GetNextDevice;
+  EFI_ATA_PASS_THRU_BUILD_DEVICE_PATH  BuildDevicePath;
+  EFI_ATA_PASS_THRU_GET_DEVICE         GetDevice;
+  EFI_ATA_PASS_THRU_RESET_PORT         ResetPort;
+  EFI_ATA_PASS_THRU_RESET_DEVICE       ResetDevice;
+};
+
+extern EFI_GUID gEfiAtaPassThruProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/AuthenticationInfo.h b/MdePkg/Include/Protocol/AuthenticationInfo.h
new file mode 100644
index 000000000000..99e20235913a
--- /dev/null
+++ b/MdePkg/Include/Protocol/AuthenticationInfo.h
@@ -0,0 +1,237 @@
+/** @file
+  EFI_AUTHENTICATION_INFO_PROTOCOL as defined in UEFI 2.0.
+  This protocol is used on any device handle to obtain authentication information 
+  associated with the physical or logical device.
+
+Copyright (c) 2006 - 2011, 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 __AUTHENTICATION_INFO_H__
+#define __AUTHENTICATION_INFO_H__
+
+#define EFI_AUTHENTICATION_INFO_PROTOCOL_GUID \
+  { \
+    0x7671d9d0, 0x53db, 0x4173, {0xaa, 0x69, 0x23, 0x27, 0xf2, 0x1f, 0x0b, 0xc7 } \
+  }
+  
+#define EFI_AUTHENTICATION_CHAP_RADIUS_GUID \
+  { \
+    0xd6062b50, 0x15ca, 0x11da, {0x92, 0x19, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d } \
+  }
+
+#define EFI_AUTHENTICATION_CHAP_LOCAL_GUID \
+  { \
+    0xc280c73e, 0x15ca, 0x11da, {0xb0, 0xca, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d } \
+  }
+
+typedef struct _EFI_AUTHENTICATION_INFO_PROTOCOL EFI_AUTHENTICATION_INFO_PROTOCOL;
+
+#pragma pack(1)
+typedef struct {
+  ///
+  /// Authentication Type GUID.
+  ///
+  EFI_GUID         Guid;
+
+  ///
+  /// Length of this structure in bytes.
+  ///
+  UINT16           Length;
+} AUTH_NODE_HEADER;
+
+typedef struct {
+  AUTH_NODE_HEADER Header;
+
+  ///
+  /// RADIUS Server IPv4 or IPv6 Address.
+  ///
+  UINT8            RadiusIpAddr[16];         ///< IPv4 or IPv6 address.
+
+  ///
+  /// Reserved for future use.
+  ///
+  UINT16           Reserved;
+
+  ///
+  /// Network Access Server IPv4 or IPv6 Address (OPTIONAL).
+  ///
+  UINT8            NasIpAddr[16];            ///< IPv4 or IPv6 address.
+
+  ///
+  /// Network Access Server Secret Length in bytes (OPTIONAL).
+  ///
+  UINT16           NasSecretLength;
+
+  ///
+  /// Network Access Server Secret (OPTIONAL).
+  ///
+  UINT8            NasSecret[1];
+
+  /// 
+  /// CHAP Initiator Secret Length in bytes on offset NasSecret + NasSecretLength.
+  ///
+  /// UINT16           ChapSecretLength;
+  ///
+  /// CHAP Initiator Secret.
+  ///
+  /// UINT8            ChapSecret[];
+  ///
+  /// CHAP Initiator Name Length in bytes on offset ChapSecret + ChapSecretLength.
+  ///
+  /// UINT16           ChapNameLength;
+  ///
+  /// CHAP Initiator Name.
+  ///
+  /// UINT8            ChapName[];
+  ///
+  /// Reverse CHAP Name Length in bytes on offset ChapName + ChapNameLength.
+  ///
+  /// UINT16           ReverseChapNameLength;
+  ///
+  /// Reverse CHAP Name.
+  ///
+  /// UINT8            ReverseChapName[];
+  ///
+  /// Reverse CHAP Secret Length in bytes on offseet ReverseChapName + ReverseChapNameLength.
+  ///
+  /// UINT16           ReverseChapSecretLength;
+  ///
+  /// Reverse CHAP Secret.
+  ///
+  /// UINT8            ReverseChapSecret[];
+  ///
+} CHAP_RADIUS_AUTH_NODE;
+
+typedef struct {
+  AUTH_NODE_HEADER Header;
+
+  ///
+  /// Reserved for future use.
+  ///
+  UINT16           Reserved;
+
+  ///
+  /// User Secret Length in bytes.
+  ///
+  UINT16           UserSecretLength;
+
+  ///
+  /// User Secret.
+  ///
+  UINT8            UserSecret[1];
+
+  ///
+  /// User Name Length in bytes on offset UserSecret + UserSecretLength.
+  ///
+  /// UINT16           UserNameLength;
+  ///
+  /// User Name.
+  ///
+  /// UINT8            UserName[];
+  ///
+  /// CHAP Initiator Secret Length in bytes on offset UserName + UserNameLength.
+  ///
+  /// UINT16           ChapSecretLength;
+  ///
+  /// CHAP Initiator Secret.
+  ///
+  /// UINT8            ChapSecret[];
+  ///
+  /// CHAP Initiator Name Length in bytes on offset ChapSecret + ChapSecretLength.
+  ///
+  /// UINT16           ChapNameLength;
+  ///
+  /// CHAP Initiator Name.
+  ///
+  /// UINT8            ChapName[];
+  ///
+  /// Reverse CHAP Name Length in bytes on offset ChapName + ChapNameLength.
+  ///
+  /// UINT16           ReverseChapNameLength;
+  ///
+  /// Reverse CHAP Name.
+  ///
+  /// UINT8            ReverseChapName[];
+  ///
+  /// Reverse CHAP Secret Length in bytes on offset ReverseChapName + ReverseChapNameLength.
+  ///
+  /// UINT16           ReverseChapSecretLength;
+  ///
+  /// Reverse CHAP Secret.
+  ///
+  /// UINT8            ReverseChapSecret[];
+  ///
+} CHAP_LOCAL_AUTH_NODE;
+#pragma pack()
+
+/**
+  Retrieves the authentication information associated with a particular controller handle.
+
+  @param[in]  This                  The pointer to the EFI_AUTHENTICATION_INFO_PROTOCOL.
+  @param[in]  ControllerHandle      The handle to the Controller.
+  @param[out] Buffer                The pointer to the authentication information. This function is
+                                    responsible for allocating the buffer and it is the caller's
+                                    responsibility to free buffer when the caller is finished with buffer.
+
+  @retval EFI_SUCCESS           Successfully retrieved authentication information 
+                                for the given ControllerHandle.
+  @retval EFI_INVALID_PARAMETER No matching authentication information found for 
+                                the given ControllerHandle.
+  @retval EFI_DEVICE_ERROR      The authentication information could not be retrieved 
+                                due to a hardware error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_AUTHENTICATION_INFO_PROTOCOL_GET)(
+  IN  EFI_AUTHENTICATION_INFO_PROTOCOL *This,
+  IN  EFI_HANDLE                       ControllerHandle,
+  OUT VOID                             **Buffer
+  );
+
+/**
+  Set the authentication information for a given controller handle.
+
+  @param[in]  This                 The pointer to the EFI_AUTHENTICATION_INFO_PROTOCOL.
+  @param[in]  ControllerHandle     The handle to the Controller.
+  @param[in]  Buffer               The pointer to the authentication information.
+                                
+  @retval EFI_SUCCESS          Successfully set authentication information for the 
+                               given ControllerHandle.
+  @retval EFI_UNSUPPORTED      If the platform policies do not allow setting of 
+                               the authentication information.
+  @retval EFI_DEVICE_ERROR     The authentication information could not be configured 
+                               due to a hardware error.
+  @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the data.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_AUTHENTICATION_INFO_PROTOCOL_SET)(
+  IN EFI_AUTHENTICATION_INFO_PROTOCOL  *This,
+  IN EFI_HANDLE                        ControllerHandle,
+  IN VOID                              *Buffer
+  );  
+
+///
+/// This protocol is used on any device handle to obtain authentication 
+/// information associated with the physical or logical device.
+///
+struct _EFI_AUTHENTICATION_INFO_PROTOCOL {
+  EFI_AUTHENTICATION_INFO_PROTOCOL_GET Get;
+  EFI_AUTHENTICATION_INFO_PROTOCOL_SET Set;
+};
+
+extern EFI_GUID gEfiAuthenticationInfoProtocolGuid;
+extern EFI_GUID gEfiAuthenticationChapRadiusGuid;
+extern EFI_GUID gEfiAuthenticationChapLocalGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Bds.h b/MdePkg/Include/Protocol/Bds.h
new file mode 100644
index 000000000000..0ecc66c8cab3
--- /dev/null
+++ b/MdePkg/Include/Protocol/Bds.h
@@ -0,0 +1,72 @@
+/** @file
+  Boot Device Selection Architectural Protocol as defined in PI spec Volume 2 DXE
+
+  When the DXE core is done it calls the BDS via this protocol.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_BDS_H__
+#define __ARCH_PROTOCOL_BDS_H__
+
+///
+/// Global ID for the BDS Architectural Protocol
+///
+#define EFI_BDS_ARCH_PROTOCOL_GUID \
+  { 0x665E3FF6, 0x46CC, 0x11d4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } }
+
+///
+/// Declare forward reference for the BDS Architectural Protocol
+///
+typedef struct _EFI_BDS_ARCH_PROTOCOL   EFI_BDS_ARCH_PROTOCOL;
+
+/**
+  This function uses policy data from the platform to determine what operating 
+  system or system utility should be loaded and invoked.  This function call 
+  also optionally make the use of user input to determine the operating system 
+  or system utility to be loaded and invoked.  When the DXE Core has dispatched 
+  all the drivers on the dispatch queue, this function is called.  This 
+  function will attempt to connect the boot devices required to load and invoke 
+  the selected operating system or system utility.  During this process, 
+  additional firmware volumes may be discovered that may contain addition DXE 
+  drivers that can be dispatched by the DXE Core.   If a boot device cannot be 
+  fully connected, this function calls the DXE Service Dispatch() to allow the 
+  DXE drivers from any newly discovered firmware volumes to be dispatched.  
+  Then the boot device connection can be attempted again.  If the same boot 
+  device connection operation fails twice in a row, then that boot device has 
+  failed, and should be skipped.  This function should never return.
+
+  @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
+
+  @return None.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_BDS_ENTRY)(
+  IN EFI_BDS_ARCH_PROTOCOL  *This
+  );
+
+///
+/// The EFI_BDS_ARCH_PROTOCOL transfers control from DXE to an operating 
+/// system or a system utility.  If there are not enough drivers initialized 
+/// when this protocol is used to access the required boot device(s), then 
+/// this protocol should add drivers to the dispatch queue and return control 
+/// back to the dispatcher.  Once the required boot devices are available, then 
+/// the boot device can be used to load and invoke an OS or a system utility.
+///
+struct _EFI_BDS_ARCH_PROTOCOL {
+  EFI_BDS_ENTRY Entry;
+};
+
+extern EFI_GUID gEfiBdsArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Bis.h b/MdePkg/Include/Protocol/Bis.h
new file mode 100644
index 000000000000..b3ac58ec0302
--- /dev/null
+++ b/MdePkg/Include/Protocol/Bis.h
@@ -0,0 +1,451 @@
+/** @file
+  The EFI_BIS_PROTOCOL is used to check a digital signature of a data block 
+  against a digital certificate for the purpose of an integrity and authorization check.
+
+Copyright (c) 2006 - 2010, 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.        
+
+  @par Revision Reference:          
+  This Protocol is introduced in EFI Specification 1.10.     
+
+**/
+
+#ifndef __BIS_H__
+#define __BIS_H__
+
+#define EFI_BIS_PROTOCOL_GUID \
+  { \
+    0x0b64aab0, 0x5429, 0x11d4, {0x98, 0x16, 0x00, 0xa0, 0xc9, 0x1f, 0xad, 0xcf } \
+  }
+
+//
+// X-Intel-BIS-ParameterSet
+// Attribute value
+// Binary Value of X-Intel-BIS-ParameterSet Attribute.
+// (Value is Base-64 encoded in actual signed manifest).
+//
+#define BOOT_OBJECT_AUTHORIZATION_PARMSET_GUID \
+  { \
+    0xedd35e31, 0x7b9, 0x11d2, { 0x83,0xa3,0x0,0xa0,0xc9,0x1f,0xad,0xcf } \
+  }
+
+
+
+typedef struct _EFI_BIS_PROTOCOL  EFI_BIS_PROTOCOL;
+
+
+//
+// Basic types
+//
+typedef VOID    *BIS_APPLICATION_HANDLE;
+typedef UINT16  BIS_ALG_ID;
+typedef UINT32  BIS_CERT_ID;
+
+///
+/// EFI_BIS_DATA instances obtained from BIS must be freed by calling Free( ).
+///
+typedef struct {
+  UINT32  Length; ///< The length of Data in 8 bit bytes.
+  UINT8   *Data;  ///< 32 Bit Flat Address of data.
+} EFI_BIS_DATA;
+
+///
+/// EFI_BIS_VERSION type.
+///
+typedef struct {
+  UINT32  Major;  ///< The major BIS version number.
+  UINT32  Minor;  ///< A minor BIS version number.
+} EFI_BIS_VERSION;
+
+//
+// ----------------------------------------------------//
+// Use these values to initialize EFI_BIS_VERSION.Major
+// and to interpret results of Initialize.
+// ----------------------------------------------------//
+//
+#define BIS_CURRENT_VERSION_MAJOR BIS_VERSION_1
+#define BIS_VERSION_1             1
+
+///
+/// EFI_BIS_SIGNATURE_INFO type.
+///
+typedef struct {
+  BIS_CERT_ID CertificateID;  ///< Truncated hash of platform Boot Object
+  BIS_ALG_ID  AlgorithmID;    ///< A signature algorithm number.
+  UINT16      KeyLength;      ///< The length of alg. keys in bits.
+} EFI_BIS_SIGNATURE_INFO;
+
+///
+/// values for EFI_BIS_SIGNATURE_INFO.AlgorithmID.
+/// The exact numeric values come from the
+///    "Common Data Security Architecture (CDSA) Specification".
+///
+#define BIS_ALG_DSA     (41)  // CSSM_ALGID_DSA
+#define BIS_ALG_RSA_MD5 (42)  // CSSM_ALGID_MD5_WITH_RSA
+///
+/// values for EFI_BIS_SIGNATURE_INFO.CertificateId.
+///
+#define BIS_CERT_ID_DSA     BIS_ALG_DSA     // CSSM_ALGID_DSA
+#define BIS_CERT_ID_RSA_MD5 BIS_ALG_RSA_MD5 // CSSM_ALGID_MD5_WITH_RSA
+///
+/// The mask value that gets applied to the truncated hash of a
+/// platform  Boot Object Authorization Certificate to create the certificateID.
+/// A certificateID must not have any bits set to the value 1 other than bits in
+/// this mask.
+///
+#define BIS_CERT_ID_MASK  (0xFF7F7FFF)
+
+///
+/// Macros for dealing with the EFI_BIS_DATA object obtained
+/// from BIS_GetSignatureInfo().
+/// BIS_GET_SIGINFO_COUNT - tells how many EFI_BIS_SIGNATURE_INFO
+///  elements are contained in a EFI_BIS_DATA struct pointed to
+///  by the provided EFI_BIS_DATA*.
+///
+#define BIS_GET_SIGINFO_COUNT(BisDataPtr) ((BisDataPtr)->Length / sizeof (EFI_BIS_SIGNATURE_INFO))
+
+///
+/// BIS_GET_SIGINFO_ARRAY - produces a EFI_BIS_SIGNATURE_INFO*
+///  from a given EFI_BIS_DATA*.
+///
+#define BIS_GET_SIGINFO_ARRAY(BisDataPtr) ((EFI_BIS_SIGNATURE_INFO *) (BisDataPtr)->Data)
+
+///
+/// Support an old name for backward compatibility.
+///
+#define BOOT_OBJECT_AUTHORIZATION_PARMSET_GUIDVALUE \
+        BOOT_OBJECT_AUTHORIZATION_PARMSET_GUID
+
+/**                                                                 
+  Initializes the BIS service, checking that it is compatible with the version requested by the caller.
+  After this call, other BIS functions may be invoked.                                                 
+    
+  @param  This                     A pointer to the EFI_BIS_PROTOCOL object.
+  @param  AppHandle                The function writes the new BIS_APPLICATION_HANDLE if           
+                                   successful, otherwise it writes NULL. The caller must eventually
+                                   destroy this handle by calling Shutdown().                      
+  @param  InterfaceVersion         On input, the caller supplies the major version number of the
+                                   interface version desired.                                   
+                                   On output, both the major and minor                         
+                                   version numbers are updated with the major and minor version
+                                   numbers of the interface. This update is done whether or not the
+                                   initialization was successful.                                    
+  @param  TargetAddress            Indicates a network or device address of the BIS platform to connect to.                                                                 
+
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_INCOMPATIBLE_VERSION The InterfaceVersion.Major requested by the                
+                                   caller was not compatible with the interface version of the
+                                   implementation. The InterfaceVersion.Major has
+                                   been updated with the current interface version.
+  @retval EFI_UNSUPPORTED          This is a local-platform implementation and        
+                                   TargetAddress.Data was not NULL, or                
+                                   TargetAddress.Data was any other value that was not
+                                   supported by the implementation.                   
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                              
+  @retval EFI_DEVICE_ERROR         One of the following device errors:
+                                   * The function encountered an unexpected internal failure while initializing a cryptographic software module
+                                   * No cryptographic software module with compatible version was found
+                                   found
+                                   * A resource limitation was encountered while using a cryptographic software module.
+  @retval EFI_INVALID_PARAMETER    The This parameter supplied by the caller is NULL or does not
+                                   reference a valid EFI_BIS_PROTOCOL object. Or,
+                                   the AppHandle parameter supplied by the caller is NULL or
+                                   an invalid memory reference. Or,
+                                   the InterfaceVersion parameter supplied by the caller
+                                   is NULL or an invalid memory reference. Or,
+                                   the TargetAddress parameter supplied by the caller is
+                                   NULL or an invalid memory reference.
+                                          
+**/                                       
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_INITIALIZE)(
+  IN     EFI_BIS_PROTOCOL        *This,              
+  OUT    BIS_APPLICATION_HANDLE  *AppHandle,         
+  IN OUT EFI_BIS_VERSION         *InterfaceVersion,  
+  IN     EFI_BIS_DATA            *TargetAddress      
+  );
+
+/**                                                                 
+  Frees memory structures allocated and returned by other functions in the EFI_BIS protocol.  
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                         
+  @param  ToFree                   An EFI_BIS_DATA* and associated memory block to be freed. 
+                                   This EFI_BIS_DATA* must have been allocated by one of the other BIS functions.
+
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                     
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_INVALID_PARAMETER    The ToFree parameter is not or is no longer a memory resource
+                                   associated with this AppHandle.                              
+                                           
+**/     
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_FREE)(
+  IN BIS_APPLICATION_HANDLE  AppHandle,               
+  IN EFI_BIS_DATA            *ToFree                  
+  );
+
+/**                                                                 
+  Shuts down an application's instance of the BIS service, invalidating the application handle. After
+  this call, other BIS functions may no longer be invoked using the application handle value.         
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not, or is no longer, a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                     
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_DEVICE_ERROR         The function encountered an unexpected internal failure while
+                                   returning resources associated with a cryptographic software module, or
+                                   while trying to shut down a cryptographic software module.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_SHUTDOWN)(
+  IN BIS_APPLICATION_HANDLE  AppHandle               
+  );
+
+/**                                                                 
+  Retrieves the certificate that has been configured as the identity of the organization designated as
+  the source of authorization for signatures of boot objects.
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+  @param  Certificate              The function writes an allocated EFI_BIS_DATA* containing the Boot
+                                   Object Authorization Certificate object.  The caller must
+                                   eventually free the memory allocated by this function using the function Free().
+
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                     
+  @retval EFI_NOT_FOUND            There is no Boot Object Authorization Certificate currently installed.                        
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_INVALID_PARAMETER    The Certificate parameter supplied by the caller is NULL or
+                                   an invalid memory reference.                                       
+                                   
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_CERTIFICATE)(
+  IN  BIS_APPLICATION_HANDLE  AppHandle,              
+  OUT EFI_BIS_DATA            **Certificate           
+  );
+
+/**                                                                 
+  Verifies the integrity and authorization of the indicated data object according to the
+  indicated credentials.                                                                
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+  @param  Credentials              A Signed Manifest containing verification information for the indicated
+                                   data object.                                                            
+  @param  DataObject               An in-memory copy of the raw data object to be verified.
+  @param  IsVerified               The function writes TRUE if the verification succeeded, otherwise
+                                   FALSE.                                                           
+                                   
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                       
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_INVALID_PARAMETER    One or more parameters are invalid.
+  @retval EFI_SECURITY_VIOLATION   The signed manifest supplied as the Credentials parameter
+                                   was invalid (could not be parsed) or Platform-specific authorization failed, etc.
+  @retval EFI_DEVICE_ERROR         An unexpected internal error occurred.                           
+                                   
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_VERIFY_BOOT_OBJECT)(
+  IN  BIS_APPLICATION_HANDLE AppHandle,               
+  IN  EFI_BIS_DATA           *Credentials,            
+  IN  EFI_BIS_DATA           *DataObject,             
+  OUT BOOLEAN                *IsVerified              
+  );
+
+/**                                                                 
+  Retrieves the current status of the Boot Authorization Check Flag.
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+  @param  CheckIsRequired          The function writes the value TRUE if a Boot Authorization Check is
+                                   currently required on this platform, otherwise the function writes 
+                                   FALSE.                                                             
+                                   
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                       
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_INVALID_PARAMETER    The CheckIsRequired parameter supplied by the caller is
+                                   NULL or an invalid memory reference.                   
+                                   
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_CHECKFLAG)(
+  IN  BIS_APPLICATION_HANDLE  AppHandle,             
+  OUT BOOLEAN                 *CheckIsRequired       
+  );
+
+/**                                                                 
+  Retrieves a unique token value to be included in the request credential for the next update of any
+  parameter in the Boot Object Authorization set                                                    
+      
+  @param  AppHandle                An opaque handle that identifies the caller's 
+                                   instance of initialization of the BIS service.                                                                                           
+  @param  UpdateToken              The function writes an allocated EFI_BIS_DATA* 
+                                   containing the newunique update token value.  
+                                   The caller musteventually free the memory allocated  
+                                   by this function using the function Free().
+                                   
+  @retval EFI_SUCCESS              The function completed successfully.
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid
+                                   application instance handle associated with the EFI_BIS protocol.                                       
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                                
+  @retval EFI_INVALID_PARAMETER    The UpdateToken parameter supplied by the caller is NULL or
+                                   an invalid memory reference.        
+  @retval EFI_DEVICE_ERROR         An unexpected internal error occurred.                                                            
+                                   
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_UPDATE_TOKEN)(
+  IN  BIS_APPLICATION_HANDLE  AppHandle,              
+  OUT EFI_BIS_DATA            **UpdateToken           
+  );
+
+/**                                                                 
+  Updates one of the configurable parameters of the Boot Object Authorization set.
+      
+  @param  AppHandle                An opaque handle that identifies the caller's 
+                                   instance of initialization of the BIS service.                                                                                           
+  @param  RequestCredential        This is a Signed Manifest with embedded attributes 
+                                   that carry the details of the requested update.                                                 
+  @param  NewUpdateToken           The function writes an allocated EFI_BIS_DATA* 
+                                   containing the new unique update token value. 
+                                   The caller must eventually free the memory allocated  
+                                   by this function using the function Free().
+                                   
+  @retval EFI_SUCCESS              The function completed successfully.                                                
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid                              
+                                   application instance handle associated with the EFI_BIS protocol.                   
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                       
+  @retval EFI_INVALID_PARAMETER    One or more parameters are invalid.                                                 
+  @retval EFI_SECURITY_VIOLATION   The signed manifest supplied as the RequestCredential parameter                           
+                                   was invalid (could not be parsed) or Platform-specific authorization failed, etc.   
+  @retval EFI_DEVICE_ERROR         An unexpected internal error occurred while analyzing the new
+                                   certificate's key algorithm, or while attempting to retrieve
+                                   the public key algorithm of the manifest's signer's certificate,
+                                   or An unexpected internal error occurred in a cryptographic software module.                                                                                                                                                                  
+                                   
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_UPDATE_BOOT_OBJECT_AUTHORIZATION)(
+  IN  BIS_APPLICATION_HANDLE AppHandle,               
+  IN  EFI_BIS_DATA           *RequestCredential,      
+  OUT EFI_BIS_DATA           **NewUpdateToken         
+  );
+
+/**                                                                 
+  Verifies the integrity and authorization of the indicated data object according to the indicated
+  credentials and authority certificate.                                                          
+      
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+  @param  Credentials              A Signed Manifest containing verification information for the
+                                   indicated data object.                                       
+  @param  DataObject               An in-memory copy of the raw data object to be verified.
+  @param  SectionName              An ASCII string giving the section name in the  
+                                   manifest holding the verification information (in other words,
+                                   hash value) that corresponds to DataObject.                             
+  @param  AuthorityCertificate     A digital certificate whose public key must match the signer's                              
+                                   public key which is found in the credentials.                  
+  @param  IsVerified               The function writes TRUE if the verification was successful.
+                                   Otherwise, the function writes FALSE.                       
+                                   
+  @retval EFI_SUCCESS              The function completed successfully.                                                
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid                              
+                                   application instance handle associated with the EFI_BIS protocol.                   
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                       
+  @retval EFI_INVALID_PARAMETER    One or more parameters are invalid.                                                 
+  @retval EFI_SECURITY_VIOLATION   The Credentials.Data supplied by the caller is NULL,
+                                   or the AuthorityCertificate supplied by the caller was 
+                                   invalid (could not be parsed),                      
+                                   or Platform-specific authorization failed, etc.   
+  @retval EFI_DEVICE_ERROR         An unexpected internal error occurred while attempting to retrieve
+                                   the public key algorithm of the manifest's signer's certificate,
+                                   or An unexpected internal error occurred in a cryptographic software module.                                                                                                                                                                  
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_VERIFY_OBJECT_WITH_CREDENTIAL)(
+  IN  BIS_APPLICATION_HANDLE AppHandle,              
+  IN  EFI_BIS_DATA           *Credentials,           
+  IN  EFI_BIS_DATA           *DataObject,            
+  IN  EFI_BIS_DATA           *SectionName,           
+  IN  EFI_BIS_DATA           *AuthorityCertificate,  
+  OUT BOOLEAN                *IsVerified             
+  );
+
+/**                                                                 
+  Retrieves a list of digital certificate identifier, digital signature algorithm, hash algorithm, and keylength
+  combinations that the platform supports.                                                                      
+
+  @param  AppHandle                An opaque handle that identifies the caller's instance of initialization
+                                   of the BIS service.                                                                                           
+  @param  SignatureInfo            The function writes an allocated EFI_BIS_DATA* containing the array
+                                   of EFI_BIS_SIGNATURE_INFO structures representing the supported    
+                                   digital certificate identifier, algorithm, and key length combinations.
+                                   The caller must eventually free the memory allocated by this function using the function Free().
+
+  @retval EFI_SUCCESS              The function completed successfully.                                                
+  @retval EFI_NO_MAPPING           The AppHandle parameter is not or is no longer a valid                              
+                                   application instance handle associated with the EFI_BIS protocol.                   
+  @retval EFI_OUT_OF_RESOURCES     The function failed due to lack of memory or other resources.                       
+  @retval EFI_INVALID_PARAMETER    The SignatureInfo parameter supplied by the caller is NULL
+                                   or an invalid memory reference.
+  @retval EFI_DEVICE_ERROR         An unexpected internal error occurred in a
+                                   cryptographic software module, or
+                                   The function encountered an unexpected internal consistency check
+                                   failure (possible corruption of stored Boot Object Authorization Certificate).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BIS_GET_SIGNATURE_INFO)(
+  IN  BIS_APPLICATION_HANDLE  AppHandle,           
+  OUT EFI_BIS_DATA            **SignatureInfo      
+  );
+
+///
+/// The EFI_BIS_PROTOCOL is used to check a digital signature of a data block against a digital
+/// certificate for the purpose of an integrity and authorization check.
+///
+struct _EFI_BIS_PROTOCOL {
+  EFI_BIS_INITIALIZE                                  Initialize;
+  EFI_BIS_SHUTDOWN                                    Shutdown;
+  EFI_BIS_FREE                                        Free;
+  EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_CERTIFICATE   GetBootObjectAuthorizationCertificate;
+  EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_CHECKFLAG     GetBootObjectAuthorizationCheckFlag;
+  EFI_BIS_GET_BOOT_OBJECT_AUTHORIZATION_UPDATE_TOKEN  GetBootObjectAuthorizationUpdateToken;
+  EFI_BIS_GET_SIGNATURE_INFO                          GetSignatureInfo;
+  EFI_BIS_UPDATE_BOOT_OBJECT_AUTHORIZATION            UpdateBootObjectAuthorization;
+  EFI_BIS_VERIFY_BOOT_OBJECT                          VerifyBootObject;
+  EFI_BIS_VERIFY_OBJECT_WITH_CREDENTIAL               VerifyObjectWithCredential;
+};
+
+extern EFI_GUID gEfiBisProtocolGuid;
+extern EFI_GUID gBootObjectAuthorizationParmsetGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BlockIo.h b/MdePkg/Include/Protocol/BlockIo.h
new file mode 100644
index 000000000000..4bc2109db122
--- /dev/null
+++ b/MdePkg/Include/Protocol/BlockIo.h
@@ -0,0 +1,241 @@
+/** @file
+  Block IO protocol as defined in the UEFI 2.0 specification.
+
+  The Block IO protocol is used to abstract block devices like hard drives,
+  DVD-ROMs and floppy drives.
+
+  Copyright (c) 2006 - 2011, 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 __BLOCK_IO_H__
+#define __BLOCK_IO_H__
+
+#define EFI_BLOCK_IO_PROTOCOL_GUID \
+  { \
+    0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_BLOCK_IO_PROTOCOL  EFI_BLOCK_IO_PROTOCOL;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+/// 
+#define BLOCK_IO_PROTOCOL       EFI_BLOCK_IO_PROTOCOL_GUID
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_BLOCK_IO_PROTOCOL   EFI_BLOCK_IO;
+
+/**
+  Reset the Block Device.
+
+  @param  This                 Indicates a pointer to the calling context.
+  @param  ExtendedVerification Driver may perform diagnostics on reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
+                               not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_RESET)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN BOOLEAN                        ExtendedVerification
+  );
+
+/**
+  Read BufferSize bytes from Lba into Buffer.
+
+  @param  This       Indicates a pointer to the calling context.
+  @param  MediaId    Id of the media, changes every time the media is replaced.
+  @param  Lba        The starting Logical Block Address to read from
+  @param  BufferSize Size of Buffer, must be a multiple of device block size.
+  @param  Buffer     A pointer to the destination buffer for the data. The caller is
+                     responsible for either having implicit or explicit ownership of the buffer.
+
+  @retval EFI_SUCCESS           The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.
+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
+  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid, 
+                                or the buffer is not on proper alignment.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_READ)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN UINT32                         MediaId,
+  IN EFI_LBA                        Lba,
+  IN UINTN                          BufferSize,
+  OUT VOID                          *Buffer
+  );
+
+/**
+  Write BufferSize bytes from Lba into Buffer.
+
+  @param  This       Indicates a pointer to the calling context.
+  @param  MediaId    The media ID that the write request is for.
+  @param  Lba        The starting logical block address to be written. The caller is
+                     responsible for writing to only legitimate locations.
+  @param  BufferSize Size of Buffer, must be a multiple of device block size.
+  @param  Buffer     A pointer to the source buffer for the data.
+
+  @retval EFI_SUCCESS           The data was written correctly to the device.
+  @retval EFI_WRITE_PROTECTED   The device can not be written to.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
+  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid, 
+                                or the buffer is not on proper alignment.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_WRITE)(
+  IN EFI_BLOCK_IO_PROTOCOL          *This,
+  IN UINT32                         MediaId,
+  IN EFI_LBA                        Lba,
+  IN UINTN                          BufferSize,
+  IN VOID                           *Buffer
+  );
+
+/**
+  Flush the Block Device.
+
+  @param  This              Indicates a pointer to the calling context.
+
+  @retval EFI_SUCCESS       All outstanding data was written to the device
+  @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data
+  @retval EFI_NO_MEDIA      There is no media in the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_FLUSH)(
+  IN EFI_BLOCK_IO_PROTOCOL  *This
+  );
+
+/**
+  Block IO read only mode data and updated only via members of BlockIO
+**/
+typedef struct {
+  ///
+  /// The curent media Id. If the media changes, this value is changed.
+  ///
+  UINT32  MediaId;         
+   
+  ///
+  /// TRUE if the media is removable; otherwise, FALSE.
+  ///    
+  BOOLEAN RemovableMedia;
+  
+  ///
+  /// TRUE if there is a media currently present in the device;
+  /// othersise, FALSE. THis field shows the media present status
+  /// as of the most recent ReadBlocks() or WriteBlocks() call.  
+  ///
+  BOOLEAN MediaPresent;
+
+  ///
+  /// TRUE if LBA 0 is the first block of a partition; otherwise
+  /// FALSE. For media with only one partition this would be TRUE.
+  ///
+  BOOLEAN LogicalPartition;
+  
+  ///
+  /// TRUE if the media is marked read-only otherwise, FALSE.
+  /// This field shows the read-only status as of the most recent WriteBlocks () call.
+  ///
+  BOOLEAN ReadOnly;
+  
+  ///
+  /// TRUE if the WriteBlock () function caches write data.
+  ///
+  BOOLEAN WriteCaching; 
+  
+  ///
+  /// The intrinsic block size of the device. If the media changes, then
+  /// this field is updated.  
+  ///
+  UINT32  BlockSize; 
+  
+  ///
+  /// Supplies the alignment requirement for any buffer to read or write block(s).
+  ///
+  UINT32  IoAlign; 
+  
+  ///
+  /// The last logical block address on the device.
+  /// If the media changes, then this field is updated. 
+  ///
+  EFI_LBA LastBlock; 
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION2. Returns the first LBA is aligned to 
+  /// a physical block boundary. 
+  ///
+  EFI_LBA LowestAlignedLba;
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION2. Returns the number of logical blocks 
+  /// per physical block.
+  ///
+  UINT32 LogicalBlocksPerPhysicalBlock;
+
+  ///
+  /// Only present if EFI_BLOCK_IO_PROTOCOL.Revision is greater than or equal to
+  /// EFI_BLOCK_IO_PROTOCOL_REVISION3. Returns the optimal transfer length
+  /// granularity as a number of logical blocks.
+  ///
+  UINT32 OptimalTransferLengthGranularity;
+} EFI_BLOCK_IO_MEDIA;
+
+#define EFI_BLOCK_IO_PROTOCOL_REVISION  0x00010000
+#define EFI_BLOCK_IO_PROTOCOL_REVISION2 0x00020001
+#define EFI_BLOCK_IO_PROTOCOL_REVISION3 0x00020031
+
+///
+/// Revision defined in EFI1.1.
+/// 
+#define EFI_BLOCK_IO_INTERFACE_REVISION   EFI_BLOCK_IO_PROTOCOL_REVISION
+
+///
+///  This protocol provides control over block devices.
+///
+struct _EFI_BLOCK_IO_PROTOCOL {
+  ///
+  /// The revision to which the block IO interface adheres. All future
+  /// revisions must be backwards compatible. If a future version is not
+  /// back wards compatible, it is not the same GUID.
+  ///
+  UINT64              Revision;
+  ///
+  /// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
+  ///
+  EFI_BLOCK_IO_MEDIA  *Media;
+
+  EFI_BLOCK_RESET     Reset;
+  EFI_BLOCK_READ      ReadBlocks;
+  EFI_BLOCK_WRITE     WriteBlocks;
+  EFI_BLOCK_FLUSH     FlushBlocks;
+
+};
+
+extern EFI_GUID gEfiBlockIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BlockIo2.h b/MdePkg/Include/Protocol/BlockIo2.h
new file mode 100644
index 000000000000..0e4bb289cffd
--- /dev/null
+++ b/MdePkg/Include/Protocol/BlockIo2.h
@@ -0,0 +1,206 @@
+/** @file
+  Block IO2 protocol as defined in the UEFI 2.3.1 specification.
+
+  The Block IO2 protocol defines an extension to the Block IO protocol which
+  enables the ability to read and write data at a block level in a non-blocking
+  manner.
+
+  Copyright (c) 2011, 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 __BLOCK_IO2_H__
+#define __BLOCK_IO2_H__
+
+#include <Protocol/BlockIo.h>
+
+#define EFI_BLOCK_IO2_PROTOCOL_GUID \
+  { \
+    0xa77b2472, 0xe282, 0x4e9f, {0xa2, 0x45, 0xc2, 0xc0, 0xe2, 0x7b, 0xbc, 0xc1} \
+  }
+
+typedef struct _EFI_BLOCK_IO2_PROTOCOL  EFI_BLOCK_IO2_PROTOCOL;
+
+/**
+  The struct of Block IO2 Token.
+**/
+typedef struct {
+
+  ///
+  /// If Event is NULL, then blocking I/O is performed.If Event is not NULL and
+  /// non-blocking I/O is supported, then non-blocking I/O is performed, and
+  /// Event will be signaled when the read request is completed.
+  ///
+  EFI_EVENT               Event;
+
+  ///
+  /// Defines whether or not the signaled event encountered an error.
+  ///
+  EFI_STATUS              TransactionStatus;
+} EFI_BLOCK_IO2_TOKEN;
+
+
+/**
+  Reset the block device hardware.
+
+  @param[in]  This                 Indicates a pointer to the calling context.
+  @param[in]  ExtendedVerification Indicates that the driver may perform a more
+                                   exhausive verification operation of the device
+                                   during reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
+                               not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_RESET_EX) (
+  IN EFI_BLOCK_IO2_PROTOCOL  *This,
+  IN BOOLEAN                 ExtendedVerification
+  );
+
+/**
+  Read BufferSize bytes from Lba into Buffer.
+  
+  This function reads the requested number of blocks from the device. All the
+  blocks are read, or an error is returned.
+  If EFI_DEVICE_ERROR, EFI_NO_MEDIA,_or EFI_MEDIA_CHANGED is returned and
+  non-blocking I/O is being used, the Event associated with this request will
+  not be signaled.
+
+  @param[in]       This       Indicates a pointer to the calling context.
+  @param[in]       MediaId    Id of the media, changes every time the media is 
+                              replaced.
+  @param[in]       Lba        The starting Logical Block Address to read from.
+  @param[in, out]  Token	    A pointer to the token associated with the transaction.
+  @param[in]       BufferSize Size of Buffer, must be a multiple of device block size.  
+  @param[out]      Buffer     A pointer to the destination buffer for the data. The 
+                              caller is responsible for either having implicit or 
+                              explicit ownership of the buffer.
+
+  @retval EFI_SUCCESS           The read request was queued if Token->Event is
+                                not NULL.The data was read correctly from the
+                                device if the Token->Event is NULL.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing
+                                the read.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId is not for the current media.
+  @retval EFI_BAD_BUFFER_SIZE   The BufferSize parameter is not a multiple of the
+                                intrinsic block size of the device.
+  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid, 
+                                or the buffer is not on proper alignment.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack
+                                of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_READ_EX) (
+  IN     EFI_BLOCK_IO2_PROTOCOL *This,
+  IN     UINT32                 MediaId,
+  IN     EFI_LBA                LBA,
+  IN OUT EFI_BLOCK_IO2_TOKEN    *Token,
+  IN     UINTN                  BufferSize,
+     OUT VOID                  *Buffer
+  );
+
+/**
+  Write BufferSize bytes from Lba into Buffer.
+
+  This function writes the requested number of blocks to the device. All blocks
+  are written, or an error is returned.If EFI_DEVICE_ERROR, EFI_NO_MEDIA,
+  EFI_WRITE_PROTECTED or EFI_MEDIA_CHANGED is returned and non-blocking I/O is
+  being used, the Event associated with this request will not be signaled.
+
+  @param[in]       This       Indicates a pointer to the calling context.
+  @param[in]       MediaId    The media ID that the write request is for.
+  @param[in]       Lba        The starting logical block address to be written. The
+                              caller is responsible for writing to only legitimate
+                              locations.
+  @param[in, out]  Token      A pointer to the token associated with the transaction.
+  @param[in]       BufferSize Size of Buffer, must be a multiple of device block size.
+  @param[in]       Buffer     A pointer to the source buffer for the data.
+
+  @retval EFI_SUCCESS           The write request was queued if Event is not NULL.
+                                The data was written correctly to the device if
+                                the Event is NULL.
+  @retval EFI_WRITE_PROTECTED   The device can not be written to.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
+  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid, 
+                                or the buffer is not on proper alignment.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack
+                                of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_WRITE_EX) (
+  IN     EFI_BLOCK_IO2_PROTOCOL  *This,
+  IN     UINT32                 MediaId,
+  IN     EFI_LBA                LBA,
+  IN OUT EFI_BLOCK_IO2_TOKEN    *Token,
+  IN     UINTN                  BufferSize,
+  IN     VOID                   *Buffer
+  );
+
+/**
+  Flush the Block Device.
+ 
+  If EFI_DEVICE_ERROR, EFI_NO_MEDIA,_EFI_WRITE_PROTECTED or EFI_MEDIA_CHANGED
+  is returned and non-blocking I/O is being used, the Event associated with
+  this request will not be signaled.  
+
+  @param[in]      This     Indicates a pointer to the calling context.
+  @param[in,out]  Token    A pointer to the token associated with the transaction
+
+  @retval EFI_SUCCESS          The flush request was queued if Event is not NULL.
+                               All outstanding data was written correctly to the
+                               device if the Event is NULL.
+  @retval EFI_DEVICE_ERROR     The device reported an error while writting back
+                               the data.
+  @retval EFI_WRITE_PROTECTED  The device cannot be written to.
+  @retval EFI_NO_MEDIA         There is no media in the device.
+  @retval EFI_MEDIA_CHANGED    The MediaId is not for the current media.
+  @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack
+                               of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_FLUSH_EX) (
+  IN     EFI_BLOCK_IO2_PROTOCOL   *This,
+  IN OUT EFI_BLOCK_IO2_TOKEN      *Token
+  );
+
+///
+///  The Block I/O2 protocol defines an extension to the Block I/O protocol which
+///  enables the ability to read and write data at a block level in a non-blocking
+//   manner.
+///
+struct _EFI_BLOCK_IO2_PROTOCOL {
+  ///
+  /// A pointer to the EFI_BLOCK_IO_MEDIA data for this device. 
+  /// Type EFI_BLOCK_IO_MEDIA is defined in BlockIo.h.
+  ///  
+  EFI_BLOCK_IO_MEDIA      *Media;
+
+  EFI_BLOCK_RESET_EX      Reset;
+  EFI_BLOCK_READ_EX       ReadBlocksEx;
+  EFI_BLOCK_WRITE_EX      WriteBlocksEx;
+  EFI_BLOCK_FLUSH_EX      FlushBlocksEx;
+};
+
+extern EFI_GUID gEfiBlockIo2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/BlockIoCrypto.h b/MdePkg/Include/Protocol/BlockIoCrypto.h
new file mode 100644
index 000000000000..ffac54b3b157
--- /dev/null
+++ b/MdePkg/Include/Protocol/BlockIoCrypto.h
@@ -0,0 +1,527 @@
+/** @file
+  The UEFI Inline Cryptographic Interface protocol provides services to abstract
+  access to inline cryptographic capabilities.
+
+  Copyright (c) 2015, 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 __BLOCK_IO_CRYPTO_H__
+#define __BLOCK_IO_CRYPTO_H__
+
+#include <Protocol/BlockIo.h>
+
+#define EFI_BLOCK_IO_CRYPTO_PROTOCOL_GUID \
+    { \
+      0xa00490ba, 0x3f1a, 0x4b4c, {0xab, 0x90, 0x4f, 0xa9, 0x97, 0x26, 0xa1, 0xe8} \
+    }
+
+typedef struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL  EFI_BLOCK_IO_CRYPTO_PROTOCOL;
+
+///
+/// The struct of Block I/O Crypto Token.
+///
+typedef struct {
+  //
+  // If Event is NULL, then blocking I/O is performed. If Event is not NULL and
+  // non-blocking I/O is supported, then non-blocking I/O is performed, and
+  // Event will be signaled when the read request is completed and data was
+  // decrypted  (when Index was specified).
+  //
+  EFI_EVENT               Event;
+  //
+  // Defines whether or not the signaled event encountered an error.
+  //
+  EFI_STATUS              TransactionStatus;
+} EFI_BLOCK_IO_CRYPTO_TOKEN;
+
+typedef struct {
+  //
+  // GUID of the algorithm.
+  //
+  EFI_GUID       Algorithm;
+  //
+  // Specifies KeySizein bits used with this Algorithm.
+  //
+  UINT64         KeySize;
+  //
+  // Specifies bitmask of block sizes supported by this algorithm.
+  // Bit j being set means that 2^j bytes crypto block size is supported.
+  //
+  UINT64         CryptoBlockSizeBitMask;
+} EFI_BLOCK_IO_CRYPTO_CAPABILITY;
+
+///
+/// EFI_BLOCK_IO_CRYPTO_IV_INPUT structure is used as a common header in CryptoIvInput
+/// parameters passed to the ReadExtended and WriteExtended methods for Inline
+/// Cryptographic Interface.
+/// Its purpose is to pass size of the entire CryptoIvInputparameter memory buffer to
+/// the Inline Cryptographic Interface.
+///
+typedef struct {
+  UINT64         InputSize;
+} EFI_BLOCK_IO_CRYPTO_IV_INPUT;
+
+#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_XTS \
+    { \
+      0x2f87ba6a, 0x5c04, 0x4385, {0xa7, 0x80, 0xf3, 0xbf, 0x78, 0xa9, 0x7b, 0xec} \
+    }
+
+extern EFI_GUID gEfiBlockIoCryptoAlgoAesXtsGuid;
+
+typedef struct {
+  EFI_BLOCK_IO_CRYPTO_IV_INPUT Header;
+  UINT64                       CryptoBlockNumber;
+  UINT64                       CryptoBlockByteSize;
+} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_XTS;
+
+#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_CBC_MICROSOFT_BITLOCKER \
+    { \
+      0x689e4c62, 0x70bf, 0x4cf3, {0x88, 0xbb, 0x33, 0xb3, 0x18, 0x26, 0x86, 0x70} \
+    }
+
+extern EFI_GUID gEfiBlockIoCryptoAlgoAesCbcMsBitlockerGuid;
+
+typedef struct {
+  EFI_BLOCK_IO_CRYPTO_IV_INPUT  Header;
+  UINT64                        CryptoBlockByteOffset;
+  UINT64                        CryptoBlockByteSize;
+} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_CBC_MICROSOFT_BITLOCKER;
+
+#define EFI_BLOCK_IO_CRYPTO_INDEX_ANY 0xFFFFFFFFFFFFFFFF
+
+typedef struct {
+  //
+  // Is inline cryptographic capability supported on this device.
+  //
+  BOOLEAN                         Supported;
+  //
+  // Maximum number of keys that can be configured at the same time.
+  //
+  UINT64                          KeyCount;
+  //
+  // Number of supported capabilities.
+  //
+  UINT64                          CapabilityCount;
+  //
+  // Array of supported capabilities.
+  //
+  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capabilities[1];
+} EFI_BLOCK_IO_CRYPTO_CAPABILITIES;
+
+typedef struct {
+  //
+  // Configuration table index. A special Index EFI_BLOCK_IO_CRYPTO_INDEX_ANY can be
+  // used to set any available entry in the configuration table.
+  //
+  UINT64                          Index;
+  //
+  // Identifies the owner of the configuration table entry. Entry can also be used
+  // with the Nil value to clear key from the configuration table index.
+  //
+  EFI_GUID                        KeyOwnerGuid;
+  //
+  // A supported capability to be used. The CryptoBlockSizeBitMask field of the
+  // structure should have only one bit set from the supported mask.
+  //
+  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capability;
+  //
+  // Pointer to the key. The size of the key is defined by the KeySize field of
+  // the capability specified by the Capability parameter.
+  //
+  VOID                            *CryptoKey;
+} EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY;
+
+typedef struct {
+  //
+  // Configuration table index.
+  //
+  UINT64                          Index;
+  //
+  // Identifies the current owner of the entry.
+  //
+  EFI_GUID                        KeyOwnerGuid;
+  //
+  // The capability to be used. The CryptoBlockSizeBitMask field of the structure
+  // has only one bit set from the supported mask.
+  //
+  EFI_BLOCK_IO_CRYPTO_CAPABILITY  Capability;
+} EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY;
+
+/**
+  Reset the block device hardware.
+
+  The Reset() function resets the block device hardware.
+
+  As part of the initialization process, the firmware/device will make a quick but
+  reasonable attempt to verify that the device is functioning.
+
+  If the ExtendedVerificationflag is TRUE the firmware may take an extended amount
+  of time to verify the device is operating on reset. Otherwise the reset operation
+  is to occur as quickly as possible.
+
+  The hardware verification process is not defined by this specification and is left
+  up to the platform firmware or driver to implement.
+
+  @param[in]  This                 Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in]  ExtendedVerification Indicates that the driver may perform a more exhausive
+                                   verification operation of the device during reset.
+
+  @retval EFI_SUCCESS              The block device was reset.
+  @retval EFI_DEVICE_ERROR         The block device is not functioning correctly and could
+                                   not be reset.
+  @retval EFI_INVALID_PARAMETER    This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_RESET) (
+  IN EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
+  IN BOOLEAN                       ExtendedVerification
+  );
+
+/**
+  Get the capabilities of the underlying inline cryptographic interface.
+
+  The GetCapabilities() function determines whether pre-OS controllable inline crypto
+  is supported by the system for the current disk and, if so, returns the capabilities
+  of the crypto engine.
+
+  The caller is responsible for providing the Capabilities structure with a sufficient
+  number of entries.
+
+  If the structure is too small, the EFI_BUFFER_TOO_SMALL error code is returned and the
+  CapabilityCount field contains the number of entries needed to contain the capabilities.
+
+  @param[in]  This              Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[out] Capabilities      Pointer to the EFI_BLOCK_IO_CRYPTO_CAPABILITIES structure.
+
+  @retval EFI_SUCCESS           The ICI is ready for use.
+  @retval EFI_BUFFER_TOO_SMALL  The Capabilities structure was too small. The number of
+                                entries needed is returned in the CapabilityCount field
+                                of the structure.
+  @retval EFI_NO_RESPONSE       No response was received from the ICI.
+  @retval EFI_DEVICE_ERROR      An error occurred when attempting to access the ICI.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER Capabilities is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL           *This,
+     OUT EFI_BLOCK_IO_CRYPTO_CAPABILITIES       *Capabilities
+  );
+
+/**
+  Set the configuration of the underlying inline cryptographic interface.
+
+  The SetConfiguration() function allows the user to set the current configuration of the
+  inline cryptographic interface and should be called before attempting any crypto operations.
+
+  This configures the configuration table entries with algorithms, key sizes and keys. Each
+  configured entry can later be referred to by index at the time of storage transaction.
+
+  The configuration table index will refer to the combination ofKeyOwnerGuid, Algorithm, and
+  CryptoKey.
+
+  KeyOwnerGuid identifies the component taking ownership of the entry. It helps components to
+  identify their own entries, cooperate with other owner components, and avoid conflicts. This
+  Guid identifier is there to help coordination between cooperating components and not a security
+  or synchronization feature. The Nil GUID can be used by a component to release use of entry
+  owned. It is also used to identify potentially available entries (see GetConfiguration).
+
+  CryptoKey specifies algorithm-specific key material to use within parameters of selected crypto
+  capability.
+
+  This function is called infrequently typically once, on device start, before IO starts. It
+  can be called at later times in cases the number of keysused on the drive is higher than what
+  can be configured at a time or a new key has to be added.
+
+  Components setting or changing an entry or entries for a given index or indices must ensure
+  that IO referencing affected indices is temporarily blocked (run-down) at the time of change.
+
+  Indices parameters in each parameter table entry allow to set only a portion of the available
+  table entries in the crypto module anywhere from single entry to entire table supported.
+
+  If corresponding table entry or entries being set are already in use by another owner the call
+  should be failed and none of the entries should be modified. The interface implementation must
+  enforce atomicity of this operation (should either succeed fully or fail completely without
+  modifying state).
+
+  Note that components using GetConfiguration command to discover available entries should be
+  prepared that by the time of calling SetConfiguration the previously available entry may have
+  become occupied. Such components should be prepared to re-try the sequence of operations.
+
+  Alternatively EFI_BLOCK_IO_CRYPTO_INDEX_ANY can be used to have the implementation discover
+  and allocate available,if any, indices atomically.
+
+  An optional ResultingTable pointer can be provided by the caller to receive the newly configured
+  entries. The array provided by the caller must have at least ConfigurationCount of entries.
+
+  @param[in]  This                Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in]  ConfigurationCount  Number of entries being configured with this call.
+  @param[in]  ConfigurationTable  Pointer to a table used to populate the configuration table.
+  @param[out] ResultingTable      Optional pointer to a table that receives the newly configured
+                                  entries.
+
+  @retval EFI_SUCCESS             The ICI is ready for use.
+  @retval EFI_NO_RESPONSE         No response was received from the ICI.
+  @retval EFI_DEVICE_ERROR        An error occurred when attempting to access the ICI.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_INVALID_PARAMETER   ConfigurationTable is NULL.
+  @retval EFI_INVALID_PARAMETER   ConfigurationCount is 0.
+  @retval EFI_OUT_OF_RESOURCES    Could not find the requested number of available entries in the
+                                  configuration table.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL                     *This,
+  IN     UINT64                                           ConfigurationCount,
+  IN     EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY    *ConfigurationTable,
+     OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY *ResultingTable OPTIONAL
+  );
+
+/**
+  Get the configuration of the underlying inline cryptographic interface.
+
+  The GetConfiguration() function allows the user to get the configuration of the inline
+  cryptographic interface.
+
+  Retrieves, entirely or partially, the currently configured key table. Note that the keys
+  themselves are not retrieved, but rather just indices, owner GUIDs and capabilities.
+
+  If fewer entries than specified by ConfigurationCount are returned, the Index field of the
+  unused entries is set to EFI_BLOCK_IO_CRYPTO_INDEX_ANY.
+
+  @param[in]  This                Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in]  StartIndex          Configuration table index at which to start the configuration
+                                  query.
+  @param[in]  ConfigurationCount  Number of entries to return in the response table.
+  @param[in]  KeyOwnerGuid        Optional parameter to filter response down to entries with a
+                                  given owner. A pointer to the Nil value can be used to return
+                                  available entries. Set to NULL when no owner filtering is required.
+  @param[out] ConfigurationTable  Table of configured configuration table entries (with no CryptoKey
+                                  returned): configuration table index, KeyOwnerGuid, Capability.
+                                  Should have sufficient space to store up to ConfigurationCount
+                                  entries.
+
+  @retval EFI_SUCCESS             The ICI is ready for use.
+  @retval EFI_NO_RESPONSE         No response was received from the ICI.
+  @retval EFI_DEVICE_ERROR        An error occurred when attempting to access the ICI.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_INVALID_PARAMETER   Configuration table is NULL.
+  @retval EFI_INVALID_PARAMETER   StartIndex is out of bounds.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL                     *This,
+  IN     UINT64                                           StartIndex,
+  IN     UINT64                                           ConfigurationCount,
+  IN     EFI_GUID                                         *KeyOwnerGuid OPTIONAL,
+     OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY *ConfigurationTable
+);
+
+/**
+  Reads the requested number of blocks from the device and optionally decrypts
+  them inline.
+
+  TheReadExtended() function allows the caller to perform a storage device read
+  operation. The function reads the requested number of blocks from the device
+  and then if Index is specified decrypts them inline. All the blocks are read
+  and decrypted (if decryption requested),  or an error is returned.
+
+  If there is no media in the device, the function returns EFI_NO_MEDIA. If the
+  MediaId is not the ID for the current media in the device, the function returns
+  EFI_MEDIA_CHANGED.
+
+  If EFI_DEVICE_ERROR, EFI_NO_MEDIA, or EFI_MEDIA_CHANGED is returned and nonblocking
+  I/O is being used, the Event associated with this request will not be signaled.
+
+  In addition to standard storage transaction parameters (LBA, IO size, and buffer),
+  this command will also specify a configuration table Index and CryptoIvInput
+  when data has  to be decrypted inline by the controller after being read from
+  the storage device. If an Index parameter is not specified, no decryption is
+  performed.
+
+  @param[in]      This          Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in]      MediaId       The media ID that the read request is for.
+  @param[in]      LBA           The starting logical block address to read from on
+                                the device.
+  @param[in, out] Token         A pointer to the token associated with the transaction.
+  @param[in]      BufferSize    The size of the Buffer in bytes. This must be a multiple
+                                of the intrinsic block size of the device.
+  @param[out]     Buffer        A pointer to the destination buffer for the data. The
+                                caller is responsible for either having implicit or
+                                explicit ownership of the buffer.
+  @param[in]      Index         A pointer to the configuration table index. This is
+                                optional.
+  @param[in]      CryptoIvInput A pointer to a buffer that contains additional
+                                cryptographic parameters as required by the capability
+                                referenced by the configuration table index, such as
+                                cryptographic initialization vector.
+
+  @retval EFI_SUCCESS           The read request was queued if Token-> Event is not NULL.
+                                The data was read correctly from the device if the
+                                Token->Event is NULL.
+  @retval EFI_DEVICE_ERROR      The device reported an error while attempting to perform
+                                the read operation and/or decryption operation.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId is not for the current media.
+  @retval EFI_BAD_BUFFER_SIZE   The BufferSize parameter is not a multiple of the intrinsic
+                                block size of the device.
+  @retval EFI_INVALID_PARAMETER This is NULL, or the read request contains LBAs that are
+                                not valid, or the buffer is not on proper alignment.
+  @retval EFI_INVALID_PARAMETER CryptoIvInput is incorrect.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of
+                                resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_READ_EXTENDED) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
+  IN     UINT32                        MediaId,
+  IN     EFI_LBA                       LBA,
+  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token,
+  IN     UINT64                        BufferSize,
+     OUT VOID                          *Buffer,
+  IN     UINT64                        *Index OPTIONAL,
+  IN     VOID                          *CryptoIvInput OPTIONAL
+  );
+
+/**
+  Optionally encrypts a specified number of blocks inline and then writes to the
+  device.
+
+  The WriteExtended() function allows the caller to perform a storage device write
+  operation. The function encrypts the requested number of blocks inline if Index
+  is specified  and then writes them to the device. All the blocks are encrypted
+  (if encryption requested) and  written, or an error is returned.
+
+  If there is no media in the device, the function returns EFI_NO_MEDIA. If the
+  MediaId is not the ID for the current media in the device, the function returns
+  EFI_MEDIA_CHANGED.
+
+  If EFI_DEVICE_ERROR, EFI_NO_MEDIA, or EFI_MEDIA_CHANGED is returned and nonblocking
+  I/O is being used, the Event associated with this request will not be signaled.
+
+  In addition to standard storage transaction parameters (LBA, IO size, and buffer),
+  this command will also specify a configuration table Index and a CryptoIvInput
+  when data has to be decrypted inline by the controller before being written to
+  the storage device. If no Index parameter is specified, no encryption is performed.
+
+  @param[in]      This          Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in]      MediaId       The media ID that the read request is for.
+  @param[in]      LBA           The starting logical block address to read from on
+                                the device.
+  @param[in, out] Token         A pointer to the token associated with the transaction.
+  @param[in]      BufferSize    The size of the Buffer in bytes. This must be a multiple
+                                of the intrinsic block size of the device.
+  @param[in]      Buffer        A pointer to the source buffer for the data.
+  @param[in]      Index         A pointer to the configuration table index. This is
+                                optional.
+  @param[in]      CryptoIvInput A pointer to a buffer that contains additional
+                                cryptographic parameters as required by the capability
+                                referenced by the configuration table index, such as
+                                cryptographic initialization vector.
+
+  @retval EFI_SUCCESS           The request to encrypt (optionally) and write was queued
+                                if Event is not NULL. The data was encrypted (optionally)
+                                and written correctly to the device if the Event is NULL.
+  @retval EFI_WRITE_PROTECTED   The device cannot be written to.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId is not for the current media.
+  @retval EFI_DEVICE_ERROR      The device reported an error while attempting to encrypt
+                                blocks or to perform the write operation.
+  @retval EFI_BAD_BUFFER_SIZE   The BufferSize parameter is not a multiple of the intrinsic
+                                block size of the device.
+  @retval EFI_INVALID_PARAMETER This is NULL, or the write request contains LBAs that are
+                                not valid, or the buffer is not on proper alignment.
+  @retval EFI_INVALID_PARAMETER CryptoIvInput is incorrect.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of
+                                resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
+  IN     UINT32                        MediaId,
+  IN     EFI_LBA                       LBA,
+  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token,
+  IN     UINT64                        BufferSize,
+  IN     VOID                          *Buffer,
+  IN     UINT64                        *Index OPTIONAL,
+  IN     VOID                          *CryptoIvInput OPTIONAL
+  );
+
+/**
+  Flushes all modified data toa physical block device.
+
+  The FlushBlocks() function flushes all modified data to the physical block device.
+  Any modified data that has to be encrypted must have been already encrypted as a
+  part of WriteExtended() operation - inline crypto operation cannot be a part of
+  flush operation.
+
+  All data written to the device prior to the flush must be physically written before
+  returning EFI_SUCCESS from this function. This would include any cached data the
+  driver may have cached, and cached data the device may have cached. A flush may
+  cause a read request following the flush to force a device access.
+
+  If EFI_DEVICE_ERROR, EFI_NO_MEDIA, EFI_WRITE_PROTECTED or EFI_MEDIA_CHANGED is
+  returned and non-blocking I/O is being used, the Event associated with this request
+  will not be signaled.
+
+  @param[in]      This          Pointer to the EFI_BLOCK_IO_CRYPTO_PROTOCOL instance.
+  @param[in, out] Token         A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS           The flush request was queued if Event is not NULL. All
+                                outstanding data was written correctly to the device if
+                                the Event is NULL.
+  @retval EFI_DEVICE_ERROR      The device reported an error while attempting to write data.
+  @retval EFI_WRITE_PROTECTED   The device cannot be written to.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHANGED     The MediaId is not for the current media.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of
+                                resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_IO_CRYPTO_FLUSH) (
+  IN     EFI_BLOCK_IO_CRYPTO_PROTOCOL  *This,
+  IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN     *Token
+  );
+
+///
+/// The EFI_BLOCK_IO_CRYPTO_PROTOCOL defines a UEFI protocol that can be used by UEFI
+/// drivers and applications to perform block encryption on a storage device, such as UFS.
+///
+struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL {
+  EFI_BLOCK_IO_MEDIA                        *Media;
+  EFI_BLOCK_IO_CRYPTO_RESET                 Reset;
+  EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES      GetCapabilities;
+  EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION     SetConfiguration;
+  EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION     GetConfiguration;
+  EFI_BLOCK_IO_CRYPTO_READ_EXTENDED         ReadExtended;
+  EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED        WriteExtended;
+  EFI_BLOCK_IO_CRYPTO_FLUSH                 FlushBlocks;
+};
+
+extern EFI_GUID gEfiBlockIoCryptoProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/BluetoothConfig.h b/MdePkg/Include/Protocol/BluetoothConfig.h
new file mode 100644
index 000000000000..cc72b1e21a6a
--- /dev/null
+++ b/MdePkg/Include/Protocol/BluetoothConfig.h
@@ -0,0 +1,514 @@
+/** @file
+  EFI Bluetooth Configuration Protocol as defined in UEFI 2.5.
+  This protocol abstracts user interface configuration for Bluetooth device.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_BLUETOOTH_CONFIG_PROTOCOL_H__
+#define __EFI_BLUETOOTH_CONFIG_PROTOCOL_H__
+
+#include <IndustryStandard/Bluetooth.h>
+
+#define EFI_BLUETOOTH_CONFIG_PROTOCOL_GUID \
+  { \
+    0x62960cf3, 0x40ff, 0x4263, { 0xa7, 0x7c, 0xdf, 0xde, 0xbd, 0x19, 0x1b, 0x4b } \
+  }
+  
+typedef struct _EFI_BLUETOOTH_CONFIG_PROTOCOL EFI_BLUETOOTH_CONFIG_PROTOCOL;
+
+typedef UINT32      EFI_BLUETOOTH_CONFIG_REMOTE_DEVICE_STATE_TYPE;
+#define EFI_BLUETOOTH_CONFIG_REMOTE_DEVICE_STATE_CONNECTED    0x1
+#define EFI_BLUETOOTH_CONFIG_REMOTE_DEVICE_STATE_PAIRED       0x2
+
+///
+/// EFI_BLUETOOTH_SCAN_CALLBACK_INFORMATION
+///
+typedef struct {
+  ///
+  /// 48bit Bluetooth device address.
+  ///
+  BLUETOOTH_ADDRESS         BDAddr;
+  ///
+  /// State of the remote deive 
+  ///
+  UINT8                     RemoteDeviceState;
+  ///
+  /// Bluetooth ClassOfDevice. See Bluetooth specification for detail.
+  ///
+  BLUETOOTH_CLASS_OF_DEVICE ClassOfDevice;
+  ///
+  /// Remote device name
+  ///
+  UINT8                     RemoteDeviceName[BLUETOOTH_HCI_COMMAND_LOCAL_READABLE_NAME_MAX_SIZE];
+} EFI_BLUETOOTH_SCAN_CALLBACK_INFORMATION;
+
+///
+/// EFI_BLUETOOTH_CONFIG_DATA_TYPE
+///
+typedef enum {
+  ///
+  /// Local/Remote Bluetooth device name. Data structure is zero terminated CHAR8[].
+  ///
+  EfiBluetoothConfigDataTypeDeviceName,
+  ///
+  /// Local/Remote Bluetooth device ClassOfDevice. Data structure is BLUETOOTH_CLASS_OF_DEVICE.
+  ///
+  EfiBluetoothConfigDataTypeClassOfDevice,
+  ///
+  /// Remote Bluetooth device state. Data structure is EFI_BLUETOOTH_CONFIG_REMOTE_DEVICE_STATE_TYPE.
+  ///
+  EfiBluetoothConfigDataTypeRemoteDeviceState,
+  ///
+  /// Local/Remote Bluetooth device SDP information. Data structure is UINT8[].
+  ///
+  EfiBluetoothConfigDataTypeSdpInfo,
+  ///
+  /// Local Bluetooth device address. Data structure is BLUETOOTH_ADDRESS.
+  ///
+  EfiBluetoothConfigDataTypeBDADDR,
+  ///
+  /// Local Bluetooth discoverable state. Data structure is UINT8. (Page scan and/or Inquiry scan)
+  ///
+  EfiBluetoothConfigDataTypeDiscoverable,
+  ///
+  /// Local Bluetooth controller stored paired device list. Data structure is BLUETOOTH_ADDRESS[].
+  ///
+  EfiBluetoothConfigDataTypeControllerStoredPairedDeviceList,
+  ///
+  /// Local available device list. Data structure is BLUETOOTH_ADDRESS[].
+  ///
+  EfiBluetoothConfigDataTypeAvailableDeviceList,
+  EfiBluetoothConfigDataTypeMax,
+} EFI_BLUETOOTH_CONFIG_DATA_TYPE;
+
+///
+/// EFI_BLUETOOTH_PIN_CALLBACK_TYPE.
+///
+typedef enum {
+  ///
+  /// For SSP - passkey entry. Input buffer is Passkey (4 bytes). No output buffer. 
+  /// See Bluetooth HCI command for detail.
+  ///
+  EfiBluetoothCallbackTypeUserPasskeyNotification,
+  ///
+  /// For SSP - just work and numeric comparison. Input buffer is numeric value (4 bytes). 
+  /// Output buffer is BOOLEAN (1 byte). See Bluetooth HCI command for detail.
+  ///
+  EfiBluetoothCallbackTypeUserConfirmationRequest,
+  ///
+  /// For SSP - OOB. See Bluetooth HCI command for detail.
+  ///
+  EfiBluetoothCallbackTypeOOBDataRequest,
+  ///
+  /// For legacy paring. No input buffer. Output buffer is PIN code( <= 16 bytes). 
+  /// See Bluetooth HCI command for detail.
+  ///
+  EfiBluetoothCallbackTypePinCodeRequest,
+  EfiBluetoothCallbackTypeMax
+} EFI_BLUETOOTH_PIN_CALLBACK_TYPE;
+
+///
+/// EFI_BLUETOOTH_CONNECT_COMPLETE_CALLBACK_TYPE.
+///
+typedef enum {
+  ///
+  /// This callback is called when Bluetooth receive Disconnection_Complete event. Input buffer is Event 
+  /// Parameters of Disconnection_Complete Event defined in Bluetooth specification.
+  ///
+  EfiBluetoothConnCallbackTypeDisconnected,
+  ///
+  /// This callback is called when Bluetooth receive Connection_Complete event. Input buffer is Event 
+  /// Parameters of Connection_Complete Event defined in Bluetooth specification.
+  ///
+  EfiBluetoothConnCallbackTypeConnected,
+  ///
+  /// This callback is called when Bluetooth receive Authentication_Complete event. Input buffer is Event 
+  /// Parameters of Authentication_Complete Event defined in Bluetooth specification.
+  ///
+  EfiBluetoothConnCallbackTypeAuthenticated,
+  ///
+  /// This callback is called when Bluetooth receive Encryption_Change event. Input buffer is Event 
+  /// Parameters of Encryption_Change Event defined in Bluetooth specification.
+  ///
+  EfiBluetoothConnCallbackTypeEncrypted
+} EFI_BLUETOOTH_CONNECT_COMPLETE_CALLBACK_TYPE;
+
+  
+/**
+  Initialize Bluetooth host controller and local device.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The Bluetooth host controller and local device is initialized successfully.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to initialize the Bluetooth host controller 
+                                and local device.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_INIT)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL  *This
+  );
+  
+/**
+  Callback function, it is called if a Bluetooth device is found during scan process.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Context         Context passed from scan request.
+  @param  CallbackInfo    Data related to scan result. NULL CallbackInfo means scan complete.
+
+  @retval EFI_SUCCESS       The callback function complete successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_SCAN_CALLBACK_FUNCTION) (
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL            *This,
+  IN VOID                                     *Context,
+  IN EFI_BLUETOOTH_SCAN_CALLBACK_INFORMATION  *CallbackInfo
+  );
+  
+/**
+  Scan Bluetooth device.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  ReScan        If TRUE, a new scan request is submitted no matter there is scan result before. 
+                        If FALSE and there is scan result, the previous scan result is returned and no scan request 
+                        is submitted.
+  @param  ScanType      Bluetooth scan type, Inquiry and/or Page. See Bluetooth specification for detail.
+  @param  Callback      The callback function. This function is called if a Bluetooth device is found during scan 
+                        process.
+  @param  Context       Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The Bluetooth scan request is submitted.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to scan the Bluetooth device.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_SCAN)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN BOOLEAN                                        ReScan,
+  IN UINT8                                          ScanType,
+  IN EFI_BLUETOOTH_CONFIG_SCAN_CALLBACK_FUNCTION    Callback,
+  IN VOID                                           *Context
+  );
+  
+/**
+  Connect a Bluetooth device.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  BD_ADDR       The address of Bluetooth device to be connected.
+
+  @retval EFI_SUCCESS           The Bluetooth device is connected successfully.
+  @retval EFI_ALREADY_STARTED   The Bluetooth device is already connected.
+  @retval EFI_NOT_FOUND         The Bluetooth device is not found.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to connect the Bluetooth device.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_CONNECT)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN BLUETOOTH_ADDRESS                              *BD_ADDR
+  );
+
+/**
+  Disconnect a Bluetooth device.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  BD_ADDR       The address of Bluetooth device to be connected.
+  @param  Reason        Bluetooth disconnect reason. See Bluetooth specification for detail.
+
+  @retval EFI_SUCCESS           The Bluetooth device is disconnected successfully.
+  @retval EFI_NOT_STARTED       The Bluetooth device is not connected.
+  @retval EFI_NOT_FOUND         The Bluetooth device is not found.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to disconnect the Bluetooth device.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_DISCONNECT)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN BLUETOOTH_ADDRESS                              *BD_ADDR,
+  IN UINT8                                          Reason
+  );
+  
+/**
+  Get Bluetooth configuration data.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  DataType      Configuration data type.
+  @param  DataSize      On input, indicates the size, in bytes, of the data buffer specified by Data.
+                        On output, indicates the amount of data actually returned.
+  @param  Data          A pointer to the buffer of data that will be returned.
+
+  @retval EFI_SUCCESS           The Bluetooth configuration data is returned successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataSize is NULL.
+                                - *DataSize is 0.
+                                - Data is NULL.
+  @retval EFI_UNSUPPORTED       The DataType is unsupported.
+  @retval EFI_NOT_FOUND         The DataType is not found.
+  @retval EFI_BUFFER_TOO_SMALL  The buffer is too small to hold the buffer.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_GET_DATA)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN EFI_BLUETOOTH_CONFIG_DATA_TYPE                 DataType,
+  IN OUT UINTN                                      *DataSize,
+  IN OUT VOID                                       *Data
+  );
+  
+/**
+  Set Bluetooth configuration data.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  DataType      Configuration data type.
+  @param  DataSize      Indicates the size, in bytes, of the data buffer specified by Data.
+  @param  Data          A pointer to the buffer of data that will be set.
+
+  @retval EFI_SUCCESS           The Bluetooth configuration data is set successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataSize is 0.
+                                - Data is NULL.
+  @retval EFI_UNSUPPORTED       The DataType is unsupported.
+  @retval EFI_BUFFER_TOO_SMALL  Cannot set configuration data.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_SET_DATA)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN EFI_BLUETOOTH_CONFIG_DATA_TYPE                 DataType,
+  IN UINTN                                          DataSize,
+  IN VOID                                           *Data
+  );
+  
+/**
+  Get remove Bluetooth device configuration data.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  DataType      Configuration data type.
+  @param  BDAddr        Remote Bluetooth device address.
+  @param  DataSize      On input, indicates the size, in bytes, of the data buffer specified by Data.
+                        On output, indicates the amount of data actually returned.
+  @param  Data          A pointer to the buffer of data that will be returned.
+
+  @retval EFI_SUCCESS           The remote Bluetooth device configuration data is returned successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataSize is NULL.
+                                - *DataSize is 0.
+                                - Data is NULL.
+  @retval EFI_UNSUPPORTED       The DataType is unsupported.
+  @retval EFI_NOT_FOUND         The DataType is not found.
+  @retval EFI_BUFFER_TOO_SMALL  The buffer is too small to hold the buffer.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_GET_REMOTE_DATA)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN EFI_BLUETOOTH_CONFIG_DATA_TYPE                 DataType,
+  IN BLUETOOTH_ADDRESS                              BDAddr,
+  IN OUT UINTN                                      *DataSize,
+  IN OUT VOID                                       *Data
+  );
+  
+/**
+  The callback function for PIN code.
+
+  @param  This                Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Context             Context passed from registration.
+  @param  CallbackType        Callback type in EFI_BLUETOOTH_PIN_CALLBACK_TYPE.
+  @param  InputBuffer         A pointer to the buffer of data that is input from callback caller.
+  @param  InputBufferSize     Indicates the size, in bytes, of the data buffer specified by InputBuffer.
+  @param  OutputBuffer        A pointer to the buffer of data that will be output from callback callee. 
+                              Callee allocates this buffer by using EFI Boot Service AllocatePool().
+  @param  OutputBufferSize    Indicates the size, in bytes, of the data buffer specified by OutputBuffer.
+
+  @retval EFI_SUCCESS   The callback function complete successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_PIN_CALLBACK_FUNCTION)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                        *This,
+  IN VOID                                                 *Context,
+  IN EFI_BLUETOOTH_PIN_CALLBACK_TYPE                      CallbackType,
+  IN VOID                                                 *InputBuffer,
+  IN UINTN                                                InputBufferSize,
+  OUT VOID                                                **OutputBuffer,
+  OUT UINTN                                               *OutputBufferSize
+  );
+  
+/**
+  Register PIN callback function.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Callback      The callback function. NULL means unregister.
+  @param  Context       Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS   The PIN callback function is registered successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_PIN_CALLBACK)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                        *This,
+  IN EFI_BLUETOOTH_CONFIG_REGISTER_PIN_CALLBACK_FUNCTION  Callback,
+  IN VOID                                                 *Context
+  );
+
+/**
+  The callback function to get link key.
+
+  @param  This                Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Context             Context passed from registration.
+  @param  BDAddr              A pointer to Bluetooth device address.
+  @param  LinkKey             A pointer to the buffer of link key.
+
+  @retval EFI_SUCCESS   The callback function complete successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_GET_LINK_KEY_CALLBACK_FUNCTION)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL        *This,
+  IN VOID                                 *Context,
+  IN BLUETOOTH_ADDRESS                    *BDAddr,
+  OUT UINT8                               LinkKey[BLUETOOTH_HCI_LINK_KEY_SIZE]
+  );
+  
+/**
+  Register get link key callback function.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Callback      The callback function. NULL means unregister.
+  @param  Context       Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS   The link key callback function is registered successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_GET_LINK_KEY_CALLBACK)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                                  *This,
+  IN EFI_BLUETOOTH_CONFIG_REGISTER_GET_LINK_KEY_CALLBACK_FUNCTION   Callback,
+  IN VOID                                                           *Context
+  );
+  
+/**
+  The callback function to set link key.
+
+  @param  This                Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Context             Context passed from registration.
+  @param  BDAddr              A pointer to Bluetooth device address.
+  @param  LinkKey             A pointer to the buffer of link key.
+
+  @retval EFI_SUCCESS   The callback function complete successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_SET_LINK_KEY_CALLBACK_FUNCTION)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL        *This,
+  IN VOID                                 *Context,
+  IN BLUETOOTH_ADDRESS                    *BDAddr,
+  IN UINT8                                LinkKey[BLUETOOTH_HCI_LINK_KEY_SIZE]
+  );
+  
+/**
+  Register set link key callback function.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Callback      The callback function. NULL means unregister.
+  @param  Context       Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS   The link key callback function is registered successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_SET_LINK_KEY_CALLBACK)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                                  *This,
+  IN EFI_BLUETOOTH_CONFIG_REGISTER_SET_LINK_KEY_CALLBACK_FUNCTION   Callback,
+  IN VOID                                                           *Context
+  );
+  
+/**
+  The callback function. It is called after connect completed.
+
+  @param  This                Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Context             Context passed from registration.
+  @param  CallbackType        Callback type in EFI_BLUETOOTH_CONNECT_COMPLETE_CALLBACK_TYPE.
+  @param  BDAddr              A pointer to Bluetooth device address.
+  @param  InputBuffer         A pointer to the buffer of data that is input from callback caller.
+  @param  InputBufferSize     Indicates the size, in bytes, of the data buffer specified by InputBuffer.
+
+  @retval EFI_SUCCESS   The callback function complete successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_CONNECT_COMPLETE_CALLBACK_FUNCTION)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                  *This,
+  IN VOID                                           *Context,
+  IN EFI_BLUETOOTH_CONNECT_COMPLETE_CALLBACK_TYPE   CallbackType,
+  IN BLUETOOTH_ADDRESS                              *BDAddr,
+  IN VOID                                           *InputBuffer,
+  IN UINTN                                          InputBufferSize
+  );
+  
+/**
+  Register link connect complete callback function.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_CONFIG_PROTOCOL instance.
+  @param  Callback      The callback function. NULL means unregister.
+  @param  Context       Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS   The link connect complete callback function is registered successfully.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_CONFIG_REGISTER_CONNECT_COMPLETE_CALLBACK)(
+  IN EFI_BLUETOOTH_CONFIG_PROTOCOL                                      *This,
+  IN EFI_BLUETOOTH_CONFIG_REGISTER_CONNECT_COMPLETE_CALLBACK_FUNCTION   Callback,
+  IN VOID                                                               *Context
+  );
+  
+///
+/// This protocol abstracts user interface configuration for Bluetooth device.
+///
+struct _EFI_BLUETOOTH_CONFIG_PROTOCOL {
+  EFI_BLUETOOTH_CONFIG_INIT                               Init;
+  EFI_BLUETOOTH_CONFIG_SCAN                               Scan;
+  EFI_BLUETOOTH_CONFIG_CONNECT                            Connect;
+  EFI_BLUETOOTH_CONFIG_DISCONNECT                         Disconnect;
+  EFI_BLUETOOTH_CONFIG_GET_DATA                           GetData;
+  EFI_BLUETOOTH_CONFIG_SET_DATA                           SetData;
+  EFI_BLUETOOTH_CONFIG_GET_REMOTE_DATA                    GetRemoteData;
+  EFI_BLUETOOTH_CONFIG_REGISTER_PIN_CALLBACK              RegisterPinCallback;
+  EFI_BLUETOOTH_CONFIG_REGISTER_GET_LINK_KEY_CALLBACK     RegisterGetLinkKeyCallback;
+  EFI_BLUETOOTH_CONFIG_REGISTER_SET_LINK_KEY_CALLBACK     RegisterSetLinkKeyCallback;
+  EFI_BLUETOOTH_CONFIG_REGISTER_CONNECT_COMPLETE_CALLBACK RegisterLinkConnectCompleteCallback;
+};
+
+extern EFI_GUID gEfiBluetoothConfigProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BluetoothHc.h b/MdePkg/Include/Protocol/BluetoothHc.h
new file mode 100644
index 000000000000..eb55079bb81c
--- /dev/null
+++ b/MdePkg/Include/Protocol/BluetoothHc.h
@@ -0,0 +1,328 @@
+/** @file
+  EFI Bluetooth Host Controller Protocol as defined in UEFI 2.5.
+  This protocol abstracts the Bluetooth host controller layer message transmit and receive.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_BLUETOOTH_HC_PROTOCOL_H__
+#define __EFI_BLUETOOTH_HC_PROTOCOL_H__
+
+#define EFI_BLUETOOTH_HC_PROTOCOL_GUID \
+  { \
+    0xb3930571, 0xbeba, 0x4fc5, { 0x92, 0x3, 0x94, 0x27, 0x24, 0x2e, 0x6a, 0x43 } \
+  }
+  
+typedef struct _EFI_BLUETOOTH_HC_PROTOCOL EFI_BLUETOOTH_HC_PROTOCOL;
+
+/**
+  Send HCI command packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be transmitted to Bluetooth host 
+                        controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI command packet is sent successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Sending HCI command packet fail due to timeout.
+  @retval EFI_DEVICE_ERROR      Sending HCI command packet fail due to host controller or device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_SEND_COMMAND)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+
+/**
+  Receive HCI event packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be received from Bluetooth host controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI event packet is received successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Receiving HCI event packet fail due to timeout.
+  @retval EFI_DEVICE_ERROR      Receiving HCI event packet fail due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_RECEIVE_EVENT)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Callback function, it is called when asynchronous transfer is completed.
+
+  @param  Data              Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  DataLength        Specifies the length, in bytes, of the data to be received.
+  @param  Context           Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS             The callback function complete successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_ASYNC_FUNC_CALLBACK) (
+  IN VOID                       *Data,
+  IN UINTN                      DataLength,
+  IN VOID                       *Context
+  );
+  
+/**
+  Receive HCI event packet in non-blocking way.
+
+  @param  This              Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  IsNewTransfer     If TRUE, a new transfer will be submitted. If FALSE, the request is deleted.
+  @param  PollingInterval   Indicates the periodic rate, in milliseconds, that the transfer is to be executed.
+  @param  DataLength        Specifies the length, in bytes, of the data to be received.
+  @param  Callback          The callback function. This function is called if the asynchronous transfer is 
+                            completed.
+  @param  Context           Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The HCI asynchronous receive request is submitted successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataLength is 0.
+                                - If IsNewTransfer is TRUE, and an asynchronous receive request already exists.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_ASYNC_RECEIVE_EVENT)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL            *This,
+  IN BOOLEAN                              IsNewTransfer,
+  IN UINTN                                PollingInterval,
+  IN UINTN                                DataLength,
+  IN EFI_BLUETOOTH_HC_ASYNC_FUNC_CALLBACK Callback,
+  IN VOID                                 *Context
+  );
+  
+/**
+  Send HCI ACL data packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be transmitted to Bluetooth host 
+                        controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI ACL data packet is sent successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Sending HCI ACL data packet fail due to timeout.
+  @retval EFI_DEVICE_ERROR      Sending HCI ACL data packet fail due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_SEND_ACL_DATA)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Receive HCI ACL data packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be received from Bluetooth host controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI ACL data packet is received successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Receiving HCI ACL data packet fail due to timeout.
+  @retval EFI_DEVICE_ERROR      Receiving HCI ACL data packet fail due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_RECEIVE_ACL_DATA)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+
+/**
+  Receive HCI ACL data packet in non-blocking way.
+
+  @param  This              Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  IsNewTransfer     If TRUE, a new transfer will be submitted. If FALSE, the request is deleted.
+  @param  PollingInterval   Indicates the periodic rate, in milliseconds, that the transfer is to be executed.
+  @param  DataLength        Specifies the length, in bytes, of the data to be received.
+  @param  Callback          The callback function. This function is called if the asynchronous transfer is 
+                            completed.
+  @param  Context           Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The HCI asynchronous receive request is submitted successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataLength is 0.
+                                - If IsNewTransfer is TRUE, and an asynchronous receive request already exists.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_ASYNC_RECEIVE_ACL_DATA) (
+  IN EFI_BLUETOOTH_HC_PROTOCOL            *This,
+  IN BOOLEAN                              IsNewTransfer,
+  IN UINTN                                PollingInterval,
+  IN UINTN                                DataLength,
+  IN EFI_BLUETOOTH_HC_ASYNC_FUNC_CALLBACK Callback,
+  IN VOID                                 *Context
+  );
+  
+/**
+  Send HCI SCO data packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be transmitted to Bluetooth host 
+                        controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI SCO data packet is sent successfully.
+  @retval EFI_UNSUPPORTED       The implementation does not support HCI SCO transfer.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Sending HCI SCO data packet fail due to timeout.
+  @retval EFI_DEVICE_ERROR      Sending HCI SCO data packet fail due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_SEND_SCO_DATA)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Receive HCI SCO data packet.
+
+  @param  This          Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  BufferSize    On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                        On output, indicates the amount of data actually transferred.
+  @param  Buffer        A pointer to the buffer of data that will be received from Bluetooth host controller.
+  @param  Timeout       Indicating the transfer should be completed within this time frame. The units are 
+                        in milliseconds. If Timeout is 0, then the caller must wait for the function to 
+                        be completed until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS           The HCI SCO data packet is received successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - BufferSize is NULL.
+                                - *BufferSize is 0.
+                                - Buffer is NULL.
+  @retval EFI_TIMEOUT           Receiving HCI SCO data packet fail due to timeout
+  @retval EFI_DEVICE_ERROR      Receiving HCI SCO data packet fail due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_RECEIVE_SCO_DATA)(
+  IN EFI_BLUETOOTH_HC_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer,
+  IN UINTN                      Timeout
+  );
+
+/**
+  Receive HCI SCO data packet in non-blocking way.
+
+  @param  This              Pointer to the EFI_BLUETOOTH_HC_PROTOCOL instance.
+  @param  IsNewTransfer     If TRUE, a new transfer will be submitted. If FALSE, the request is deleted.
+  @param  PollingInterval   Indicates the periodic rate, in milliseconds, that the transfer is to be executed.
+  @param  DataLength        Specifies the length, in bytes, of the data to be received.
+  @param  Callback          The callback function. This function is called if the asynchronous transfer is 
+                            completed.
+  @param  Context           Data passed into Callback function. This is optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The HCI asynchronous receive request is submitted successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - DataLength is 0.
+                                - If IsNewTransfer is TRUE, and an asynchronous receive request already exists.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_HC_ASYNC_RECEIVE_SCO_DATA) (
+  IN EFI_BLUETOOTH_HC_PROTOCOL            *This,
+  IN BOOLEAN                              IsNewTransfer,
+  IN UINTN                                PollingInterval,
+  IN UINTN                                DataLength,
+  IN EFI_BLUETOOTH_HC_ASYNC_FUNC_CALLBACK Callback,
+  IN VOID                                 *Context
+  );
+  
+///
+/// This protocol abstracts the Bluetooth host controller layer message transmit and receive.
+///
+struct _EFI_BLUETOOTH_HC_PROTOCOL {
+  EFI_BLUETOOTH_HC_SEND_COMMAND               SendCommand;
+  EFI_BLUETOOTH_HC_RECEIVE_EVENT              ReceiveEvent;
+  EFI_BLUETOOTH_HC_ASYNC_RECEIVE_EVENT        AsyncReceiveEvent;
+  EFI_BLUETOOTH_HC_SEND_ACL_DATA              SendACLData;
+  EFI_BLUETOOTH_HC_RECEIVE_ACL_DATA           ReceiveACLData;
+  EFI_BLUETOOTH_HC_ASYNC_RECEIVE_ACL_DATA     AsyncReceiveACLData;
+  EFI_BLUETOOTH_HC_SEND_SCO_DATA              SendSCOData;
+  EFI_BLUETOOTH_HC_RECEIVE_SCO_DATA           ReceiveSCOData;
+  EFI_BLUETOOTH_HC_ASYNC_RECEIVE_SCO_DATA     AsyncReceiveSCOData;
+};
+  
+extern EFI_GUID gEfiBluetoothHcProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BluetoothIo.h b/MdePkg/Include/Protocol/BluetoothIo.h
new file mode 100644
index 000000000000..652de57a95d6
--- /dev/null
+++ b/MdePkg/Include/Protocol/BluetoothIo.h
@@ -0,0 +1,416 @@
+/** @file
+  EFI Bluetooth IO Service Binding Protocol as defined in UEFI 2.5.
+  EFI Bluetooth IO Protocol as defined in UEFI 2.5.
+  The EFI Bluetooth IO Service Binding Protocol is used to locate EFI Bluetooth IO Protocol drivers to 
+  create and destroy child of the driver to communicate with other Bluetooth device by using Bluetooth IO protocol.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_BLUETOOTH_IO_PROTOCOL_H__
+#define __EFI_BLUETOOTH_IO_PROTOCOL_H__
+
+#include <IndustryStandard/Bluetooth.h>
+
+#define EFI_BLUETOOTH_IO_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x388278d3, 0x7b85, 0x42f0, { 0xab, 0xa9, 0xfb, 0x4b, 0xfd, 0x69, 0xf5, 0xab   } \
+  }
+  
+#define EFI_BLUETOOTH_IO_PROTOCOL_GUID \
+  { \
+    0x467313de, 0x4e30, 0x43f1, { 0x94, 0x3e, 0x32, 0x3f, 0x89, 0x84, 0x5d, 0xb5  } \
+  }
+  
+typedef struct _EFI_BLUETOOTH_IO_PROTOCOL EFI_BLUETOOTH_IO_PROTOCOL;
+
+///
+/// EFI_BLUETOOTH_DEVICE_INFO
+///
+typedef struct {
+  ///
+  /// The version of the structure
+  ///
+  UINT32                      Version;
+  ///
+  /// 48bit Bluetooth device address.
+  ///
+  BLUETOOTH_ADDRESS           BD_ADDR;
+  ///
+  /// Bluetooth PageScanRepetitionMode. See Bluetooth specification for detail.
+  ///
+  UINT8                       PageScanRepetitionMode;
+  ///
+  /// Bluetooth ClassOfDevice. See Bluetooth specification for detail.
+  ///
+  BLUETOOTH_CLASS_OF_DEVICE   ClassOfDevice;
+  ///
+  /// Bluetooth CloseOffset. See Bluetooth specification for detail.
+  ///
+  UINT16                      ClockOffset;
+  ///
+  /// Bluetooth RSSI. See Bluetooth specification for detail.
+  ///
+  UINT8                       RSSI;
+  ///
+  /// Bluetooth ExtendedInquiryResponse. See Bluetooth specification for detail.
+  ///
+  UINT8                       ExtendedInquiryResponse[240];
+} EFI_BLUETOOTH_DEVICE_INFO;
+
+/**
+  Get Bluetooth device information.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  DeviceInfoSize  A pointer to the size, in bytes, of the DeviceInfo buffer.
+  @param  DeviceInfo      A pointer to a callee allocated buffer that returns Bluetooth device information.
+
+  @retval EFI_SUCCESS           The Bluetooth device information is returned successfully.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the Bluetooth device information.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_GET_DEVICE_INFO)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  OUT UINTN                     *DeviceInfoSize,
+  OUT VOID                      **DeviceInfo
+  );
+  
+/**
+  Get Bluetooth SDP information.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  SdpInfoSize     A pointer to the size, in bytes, of the SdpInfo buffer.
+  @param  SdpInfo         A pointer to a callee allocated buffer that returns Bluetooth SDP information.
+
+  @retval EFI_SUCCESS           The Bluetooth device information is returned successfully.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the Bluetooth SDP information.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_GET_SDP_INFO)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  OUT UINTN                     *SdpInfoSize,
+  OUT VOID                      **SdpInfo
+  );
+  
+/**
+  Send L2CAP message (including L2CAP header).
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  BufferSize      On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                          On output, indicates the amount of data actually transferred.
+  @param  Buffer          A pointer to the buffer of data that will be transmitted to Bluetooth L2CAP layer.
+  @param  Timeout         Indicating the transfer should be completed within this time frame. The units are in 
+                          milliseconds. If Timeout is 0, then the caller must wait for the function to be completed 
+                          until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS             The L2CAP message is sent successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - BufferSize is NULL.
+                                  - *BufferSize is 0.
+                                  - Buffer is NULL.
+  @retval EFI_TIMEOUT             Sending L2CAP message fail due to timeout.
+  @retval EFI_DEVICE_ERROR        Sending L2CAP message fail due to host controller or device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_RAW_SEND)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Receive L2CAP message (including L2CAP header).
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  BufferSize      On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                          On output, indicates the amount of data actually transferred.
+  @param  Buffer          A pointer to the buffer of data that will be received from Bluetooth L2CAP layer.
+  @param  Timeout         Indicating the transfer should be completed within this time frame. The units are in 
+                          milliseconds. If Timeout is 0, then the caller must wait for the function to be completed 
+                          until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS             The L2CAP message is received successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - BufferSize is NULL.
+                                  - *BufferSize is 0.
+                                  - Buffer is NULL.
+  @retval EFI_TIMEOUT             Receiving L2CAP message fail due to timeout.
+  @retval EFI_DEVICE_ERROR        Receiving L2CAP message fail due to host controller or device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_RAW_RECEIVE)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Callback function, it is called when asynchronous transfer is completed.
+
+  @param  ChannelID         Bluetooth L2CAP message channel ID.
+  @param  Data              Data received via asynchronous transfer.
+  @param  DataLength        The length of Data in bytes, received via asynchronous transfer.
+  @param  Context           Context passed from asynchronous transfer request.
+
+  @retval EFI_SUCCESS       The callback function complete successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_ASYNC_FUNC_CALLBACK) (
+  IN UINT16                     ChannelID,
+  IN VOID                       *Data,
+  IN UINTN                      DataLength,
+  IN VOID                       *Context
+  );
+  
+/**
+  Receive L2CAP message (including L2CAP header) in non-blocking way.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  IsNewTransfer   If TRUE, a new transfer will be submitted. If FALSE, the request is deleted.
+  @param  PollingInterval Indicates the periodic rate, in milliseconds, that the transfer is to be executed.
+  @param  DataLength      Specifies the length, in bytes, of the data to be received.
+  @param  Callback        The callback function. This function is called if the asynchronous transfer is 
+                          completed.
+  @param  Context         Data passed into Callback function. This is optional parameter and may be NULL. 
+  
+  @retval EFI_SUCCESS             The L2CAP asynchronous receive request is submitted successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - DataLength is 0.
+                                  - If IsNewTransfer is TRUE, and an asynchronous receive request already exists.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_RAW_ASYNC_RECEIVE)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL              *This,
+  IN BOOLEAN                                IsNewTransfer,
+  IN UINTN                                  PollingInterval,
+  IN UINTN                                  DataLength,
+  IN EFI_BLUETOOTH_IO_ASYNC_FUNC_CALLBACK   Callback,
+  IN VOID                                   *Context
+  );
+
+/**
+  Send L2CAP message (excluding L2CAP header) to a specific channel.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handle          A handle created by EFI_BLUETOOTH_IO_PROTOCOL.L2CapConnect indicates which channel to send.
+  @param  BufferSize      On input, indicates the size, in bytes, of the data buffer specified by Buffer. 
+                          On output, indicates the amount of data actually transferred.
+  @param  Buffer          A pointer to the buffer of data that will be transmitted to Bluetooth L2CAP layer.
+  @param  Timeout         Indicating the transfer should be completed within this time frame. The units are in 
+                          milliseconds. If Timeout is 0, then the caller must wait for the function to be completed 
+                          until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS             The L2CAP message is sent successfully.
+  @retval EFI_NOT_FOUND           Handle is invalid or not found.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - BufferSize is NULL.
+                                  - *BufferSize is 0.
+                                  - Buffer is NULL.
+  @retval EFI_TIMEOUT             Sending L2CAP message fail due to timeout.
+  @retval EFI_DEVICE_ERROR        Sending L2CAP message fail due to host controller or device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_SEND)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  IN EFI_HANDLE                 Handle,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Receive L2CAP message (excluding L2CAP header) from a specific channel.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handle          A handle created by EFI_BLUETOOTH_IO_PROTOCOL.L2CapConnect indicates which channel to receive.
+  @param  BufferSize      Indicates the size, in bytes, of the data buffer specified by Buffer.
+  @param  Buffer          A pointer to the buffer of data that will be received from Bluetooth L2CAP layer.
+  @param  Timeout         Indicating the transfer should be completed within this time frame. The units are in 
+                          milliseconds. If Timeout is 0, then the caller must wait for the function to be completed 
+                          until EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+
+  @retval EFI_SUCCESS             The L2CAP message is received successfully.
+  @retval EFI_NOT_FOUND           Handle is invalid or not found.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - BufferSize is NULL.
+                                  - *BufferSize is 0.
+                                  - Buffer is NULL.
+  @retval EFI_TIMEOUT             Receiving L2CAP message fail due to timeout.
+  @retval EFI_DEVICE_ERROR        Receiving L2CAP message fail due to host controller or device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_RECEIVE)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL  *This,
+  IN EFI_HANDLE                 Handle,
+  OUT UINTN                     *BufferSize,
+  OUT VOID                      **Buffer,
+  IN UINTN                      Timeout
+  );
+  
+/**
+  Callback function, it is called when asynchronous transfer is completed.
+
+  @param  Data              Data received via asynchronous transfer.
+  @param  DataLength        The length of Data in bytes, received via asynchronous transfer.
+  @param  Context           Context passed from asynchronous transfer request.
+
+  @retval EFI_SUCCESS       The callback function complete successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_CHANNEL_SERVICE_CALLBACK) (
+  IN VOID                       *Data,
+  IN UINTN                      DataLength,
+  IN VOID                       *Context
+  );
+  
+/**
+  Receive L2CAP message (excluding L2CAP header) in non-blocking way from a specific channel.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handel          A handle created by EFI_BLUETOOTH_IO_PROTOCOL.L2CapConnect indicates which channel to receive.
+  @param  Callback        The callback function. This function is called if the asynchronous transfer is 
+                          completed.
+  @param  Context         Data passed into Callback function. This is optional parameter and may be NULL. 
+  
+  @retval EFI_SUCCESS             The L2CAP asynchronous receive request is submitted successfully.
+  @retval EFI_NOT_FOUND           Handle is invalid or not found.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - DataLength is 0.
+                                  - If an asynchronous receive request already exists on same Handle.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_ASYNC_RECEIVE)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL                    *This,
+  IN EFI_HANDLE                                   Handle,
+  IN EFI_BLUETOOTH_IO_CHANNEL_SERVICE_CALLBACK    Callback,
+  IN VOID                                         *Context
+  );
+  
+/**
+  Do L2CAP connection.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handel          A handle to indicate this L2CAP connection.
+  @param  Psm             Bluetooth PSM. See Bluetooth specification for detail.
+  @param  Mtu             Bluetooth MTU. See Bluetooth specification for detail.
+  @param  Callback        The callback function. This function is called whenever there is message received 
+                          in this channel.
+  @param  Context         Data passed into Callback function. This is optional parameter and may be NULL.
+  
+  @retval EFI_SUCCESS             The Bluetooth L2CAP layer connection is created successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  - Handle is NULL.
+  @retval EFI_DEVICE_ERROR        A hardware error occurred trying to do Bluetooth L2CAP connection.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_CONNECT)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL                    *This,
+  OUT EFI_HANDLE                                  *Handle,
+  IN UINT16                                       Psm,
+  IN UINT16                                       Mtu,
+  IN EFI_BLUETOOTH_IO_CHANNEL_SERVICE_CALLBACK    Callback,
+  IN VOID                                         *Context
+  );
+  
+/**
+  Do L2CAP disconnection.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handel          A handle to indicate this L2CAP connection.
+  
+  @retval EFI_SUCCESS             The Bluetooth L2CAP layer is disconnected successfully.
+  @retval EFI_NOT_FOUND           Handle is invalid or not found.
+  @retval EFI_DEVICE_ERROR        A hardware error occurred trying to do Bluetooth L2CAP disconnection.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_DISCONNECT)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL                    *This,
+  IN EFI_HANDLE                                   Handle
+  );
+  
+/**
+  Register L2CAP callback function for special channel.
+
+  @param  This            Pointer to the EFI_BLUETOOTH_IO_PROTOCOL instance.
+  @param  Handel          A handle to indicate this L2CAP connection.
+  @param  Psm             Bluetooth PSM. See Bluetooth specification for detail.
+  @param  Mtu             Bluetooth MTU. See Bluetooth specification for detail.
+  @param  Callback        The callback function. This function is called whenever there is message received 
+                          in this channel. NULL means unregister.
+  @param  Context         Data passed into Callback function. This is optional parameter and may be NULL.
+  
+  @retval EFI_SUCCESS             The Bluetooth L2CAP callback function is registered successfully.
+  @retval EFI_ALREADY_STARTED     The callback function already exists when register.
+  @retval EFI_NOT_FOUND           The callback function does not exist when unregister.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_BLUETOOTH_IO_L2CAP_REGISTER_SERVICE)(
+  IN EFI_BLUETOOTH_IO_PROTOCOL                    *This,
+  OUT EFI_HANDLE                                  *Handle,
+  IN UINT16                                       Psm,
+  IN UINT16                                       Mtu,
+  IN EFI_BLUETOOTH_IO_CHANNEL_SERVICE_CALLBACK    Callback,
+  IN VOID                                         *Context
+  );
+  
+///
+/// This protocol provides service for Bluetooth L2CAP (Logical Link Control and Adaptation Protocol) 
+/// and SDP (Service Discovery Protocol).
+///
+struct _EFI_BLUETOOTH_IO_PROTOCOL {
+  EFI_BLUETOOTH_IO_GET_DEVICE_INFO            GetDeviceInfo;
+  EFI_BLUETOOTH_IO_GET_SDP_INFO               GetSdpInfo;
+  EFI_BLUETOOTH_IO_L2CAP_RAW_SEND             L2CapRawSend;
+  EFI_BLUETOOTH_IO_L2CAP_RAW_RECEIVE          L2CapRawReceive;
+  EFI_BLUETOOTH_IO_L2CAP_RAW_ASYNC_RECEIVE    L2CapRawAsyncReceive;
+  EFI_BLUETOOTH_IO_L2CAP_SEND                 L2CapSend;
+  EFI_BLUETOOTH_IO_L2CAP_RECEIVE              L2CapReceive;
+  EFI_BLUETOOTH_IO_L2CAP_ASYNC_RECEIVE        L2CapAsyncReceive;
+  EFI_BLUETOOTH_IO_L2CAP_CONNECT              L2CapConnect;
+  EFI_BLUETOOTH_IO_L2CAP_DISCONNECT           L2CapDisconnect;
+  EFI_BLUETOOTH_IO_L2CAP_REGISTER_SERVICE     L2CapRegisterService;
+};
+
+extern EFI_GUID gEfiBluetoothIoServiceBindingProtocolGuid;
+extern EFI_GUID gEfiBluetoothIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BootManagerPolicy.h b/MdePkg/Include/Protocol/BootManagerPolicy.h
new file mode 100644
index 000000000000..f348e3f101da
--- /dev/null
+++ b/MdePkg/Include/Protocol/BootManagerPolicy.h
@@ -0,0 +1,138 @@
+/** @file
+  Boot Manager Policy Protocol as defined in UEFI Specification.
+
+  This protocol is used by EFI Applications to request the UEFI Boot Manager
+  to connect devices using platform policy.
+
+  Copyright (c) 2015, 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 __BOOT_MANAGER_POLICY_H__
+#define __BOOT_MANAGER_POLICY_H__
+
+#define EFI_BOOT_MANAGER_POLICY_PROTOCOL_GUID \
+  { \
+    0xFEDF8E0C, 0xE147, 0x11E3, { 0x99, 0x03, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA } \
+  }
+
+#define EFI_BOOT_MANAGER_POLICY_CONSOLE_GUID \
+  { \
+    0xCAB0E94C, 0xE15F, 0x11E3, { 0x91, 0x8D, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA } \
+  }
+
+#define EFI_BOOT_MANAGER_POLICY_NETWORK_GUID \
+  { \
+    0xD04159DC, 0xE15F, 0x11E3, { 0xB2, 0x61, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA } \
+  }
+
+#define EFI_BOOT_MANAGER_POLICY_CONNECT_ALL_GUID \
+  { \
+    0x113B2126, 0xFC8A, 0x11E3, { 0xBD, 0x6C, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA } \
+  }
+
+typedef struct _EFI_BOOT_MANAGER_POLICY_PROTOCOL EFI_BOOT_MANAGER_POLICY_PROTOCOL;
+
+#define EFI_BOOT_MANAGER_POLICY_PROTOCOL_REVISION 0x00010000
+
+/**
+  Connect a device path following the platforms EFI Boot Manager policy.
+
+  The ConnectDevicePath() function allows the caller to connect a DevicePath using the
+  same policy as the EFI Boot Manger.
+
+  @param[in] This       A pointer to the EFI_BOOT_MANAGER_POLICY_PROTOCOL instance.
+  @param[in] DevicePath Points to the start of the EFI device path to connect.
+                        If DevicePath is NULL then all the controllers in the
+                        system will be connected using the platforms EFI Boot
+                        Manager policy.
+  @param[in] Recursive  If TRUE, then ConnectController() is called recursively
+                        until the entire tree of controllers below the 
+                        controller specified by DevicePath have been created.
+                        If FALSE, then the tree of controllers is only expanded
+                        one level. If DevicePath is NULL then Recursive is ignored.
+
+  @retval EFI_SUCCESS            The DevicePath was connected.
+  @retval EFI_NOT_FOUND          The DevicePath was not found.
+  @retval EFI_NOT_FOUND          No driver was connected to DevicePath.
+  @retval EFI_SECURITY_VIOLATION The user has no permission to start UEFI device 
+                                 drivers on the DevicePath.
+  @retval EFI_UNSUPPORTED        The current TPL is not TPL_APPLICATION.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BOOT_MANAGER_POLICY_CONNECT_DEVICE_PATH)(
+  IN EFI_BOOT_MANAGER_POLICY_PROTOCOL *This,
+  IN EFI_DEVICE_PATH                  *DevicePath,
+  IN BOOLEAN                          Recursive
+  );
+
+/**
+  Connect a class of devices using the platform Boot Manager policy.
+
+  The ConnectDeviceClass() function allows the caller to request that the Boot
+  Manager connect a class of devices.
+
+  If Class is EFI_BOOT_MANAGER_POLICY_CONSOLE_GUID then the Boot Manager will
+  use platform policy to connect consoles. Some platforms may restrict the 
+  number of consoles connected as they attempt to fast boot, and calling
+  ConnectDeviceClass() with a Class value of EFI_BOOT_MANAGER_POLICY_CONSOLE_GUID
+  must connect the set of consoles that follow the Boot Manager platform policy,
+  and the EFI_SIMPLE_TEXT_INPUT_PROTOCOL, EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL, and
+  the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL are produced on the connected handles.
+  The Boot Manager may restrict which consoles get connect due to platform policy,
+  for example a security policy may require that a given console is not connected.
+
+  If Class is EFI_BOOT_MANAGER_POLICY_NETWORK_GUID then the Boot Manager will
+  connect the protocols the platforms supports for UEFI general purpose network
+  applications on one or more handles. If more than one network controller is
+  available a platform will connect, one, many, or all of the networks based
+  on platform policy. Connecting UEFI networking protocols, like EFI_DHCP4_PROTOCOL,
+  does not establish connections on the network. The UEFI general purpose network
+  application that called ConnectDeviceClass() may need to use the published
+  protocols to establish the network connection. The Boot Manager can optionally
+  have a policy to establish a network connection.
+  
+  If Class is EFI_BOOT_MANAGER_POLICY_CONNECT_ALL_GUID then the Boot Manager
+  will connect all UEFI drivers using the UEFI Boot Service
+  EFI_BOOT_SERVICES.ConnectController(). If the Boot Manager has policy
+  associated with connect all UEFI drivers this policy will be used.
+
+  A platform can also define platform specific Class values as a properly generated
+  EFI_GUID would never conflict with this specification.
+
+  @param[in] This  A pointer to the EFI_BOOT_MANAGER_POLICY_PROTOCOL instance.
+  @param[in] Class A pointer to an EFI_GUID that represents a class of devices
+                   that will be connected using the Boot Mangers platform policy.
+
+  @retval EFI_SUCCESS      At least one devices of the Class was connected.
+  @retval EFI_DEVICE_ERROR Devices were not connected due to an error.
+  @retval EFI_NOT_FOUND    The Class is not supported by the platform.
+  @retval EFI_UNSUPPORTED  The current TPL is not TPL_APPLICATION.
+**/        
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BOOT_MANAGER_POLICY_CONNECT_DEVICE_CLASS)(
+  IN EFI_BOOT_MANAGER_POLICY_PROTOCOL *This,
+  IN EFI_GUID                         *Class
+  );
+
+struct _EFI_BOOT_MANAGER_POLICY_PROTOCOL {
+  UINT64                                       Revision;
+  EFI_BOOT_MANAGER_POLICY_CONNECT_DEVICE_PATH  ConnectDevicePath;
+  EFI_BOOT_MANAGER_POLICY_CONNECT_DEVICE_CLASS ConnectDeviceClass;
+};
+
+extern EFI_GUID gEfiBootManagerPolicyProtocolGuid;
+
+extern EFI_GUID gEfiBootManagerPolicyConsoleGuid;
+extern EFI_GUID gEfiBootManagerPolicyNetworkGuid;
+extern EFI_GUID gEfiBootManagerPolicyConnectAllGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/BusSpecificDriverOverride.h b/MdePkg/Include/Protocol/BusSpecificDriverOverride.h
new file mode 100644
index 000000000000..dcaeb9c53574
--- /dev/null
+++ b/MdePkg/Include/Protocol/BusSpecificDriverOverride.h
@@ -0,0 +1,72 @@
+/** @file
+  Bus Specific Driver Override protocol as defined in the UEFI 2.0 specification.
+
+  Bus drivers that have a bus specific algorithm for matching drivers to controllers are
+  required to produce this protocol for each controller. For example, a PCI Bus Driver will produce an
+  instance of this protocol for every PCI controller that has a PCI option ROM that contains one or
+  more UEFI drivers. The protocol instance is attached to the handle of the PCI controller.
+
+  Copyright (c) 2006 - 2008, 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 _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_H_
+#define _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_H_
+
+///
+/// Global ID for the Bus Specific Driver Override Protocol
+///
+#define EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_GUID \
+  { \
+    0x3bc1b285, 0x8a15, 0x4a82, {0xaa, 0xbf, 0x4d, 0x7d, 0x13, 0xfb, 0x32, 0x65 } \
+  }
+
+typedef struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL  EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL;
+
+//
+// Prototypes for the Bus Specific Driver Override Protocol
+//
+
+/**                                                                   
+  Uses a bus specific algorithm to retrieve a driver image handle for a controller.
+    
+  @param  This                  A pointer to the EFI_BUS_SPECIFIC_DRIVER_
+                                OVERRIDE_PROTOCOL instance.              
+  @param  DriverImageHandle     On input, a pointer to the previous driver image handle returned
+                                by GetDriver(). On output, a pointer to the next driver         
+                                image handle. Passing in a NULL, will return the first driver   
+                                image handle.
+
+  @retval EFI_SUCCESS           A bus specific override driver is returned in DriverImageHandle.
+  @retval EFI_NOT_FOUND         The end of the list of override drivers was reached.
+                                A bus specific override driver is not returned in DriverImageHandle.
+  @retval EFI_INVALID_PARAMETER DriverImageHandle is not a handle that was returned on a
+                                previous call to GetDriver().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER)(
+  IN EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL              *This,
+  IN OUT EFI_HANDLE                                         *DriverImageHandle
+  );
+
+///
+/// This protocol matches one or more drivers to a controller. This protocol is produced by a bus driver,
+/// and it is installed on the child handles of buses that require a bus specific algorithm for matching
+/// drivers to controllers.
+///
+struct _EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL {
+  EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_GET_DRIVER GetDriver;
+};
+
+extern EFI_GUID gEfiBusSpecificDriverOverrideProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Capsule.h b/MdePkg/Include/Protocol/Capsule.h
new file mode 100644
index 000000000000..e35035da6a29
--- /dev/null
+++ b/MdePkg/Include/Protocol/Capsule.h
@@ -0,0 +1,35 @@
+/** @file
+  Capsule Architectural Protocol as defined in PI1.0a Specification VOLUME 2 DXE
+
+  The DXE Driver that produces this protocol must be a runtime driver. 
+  The driver is responsible for initializing the CapsuleUpdate() and 
+  QueryCapsuleCapabilities() fields of the UEFI Runtime Services Table. 
+  After the two fields of the UEFI Runtime Services Table have been initialized, 
+  the driver must install the EFI_CAPSULE_ARCH_PROTOCOL_GUID on a new handle 
+  with a NULL interface pointer. The installation of this protocol informs 
+  the DXE Foundation that the Capsule related services are now available and 
+  that the DXE Foundation must update the 32-bit CRC of the UEFI Runtime Services Table.
+
+Copyright (c) 2006 - 2009, 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 __ARCH_PROTOCOL_CAPSULE_ARCH_H__
+#define __ARCH_PROTOCOL_CAPSULE_ARCH_H__
+
+//
+// Global ID for the Capsule Architectural Protocol
+//
+#define EFI_CAPSULE_ARCH_PROTOCOL_GUID \
+  { 0x5053697e, 0x2cbc, 0x4819, {0x90, 0xd9, 0x05, 0x80, 0xde, 0xee, 0x57, 0x54 }}
+
+extern EFI_GUID gEfiCapsuleArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ComponentName.h b/MdePkg/Include/Protocol/ComponentName.h
new file mode 100644
index 000000000000..cdd87fce3157
--- /dev/null
+++ b/MdePkg/Include/Protocol/ComponentName.h
@@ -0,0 +1,129 @@
+/** @file
+  EFI Component Name Protocol as defined in the EFI 1.1 specification.
+  This protocol is used to retrieve user readable names of EFI Drivers 
+  and controllers managed by EFI Drivers.
+
+Copyright (c) 2006 - 2011, 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_COMPONENT_NAME_H__
+#define __EFI_COMPONENT_NAME_H__
+
+///
+/// The global ID for the Component Name Protocol.
+///
+#define EFI_COMPONENT_NAME_PROTOCOL_GUID \
+  { \
+    0x107a772c, 0xd5e1, 0x11d4, {0x9a, 0x46, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_COMPONENT_NAME_PROTOCOL  EFI_COMPONENT_NAME_PROTOCOL;
+
+
+/**
+  Retrieves a Unicode string that is the user-readable name of the EFI Driver.
+
+  @param  This       A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
+  @param  Language   A pointer to a three-character ISO 639-2 language identifier.
+                     This is the language of the driver name that that the caller
+                     is requesting, and it must match one of the languages specified
+                     in SupportedLanguages.  The number of languages supported by a
+                     driver is up to the driver writer.
+  @param  DriverName A pointer to the Unicode string to return.  This Unicode string
+                     is the name of the driver specified by This in the language
+                     specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by This
+                                and the language specified by Language was returned
+                                in DriverName.
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_COMPONENT_NAME_GET_DRIVER_NAME)(
+  IN EFI_COMPONENT_NAME_PROTOCOL           *This,
+  IN  CHAR8                                *Language,
+  OUT CHAR16                               **DriverName
+  );
+
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by an EFI Driver.
+
+  @param  This             A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
+  @param  ControllerHandle The handle of a controller that the driver specified by
+                           This is managing.  This handle specifies the controller
+                           whose name is to be returned.
+  @param  ChildHandle      The handle of the child controller to retrieve the name
+                           of.  This is an optional parameter that may be NULL.  It
+                           will be NULL for device drivers.  It will also be NULL
+                           for a bus drivers that wish to retrieve the name of the
+                           bus controller.  It will not be NULL for a bus driver
+                           that wishes to retrieve the name of a child controller.
+  @param  Language         A pointer to a three character ISO 639-2 language
+                           identifier.  This is the language of the controller name
+                           that the caller is requesting, and it must match one
+                           of the languages specified in SupportedLanguages.  The
+                           number of languages supported by a driver is up to the
+                           driver writer.
+  @param  ControllerName   A pointer to the Unicode string to return.  This Unicode
+                           string is the name of the controller specified by
+                           ControllerHandle and ChildHandle in the language specified
+                           by Language, from the point of view of the driver specified
+                           by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user-readable name in the
+                                language specified by Language for the driver
+                                specified by This was returned in DriverName.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently managing
+                                the controller specified by ControllerHandle and
+                                ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_COMPONENT_NAME_GET_CONTROLLER_NAME)(
+  IN EFI_COMPONENT_NAME_PROTOCOL                              *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle        OPTIONAL,
+  IN  CHAR8                                                   *Language,
+  OUT CHAR16                                                  **ControllerName
+  );
+
+///
+/// This protocol is used to retrieve user readable names of drivers 
+/// and controllers managed by UEFI Drivers.
+///
+struct _EFI_COMPONENT_NAME_PROTOCOL {
+  EFI_COMPONENT_NAME_GET_DRIVER_NAME      GetDriverName;
+  EFI_COMPONENT_NAME_GET_CONTROLLER_NAME  GetControllerName;
+  ///
+  /// A Null-terminated ASCII string that contains one or more
+  /// ISO 639-2 language codes. This is the list of language codes
+  /// that this protocol supports.  
+  ///
+  CHAR8                                   *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiComponentNameProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ComponentName2.h b/MdePkg/Include/Protocol/ComponentName2.h
new file mode 100644
index 000000000000..d005b02b873f
--- /dev/null
+++ b/MdePkg/Include/Protocol/ComponentName2.h
@@ -0,0 +1,172 @@
+/** @file
+  UEFI Component Name 2 Protocol as defined in the UEFI 2.1 specification.
+  This protocol is used to retrieve user readable names of drivers 
+  and controllers managed by UEFI Drivers.
+
+  Copyright (c) 2006 - 2011, 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 __EFI_COMPONENT_NAME2_H__
+#define __EFI_COMPONENT_NAME2_H__
+
+///
+/// Global ID for the Component Name Protocol
+///
+#define EFI_COMPONENT_NAME2_PROTOCOL_GUID \
+  {0x6a7a5cff, 0xe8d9, 0x4f70, { 0xba, 0xda, 0x75, 0xab, 0x30, 0x25, 0xce, 0x14 } }
+
+typedef struct _EFI_COMPONENT_NAME2_PROTOCOL  EFI_COMPONENT_NAME2_PROTOCOL;
+
+
+/**
+  Retrieves a string that is the user readable name of
+  the EFI Driver.
+
+  @param  This       A pointer to the
+                     EFI_COMPONENT_NAME2_PROTOCOL instance.
+  
+  @param  Language   A pointer to a Null-terminated ASCII string
+                     array indicating the language. This is the
+                     language of the driver name that the caller
+                     is requesting, and it must match one of the
+                     languages specified in SupportedLanguages.
+                     The number of languages supported by a
+                     driver is up to the driver writer. Language
+                     is specified in RFC 4646 language code
+                     format.
+  
+  @param  DriverName A pointer to the string to return.
+                     This string is the name of the
+                     driver specified by This in the language
+                     specified by Language.
+
+  @retval EFI_SUCCESS           The string for the
+                                Driver specified by This and the
+                                language specified by Language
+                                was returned in DriverName.
+  
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+  
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+  
+  @retval EFI_UNSUPPORTED       The driver specified by This
+                                does not support the language
+                                specified by Language.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_COMPONENT_NAME2_GET_DRIVER_NAME)(
+  IN EFI_COMPONENT_NAME2_PROTOCOL          *This,
+  IN  CHAR8                                *Language,
+  OUT CHAR16                               **DriverName
+  );
+
+
+/**
+  Retrieves a string that is the user readable name of
+  the controller that is being managed by an EFI Driver.
+
+  @param  This             A pointer to the
+                           EFI_COMPONENT_NAME2_PROTOCOL instance.
+
+  @param  ControllerHandle The handle of a controller that the
+                           driver specified by This is managing.
+                           This handle specifies the controller
+                           whose name is to be returned.
+
+  @param  ChildHandle      The handle of the child controller to
+                           retrieve the name of.  This is an
+                           optional parameter that may be NULL.
+                           It will be NULL for device drivers.
+                           It will also be NULL for bus
+                           drivers that wish to retrieve the
+                           name of the bus controller.  It will
+                           not be NULL for a bus driver that
+                           wishes to retrieve the name of a
+                           child controller.
+
+  @param  Language         A pointer to a Null-terminated ASCII
+                           string array indicating the language.
+                           This is the language of the driver
+                           name that the caller is requesting,
+                           and it must match one of the
+                           languages specified in
+                           SupportedLanguages. The number of
+                           languages supported by a driver is up
+                           to the driver writer. Language is
+                           specified in RFC 4646 language code
+                           format.
+
+  @param  ControllerName   A pointer to the string to return.
+                           This string is the name of the controller
+                           specified by ControllerHandle and ChildHandle
+                           in the language specified by Language
+                           from the point of view of the driver
+                           specified by This.
+
+  @retval EFI_SUCCESS           The string for the user
+                                readable name in the language
+                                specified by Language for the
+                                driver specified by This was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it
+                                is not a valid EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is
+                                not currently managing the
+                                controller specified by
+                                ControllerHandle and
+                                ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This
+                                does not support the language
+                                specified by Language.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)(
+  IN EFI_COMPONENT_NAME2_PROTOCOL *This,
+  IN  EFI_HANDLE                  ControllerHandle,
+  IN  EFI_HANDLE                  ChildHandle        OPTIONAL,
+  IN  CHAR8                       *Language,
+  OUT CHAR16                      **ControllerName
+  );
+
+///
+/// This protocol is used to retrieve user readable names of drivers 
+/// and controllers managed by UEFI Drivers.
+///
+struct _EFI_COMPONENT_NAME2_PROTOCOL {
+  EFI_COMPONENT_NAME2_GET_DRIVER_NAME      GetDriverName;
+  EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME  GetControllerName;
+
+  ///
+  /// A Null-terminated ASCII string array that contains one or more
+  /// supported language codes. This is the list of language codes that
+  /// this protocol supports. The number of languages supported by a
+  /// driver is up to the driver writer. SupportedLanguages is
+  /// specified in RFC 4646 format.  
+  ///
+  CHAR8                                    *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiComponentName2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Cpu.h b/MdePkg/Include/Protocol/Cpu.h
new file mode 100644
index 000000000000..cfb2e7570155
--- /dev/null
+++ b/MdePkg/Include/Protocol/Cpu.h
@@ -0,0 +1,300 @@
+/** @file
+  CPU Architectural Protocol as defined in PI spec Volume 2 DXE
+
+  This code abstracts the DXE core from processor implementation details.
+
+  Copyright (c) 2006 - 2016, 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 __ARCH_PROTOCOL_CPU_H__
+#define __ARCH_PROTOCOL_CPU_H__
+
+#include <Protocol/DebugSupport.h>
+
+#define EFI_CPU_ARCH_PROTOCOL_GUID \
+  { 0x26baccb1, 0x6f42, 0x11d4, {0xbc, 0xe7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+typedef struct _EFI_CPU_ARCH_PROTOCOL   EFI_CPU_ARCH_PROTOCOL;
+
+///
+/// The type of flush operation
+///
+typedef enum {
+  EfiCpuFlushTypeWriteBackInvalidate,
+  EfiCpuFlushTypeWriteBack,
+  EfiCpuFlushTypeInvalidate,
+  EfiCpuMaxFlushType
+} EFI_CPU_FLUSH_TYPE;
+
+///
+/// The type of processor INIT.
+///
+typedef enum {
+  EfiCpuInit,
+  EfiCpuMaxInitType
+} EFI_CPU_INIT_TYPE;
+
+/**
+  EFI_CPU_INTERRUPT_HANDLER that is called when a processor interrupt occurs.
+
+  @param  InterruptType    Defines the type of interrupt or exception that
+                           occurred on the processor.This parameter is processor architecture specific.
+  @param  SystemContext    A pointer to the processor context when
+                           the interrupt occurred on the processor.
+
+  @return None
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_CPU_INTERRUPT_HANDLER)(
+  IN CONST  EFI_EXCEPTION_TYPE  InterruptType,
+  IN CONST  EFI_SYSTEM_CONTEXT  SystemContext
+  );
+
+/**
+  This function flushes the range of addresses from Start to Start+Length 
+  from the processor's data cache. If Start is not aligned to a cache line 
+  boundary, then the bytes before Start to the preceding cache line boundary 
+  are also flushed. If Start+Length is not aligned to a cache line boundary, 
+  then the bytes past Start+Length to the end of the next cache line boundary 
+  are also flushed. The FlushType of EfiCpuFlushTypeWriteBackInvalidate must be 
+  supported. If the data cache is fully coherent with all DMA operations, then 
+  this function can just return EFI_SUCCESS. If the processor does not support 
+  flushing a range of the data cache, then the entire data cache can be flushed.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  Start            The beginning physical address to flush from the processor's data
+                           cache.
+  @param  Length           The number of bytes to flush from the processor's data cache. This
+                           function may flush more bytes than Length specifies depending upon
+                           the granularity of the flush operation that the processor supports.
+  @param  FlushType        Specifies the type of flush operation to perform.
+
+  @retval EFI_SUCCESS           The address range from Start to Start+Length was flushed from
+                                the processor's data cache.
+  @retval EFI_UNSUPPORTED       The processor does not support the cache flush type specified
+                                by FlushType.
+  @retval EFI_DEVICE_ERROR      The address range from Start to Start+Length could not be flushed
+                                from the processor's data cache.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_FLUSH_DATA_CACHE)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  IN EFI_PHYSICAL_ADDRESS               Start,
+  IN UINT64                             Length,
+  IN EFI_CPU_FLUSH_TYPE                 FlushType
+  );
+
+
+/**
+  This function enables interrupt processing by the processor. 
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           Interrupts are enabled on the processor.
+  @retval EFI_DEVICE_ERROR      Interrupts could not be enabled on the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_ENABLE_INTERRUPT)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This
+  );
+
+
+/**
+  This function disables interrupt processing by the processor.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           Interrupts are disabled on the processor.
+  @retval EFI_DEVICE_ERROR      Interrupts could not be disabled on the processor.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_DISABLE_INTERRUPT)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This
+  );
+
+
+/**
+  This function retrieves the processor's current interrupt state a returns it in 
+  State. If interrupts are currently enabled, then TRUE is returned. If interrupts 
+  are currently disabled, then FALSE is returned.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  State            A pointer to the processor's current interrupt state. Set to TRUE if
+                           interrupts are enabled and FALSE if interrupts are disabled.
+
+  @retval EFI_SUCCESS           The processor's current interrupt state was returned in State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_GET_INTERRUPT_STATE)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  OUT BOOLEAN                           *State
+  );
+
+
+/**
+  This function generates an INIT on the processor. If this function succeeds, then the
+  processor will be reset, and control will not be returned to the caller. If InitType is 
+  not supported by this processor, or the processor cannot programmatically generate an 
+  INIT without help from external hardware, then EFI_UNSUPPORTED is returned. If an error 
+  occurs attempting to generate an INIT, then EFI_DEVICE_ERROR is returned.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  InitType         The type of processor INIT to perform.
+
+  @retval EFI_SUCCESS           The processor INIT was performed. This return code should never be seen.
+  @retval EFI_UNSUPPORTED       The processor INIT operation specified by InitType is not supported
+                                by this processor.
+  @retval EFI_DEVICE_ERROR      The processor INIT failed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_INIT)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  IN EFI_CPU_INIT_TYPE                  InitType
+  );
+
+
+/**
+  This function registers and enables the handler specified by InterruptHandler for a processor 
+  interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the 
+  handler for the processor interrupt or exception type specified by InterruptType is uninstalled. 
+  The installed handler is called once for each processor interrupt or exception.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  InterruptType    A pointer to the processor's current interrupt state. Set to TRUE if interrupts
+                           are enabled and FALSE if interrupts are disabled.
+  @param  InterruptHandler A pointer to a function of type EFI_CPU_INTERRUPT_HANDLER that is called
+                           when a processor interrupt occurs. If this parameter is NULL, then the handler
+                           will be uninstalled.
+
+  @retval EFI_SUCCESS           The handler for the processor interrupt was successfully installed or uninstalled.
+  @retval EFI_ALREADY_STARTED   InterruptHandler is not NULL, and a handler for InterruptType was
+                                previously installed.
+  @retval EFI_INVALID_PARAMETER InterruptHandler is NULL, and a handler for InterruptType was not
+                                previously installed.
+  @retval EFI_UNSUPPORTED       The interrupt specified by InterruptType is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_REGISTER_INTERRUPT_HANDLER)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  IN EFI_EXCEPTION_TYPE                 InterruptType,
+  IN EFI_CPU_INTERRUPT_HANDLER          InterruptHandler
+  );
+
+
+/**
+  This function reads the processor timer specified by TimerIndex and returns it in TimerValue.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  TimerIndex       Specifies which processor timer is to be returned in TimerValue. This parameter
+                           must be between 0 and NumberOfTimers-1.
+  @param  TimerValue       Pointer to the returned timer value.
+  @param  TimerPeriod      A pointer to the amount of time that passes in femtoseconds for each increment
+                           of TimerValue. If TimerValue does not increment at a predictable rate, then 0 is
+                           returned. This parameter is optional and may be NULL.
+
+  @retval EFI_SUCCESS           The processor timer value specified by TimerIndex was returned in TimerValue.
+  @retval EFI_DEVICE_ERROR      An error occurred attempting to read one of the processor's timers.
+  @retval EFI_INVALID_PARAMETER TimerValue is NULL or TimerIndex is not valid.
+  @retval EFI_UNSUPPORTED       The processor does not have any readable timers.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_GET_TIMER_VALUE)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  IN UINT32                             TimerIndex,
+  OUT UINT64                            *TimerValue,
+  OUT UINT64                            *TimerPeriod OPTIONAL
+  );
+
+
+/**
+  This function modifies the attributes for the memory region specified by BaseAddress and
+  Length from their current attributes to the attributes specified by Attributes.
+
+  @param  This             The EFI_CPU_ARCH_PROTOCOL instance.
+  @param  BaseAddress      The physical address that is the start address of a memory region.
+  @param  Length           The size in bytes of the memory region.
+  @param  Attributes       The bit mask of attributes to set for the memory region.
+
+  @retval EFI_SUCCESS           The attributes were set for the memory region.
+  @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
+                                BaseAddress and Length cannot be modified.
+  @retval EFI_INVALID_PARAMETER Length is zero.
+                                Attributes specified an illegal combination of attributes that
+                                cannot be set together.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
+                                the memory resource range.
+  @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
+                                resource range specified by BaseAddress and Length.
+                                The bit mask of attributes is not support for the memory resource
+                                range specified by BaseAddress and Length.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_SET_MEMORY_ATTRIBUTES)(
+  IN EFI_CPU_ARCH_PROTOCOL              *This,
+  IN  EFI_PHYSICAL_ADDRESS              BaseAddress,
+  IN  UINT64                            Length,
+  IN  UINT64                            Attributes
+  );
+
+
+///
+/// The EFI_CPU_ARCH_PROTOCOL is used to abstract processor-specific functions from the DXE
+/// Foundation. This includes flushing caches, enabling and disabling interrupts, hooking interrupt
+/// vectors and exception vectors, reading internal processor timers, resetting the processor, and
+/// determining the processor frequency.
+///
+struct _EFI_CPU_ARCH_PROTOCOL {
+  EFI_CPU_FLUSH_DATA_CACHE            FlushDataCache;
+  EFI_CPU_ENABLE_INTERRUPT            EnableInterrupt;
+  EFI_CPU_DISABLE_INTERRUPT           DisableInterrupt;
+  EFI_CPU_GET_INTERRUPT_STATE         GetInterruptState;
+  EFI_CPU_INIT                        Init;
+  EFI_CPU_REGISTER_INTERRUPT_HANDLER  RegisterInterruptHandler;
+  EFI_CPU_GET_TIMER_VALUE             GetTimerValue;
+  EFI_CPU_SET_MEMORY_ATTRIBUTES       SetMemoryAttributes;
+  ///
+  /// The number of timers that are available in a processor. The value in this 
+  /// field is a constant that must not be modified after the CPU Architectural 
+  /// Protocol is installed. All consumers must treat this as a read-only field.
+  ///
+  UINT32                              NumberOfTimers;
+  ///
+  /// The size, in bytes, of the alignment required for DMA buffer allocations. 
+  /// This is typically the size of the largest data cache line in the platform. 
+  /// The value in this field is a constant that must not be modified after the 
+  /// CPU Architectural Protocol is installed. All consumers must treat this as 
+  /// a read-only field.  
+  ///
+  UINT32                              DmaBufferAlignment;
+};
+
+extern EFI_GUID gEfiCpuArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/CpuIo2.h b/MdePkg/Include/Protocol/CpuIo2.h
new file mode 100644
index 000000000000..49fb470713e7
--- /dev/null
+++ b/MdePkg/Include/Protocol/CpuIo2.h
@@ -0,0 +1,142 @@
+/** @file
+  This files describes the CPU I/O 2 Protocol.
+  
+  This protocol provides an I/O abstraction for a system processor. This protocol
+  is used by a PCI root bridge I/O driver to perform memory-mapped I/O and I/O transactions.
+  The I/O or memory primitives can be used by the consumer of the protocol to materialize
+  bus-specific configuration cycles, such as the transitional configuration address and data
+  ports for PCI. Only drivers that require direct access to the entire system should use this 
+  protocol. 
+  
+  Note: This is a boot-services only protocol and it may not be used by runtime drivers after
+  ExitBootServices(). It is different from the Framework CPU I/O Protocol, which is a runtime
+  protocol and can be used by runtime drivers after ExitBootServices().
+
+  Copyright (c) 2007 - 2010, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+
+**/
+
+#ifndef __CPU_IO2_H__
+#define __CPU_IO2_H__
+
+#define EFI_CPU_IO2_PROTOCOL_GUID \
+  { \
+    0xad61f191, 0xae5f, 0x4c0e, {0xb9, 0xfa, 0xe8, 0x69, 0xd2, 0x88, 0xc6, 0x4f} \
+  }
+
+typedef struct _EFI_CPU_IO2_PROTOCOL EFI_CPU_IO2_PROTOCOL;
+
+///
+/// Enumeration that defines the width of the I/O operation.
+///
+typedef enum {
+  EfiCpuIoWidthUint8,
+  EfiCpuIoWidthUint16,
+  EfiCpuIoWidthUint32,
+  EfiCpuIoWidthUint64,
+  EfiCpuIoWidthFifoUint8,
+  EfiCpuIoWidthFifoUint16,
+  EfiCpuIoWidthFifoUint32,
+  EfiCpuIoWidthFifoUint64,
+  EfiCpuIoWidthFillUint8,
+  EfiCpuIoWidthFillUint16,
+  EfiCpuIoWidthFillUint32,
+  EfiCpuIoWidthFillUint64,
+  EfiCpuIoWidthMaximum
+} EFI_CPU_IO_PROTOCOL_WIDTH;
+
+/**
+  Enables a driver to access registers in the PI CPU I/O space. 
+
+  The Io.Read() and Io.Write() functions enable a driver to access PCI controller 
+  registers in the PI CPU I/O space. 
+
+  The I/O operations are carried out exactly as requested. The caller is responsible 
+  for satisfying any alignment and I/O width restrictions that a PI System on a 
+  platform might require. For example on some platforms, width requests of 
+  EfiCpuIoWidthUint64 do not work. Misaligned buffers, on the other hand, will 
+  be handled by the driver.
+  
+  If Width is EfiCpuIoWidthUint8, EfiCpuIoWidthUint16, EfiCpuIoWidthUint32, 
+  or EfiCpuIoWidthUint64, then both Address and Buffer are incremented for 
+  each of the Count operations that is performed.
+  
+  If Width is EfiCpuIoWidthFifoUint8, EfiCpuIoWidthFifoUint16, 
+  EfiCpuIoWidthFifoUint32, or EfiCpuIoWidthFifoUint64, then only Buffer is 
+  incremented for each of the Count operations that is performed. The read or 
+  write operation is performed Count times on the same Address.
+  
+  If Width is EfiCpuIoWidthFillUint8, EfiCpuIoWidthFillUint16, 
+  EfiCpuIoWidthFillUint32, or EfiCpuIoWidthFillUint64, then only Address is 
+  incremented for each of the Count operations that is performed. The read or 
+  write operation is performed Count times from the first element of Buffer.
+
+  @param[in]       This     A pointer to the EFI_CPU_IO2_PROTOCOL instance.
+  @param[in]       Width    Signifies the width of the I/O or Memory operation.
+  @param[in]       Address  The base address of the I/O operation. 
+  @param[in]       Count    The number of I/O operations to perform. The number 
+                            of bytes moved is Width size * Count, starting at Address.
+  @param[in, out]  Buffer   For read operations, the destination buffer to store the results.
+                            For write operations, the source buffer from which to write data.
+
+  @retval EFI_SUCCESS            The data was read from or written to the PI system.
+  @retval EFI_INVALID_PARAMETER  Width is invalid for this PI system.
+  @retval EFI_INVALID_PARAMETER  Buffer is NULL.
+  @retval EFI_UNSUPPORTED        The Buffer is not aligned for the given Width.
+  @retval EFI_UNSUPPORTED        The address range specified by Address, Width, 
+                                 and Count is not valid for this PI system.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CPU_IO_PROTOCOL_IO_MEM)(
+  IN     EFI_CPU_IO2_PROTOCOL              *This,
+  IN     EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN     UINT64                            Address,
+  IN     UINTN                             Count,
+  IN OUT VOID                              *Buffer
+  );
+
+///
+/// Service for read and write accesses.
+///
+typedef struct {
+  ///
+  /// This service provides the various modalities of memory and I/O read.
+  ///
+  EFI_CPU_IO_PROTOCOL_IO_MEM  Read;
+  ///
+  /// This service provides the various modalities of memory and I/O write.
+  ///
+  EFI_CPU_IO_PROTOCOL_IO_MEM  Write;
+} EFI_CPU_IO_PROTOCOL_ACCESS;
+
+///
+/// Provides the basic memory and I/O interfaces that are used to abstract
+/// accesses to devices in a system.
+///
+struct _EFI_CPU_IO2_PROTOCOL {
+  ///
+  /// Enables a driver to access memory-mapped registers in the EFI system memory space.
+  ///
+  EFI_CPU_IO_PROTOCOL_ACCESS  Mem;
+  ///
+  /// Enables a driver to access registers in the EFI CPU I/O space.
+  ///
+  EFI_CPU_IO_PROTOCOL_ACCESS  Io;
+};
+
+extern EFI_GUID gEfiCpuIo2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DebugPort.h b/MdePkg/Include/Protocol/DebugPort.h
new file mode 100644
index 000000000000..ba14591107e7
--- /dev/null
+++ b/MdePkg/Include/Protocol/DebugPort.h
@@ -0,0 +1,146 @@
+/** @file
+  
+  The file defines the EFI Debugport protocol.
+  This protocol is used by debug agent to communicate with the
+  remote debug host.
+  
+  Copyright (c) 2006 - 2013, 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 __DEBUG_PORT_H__
+#define __DEBUG_PORT_H__
+
+
+///
+/// DebugPortIo protocol {EBA4E8D2-3858-41EC-A281-2647BA9660D0}
+///
+#define EFI_DEBUGPORT_PROTOCOL_GUID \
+  { \
+    0xEBA4E8D2, 0x3858, 0x41EC, {0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60, 0xD0 } \
+  }
+
+extern EFI_GUID gEfiDebugPortProtocolGuid;
+
+typedef struct _EFI_DEBUGPORT_PROTOCOL EFI_DEBUGPORT_PROTOCOL;
+
+//
+// DebugPort member functions
+//
+
+/**                                                                 
+  Resets the debugport.
+    
+  @param  This                  A pointer to the EFI_DEBUGPORT_PROTOCOL instance.
+                                
+  @retval EFI_SUCCESS           The debugport device was reset and is in usable state.
+  @retval EFI_DEVICE_ERROR      The debugport device could not be reset and is unusable.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_RESET)(
+  IN EFI_DEBUGPORT_PROTOCOL               *This
+  );
+
+/**                                                                 
+  Writes data to the debugport.
+    
+  @param  This                  A pointer to the EFI_DEBUGPORT_PROTOCOL instance.
+  @param  Timeout               The number of microseconds to wait before timing out a write operation.
+  @param  BufferSize            On input, the requested number of bytes of data to write. On output, the
+                                number of bytes of data actually written.
+  @param  Buffer                A pointer to a buffer containing the data to write.                                
+                                  
+  @retval EFI_SUCCESS           The data was written.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_TIMEOUT           The data write was stopped due to a timeout.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_WRITE)(
+  IN EFI_DEBUGPORT_PROTOCOL               *This,
+  IN UINT32                               Timeout,
+  IN OUT UINTN                            *BufferSize,
+  IN VOID                                 *Buffer
+  );
+
+/**                                                                 
+  Reads data from the debugport.
+    
+  @param  This                  A pointer to the EFI_DEBUGPORT_PROTOCOL instance.
+  @param  Timeout               The number of microseconds to wait before timing out a read operation.
+  @param  BufferSize            On input, the requested number of bytes of data to read. On output, the
+                                number of bytes of data actually number of bytes
+                                of data read and returned in Buffer.
+  @param  Buffer                A pointer to a buffer into which the data read will be saved.
+                                  
+  @retval EFI_SUCCESS           The data was read.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_TIMEOUT           The operation was stopped due to a timeout or overrun.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_READ)(
+  IN EFI_DEBUGPORT_PROTOCOL               *This,
+  IN UINT32                               Timeout,
+  IN OUT UINTN                            *BufferSize,
+  OUT VOID                                *Buffer
+  );
+
+/**                                                                 
+  Checks to see if any data is available to be read from the debugport device.
+    
+  @param  This                  A pointer to the EFI_DEBUGPORT_PROTOCOL instance.
+                                  
+  @retval EFI_SUCCESS           At least one byte of data is available to be read.
+  @retval EFI_DEVICE_ERROR      The debugport device is not functioning correctly.
+  @retval EFI_NOT_READY         No data is available to be read.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_POLL)(
+  IN EFI_DEBUGPORT_PROTOCOL               *This
+  );
+
+///
+/// This protocol provides the communication link between the debug agent and the remote host.
+///
+struct _EFI_DEBUGPORT_PROTOCOL {
+  EFI_DEBUGPORT_RESET Reset;
+  EFI_DEBUGPORT_WRITE Write;
+  EFI_DEBUGPORT_READ  Read;
+  EFI_DEBUGPORT_POLL  Poll;
+};
+
+//
+// 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;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DebugSupport.h b/MdePkg/Include/Protocol/DebugSupport.h
new file mode 100644
index 000000000000..80f87061bd0e
--- /dev/null
+++ b/MdePkg/Include/Protocol/DebugSupport.h
@@ -0,0 +1,778 @@
+/** @file
+  DebugSupport protocol and supporting definitions as defined in the UEFI2.4
+  specification.
+
+  The DebugSupport protocol is used by source level debuggers to abstract the
+  processor and handle context save and restore operations.
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011 - 2013, ARM Ltd. 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 __DEBUG_SUPPORT_H__
+#define __DEBUG_SUPPORT_H__
+
+#include <IndustryStandard/PeImage.h>
+
+typedef struct _EFI_DEBUG_SUPPORT_PROTOCOL EFI_DEBUG_SUPPORT_PROTOCOL;
+
+///
+/// Debug Support protocol {2755590C-6F3C-42FA-9EA4-A3BA543CDA25}.
+///
+#define EFI_DEBUG_SUPPORT_PROTOCOL_GUID \
+  { \
+    0x2755590C, 0x6F3C, 0x42FA, {0x9E, 0xA4, 0xA3, 0xBA, 0x54, 0x3C, 0xDA, 0x25 } \
+  }
+
+///
+/// Processor exception to be hooked.
+/// All exception types for IA32, X64, Itanium and EBC processors are defined.
+///
+typedef INTN  EFI_EXCEPTION_TYPE;
+
+///
+///  IA-32 processor exception types.
+///
+#define EXCEPT_IA32_DIVIDE_ERROR    0
+#define EXCEPT_IA32_DEBUG           1
+#define EXCEPT_IA32_NMI             2
+#define EXCEPT_IA32_BREAKPOINT      3
+#define EXCEPT_IA32_OVERFLOW        4
+#define EXCEPT_IA32_BOUND           5
+#define EXCEPT_IA32_INVALID_OPCODE  6
+#define EXCEPT_IA32_DOUBLE_FAULT    8
+#define EXCEPT_IA32_INVALID_TSS     10
+#define EXCEPT_IA32_SEG_NOT_PRESENT 11
+#define EXCEPT_IA32_STACK_FAULT     12
+#define EXCEPT_IA32_GP_FAULT        13
+#define EXCEPT_IA32_PAGE_FAULT      14
+#define EXCEPT_IA32_FP_ERROR        16
+#define EXCEPT_IA32_ALIGNMENT_CHECK 17
+#define EXCEPT_IA32_MACHINE_CHECK   18
+#define EXCEPT_IA32_SIMD            19
+
+///
+/// FXSAVE_STATE.
+/// FP / MMX / XMM registers (see fxrstor instruction definition).
+///
+typedef struct {
+  UINT16  Fcw;
+  UINT16  Fsw;
+  UINT16  Ftw;
+  UINT16  Opcode;
+  UINT32  Eip;
+  UINT16  Cs;
+  UINT16  Reserved1;
+  UINT32  DataOffset;
+  UINT16  Ds;
+  UINT8   Reserved2[10];
+  UINT8   St0Mm0[10], Reserved3[6];
+  UINT8   St1Mm1[10], Reserved4[6];
+  UINT8   St2Mm2[10], Reserved5[6];
+  UINT8   St3Mm3[10], Reserved6[6];
+  UINT8   St4Mm4[10], Reserved7[6];
+  UINT8   St5Mm5[10], Reserved8[6];
+  UINT8   St6Mm6[10], Reserved9[6];
+  UINT8   St7Mm7[10], Reserved10[6];
+  UINT8   Xmm0[16];
+  UINT8   Xmm1[16];
+  UINT8   Xmm2[16];
+  UINT8   Xmm3[16];
+  UINT8   Xmm4[16];
+  UINT8   Xmm5[16];
+  UINT8   Xmm6[16];
+  UINT8   Xmm7[16];
+  UINT8   Reserved11[14 * 16];
+} EFI_FX_SAVE_STATE_IA32;
+
+///
+///  IA-32 processor context definition.
+///
+typedef struct {
+  UINT32                 ExceptionData;
+  EFI_FX_SAVE_STATE_IA32 FxSaveState;
+  UINT32                 Dr0;
+  UINT32                 Dr1;
+  UINT32                 Dr2;
+  UINT32                 Dr3;
+  UINT32                 Dr6;
+  UINT32                 Dr7;
+  UINT32                 Cr0;
+  UINT32                 Cr1;  /* Reserved */
+  UINT32                 Cr2;
+  UINT32                 Cr3;
+  UINT32                 Cr4;
+  UINT32                 Eflags;
+  UINT32                 Ldtr;
+  UINT32                 Tr;
+  UINT32                 Gdtr[2];
+  UINT32                 Idtr[2];
+  UINT32                 Eip;
+  UINT32                 Gs;
+  UINT32                 Fs;
+  UINT32                 Es;
+  UINT32                 Ds;
+  UINT32                 Cs;
+  UINT32                 Ss;
+  UINT32                 Edi;
+  UINT32                 Esi;
+  UINT32                 Ebp;
+  UINT32                 Esp;
+  UINT32                 Ebx;
+  UINT32                 Edx;
+  UINT32                 Ecx;
+  UINT32                 Eax;
+} EFI_SYSTEM_CONTEXT_IA32;
+
+///
+///  x64 processor exception types.
+///
+#define EXCEPT_X64_DIVIDE_ERROR    0
+#define EXCEPT_X64_DEBUG           1
+#define EXCEPT_X64_NMI             2
+#define EXCEPT_X64_BREAKPOINT      3
+#define EXCEPT_X64_OVERFLOW        4
+#define EXCEPT_X64_BOUND           5
+#define EXCEPT_X64_INVALID_OPCODE  6
+#define EXCEPT_X64_DOUBLE_FAULT    8
+#define EXCEPT_X64_INVALID_TSS     10
+#define EXCEPT_X64_SEG_NOT_PRESENT 11
+#define EXCEPT_X64_STACK_FAULT     12
+#define EXCEPT_X64_GP_FAULT        13
+#define EXCEPT_X64_PAGE_FAULT      14
+#define EXCEPT_X64_FP_ERROR        16
+#define EXCEPT_X64_ALIGNMENT_CHECK 17
+#define EXCEPT_X64_MACHINE_CHECK   18
+#define EXCEPT_X64_SIMD            19
+
+///
+/// FXSAVE_STATE.
+/// FP / MMX / XMM registers (see fxrstor instruction definition).
+///
+typedef struct {
+  UINT16  Fcw;
+  UINT16  Fsw;
+  UINT16  Ftw;
+  UINT16  Opcode;
+  UINT64  Rip;
+  UINT64  DataOffset;
+  UINT8   Reserved1[8];
+  UINT8   St0Mm0[10], Reserved2[6];
+  UINT8   St1Mm1[10], Reserved3[6];
+  UINT8   St2Mm2[10], Reserved4[6];
+  UINT8   St3Mm3[10], Reserved5[6];
+  UINT8   St4Mm4[10], Reserved6[6];
+  UINT8   St5Mm5[10], Reserved7[6];
+  UINT8   St6Mm6[10], Reserved8[6];
+  UINT8   St7Mm7[10], Reserved9[6];
+  UINT8   Xmm0[16];
+  UINT8   Xmm1[16];
+  UINT8   Xmm2[16];
+  UINT8   Xmm3[16];
+  UINT8   Xmm4[16];
+  UINT8   Xmm5[16];
+  UINT8   Xmm6[16];
+  UINT8   Xmm7[16];
+  //
+  // NOTE: UEFI 2.0 spec definition as follows. 
+  //
+  UINT8   Reserved11[14 * 16];
+} EFI_FX_SAVE_STATE_X64;
+
+///
+///  x64 processor context definition.
+///
+typedef struct {
+  UINT64                ExceptionData;
+  EFI_FX_SAVE_STATE_X64 FxSaveState;
+  UINT64                Dr0;
+  UINT64                Dr1;
+  UINT64                Dr2;
+  UINT64                Dr3;
+  UINT64                Dr6;
+  UINT64                Dr7;
+  UINT64                Cr0;
+  UINT64                Cr1;  /* Reserved */
+  UINT64                Cr2;
+  UINT64                Cr3;
+  UINT64                Cr4;
+  UINT64                Cr8;
+  UINT64                Rflags;
+  UINT64                Ldtr;
+  UINT64                Tr;
+  UINT64                Gdtr[2];
+  UINT64                Idtr[2];
+  UINT64                Rip;
+  UINT64                Gs;
+  UINT64                Fs;
+  UINT64                Es;
+  UINT64                Ds;
+  UINT64                Cs;
+  UINT64                Ss;
+  UINT64                Rdi;
+  UINT64                Rsi;
+  UINT64                Rbp;
+  UINT64                Rsp;
+  UINT64                Rbx;
+  UINT64                Rdx;
+  UINT64                Rcx;
+  UINT64                Rax;
+  UINT64                R8;
+  UINT64                R9;
+  UINT64                R10;
+  UINT64                R11;
+  UINT64                R12;
+  UINT64                R13;
+  UINT64                R14;
+  UINT64                R15;
+} EFI_SYSTEM_CONTEXT_X64;
+
+///
+///  Itanium Processor Family Exception types.
+///
+#define EXCEPT_IPF_VHTP_TRANSLATION       0
+#define EXCEPT_IPF_INSTRUCTION_TLB        1
+#define EXCEPT_IPF_DATA_TLB               2
+#define EXCEPT_IPF_ALT_INSTRUCTION_TLB    3
+#define EXCEPT_IPF_ALT_DATA_TLB           4
+#define EXCEPT_IPF_DATA_NESTED_TLB        5
+#define EXCEPT_IPF_INSTRUCTION_KEY_MISSED 6
+#define EXCEPT_IPF_DATA_KEY_MISSED        7
+#define EXCEPT_IPF_DIRTY_BIT              8
+#define EXCEPT_IPF_INSTRUCTION_ACCESS_BIT 9
+#define EXCEPT_IPF_DATA_ACCESS_BIT        10
+#define EXCEPT_IPF_BREAKPOINT             11
+#define EXCEPT_IPF_EXTERNAL_INTERRUPT     12
+//
+// 13 - 19 reserved
+//
+#define EXCEPT_IPF_PAGE_NOT_PRESENT           20
+#define EXCEPT_IPF_KEY_PERMISSION             21
+#define EXCEPT_IPF_INSTRUCTION_ACCESS_RIGHTS  22
+#define EXCEPT_IPF_DATA_ACCESS_RIGHTS         23
+#define EXCEPT_IPF_GENERAL_EXCEPTION          24
+#define EXCEPT_IPF_DISABLED_FP_REGISTER       25
+#define EXCEPT_IPF_NAT_CONSUMPTION            26
+#define EXCEPT_IPF_SPECULATION                27
+//
+// 28 reserved
+//
+#define EXCEPT_IPF_DEBUG                          29
+#define EXCEPT_IPF_UNALIGNED_REFERENCE            30
+#define EXCEPT_IPF_UNSUPPORTED_DATA_REFERENCE     31
+#define EXCEPT_IPF_FP_FAULT                       32
+#define EXCEPT_IPF_FP_TRAP                        33
+#define EXCEPT_IPF_LOWER_PRIVILEGE_TRANSFER_TRAP  34
+#define EXCEPT_IPF_TAKEN_BRANCH                   35
+#define EXCEPT_IPF_SINGLE_STEP                    36
+//
+// 37 - 44 reserved
+//
+#define EXCEPT_IPF_IA32_EXCEPTION 45
+#define EXCEPT_IPF_IA32_INTERCEPT 46
+#define EXCEPT_IPF_IA32_INTERRUPT 47
+
+///
+///  IPF processor context definition.
+///
+typedef struct {
+  //
+  // The first reserved field is necessary to preserve alignment for the correct
+  // bits in UNAT and to insure F2 is 16 byte aligned.
+  //
+  UINT64  Reserved;
+  UINT64  R1;
+  UINT64  R2;
+  UINT64  R3;
+  UINT64  R4;
+  UINT64  R5;
+  UINT64  R6;
+  UINT64  R7;
+  UINT64  R8;
+  UINT64  R9;
+  UINT64  R10;
+  UINT64  R11;
+  UINT64  R12;
+  UINT64  R13;
+  UINT64  R14;
+  UINT64  R15;
+  UINT64  R16;
+  UINT64  R17;
+  UINT64  R18;
+  UINT64  R19;
+  UINT64  R20;
+  UINT64  R21;
+  UINT64  R22;
+  UINT64  R23;
+  UINT64  R24;
+  UINT64  R25;
+  UINT64  R26;
+  UINT64  R27;
+  UINT64  R28;
+  UINT64  R29;
+  UINT64  R30;
+  UINT64  R31;
+
+  UINT64  F2[2];
+  UINT64  F3[2];
+  UINT64  F4[2];
+  UINT64  F5[2];
+  UINT64  F6[2];
+  UINT64  F7[2];
+  UINT64  F8[2];
+  UINT64  F9[2];
+  UINT64  F10[2];
+  UINT64  F11[2];
+  UINT64  F12[2];
+  UINT64  F13[2];
+  UINT64  F14[2];
+  UINT64  F15[2];
+  UINT64  F16[2];
+  UINT64  F17[2];
+  UINT64  F18[2];
+  UINT64  F19[2];
+  UINT64  F20[2];
+  UINT64  F21[2];
+  UINT64  F22[2];
+  UINT64  F23[2];
+  UINT64  F24[2];
+  UINT64  F25[2];
+  UINT64  F26[2];
+  UINT64  F27[2];
+  UINT64  F28[2];
+  UINT64  F29[2];
+  UINT64  F30[2];
+  UINT64  F31[2];
+
+  UINT64  Pr;
+
+  UINT64  B0;
+  UINT64  B1;
+  UINT64  B2;
+  UINT64  B3;
+  UINT64  B4;
+  UINT64  B5;
+  UINT64  B6;
+  UINT64  B7;
+
+  //
+  // application registers
+  //
+  UINT64  ArRsc;
+  UINT64  ArBsp;
+  UINT64  ArBspstore;
+  UINT64  ArRnat;
+
+  UINT64  ArFcr;
+
+  UINT64  ArEflag;
+  UINT64  ArCsd;
+  UINT64  ArSsd;
+  UINT64  ArCflg;
+  UINT64  ArFsr;
+  UINT64  ArFir;
+  UINT64  ArFdr;
+
+  UINT64  ArCcv;
+
+  UINT64  ArUnat;
+
+  UINT64  ArFpsr;
+
+  UINT64  ArPfs;
+  UINT64  ArLc;
+  UINT64  ArEc;
+
+  //
+  // control registers
+  //
+  UINT64  CrDcr;
+  UINT64  CrItm;
+  UINT64  CrIva;
+  UINT64  CrPta;
+  UINT64  CrIpsr;
+  UINT64  CrIsr;
+  UINT64  CrIip;
+  UINT64  CrIfa;
+  UINT64  CrItir;
+  UINT64  CrIipa;
+  UINT64  CrIfs;
+  UINT64  CrIim;
+  UINT64  CrIha;
+
+  //
+  // debug registers
+  //
+  UINT64  Dbr0;
+  UINT64  Dbr1;
+  UINT64  Dbr2;
+  UINT64  Dbr3;
+  UINT64  Dbr4;
+  UINT64  Dbr5;
+  UINT64  Dbr6;
+  UINT64  Dbr7;
+
+  UINT64  Ibr0;
+  UINT64  Ibr1;
+  UINT64  Ibr2;
+  UINT64  Ibr3;
+  UINT64  Ibr4;
+  UINT64  Ibr5;
+  UINT64  Ibr6;
+  UINT64  Ibr7;
+
+  //
+  // virtual registers - nat bits for R1-R31
+  //
+  UINT64  IntNat;
+
+} EFI_SYSTEM_CONTEXT_IPF;
+
+///
+///  EBC processor exception types.
+///
+#define EXCEPT_EBC_UNDEFINED            0
+#define EXCEPT_EBC_DIVIDE_ERROR         1
+#define EXCEPT_EBC_DEBUG                2
+#define EXCEPT_EBC_BREAKPOINT           3
+#define EXCEPT_EBC_OVERFLOW             4
+#define EXCEPT_EBC_INVALID_OPCODE       5   ///< Opcode out of range.
+#define EXCEPT_EBC_STACK_FAULT          6
+#define EXCEPT_EBC_ALIGNMENT_CHECK      7
+#define EXCEPT_EBC_INSTRUCTION_ENCODING 8   ///< Malformed instruction.
+#define EXCEPT_EBC_BAD_BREAK            9   ///< BREAK 0 or undefined BREAK.
+#define EXCEPT_EBC_STEP                 10  ///< To support debug stepping.
+///
+/// For coding convenience, define the maximum valid EBC exception.
+///
+#define MAX_EBC_EXCEPTION EXCEPT_EBC_STEP
+
+///
+///  EBC processor context definition.
+///
+typedef struct {
+  UINT64  R0;
+  UINT64  R1;
+  UINT64  R2;
+  UINT64  R3;
+  UINT64  R4;
+  UINT64  R5;
+  UINT64  R6;
+  UINT64  R7;
+  UINT64  Flags;
+  UINT64  ControlFlags;
+  UINT64  Ip;
+} EFI_SYSTEM_CONTEXT_EBC;
+
+
+
+///
+///  ARM processor exception types.
+///
+#define EXCEPT_ARM_RESET                    0
+#define EXCEPT_ARM_UNDEFINED_INSTRUCTION    1
+#define EXCEPT_ARM_SOFTWARE_INTERRUPT       2
+#define EXCEPT_ARM_PREFETCH_ABORT           3
+#define EXCEPT_ARM_DATA_ABORT               4
+#define EXCEPT_ARM_RESERVED                 5
+#define EXCEPT_ARM_IRQ                      6
+#define EXCEPT_ARM_FIQ                      7
+
+///
+/// For coding convenience, define the maximum valid ARM exception.
+///
+#define MAX_ARM_EXCEPTION EXCEPT_ARM_FIQ
+
+///
+///  ARM processor context definition.
+///
+typedef struct {
+  UINT32  R0;
+  UINT32  R1;
+  UINT32  R2;
+  UINT32  R3;
+  UINT32  R4;
+  UINT32  R5;
+  UINT32  R6;
+  UINT32  R7;
+  UINT32  R8;
+  UINT32  R9;
+  UINT32  R10;
+  UINT32  R11;
+  UINT32  R12;
+  UINT32  SP;
+  UINT32  LR;
+  UINT32  PC;
+  UINT32  CPSR;
+  UINT32  DFSR;
+  UINT32  DFAR;
+  UINT32  IFSR;
+  UINT32  IFAR;
+} EFI_SYSTEM_CONTEXT_ARM;
+
+
+///
+///  AARCH64 processor exception types.
+///
+#define EXCEPT_AARCH64_SYNCHRONOUS_EXCEPTIONS    0
+#define EXCEPT_AARCH64_IRQ                       1
+#define EXCEPT_AARCH64_FIQ                       2
+#define EXCEPT_AARCH64_SERROR                    3
+
+///
+/// For coding convenience, define the maximum valid ARM exception.
+///
+#define MAX_AARCH64_EXCEPTION EXCEPT_AARCH64_SERROR
+
+typedef struct {
+  // General Purpose Registers
+  UINT64  X0;
+  UINT64  X1;
+  UINT64  X2;
+  UINT64  X3;
+  UINT64  X4;
+  UINT64  X5;
+  UINT64  X6;
+  UINT64  X7;
+  UINT64  X8;
+  UINT64  X9;
+  UINT64  X10;
+  UINT64  X11;
+  UINT64  X12;
+  UINT64  X13;
+  UINT64  X14;
+  UINT64  X15;
+  UINT64  X16;
+  UINT64  X17;
+  UINT64  X18;
+  UINT64  X19;
+  UINT64  X20;
+  UINT64  X21;
+  UINT64  X22;
+  UINT64  X23;
+  UINT64  X24;
+  UINT64  X25;
+  UINT64  X26;
+  UINT64  X27;
+  UINT64  X28;
+  UINT64  FP;   // x29 - Frame pointer
+  UINT64  LR;   // x30 - Link Register
+  UINT64  SP;   // x31 - Stack pointer
+
+  // FP/SIMD Registers
+  UINT64  V0[2];
+  UINT64  V1[2];
+  UINT64  V2[2];
+  UINT64  V3[2];
+  UINT64  V4[2];
+  UINT64  V5[2];
+  UINT64  V6[2];
+  UINT64  V7[2];
+  UINT64  V8[2];
+  UINT64  V9[2];
+  UINT64  V10[2];
+  UINT64  V11[2];
+  UINT64  V12[2];
+  UINT64  V13[2];
+  UINT64  V14[2];
+  UINT64  V15[2];
+  UINT64  V16[2];
+  UINT64  V17[2];
+  UINT64  V18[2];
+  UINT64  V19[2];
+  UINT64  V20[2];
+  UINT64  V21[2];
+  UINT64  V22[2];
+  UINT64  V23[2];
+  UINT64  V24[2];
+  UINT64  V25[2];
+  UINT64  V26[2];
+  UINT64  V27[2];
+  UINT64  V28[2];
+  UINT64  V29[2];
+  UINT64  V30[2];
+  UINT64  V31[2];
+
+  UINT64  ELR;  // Exception Link Register
+  UINT64  SPSR; // Saved Processor Status Register
+  UINT64  FPSR; // Floating Point Status Register
+  UINT64  ESR;  // Exception syndrome register
+  UINT64  FAR;  // Fault Address Register
+} EFI_SYSTEM_CONTEXT_AARCH64;
+
+
+///
+/// Universal EFI_SYSTEM_CONTEXT definition.
+///
+typedef union {
+  EFI_SYSTEM_CONTEXT_EBC  *SystemContextEbc;
+  EFI_SYSTEM_CONTEXT_IA32 *SystemContextIa32;
+  EFI_SYSTEM_CONTEXT_X64  *SystemContextX64;
+  EFI_SYSTEM_CONTEXT_IPF  *SystemContextIpf;
+  EFI_SYSTEM_CONTEXT_ARM  *SystemContextArm;
+  EFI_SYSTEM_CONTEXT_AARCH64  *SystemContextAArch64;
+} EFI_SYSTEM_CONTEXT;
+
+//
+// DebugSupport callback function prototypes
+//
+
+/**                                                                 
+  Registers and enables an exception callback function for the specified exception.
+    
+  @param  ExceptionType         Exception types in EBC, IA-32, x64, or IPF.
+  @param  SystemContext         Exception content.
+                                   
+**/
+typedef
+VOID
+(EFIAPI *EFI_EXCEPTION_CALLBACK)(
+  IN     EFI_EXCEPTION_TYPE               ExceptionType,
+  IN OUT EFI_SYSTEM_CONTEXT               SystemContext
+  );
+
+/**                                                                 
+  Registers and enables the on-target debug agent's periodic entry point.
+      
+  @param  SystemContext         Exception content.
+                                   
+**/
+typedef
+VOID
+(EFIAPI *EFI_PERIODIC_CALLBACK)(
+  IN OUT EFI_SYSTEM_CONTEXT               SystemContext
+  );
+
+///
+/// Machine type definition
+///
+typedef enum {
+  IsaIa32 = IMAGE_FILE_MACHINE_I386,           ///< 0x014C
+  IsaX64  = IMAGE_FILE_MACHINE_X64,            ///< 0x8664
+  IsaIpf  = IMAGE_FILE_MACHINE_IA64,           ///< 0x0200
+  IsaEbc  = IMAGE_FILE_MACHINE_EBC,            ///< 0x0EBC
+  IsaArm  = IMAGE_FILE_MACHINE_ARMTHUMB_MIXED, ///< 0x01c2
+  IsaAArch64  = IMAGE_FILE_MACHINE_ARM64       ///< 0xAA64
+} EFI_INSTRUCTION_SET_ARCHITECTURE;
+
+
+//
+// DebugSupport member function definitions
+//
+
+/**                                                                 
+  Returns the maximum value that may be used for the ProcessorIndex parameter in
+  RegisterPeriodicCallback() and RegisterExceptionCallback().                   
+    
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported
+                                processor index is returned.                                      
+                                
+  @retval EFI_SUCCESS           The function completed successfully.  
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MAXIMUM_PROCESSOR_INDEX)(
+  IN EFI_DEBUG_SUPPORT_PROTOCOL          *This,
+  OUT UINTN                              *MaxProcessorIndex
+  );
+
+/**                                                                 
+  Registers a function to be called back periodically in interrupt context.
+    
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main
+                                periodic entry point of the debug agent.
+                                
+  @retval EFI_SUCCESS           The function completed successfully.  
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.                
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback                               
+                                function.                                                           
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_PERIODIC_CALLBACK)(
+  IN EFI_DEBUG_SUPPORT_PROTOCOL          *This,
+  IN UINTN                               ProcessorIndex,
+  IN EFI_PERIODIC_CALLBACK               PeriodicCallback
+  );
+
+/**                                                                 
+  Registers a function to be called when a given processor exception occurs.
+    
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor the callback function applies to.
+  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called
+                                when the processor exception specified by ExceptionType occurs.  
+  @param  ExceptionType         Specifies which processor exception to hook.                       
+                                
+  @retval EFI_SUCCESS           The function completed successfully.  
+  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback
+                                function was previously registered.                
+  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback                               
+                                function.                                                           
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_EXCEPTION_CALLBACK)(
+  IN EFI_DEBUG_SUPPORT_PROTOCOL          *This,
+  IN UINTN                               ProcessorIndex,
+  IN EFI_EXCEPTION_CALLBACK              ExceptionCallback,
+  IN EFI_EXCEPTION_TYPE                  ExceptionType
+  );
+
+/**                                                                 
+  Invalidates processor instruction cache for a memory range. Subsequent execution in this range
+  causes a fresh memory fetch to retrieve code to be executed.                                  
+    
+  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.
+  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.
+  @param  Start                 Specifies the physical base of the memory range to be invalidated.                                
+  @param  Length                Specifies the minimum number of bytes in the processor's instruction
+                                cache to invalidate.                                                 
+                                
+  @retval EFI_SUCCESS           The function completed successfully.  
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INVALIDATE_INSTRUCTION_CACHE)(
+  IN EFI_DEBUG_SUPPORT_PROTOCOL          *This,
+  IN UINTN                               ProcessorIndex,
+  IN VOID                                *Start,
+  IN UINT64                              Length
+  );
+
+///
+/// This protocol provides the services to allow the debug agent to register 
+/// callback functions that are called either periodically or when specific 
+/// processor exceptions occur.
+///
+struct _EFI_DEBUG_SUPPORT_PROTOCOL {
+  ///
+  /// Declares the processor architecture for this instance of the EFI Debug Support protocol.
+  ///
+  EFI_INSTRUCTION_SET_ARCHITECTURE  Isa;
+  EFI_GET_MAXIMUM_PROCESSOR_INDEX   GetMaximumProcessorIndex;
+  EFI_REGISTER_PERIODIC_CALLBACK    RegisterPeriodicCallback;
+  EFI_REGISTER_EXCEPTION_CALLBACK   RegisterExceptionCallback;
+  EFI_INVALIDATE_INSTRUCTION_CACHE  InvalidateInstructionCache;
+};
+
+extern EFI_GUID gEfiDebugSupportProtocolGuid;
+
+#endif 
diff --git a/MdePkg/Include/Protocol/Decompress.h b/MdePkg/Include/Protocol/Decompress.h
new file mode 100644
index 000000000000..965b7d2f45ae
--- /dev/null
+++ b/MdePkg/Include/Protocol/Decompress.h
@@ -0,0 +1,122 @@
+/** @file
+  The Decompress Protocol Interface as defined in UEFI spec
+
+  Copyright (c) 2006 - 2014, 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 __DECOMPRESS_H__
+#define __DECOMPRESS_H__
+
+#define EFI_DECOMPRESS_PROTOCOL_GUID \
+  { \
+    0xd8117cfe, 0x94a6, 0x11d4, {0x9a, 0x3a, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_DECOMPRESS_PROTOCOL  EFI_DECOMPRESS_PROTOCOL;
+
+/**
+  The GetInfo() function retrieves the size of the uncompressed buffer 
+  and the temporary scratch buffer required to decompress the buffer 
+  specified by Source and SourceSize.  If the size of the uncompressed
+  buffer or the size of the scratch buffer cannot be determined from 
+  the compressed data specified by Source and SourceData, then 
+  EFI_INVALID_PARAMETER is returned.  Otherwise, the size of the uncompressed
+  buffer is returned in DestinationSize, the size of the scratch buffer is 
+  returned in ScratchSize, and EFI_SUCCESS is returned.
+
+  The GetInfo() function does not have a scratch buffer available to perform 
+  a thorough checking of the validity of the source data. It just retrieves
+  the 'Original Size' field from the beginning bytes of the source data and
+  output it as DestinationSize.  And ScratchSize is specific to the decompression
+  implementation.
+
+  @param  This            A pointer to the EFI_DECOMPRESS_PROTOCOL instance.
+  @param  Source          The source buffer containing the compressed data.
+  @param  SourceSize      The size, in bytes, of source buffer.
+  @param  DestinationSize A pointer to the size, in bytes, of the uncompressed buffer
+                          that will be generated when the compressed buffer specified
+                          by Source and SourceSize is decompressed.
+  @param  ScratchSize     A pointer to the size, in bytes, of the scratch buffer that
+                          is required to decompress the compressed buffer specified by
+                          Source and SourceSize.
+
+  @retval  EFI_SUCCESS           The size of the uncompressed data was returned in DestinationSize
+                                 and the size of the scratch buffer was returned in ScratchSize.
+  @retval  EFI_INVALID_PARAMETER The size of the uncompressed data or the size of the scratch
+                                 buffer cannot be determined from the compressed data specified by
+                                 Source and SourceData.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DECOMPRESS_GET_INFO)(
+  IN EFI_DECOMPRESS_PROTOCOL            *This,
+  IN   VOID                             *Source,
+  IN   UINT32                           SourceSize,
+  OUT  UINT32                           *DestinationSize,
+  OUT  UINT32                           *ScratchSize
+  );
+
+/**
+  The Decompress() function extracts decompressed data to its original form.
+
+  This protocol is designed so that the decompression algorithm can be 
+  implemented without using any memory services.  As a result, the 
+  Decompress() function is not allowed to call AllocatePool() or 
+  AllocatePages() in its implementation.  It is the caller's responsibility 
+  to allocate and free the Destination and Scratch buffers.
+
+  If the compressed source data specified by Source and SourceSize is 
+  successfully decompressed into Destination, then EFI_SUCCESS is returned.  
+  If the compressed source data specified by Source and SourceSize is not in 
+  a valid compressed data format, then EFI_INVALID_PARAMETER is returned.
+
+  @param  This            A pointer to the EFI_DECOMPRESS_PROTOCOL instance.
+  @param  Source          The source buffer containing the compressed data.
+  @param  SourceSize      The size of source data.
+  @param  Destination     On output, the destination buffer that contains
+                          the uncompressed data.
+  @param  DestinationSize The size of destination buffer. The size of destination
+                          buffer needed is obtained from GetInfo().
+  @param  Scratch         A temporary scratch buffer that is used to perform the
+                          decompression.          
+  @param  ScratchSize     The size of scratch buffer. The size of scratch buffer needed
+                          is obtained from GetInfo().
+
+  @retval  EFI_SUCCESS          Decompression completed successfully, and the uncompressed
+                                buffer is returned in Destination.
+  @retval EFI_INVALID_PARAMETER The source buffer specified by Source and SourceSize is
+                                corrupted (not in a valid compressed format).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DECOMPRESS_DECOMPRESS)(
+  IN EFI_DECOMPRESS_PROTOCOL              *This,
+  IN     VOID                             *Source,
+  IN     UINT32                           SourceSize,
+  IN OUT VOID                             *Destination,
+  IN     UINT32                           DestinationSize,
+  IN OUT VOID                             *Scratch,
+  IN     UINT32                           ScratchSize
+  );
+
+///
+/// Provides a decompression service.
+///
+struct _EFI_DECOMPRESS_PROTOCOL {
+  EFI_DECOMPRESS_GET_INFO   GetInfo;
+  EFI_DECOMPRESS_DECOMPRESS Decompress;
+};
+
+extern EFI_GUID gEfiDecompressProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DeferredImageLoad.h b/MdePkg/Include/Protocol/DeferredImageLoad.h
new file mode 100644
index 000000000000..4d1bbf0ed402
--- /dev/null
+++ b/MdePkg/Include/Protocol/DeferredImageLoad.h
@@ -0,0 +1,80 @@
+/** @file
+  UEFI 2.2 Deferred Image Load Protocol definition.
+
+  This protocol returns information about images whose load was denied because of security 
+  considerations. This information can be used by the Boot Manager or another agent to reevaluate the 
+  images when the current security profile has been changed, such as when the current user profile 
+  changes. There can be more than one instance of this protocol installed.
+
+  Copyright (c) 2009, 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 __DEFERRED_IMAGE_LOAD_H__
+#define __DEFERRED_IMAGE_LOAD_H__
+
+///
+/// Global ID for the Deferred Image Load Protocol
+///
+#define EFI_DEFERRED_IMAGE_LOAD_PROTOCOL_GUID \
+  { \
+    0x15853d7c, 0x3ddf, 0x43e0, { 0xa1, 0xcb, 0xeb, 0xf8, 0x5b, 0x8f, 0x87, 0x2c } \
+  };
+
+typedef struct _EFI_DEFERRED_IMAGE_LOAD_PROTOCOL  EFI_DEFERRED_IMAGE_LOAD_PROTOCOL;
+
+/**
+  Returns information about a deferred image.
+
+  This function returns information about a single deferred image. The deferred images are numbered 
+  consecutively, starting with 0.  If there is no image which corresponds to ImageIndex, then 
+  EFI_NOT_FOUND is returned. All deferred images may be returned by iteratively calling this 
+  function until EFI_NOT_FOUND is returned.
+  Image may be NULL and ImageSize set to 0 if the decision to defer execution was made because 
+  of the location of the executable image rather than its actual contents.  record handle until
+  there are no more, at which point UserInfo will point to NULL. 
+
+  @param[in]  This               Points to this instance of the EFI_DEFERRED_IMAGE_LOAD_PROTOCOL.
+  @param[in]  ImageIndex         Zero-based index of the deferred index.
+  @param[out] ImageDevicePath    On return, points to a pointer to the device path of the image. 
+                                 The device path should not be freed by the caller. 
+  @param[out] Image              On return, points to the first byte of the image or NULL if the  
+                                 image is not available. The image should not be freed by the caller 
+                                 unless LoadImage() has been called successfully.  
+  @param[out] ImageSize          On return, the size of the image, or 0 if the image is not available.
+  @param[out] BootOption         On return, points to TRUE if the image was intended as a boot option 
+                                 or FALSE if it was not intended as a boot option. 
+ 
+  @retval EFI_SUCCESS            Image information returned successfully.
+  @retval EFI_NOT_FOUND          ImageIndex does not refer to a valid image.
+  @retval EFI_INVALID_PARAMETER  ImageDevicePath is NULL or Image is NULL or ImageSize is NULL or 
+                                 BootOption is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEFERRED_IMAGE_INFO)(
+  IN  EFI_DEFERRED_IMAGE_LOAD_PROTOCOL  *This,
+  IN  UINTN                             ImageIndex,
+  OUT EFI_DEVICE_PATH_PROTOCOL          **ImageDevicePath,
+  OUT VOID                              **Image,
+  OUT UINTN                             *ImageSize,
+  OUT BOOLEAN                           *BootOption
+  );
+
+///
+/// This protocol returns information about a deferred image.
+///
+struct _EFI_DEFERRED_IMAGE_LOAD_PROTOCOL {
+  EFI_DEFERRED_IMAGE_INFO  GetImageInfo;
+};
+
+extern EFI_GUID gEfiDeferredImageLoadProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DeviceIo.h b/MdePkg/Include/Protocol/DeviceIo.h
new file mode 100644
index 000000000000..d84a6202effd
--- /dev/null
+++ b/MdePkg/Include/Protocol/DeviceIo.h
@@ -0,0 +1,268 @@
+/** @file
+  Device IO protocol as defined in the EFI 1.10 specification.
+
+  Device IO is used to abstract hardware access to devices. It includes
+  memory mapped IO, IO, PCI Config space, and DMA.
+
+  Copyright (c) 2006 - 2009, 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_IO_H__
+#define __DEVICE_IO_H__
+
+#define EFI_DEVICE_IO_PROTOCOL_GUID \
+  { \
+    0xaf6ac311, 0x84c3, 0x11d2, {0x8e, 0x3c, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_DEVICE_IO_PROTOCOL EFI_DEVICE_IO_PROTOCOL;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+/// 
+#define DEVICE_IO_PROTOCOL  EFI_DEVICE_IO_PROTOCOL_GUID
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_DEVICE_IO_PROTOCOL  EFI_DEVICE_IO_INTERFACE;
+
+///
+/// Device IO Access Width 
+///
+typedef enum {
+  IO_UINT8  = 0,
+  IO_UINT16 = 1,
+  IO_UINT32 = 2,
+  IO_UINT64 = 3,
+  //
+  // Below enumerations are added in "Extensible Firmware Interface Specification, 
+  // Version 1.10, Specification Update, Version 001".
+  //
+  MMIO_COPY_UINT8  = 4,
+  MMIO_COPY_UINT16 = 5,
+  MMIO_COPY_UINT32 = 6,
+  MMIO_COPY_UINT64 = 7
+} EFI_IO_WIDTH;
+
+/**                                                                 
+  Enables a driver to access device registers in the appropriate memory or I/O space.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+  @param  Width                 Signifies the width of the I/O operations.                                                                   
+  @param  Address               The base address of the I/O operations. 
+  @param  Count                 The number of I/O operations to perform.
+  @param  Buffer                For read operations, the destination buffer to store the results. For write
+                                operations, the source buffer to write data from. If
+                                Width is MMIO_COPY_UINT8, MMIO_COPY_UINT16,
+                                MMIO_COPY_UINT32, or MMIO_COPY_UINT64, then
+                                Buffer is interpreted as a base address of an I/O operation such as Address. 
+
+  @retval EFI_SUCCESS           The data was read from or written to the device.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.      
+  @retval EFI_INVALID_PARAMETER Width is invalid.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEVICE_IO)(
+  IN EFI_DEVICE_IO_PROTOCOL         *This,
+  IN EFI_IO_WIDTH                   Width,
+  IN UINT64                         Address,
+  IN UINTN                          Count,
+  IN OUT VOID                       *Buffer
+  );
+
+typedef struct {
+  EFI_DEVICE_IO Read;
+  EFI_DEVICE_IO Write;
+} EFI_IO_ACCESS;
+
+/**                                                                 
+  Provides an EFI Device Path for a PCI device with the given PCI configuration space address.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+  @param  PciAddress            The PCI configuration space address of the device whose Device Path
+                                is going to be returned.  
+  @param  PciDevicePath         A pointer to the pointer for the EFI Device Path for PciAddress.
+                                Memory for the Device Path is allocated from the pool.          
+
+  @retval EFI_SUCCESS           The PciDevicePath returns a pointer to a valid EFI Device Path.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.      
+  @retval EFI_UNSUPPORTED       The PciAddress does not map to a valid EFI Device Path.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_DEVICE_PATH)(
+  IN EFI_DEVICE_IO_PROTOCOL           *This,
+  IN UINT64                           PciAddress,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL     **PciDevicePath
+  );
+
+typedef enum {
+  ///
+  /// A read operation from system memory by a bus master.
+  ///
+  EfiBusMasterRead,
+
+  ///
+  /// A write operation to system memory by a bus master.
+  ///
+  EfiBusMasterWrite,
+  
+  ///
+  /// Provides both read and write access to system memory
+  /// by both the processor and a bus master. The buffer is
+  /// coherent from both the processor's and the bus master's
+  /// point of view.
+  ///
+  EfiBusMasterCommonBuffer
+} EFI_IO_OPERATION_TYPE;
+
+/**                                                                 
+  Provides the device-specific addresses needed to access system memory.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+  @param  Operation             Indicates if the bus master is going to read or write to system memory.
+  @param  HostAddress           The system memory address to map to the device.
+  @param  NumberOfBytes         On input, the number of bytes to map.
+                                On output, the number of bytes that were mapped.
+  @param  DeviceAddress         The resulting map address for the bus master device to use to access the
+                                hosts HostAddress.
+  @param  Mapping               A resulting value to pass to Unmap().
+
+  @retval EFI_SUCCESS           The range was mapped for the returned NumberOfBytes.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.      
+  @retval EFI_UNSUPPORTED       The HostAddress cannot be mapped as a common buffer.
+  @retval EFI_INVALID_PARAMETER The Operation or HostAddress is undefined.
+  @retval EFI_DEVICE_ERROR      The system hardware could not map the requested address.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IO_MAP)(
+  IN EFI_DEVICE_IO_PROTOCOL           *This,
+  IN EFI_IO_OPERATION_TYPE            Operation,
+  IN EFI_PHYSICAL_ADDRESS             *HostAddress,
+  IN OUT UINTN                        *NumberOfBytes,
+  OUT EFI_PHYSICAL_ADDRESS            *DeviceAddress,
+  OUT VOID                            **Mapping
+  );
+
+/**                                                                 
+  Completes the Map() operation and releases any corresponding resources.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+  @param  Mapping               A resulting value to pass to Unmap().
+
+  @retval EFI_SUCCESS           The range was mapped for the returned NumberOfBytes.
+  @retval EFI_DEVICE_ERROR      The system hardware could not map the requested address.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IO_UNMAP)(
+  IN EFI_DEVICE_IO_PROTOCOL           *This,
+  IN VOID                             *Mapping
+  );
+
+/**                                                                 
+  Allocates pages that are suitable for an EFIBusMasterCommonBuffer mapping.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+  @param  Type                  The type allocation to perform.
+  @param  MemoryType            The type of memory to allocate, EfiBootServicesData or
+                                EfiRuntimeServicesData.
+  @param  Pages                 The number of pages to allocate.
+  @param  HostAddress           A pointer to store the base address of the allocated range.                                
+
+  @retval EFI_SUCCESS           The requested memory pages were allocated.
+  @retval EFI_OUT_OF_RESOURCES  The memory pages could not be allocated.
+  @retval EFI_INVALID_PARAMETER The requested memory type is invalid.
+  @retval EFI_UNSUPPORTED       The requested HostAddress is not supported on
+                                this platform.                               
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IO_ALLOCATE_BUFFER)(
+  IN EFI_DEVICE_IO_PROTOCOL           *This,
+  IN EFI_ALLOCATE_TYPE                Type,
+  IN EFI_MEMORY_TYPE                  MemoryType,
+  IN UINTN                            Pages,
+  IN OUT EFI_PHYSICAL_ADDRESS         *HostAddress
+  );
+
+/**                                                                 
+  Flushes any posted write data to the device.
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.
+
+  @retval EFI_SUCCESS           The buffers were flushed.
+  @retval EFI_DEVICE_ERROR      The buffers were not flushed due to a hardware error.                                 
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IO_FLUSH)(
+  IN EFI_DEVICE_IO_PROTOCOL  *This
+  );
+
+/**                                                                 
+  Frees pages that were allocated with AllocateBuffer().
+    
+  @param  This                  A pointer to the EFI_DEVICE_IO_INTERFACE instance.  
+  @param  Pages                 The number of pages to free.
+  @param  HostAddress           The base address of the range to free.
+
+  @retval EFI_SUCCESS           The requested memory pages were allocated.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocateBuffer().  
+  @retval EFI_INVALID_PARAMETER HostAddress is not page aligned or Pages is invalid.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IO_FREE_BUFFER)(
+  IN EFI_DEVICE_IO_PROTOCOL           *This,
+  IN UINTN                            Pages,
+  IN EFI_PHYSICAL_ADDRESS             HostAddress
+  );
+
+///
+/// This protocol provides the basic Memory, I/O, and PCI interfaces that 
+/// are used to abstract accesses to devices.
+///
+struct _EFI_DEVICE_IO_PROTOCOL {
+  ///
+  /// Allows reads and writes to memory mapped I/O space.
+  ///
+  EFI_IO_ACCESS           Mem;
+  ///
+  /// Allows reads and writes to I/O space.
+  ///
+  EFI_IO_ACCESS           Io;
+  ///
+  /// Allows reads and writes to PCI configuration space.
+  ///
+  EFI_IO_ACCESS           Pci;
+  EFI_IO_MAP              Map;
+  EFI_PCI_DEVICE_PATH     PciDevicePath;
+  EFI_IO_UNMAP            Unmap;
+  EFI_IO_ALLOCATE_BUFFER  AllocateBuffer;
+  EFI_IO_FLUSH            Flush;
+  EFI_IO_FREE_BUFFER      FreeBuffer;
+};
+
+extern EFI_GUID gEfiDeviceIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DevicePath.h b/MdePkg/Include/Protocol/DevicePath.h
new file mode 100644
index 000000000000..1958a3dd180f
--- /dev/null
+++ b/MdePkg/Include/Protocol/DevicePath.h
@@ -0,0 +1,1331 @@
+/** @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) 2006 - 2016, 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_PROTOCOL_H__
+#define __EFI_DEVICE_PATH_PROTOCOL_H__
+
+#include <Guid/PcAnsi.h>
+#include <IndustryStandard/Bluetooth.h>
+#include <IndustryStandard/Acpi60.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;
+
+///
+/// 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[];
+} 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 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;
+
+//
+// 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_REGION_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_REGION_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;
+  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;
+  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;
+
+#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/MdePkg/Include/Protocol/DevicePathFromText.h b/MdePkg/Include/Protocol/DevicePathFromText.h
new file mode 100644
index 000000000000..cbdbc466dcad
--- /dev/null
+++ b/MdePkg/Include/Protocol/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) 2006 - 2008, 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*
+(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_NODE)(
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_PATH)(
+  IN 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/MdePkg/Include/Protocol/DevicePathToText.h b/MdePkg/Include/Protocol/DevicePathToText.h
new file mode 100644
index 000000000000..923ee648404f
--- /dev/null
+++ b/MdePkg/Include/Protocol/DevicePathToText.h
@@ -0,0 +1,85 @@
+/** @file
+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL as defined in UEFI 2.0.  
+  This protocol provides service to convert device nodes and paths to text.
+
+  Copyright (c) 2006 - 2008, 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_TO_TEXT_PROTOCOL_H__
+#define __DEVICE_PATH_TO_TEXT_PROTOCOL_H__
+
+///
+/// Device Path To Text protocol
+///
+#define EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID \
+  { \
+    0x8b843e20, 0x8132, 0x4852, {0x90, 0xcc, 0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c } \
+  }
+
+/**
+  Convert a device node to its text representation.
+
+  @param  DeviceNode     Points to the device node to be converted.
+  @param  DisplayOnly    If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param  AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @retval a_pointer      a pointer to the allocated text representation of the device node data
+  @retval NULL           if DeviceNode is NULL or there was insufficient memory.
+
+**/
+typedef
+CHAR16*
+(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_NODE)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DeviceNode,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  );      
+
+/**
+  Convert a device path to its text representation.
+
+  @param  DevicePath     Points to the device path to be converted.
+  @param  DisplayOnly    If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.  
+  @param  AllowShortcuts The AllowShortcuts is FALSE, then the shortcut forms of
+                         text representation for a device node cannot be used.
+
+  @retval a_pointer      a pointer to the allocated text representation of the device node.
+  @retval NULL           if DevicePath is NULL or there was insufficient memory.
+
+**/
+typedef
+CHAR16*
+(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_PATH)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  );    
+
+///
+/// This protocol converts device paths and device nodes to text.
+///
+typedef struct {
+  EFI_DEVICE_PATH_TO_TEXT_NODE        ConvertDeviceNodeToText;
+  EFI_DEVICE_PATH_TO_TEXT_PATH        ConvertDevicePathToText;
+} EFI_DEVICE_PATH_TO_TEXT_PROTOCOL;
+
+extern EFI_GUID gEfiDevicePathToTextProtocolGuid;
+
+#endif
+
+
diff --git a/MdePkg/Include/Protocol/DevicePathUtilities.h b/MdePkg/Include/Protocol/DevicePathUtilities.h
new file mode 100644
index 000000000000..35fd624f2c39
--- /dev/null
+++ b/MdePkg/Include/Protocol/DevicePathUtilities.h
@@ -0,0 +1,192 @@
+/** @file
+  EFI_DEVICE_PATH_UTILITIES_PROTOCOL as defined in UEFI 2.0.  
+  Use to create and manipulate device paths and device nodes.
+
+  Copyright (c) 2006 - 2010, 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_PROTOCOL_H__
+#define __DEVICE_PATH_UTILITIES_PROTOCOL_H__
+
+///
+/// Device Path Utilities protocol
+///
+#define EFI_DEVICE_PATH_UTILITIES_PROTOCOL_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
+(EFIAPI *EFI_DEVICE_PATH_UTILS_GET_DEVICE_PATH_SIZE)(
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_DUP_DEVICE_PATH)(
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_PATH)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *Src1,
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_NODE)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_APPEND_INSTANCE)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_GET_NEXT_INSTANCE)(
+  IN  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathInstance,
+  OUT 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*
+(EFIAPI *EFI_DEVICE_PATH_UTILS_CREATE_NODE)(
+  IN UINT8                          NodeType,
+  IN UINT8                          NodeSubType,
+  IN 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
+(EFIAPI *EFI_DEVICE_PATH_UTILS_IS_MULTI_INSTANCE)(
+  IN 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; 
+
+#endif
diff --git a/MdePkg/Include/Protocol/Dhcp4.h b/MdePkg/Include/Protocol/Dhcp4.h
new file mode 100644
index 000000000000..5dcd47c76b85
--- /dev/null
+++ b/MdePkg/Include/Protocol/Dhcp4.h
@@ -0,0 +1,780 @@
+/** @file
+  EFI_DHCP4_PROTOCOL as defined in UEFI 2.0.
+  EFI_DHCP4_SERVICE_BINDING_PROTOCOL as defined in UEFI 2.0.
+  These protocols are used to collect configuration information for the EFI IPv4 Protocol
+  drivers and to provide DHCPv4 server and PXE boot server discovery services.
+
+Copyright (c) 2006 - 2010, 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.
+
+  @par Revision Reference:          
+  This Protocol was introduced in UEFI Specification 2.0.
+
+**/
+
+#ifndef __EFI_DHCP4_PROTOCOL_H__
+#define __EFI_DHCP4_PROTOCOL_H__
+
+#define EFI_DHCP4_PROTOCOL_GUID \
+  { \
+    0x8a219718, 0x4ef5, 0x4761, {0x91, 0xc8, 0xc0, 0xf0, 0x4b, 0xda, 0x9e, 0x56 } \
+  }
+
+#define EFI_DHCP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x9d9a39d8, 0xbd42, 0x4a73, {0xa4, 0xd5, 0x8e, 0xe9, 0x4b, 0xe1, 0x13, 0x80 } \
+  }
+
+typedef struct _EFI_DHCP4_PROTOCOL EFI_DHCP4_PROTOCOL;
+
+
+#pragma pack(1)
+typedef struct {
+  ///
+  /// DHCP option code.
+  ///
+  UINT8               OpCode;
+  ///
+  /// Length of the DHCP option data. Not present if OpCode is 0 or 255.
+  ///
+  UINT8               Length;
+  ///
+  /// Start of the DHCP option data. Not present if OpCode is 0 or 255 or if Length is zero.
+  ///
+  UINT8               Data[1];
+} EFI_DHCP4_PACKET_OPTION;
+#pragma pack()
+
+
+#pragma pack(1)
+///
+/// EFI_DHCP4_PACKET defines the format of DHCPv4 packets. See RFC 2131 for more information.
+///
+typedef struct {
+  UINT8             OpCode;
+  UINT8             HwType;
+  UINT8             HwAddrLen;
+  UINT8             Hops;
+  UINT32            Xid;
+  UINT16            Seconds;
+  UINT16            Reserved;
+  EFI_IPv4_ADDRESS  ClientAddr;       ///< Client IP address from client.
+  EFI_IPv4_ADDRESS  YourAddr;         ///< Client IP address from server.
+  EFI_IPv4_ADDRESS  ServerAddr;       ///< IP address of next server in bootstrap.
+  EFI_IPv4_ADDRESS  GatewayAddr;      ///< Relay agent IP address.
+  UINT8             ClientHwAddr[16]; ///< Client hardware address.
+  CHAR8             ServerName[64];
+  CHAR8             BootFileName[128];
+}EFI_DHCP4_HEADER;
+#pragma pack()
+
+
+#pragma pack(1)
+typedef struct {
+  ///
+  /// Size of the EFI_DHCP4_PACKET buffer.
+  ///
+  UINT32              Size;
+  ///
+  /// Length of the EFI_DHCP4_PACKET from the first byte of the Header field 
+  /// to the last byte of the Option[] field.
+  ///
+  UINT32              Length;
+
+  struct {
+    ///
+    /// DHCP packet header.
+    ///
+    EFI_DHCP4_HEADER  Header;
+    ///
+    /// DHCP magik cookie in network byte order.
+    ///
+    UINT32            Magik;
+    ///
+    /// Start of the DHCP packed option data.
+    ///
+    UINT8             Option[1];
+  } Dhcp4;
+} EFI_DHCP4_PACKET;
+#pragma pack()
+
+
+typedef enum {
+  ///
+  /// The EFI DHCPv4 Protocol driver is stopped.
+  ///
+  Dhcp4Stopped        = 0x0,
+  ///
+  /// The EFI DHCPv4 Protocol driver is inactive.
+  ///
+  Dhcp4Init           = 0x1,
+  ///
+  /// The EFI DHCPv4 Protocol driver is collecting DHCP offer packets from DHCP servers.
+  ///
+  Dhcp4Selecting      = 0x2,
+  ///
+  /// The EFI DHCPv4 Protocol driver has sent the request to the DHCP server and is waiting for a response.
+  ///
+  Dhcp4Requesting     = 0x3,
+  ///
+  /// The DHCP configuration has completed.
+  ///
+  Dhcp4Bound          = 0x4,
+  ///
+  /// The DHCP configuration is being renewed and another request has
+  /// been sent out, but it has not received a response from the server yet.
+  ///
+  Dhcp4Renewing       = 0x5,
+  ///
+  /// The DHCP configuration has timed out and the EFI DHCPv4
+  /// Protocol driver is trying to extend the lease time.
+  ///
+  Dhcp4Rebinding      = 0x6,
+  ///
+  /// The EFI DHCPv4 Protocol driver was initialized with a previously
+  /// allocated or known IP address.
+  ///
+  Dhcp4InitReboot     = 0x7,
+  ///
+  /// The EFI DHCPv4 Protocol driver is seeking to reuse the previously
+  /// allocated IP address by sending a request to the DHCP server.
+  ///
+  Dhcp4Rebooting      = 0x8
+} EFI_DHCP4_STATE;
+
+
+typedef enum{
+  ///
+  /// The packet to start the configuration sequence is about to be sent.
+  ///
+  Dhcp4SendDiscover   = 0x01,
+  ///
+  /// A reply packet was just received.
+  ///
+  Dhcp4RcvdOffer      = 0x02,
+  ///
+  /// It is time for Dhcp4Callback to select an offer.
+  ///
+  Dhcp4SelectOffer    = 0x03,
+  ///
+  /// A request packet is about to be sent.
+  ///
+  Dhcp4SendRequest    = 0x04,
+  ///
+  /// A DHCPACK packet was received and will be passed to Dhcp4Callback.
+  ///
+  Dhcp4RcvdAck        = 0x05,
+  ///
+  /// A DHCPNAK packet was received and will be passed to Dhcp4Callback.
+  ///
+  Dhcp4RcvdNak        = 0x06,
+  ///
+  /// A decline packet is about to be sent.
+  ///
+  Dhcp4SendDecline    = 0x07,
+  ///
+  /// The DHCP configuration process has completed. No packet is associated with this event.
+  ///
+  Dhcp4BoundCompleted = 0x08,
+  ///
+  /// It is time to enter the Dhcp4Renewing state and to contact the server 
+  /// that originally issued the network address. No packet is associated with this event.
+  ///
+  Dhcp4EnterRenewing  = 0x09,
+  ///
+  /// It is time to enter the Dhcp4Rebinding state and to contact any server. 
+  /// No packet is associated with this event.
+  ///
+  Dhcp4EnterRebinding = 0x0a,
+  ///
+  /// The configured IP address was lost either because the lease has expired, 
+  /// the user released the configuration, or a DHCPNAK packet was received in 
+  /// the Dhcp4Renewing or Dhcp4Rebinding state. No packet is associated with this event.
+  ///
+  Dhcp4AddressLost    = 0x0b,
+  ///
+  /// The DHCP process failed because a DHCPNAK packet was received or the user 
+  /// aborted the DHCP process at a time when the configuration was not available yet. 
+  /// No packet is associated with this event.
+  ///
+  Dhcp4Fail           = 0x0c
+} EFI_DHCP4_EVENT;
+
+/**
+  Callback routine.
+  
+  EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
+  to intercept events that occurred in the configuration process. This structure
+  provides advanced control of each state transition of the DHCP process. The
+  returned status code determines the behavior of the EFI DHCPv4 Protocol driver.
+  There are three possible returned values, which are described in the following
+  table.
+
+  @param  This                  The pointer to the EFI DHCPv4 Protocol instance that is used to
+                                configure this callback function.
+  @param  Context               The pointer to the context that is initialized by
+                                EFI_DHCP4_PROTOCOL.Configure().
+  @param  CurrentState          The current operational state of the EFI DHCPv4 Protocol
+                                driver.
+  @param  Dhcp4Event            The event that occurs in the current state, which usually means a
+                                state transition.
+  @param  Packet                The DHCP packet that is going to be sent or already received.
+  @param  NewPacket             The packet that is used to replace the above Packet.
+
+  @retval EFI_SUCCESS           Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
+                                When it is in the Dhcp4Selecting state, it tells the EFI DHCPv4 Protocol
+                                driver to stop collecting additional packets. The driver will exit
+                                the Dhcp4Selecting state and enter the Dhcp4Requesting state.
+  @retval EFI_NOT_READY         Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
+                                driver will continue to wait for more packets until the retry
+                                timeout expires.
+  @retval EFI_ABORTED           Tells the EFI DHCPv4 Protocol driver to abort the current process and
+                                return to the Dhcp4Init or Dhcp4InitReboot state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_CALLBACK)(
+  IN  EFI_DHCP4_PROTOCOL         *This,
+  IN  VOID                       *Context,
+  IN  EFI_DHCP4_STATE            CurrentState,
+  IN  EFI_DHCP4_EVENT            Dhcp4Event,
+  IN  EFI_DHCP4_PACKET           *Packet     OPTIONAL,
+  OUT EFI_DHCP4_PACKET           **NewPacket OPTIONAL
+  );
+
+typedef struct {
+  ///
+  /// The number of times to try sending a packet during the Dhcp4SendDiscover
+  /// event and waiting for a response during the Dhcp4RcvdOffer event.
+  /// Set to zero to use the default try counts and timeout values.
+  ///
+  UINT32                      DiscoverTryCount;
+  ///
+  /// The maximum amount of time (in seconds) to wait for returned packets in each 
+  /// of the retries. Timeout values of zero will default to a timeout value 
+  /// of one second. Set to NULL to use default timeout values.
+  ///
+  UINT32                      *DiscoverTimeout;
+  ///
+  /// The number of times to try sending a packet during the Dhcp4SendRequest event
+  /// and waiting for a response during the Dhcp4RcvdAck event before accepting
+  /// failure. Set to zero to use the default try counts and timeout values.
+  ///
+  UINT32                      RequestTryCount;
+  ///
+  /// The maximum amount of time (in seconds) to wait for return packets in each of the retries. 
+  /// Timeout values of zero will default to a timeout value of one second. 
+  /// Set to NULL to use default timeout values.
+  ///
+  UINT32                      *RequestTimeout;
+  ///
+  /// For a DHCPDISCOVER, setting this parameter to the previously allocated IP
+  /// address will cause the EFI DHCPv4 Protocol driver to enter the Dhcp4InitReboot state. 
+  /// And set this field to 0.0.0.0 to enter the Dhcp4Init state.
+  /// For a DHCPINFORM this parameter should be set to the client network address
+  /// which was assigned to the client during a DHCPDISCOVER.
+  ///
+  EFI_IPv4_ADDRESS            ClientAddress;
+  ///
+  /// The callback function to intercept various events that occurred in 
+  /// the DHCP configuration process. Set to NULL to ignore all those events.
+  ///
+  EFI_DHCP4_CALLBACK          Dhcp4Callback;
+  ///
+  /// The pointer to the context that will be passed to Dhcp4Callback when it is called.
+  ///
+  VOID                        *CallbackContext;
+  ///
+  /// Number of DHCP options in the OptionList.
+  ///
+  UINT32                      OptionCount;
+  ///
+  /// List of DHCP options to be included in every packet that is sent during the
+  /// Dhcp4SendDiscover event. Pad options are appended automatically by DHCP driver
+  /// in outgoing DHCP packets. If OptionList itself contains pad option, they are
+  /// ignored by the driver. OptionList can be freed after EFI_DHCP4_PROTOCOL.Configure()
+  /// returns. Ignored if OptionCount is zero.
+  ///
+  EFI_DHCP4_PACKET_OPTION     **OptionList;
+} EFI_DHCP4_CONFIG_DATA;
+
+
+typedef struct {
+  ///
+  /// The EFI DHCPv4 Protocol driver operating state. 
+  ///
+  EFI_DHCP4_STATE             State;
+  ///
+  /// The configuration data of the current EFI DHCPv4 Protocol driver instance.
+  ///
+  EFI_DHCP4_CONFIG_DATA       ConfigData;
+  ///
+  /// The client IP address that was acquired from the DHCP server. If it is zero,
+  /// the DHCP acquisition has not completed yet and the following fields in this structure are undefined.
+  ///
+  EFI_IPv4_ADDRESS            ClientAddress;
+  ///
+  /// The local hardware address.
+  ///
+  EFI_MAC_ADDRESS             ClientMacAddress;
+  ///
+  /// The server IP address that is providing the DHCP service to this client.
+  ///
+  EFI_IPv4_ADDRESS            ServerAddress;
+  ///
+  /// The router IP address that was acquired from the DHCP server. 
+  /// May be zero if the server does not offer this address.
+  ///
+  EFI_IPv4_ADDRESS            RouterAddress;
+  ///
+  /// The subnet mask of the connected network that was acquired from the DHCP server.
+  ///
+  EFI_IPv4_ADDRESS            SubnetMask;
+  ///
+  /// The lease time (in 1-second units) of the configured IP address. 
+  /// The value 0xFFFFFFFF means that the lease time is infinite. 
+  /// A default lease of 7 days is used if the DHCP server does not provide a value.
+  ///
+  UINT32                      LeaseTime;
+  ///
+  /// The cached latest DHCPACK or DHCPNAK or BOOTP REPLY packet. May be NULL if no packet is cached.
+  ///
+  EFI_DHCP4_PACKET            *ReplyPacket;
+} EFI_DHCP4_MODE_DATA;
+
+
+typedef struct {
+  ///
+  /// Alternate listening address. It can be a unicast, multicast, or broadcast address.
+  ///
+  EFI_IPv4_ADDRESS            ListenAddress;
+  ///
+  /// The subnet mask of above listening unicast/broadcast IP address. 
+  /// Ignored if ListenAddress is a multicast address.
+  ///
+  EFI_IPv4_ADDRESS            SubnetMask;
+  ///
+  /// Alternate station source (or listening) port number. 
+  /// If zero, then the default station port number (68) will be used.
+  ///
+  UINT16                      ListenPort;
+} EFI_DHCP4_LISTEN_POINT;
+
+
+typedef struct {
+  ///
+  /// The completion status of transmitting and receiving.
+  ///
+  EFI_STATUS              Status;
+  ///
+  /// If not NULL, the event that will be signaled when the collection process 
+  /// completes. If NULL, this function will busy-wait until the collection process competes.
+  ///
+  EFI_EVENT               CompletionEvent;
+  ///
+  /// The pointer to the server IP address. This address may be a unicast, multicast, or broadcast address.
+  ///
+  EFI_IPv4_ADDRESS        RemoteAddress;
+  ///
+  /// The server listening port number. If zero, the default server listening port number (67) will be used.
+  ///
+  UINT16                  RemotePort;
+  ///
+  /// The pointer to the gateway address to override the existing setting.
+  ///
+  EFI_IPv4_ADDRESS        GatewayAddress;
+  ///
+  /// The number of entries in ListenPoints. If zero, the default station address and port number 68 are used.
+  ///
+  UINT32                  ListenPointCount;
+  ///
+  /// An array of station address and port number pairs that are used as receiving filters. 
+  /// The first entry is also used as the source address and source port of the outgoing packet.
+  ///
+  EFI_DHCP4_LISTEN_POINT  *ListenPoints;
+  ///
+  /// The number of seconds to collect responses. Zero is invalid.
+  ///
+  UINT32                  TimeoutValue;
+  ///
+  /// The pointer to the packet to be transmitted.
+  ///
+  EFI_DHCP4_PACKET        *Packet;
+  ///
+  /// Number of received packets.
+  ///
+  UINT32                  ResponseCount;
+  ///
+  /// The pointer to the allocated list of received packets.
+  ///
+  EFI_DHCP4_PACKET        *ResponseList;
+} EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN;
+
+
+/**
+  Returns the current operating mode and cached data packet for the EFI DHCPv4 Protocol driver.
+  
+  The GetModeData() function returns the current operating mode and cached data
+  packet for the EFI DHCPv4 Protocol driver.
+
+  @param  This          The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  Dhcp4ModeData The pointer to storage for the EFI_DHCP4_MODE_DATA structure.
+
+  @retval EFI_SUCCESS           The mode data was returned.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_GET_MODE_DATA)(
+  IN  EFI_DHCP4_PROTOCOL      *This,
+  OUT EFI_DHCP4_MODE_DATA     *Dhcp4ModeData
+  );
+
+/**
+  Initializes, changes, or resets the operational settings for the EFI DHCPv4 Protocol driver.
+
+  The Configure() function is used to initialize, change, or reset the operational
+  settings of the EFI DHCPv4 Protocol driver for the communication device on which
+  the EFI DHCPv4 Service Binding Protocol is installed. This function can be
+  successfully called only if both of the following are true:
+  * This instance of the EFI DHCPv4 Protocol driver is in the Dhcp4Stopped, Dhcp4Init,
+    Dhcp4InitReboot, or Dhcp4Bound states.
+  * No other EFI DHCPv4 Protocol driver instance that is controlled by this EFI
+    DHCPv4 Service Binding Protocol driver instance has configured this EFI DHCPv4
+    Protocol driver.
+  When this driver is in the Dhcp4Stopped state, it can transfer into one of the
+  following two possible initial states:
+  * Dhcp4Init
+  * Dhcp4InitReboot.
+  The driver can transfer into these states by calling Configure() with a non-NULL
+  Dhcp4CfgData. The driver will transfer into the appropriate state based on the
+  supplied client network address in the ClientAddress parameter and DHCP options
+  in the OptionList parameter as described in RFC 2131.
+  When Configure() is called successfully while Dhcp4CfgData is set to NULL, the
+  default configuring data will be reset in the EFI DHCPv4 Protocol driver and
+  the state of the EFI DHCPv4 Protocol driver will not be changed. If one instance
+  wants to make it possible for another instance to configure the EFI DHCPv4 Protocol
+  driver, it must call this function with Dhcp4CfgData set to NULL.
+
+  @param  This                   The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  Dhcp4CfgData           The pointer to the EFI_DHCP4_CONFIG_DATA.
+
+  @retval EFI_SUCCESS           The EFI DHCPv4 Protocol driver is now in the Dhcp4Init or
+                                Dhcp4InitReboot state, if the original state of this driver
+                                was Dhcp4Stopped, Dhcp4Init,Dhcp4InitReboot, or Dhcp4Bound
+                                and the value of Dhcp4CfgData was not NULL.
+                                Otherwise, the state was left unchanged.
+  @retval EFI_ACCESS_DENIED     This instance of the EFI DHCPv4 Protocol driver was not in the
+                                Dhcp4Stopped, Dhcp4Init, Dhcp4InitReboot, or Dhcp4Bound state;
+                                Or onother instance of this EFI DHCPv4 Protocol driver is already
+                                in a valid configured state.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE:
+                                This is NULL.
+                                DiscoverTryCount > 0 and DiscoverTimeout is NULL
+                                RequestTryCount > 0 and RequestTimeout is NULL.
+                                OptionCount >0 and OptionList is NULL.
+                                ClientAddress is not a valid unicast address.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_CONFIGURE)(
+  IN EFI_DHCP4_PROTOCOL       *This,
+  IN EFI_DHCP4_CONFIG_DATA    *Dhcp4CfgData  OPTIONAL
+  );
+
+
+/**
+  Starts the DHCP configuration process.
+
+  The Start() function starts the DHCP configuration process. This function can
+  be called only when the EFI DHCPv4 Protocol driver is in the Dhcp4Init or
+  Dhcp4InitReboot state.
+  If the DHCP process completes successfully, the state of the EFI DHCPv4 Protocol
+  driver will be transferred through Dhcp4Selecting and Dhcp4Requesting to the
+  Dhcp4Bound state. The CompletionEvent will then be signaled if it is not NULL.
+  If the process aborts, either by the user or by some unexpected network error,
+  the state is restored to the Dhcp4Init state. The Start() function can be called
+  again to restart the process.
+  Refer to RFC 2131 for precise state transitions during this process. At the
+  time when each event occurs in this process, the callback function that was set
+  by EFI_DHCP4_PROTOCOL.Configure() will be called and the user can take this
+  opportunity to control the process.
+  
+  @param  This            The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  CompletionEvent If not NULL, it indicates the event that will be signaled when the
+                          EFI DHCPv4 Protocol driver is transferred into the
+                          Dhcp4Bound state or when the DHCP process is aborted.
+                          EFI_DHCP4_PROTOCOL.GetModeData() can be called to
+                          check the completion status. If NULL,
+                          EFI_DHCP4_PROTOCOL.Start() will wait until the driver
+                          is transferred into the Dhcp4Bound state or the process fails.
+
+  @retval EFI_SUCCESS           The DHCP configuration process has started, or it has completed
+                                when CompletionEvent is NULL.
+  @retval EFI_NOT_STARTED       The EFI DHCPv4 Protocol driver is in the Dhcp4Stopped
+                                state. EFI_DHCP4_PROTOCOL. Configure() needs to be called.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_TIMEOUT           The DHCP configuration process failed because no response was
+                                received from the server within the specified timeout value.
+  @retval EFI_ABORTED           The user aborted the DHCP process.
+  @retval EFI_ALREADY_STARTED   Some other EFI DHCPv4 Protocol instance already started the
+                                DHCP process.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval EFI_NO_MEDIA          There was a media error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_START)(
+  IN EFI_DHCP4_PROTOCOL       *This,
+  IN EFI_EVENT                CompletionEvent   OPTIONAL
+  );
+
+/**
+  Extends the lease time by sending a request packet.
+  
+  The RenewRebind() function is used to manually extend the lease time when the
+  EFI DHCPv4 Protocol driver is in the Dhcp4Bound state, and the lease time has
+  not expired yet. This function will send a request packet to the previously
+  found server (or to any server when RebindRequest is TRUE) and transfer the
+  state into the Dhcp4Renewing state (or Dhcp4Rebinding when RebindingRequest is
+  TRUE). When a response is received, the state is returned to Dhcp4Bound.
+  If no response is received before the try count is exceeded (the RequestTryCount
+  field that is specified in EFI_DHCP4_CONFIG_DATA) but before the lease time that
+  was issued by the previous server expires, the driver will return to the Dhcp4Bound
+  state, and the previous configuration is restored. The outgoing and incoming packets
+  can be captured by the EFI_DHCP4_CALLBACK function.
+
+  @param  This            The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  RebindRequest   If TRUE, this function broadcasts the request packets and enters
+                          the Dhcp4Rebinding state. Otherwise, it sends a unicast
+                          request packet and enters the Dhcp4Renewing state.
+  @param  CompletionEvent If not NULL, this event is signaled when the renew/rebind phase
+                          completes or some error occurs.
+                          EFI_DHCP4_PROTOCOL.GetModeData() can be called to
+                          check the completion status. If NULL,
+                          EFI_DHCP4_PROTOCOL.RenewRebind() will busy-wait
+                          until the DHCP process finishes.
+
+  @retval EFI_SUCCESS           The EFI DHCPv4 Protocol driver is now in the
+                                Dhcp4Renewing state or is back to the Dhcp4Bound state.
+  @retval EFI_NOT_STARTED       The EFI DHCPv4 Protocol driver is in the Dhcp4Stopped
+                                state. EFI_DHCP4_PROTOCOL.Configure() needs to
+                                be called.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_TIMEOUT           There was no response from the server when the try count was
+                                exceeded.
+  @retval EFI_ACCESS_DENIED     The driver is not in the Dhcp4Bound state.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_RENEW_REBIND)(
+  IN EFI_DHCP4_PROTOCOL       *This,
+  IN BOOLEAN                  RebindRequest,
+  IN EFI_EVENT                CompletionEvent  OPTIONAL
+  );
+
+/**
+  Releases the current address configuration.
+
+  The Release() function releases the current configured IP address by doing either
+  of the following:
+  * Sending a DHCPRELEASE packet when the EFI DHCPv4 Protocol driver is in the
+    Dhcp4Bound state
+  * Setting the previously assigned IP address that was provided with the
+    EFI_DHCP4_PROTOCOL.Configure() function to 0.0.0.0 when the driver is in
+    Dhcp4InitReboot state
+  After a successful call to this function, the EFI DHCPv4 Protocol driver returns
+  to the Dhcp4Init state, and any subsequent incoming packets will be discarded silently.
+
+  @param  This                  The pointer to the EFI_DHCP4_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The EFI DHCPv4 Protocol driver is now in the Dhcp4Init phase.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv4 Protocol driver is not Dhcp4InitReboot state.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_RELEASE)(
+  IN EFI_DHCP4_PROTOCOL       *This
+  );
+
+/**
+  Stops the current address configuration.
+  
+  The Stop() function is used to stop the DHCP configuration process. After this
+  function is called successfully, the EFI DHCPv4 Protocol driver is transferred
+  into the Dhcp4Stopped state. EFI_DHCP4_PROTOCOL.Configure() needs to be called
+  before DHCP configuration process can be started again. This function can be
+  called when the EFI DHCPv4 Protocol driver is in any state.
+
+  @param  This                  The pointer to the EFI_DHCP4_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The EFI DHCPv4 Protocol driver is now in the Dhcp4Stopped phase.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_STOP)(
+  IN EFI_DHCP4_PROTOCOL       *This
+  );
+
+/**
+  Builds a DHCP packet, given the options to be appended or deleted or replaced.
+
+  The Build() function is used to assemble a new packet from the original packet
+  by replacing or deleting existing options or appending new options. This function
+  does not change any state of the EFI DHCPv4 Protocol driver and can be used at
+  any time.
+
+  @param  This        The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  SeedPacket  Initial packet to be used as a base for building new packet.
+  @param  DeleteCount Number of opcodes in the DeleteList.
+  @param  DeleteList  List of opcodes to be deleted from the seed packet.
+                      Ignored if DeleteCount is zero.
+  @param  AppendCount Number of entries in the OptionList.
+  @param  AppendList  The pointer to a DHCP option list to be appended to SeedPacket.
+                      If SeedPacket also contains options in this list, they are
+                      replaced by new options (except pad option). Ignored if
+                      AppendCount is zero. Type EFI_DHCP4_PACKET_OPTION
+  @param  NewPacket   The pointer to storage for the pointer to the new allocated packet.
+                      Use the EFI Boot Service FreePool() on the resulting pointer
+                      when done with the packet.
+
+  @retval EFI_SUCCESS           The new packet was built.
+  @retval EFI_OUT_OF_RESOURCES  Storage for the new packet could not be allocated.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                This is NULL.
+                                SeedPacket is NULL.
+                                SeedPacket is not a well-formed DHCP packet.
+                                AppendCount is not zero and AppendList is NULL.
+                                DeleteCount is not zero and DeleteList is NULL.
+                                NewPacket is NULL
+                                Both DeleteCount and AppendCount are zero and
+                                NewPacket is not NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_BUILD)(
+  IN  EFI_DHCP4_PROTOCOL      *This,
+  IN  EFI_DHCP4_PACKET        *SeedPacket,
+  IN  UINT32                  DeleteCount,
+  IN  UINT8                   *DeleteList         OPTIONAL,
+  IN  UINT32                  AppendCount,
+  IN  EFI_DHCP4_PACKET_OPTION *AppendList[]       OPTIONAL,
+  OUT EFI_DHCP4_PACKET        **NewPacket
+  );
+
+
+/**
+  Transmits a DHCP formatted packet and optionally waits for responses.
+  
+  The TransmitReceive() function is used to transmit a DHCP packet and optionally
+  wait for the response from servers. This function does not change the state of
+  the EFI DHCPv4 Protocol driver. It can be used at any time because of this.
+
+  @param  This    The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  Token   The pointer to the EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN structure.
+
+  @retval EFI_SUCCESS           The packet was successfully queued for transmission.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                This is NULL.
+                                Token.RemoteAddress is zero.
+                                Token.Packet is NULL.
+                                Token.Packet is not a well-formed DHCP packet.
+                                The transaction ID in Token.Packet is in use by another DHCP process.
+  @retval EFI_NOT_READY         The previous call to this function has not finished yet. Try to call
+                                this function after collection process completes.
+  @retval EFI_NO_MAPPING        The default station address is not available yet.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_UNSUPPORTED       The implementation doesn't support this function
+  @retval Others                Some other unexpected error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_TRANSMIT_RECEIVE)(
+  IN EFI_DHCP4_PROTOCOL                *This,
+  IN EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN  *Token
+  );
+
+
+/**
+  Parses the packed DHCP option data.
+  
+  The Parse() function is used to retrieve the option list from a DHCP packet.
+  If *OptionCount isn't zero, and there is enough space for all the DHCP options
+  in the Packet, each element of PacketOptionList is set to point to somewhere in
+  the Packet->Dhcp4.Option where a new DHCP option begins. If RFC3396 is supported,
+  the caller should reassemble the parsed DHCP options to get the final result.
+  If *OptionCount is zero or there isn't enough space for all of them, the number
+  of DHCP options in the Packet is returned in OptionCount.
+
+  @param  This             The pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param  Packet           The pointer to packet to be parsed.
+  @param  OptionCount      On input, the number of entries in the PacketOptionList.
+                           On output, the number of entries that were written into the
+                           PacketOptionList.
+  @param  PacketOptionList A list of packet option entries to be filled in. End option or pad
+                           options are not included.
+
+  @retval EFI_SUCCESS           The packet was successfully parsed.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                This is NULL.
+                                The packet is NULL.
+                                The packet is not a well-formed DHCP packet.
+                                OptionCount is NULL.
+  @retval EFI_BUFFER_TOO_SMALL  One or more of the following conditions is TRUE:
+                                1) *OptionCount is smaller than the number of options that
+                                were found in the Packet.
+                                2) PacketOptionList is NULL.
+  @retval EFI_OUT_OF_RESOURCE   The packet failed to parse because of a resource shortage.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP4_PARSE)(
+  IN EFI_DHCP4_PROTOCOL        *This,
+  IN EFI_DHCP4_PACKET          *Packet,
+  IN OUT UINT32                *OptionCount,
+  OUT EFI_DHCP4_PACKET_OPTION  *PacketOptionList[]  OPTIONAL
+  );
+
+///
+/// This protocol is used to collect configuration information for the EFI IPv4 Protocol drivers
+/// and to provide DHCPv4 server and PXE boot server discovery services.
+///
+struct _EFI_DHCP4_PROTOCOL {
+  EFI_DHCP4_GET_MODE_DATA      GetModeData;
+  EFI_DHCP4_CONFIGURE          Configure;
+  EFI_DHCP4_START              Start;
+  EFI_DHCP4_RENEW_REBIND       RenewRebind;
+  EFI_DHCP4_RELEASE            Release;
+  EFI_DHCP4_STOP               Stop;
+  EFI_DHCP4_BUILD              Build;
+  EFI_DHCP4_TRANSMIT_RECEIVE   TransmitReceive;
+  EFI_DHCP4_PARSE              Parse;
+};
+
+extern EFI_GUID gEfiDhcp4ProtocolGuid;
+extern EFI_GUID gEfiDhcp4ServiceBindingProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Dhcp6.h b/MdePkg/Include/Protocol/Dhcp6.h
new file mode 100644
index 000000000000..8e0ae27eb934
--- /dev/null
+++ b/MdePkg/Include/Protocol/Dhcp6.h
@@ -0,0 +1,786 @@
+/** @file
+  UEFI Dynamic Host Configuration Protocol 6 Definition, which is used to get IPv6
+  addresses and other configuration parameters from DHCPv6 servers.
+
+  Copyright (c) 2008 - 2010, 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. 
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_DHCP6_PROTOCOL_H__
+#define __EFI_DHCP6_PROTOCOL_H__
+
+#define EFI_DHCP6_PROTOCOL_GUID \
+  { \
+    0x87c8bad7, 0x595, 0x4053, {0x82, 0x97, 0xde, 0xde, 0x39, 0x5f, 0x5d, 0x5b } \
+  }
+
+#define EFI_DHCP6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x9fb9a8a1, 0x2f4a, 0x43a6, {0x88, 0x9c, 0xd0, 0xf7, 0xb6, 0xc4, 0x7a, 0xd5 } \
+  }
+
+typedef struct _EFI_DHCP6_PROTOCOL EFI_DHCP6_PROTOCOL;
+
+typedef enum { 
+  ///
+  /// The EFI DHCPv6 Protocol instance is configured, and start() needs 
+  /// to be called
+  ///
+  Dhcp6Init                    = 0x0,
+  ///
+  /// A Solicit packet is sent out to discover DHCPv6 server, and the EFI
+  /// DHCPv6 Protocol instance is collecting Advertise packets.
+  ///
+  Dhcp6Selecting               = 0x1,
+  ///
+  /// A Request is sent out to the DHCPv6 server, and the EFI DHCPv6 
+  /// Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Requesting              = 0x2,
+  ///
+  /// A Decline packet is sent out to indicate one or more addresses of the
+  /// configured IA are in use by another node, and the EFI DHCPv6.
+  /// Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Declining               = 0x3,
+  ///
+  /// A Confirm packet is sent out to confirm the IPv6 addresses of the 
+  /// configured IA, and the EFI DHCPv6 Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Confirming              = 0x4,
+  ///
+  /// A Release packet is sent out to release one or more IPv6 addresses of
+  /// the configured IA, and the EFI DHCPv6 Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Releasing               = 0x5,
+  ///
+  /// The DHCPv6 S.A.R.R process is completed for the configured IA.
+  ///
+  Dhcp6Bound                   = 0x6,
+  ///
+  /// A Renew packet is sent out to extend lifetime for the IPv6 addresses of
+  /// the configured IA, and the EFI DHCPv6 Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Renewing                = 0x7,
+  ///
+  /// A Rebind packet is sent out to extend lifetime for the IPv6 addresses of
+  /// the configured IA, and the EFI DHCPv6 Protocol instance is waiting for Reply packet.
+  ///
+  Dhcp6Rebinding               = 0x8
+} EFI_DHCP6_STATE;
+
+typedef enum {
+  ///     
+  /// A Solicit packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6SendSolicit             = 0x0,
+  ///     
+  /// An Advertise packet is received and will be passed to Dhcp6Callback.
+  ///
+  Dhcp6RcvdAdvertise           = 0x1,
+  ///     
+  /// It is time for Dhcp6Callback to determine whether select the default Advertise
+  /// packet by RFC 3315 policy, or overwrite it by specific user policy.
+  ///
+  Dhcp6SelectAdvertise         = 0x2,
+  ///     
+  /// A Request packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6SendRequest             = 0x3,
+  ///     
+  /// A Reply packet is received and will be passed to Dhcp6Callback.
+  ///
+  Dhcp6RcvdReply               = 0x4,
+  ///     
+  /// A Reconfigure packet is received and will be passed to Dhcp6Callback.
+  ///
+  Dhcp6RcvdReconfigure         = 0x5,
+  ///     
+  /// A Decline packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6SendDecline             = 0x6,
+  ///     
+  /// A Confirm packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6SendConfirm             = 0x7,
+  ///     
+  /// A Release packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6SendRelease             = 0x8,
+  ///     
+  /// A Renew packet is about to be sent. The packet is passed to Dhcp6Callback and
+  /// can be modified or replaced in Dhcp6Callback. 
+  ///
+  Dhcp6EnterRenewing           = 0x9,
+  ///     
+  /// A Rebind packet is about to be sent. The packet is passed to Dhcp6Callback and 
+  /// can be modified or replaced in Dhcp6Callback.
+  ///
+  Dhcp6EnterRebinding          = 0xa
+} EFI_DHCP6_EVENT;
+
+///
+/// An IA which carries assigned not temporary address.
+///
+#define EFI_DHCP6_IA_TYPE_NA   3
+///
+/// An IA which carries assigned temporary address.
+///
+#define EFI_DHCP6_IA_TYPE_TA   4
+
+#pragma pack(1)
+///
+/// EFI_DHCP6_PACKET_OPTION
+/// defines the format of the DHCPv6 option, See RFC 3315 for more information.
+/// This data structure is used to reference option data that is packed in the DHCPv6 packet. 
+///
+typedef struct {
+  ///
+  /// The DHCPv6 option code, stored in network order.
+  ///
+  UINT16                       OpCode;
+  ///
+  /// Length of the DHCPv6 option data, stored in network order.
+  /// From the first byte to the last byte of the Data field.
+  ///
+  UINT16                       OpLen;
+  ///
+  /// The data for the DHCPv6 option, stored in network order.
+  ///
+  UINT8                        Data[1];
+} EFI_DHCP6_PACKET_OPTION;
+
+///
+/// EFI_DHCP6_HEADER
+/// defines the format of the DHCPv6 header. See RFC 3315 for more information. 
+///
+typedef struct{
+  ///
+  /// The DHCPv6 transaction ID.
+  ///
+  UINT32                       MessageType:8;
+  ///
+  /// The DHCPv6 message type.
+  ///
+  UINT32                       TransactionId:24;
+} EFI_DHCP6_HEADER;
+
+///
+/// EFI_DHCP6_PACKET 
+/// defines the format of the DHCPv6 packet. See RFC 3315 for more information.
+///
+typedef struct {
+  ///
+  /// Size of the EFI_DHCP6_PACKET buffer.
+  ///
+  UINT32                       Size;
+  ///
+  /// Length of the EFI_DHCP6_PACKET from the first byte of the Header field to the last
+  /// byte of the Option[] field.
+  ///
+  UINT32                       Length;
+  struct{
+    ///
+    /// The DHCPv6 packet header.
+    ///
+    EFI_DHCP6_HEADER           Header;
+    ///
+    /// Start of the DHCPv6 packed option data.
+    ///
+    UINT8                      Option[1];
+  } Dhcp6;
+} EFI_DHCP6_PACKET;
+
+#pragma pack()
+
+typedef struct {
+  ///
+  /// Length of DUID in octects.
+  ///
+  UINT16                       Length;
+  ///
+  /// Array of DUID octects.
+  ///
+  UINT8                        Duid[1];
+} EFI_DHCP6_DUID;
+
+typedef struct {
+  ///
+  /// Initial retransmission timeout.
+  ///
+  UINT32                       Irt;
+  ///
+  /// Maximum retransmission count for one packet. If Mrc is zero, there's no upper limit 
+  /// for retransmission count.
+  ///
+  UINT32                       Mrc;
+  ///
+  /// Maximum retransmission timeout for each retry. It's the upper bound of the number of 
+  /// retransmission timeout. If Mrt is zero, there is no upper limit for retransmission 
+  /// timeout.
+  ///
+  UINT32                       Mrt;
+  ///
+  /// Maximum retransmission duration for one packet. It's the upper bound of the numbers 
+  /// the client may retransmit a message. If Mrd is zero, there's no upper limit for 
+  /// retransmission duration.
+  ///
+  UINT32                       Mrd;
+} EFI_DHCP6_RETRANSMISSION;
+
+typedef struct {
+  ///
+  /// The IPv6 address.
+  ///
+  EFI_IPv6_ADDRESS             IpAddress;
+  ///
+  /// The preferred lifetime in unit of seconds for the IPv6 address.
+  ///
+  UINT32                       PreferredLifetime;
+  ///
+  /// The valid lifetime in unit of seconds for the IPv6 address.
+  ///
+  UINT32                       ValidLifetime;
+} EFI_DHCP6_IA_ADDRESS;
+
+typedef struct {
+  UINT16                       Type; ///< Type for an IA.
+  UINT32                       IaId; ///< The identifier for an IA.
+} EFI_DHCP6_IA_DESCRIPTOR;
+
+typedef struct {
+  ///
+  /// The descriptor for IA.
+  ///
+  EFI_DHCP6_IA_DESCRIPTOR      Descriptor;
+  ///
+  /// The state of the configured IA.
+  ///
+  EFI_DHCP6_STATE              State;
+  ///
+  /// Pointer to the cached latest Reply packet. May be NULL if no packet is cached.
+  ///
+  EFI_DHCP6_PACKET             *ReplyPacket;
+  ///
+  /// Number of IPv6 addresses of the configured IA.
+  ///
+  UINT32                       IaAddressCount;
+  ///
+  /// List of the IPv6 addresses of the configured IA. When the state of the configured IA is 
+  /// in Dhcp6Bound, Dhcp6Renewing and Dhcp6Rebinding, the IPv6 addresses are usable.
+  ///
+  EFI_DHCP6_IA_ADDRESS         IaAddress[1];
+} EFI_DHCP6_IA;
+
+typedef struct {
+  ///
+  /// Pointer to the DHCPv6 unique identifier. The caller is responsible for freeing this buffer.
+  ///
+  EFI_DHCP6_DUID               *ClientId;
+  ///
+  /// Pointer to the configured IA of current instance. The caller can free this buffer after
+  /// using it.
+  ///
+  EFI_DHCP6_IA                 *Ia;
+} EFI_DHCP6_MODE_DATA;
+
+/**
+  EFI_DHCP6_CALLBACK is provided by the consumer of the EFI DHCPv6 Protocol instance to 
+  intercept events that occurs in the DHCPv6 S.A.R.R process.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance that is used to configure this 
+                                callback function.
+  @param[in]  Context           Pointer to the context that is initialized by EFI_DHCP6_PROTOCOL.Configure().
+  @param[in]  CurrentState      The current state of the configured IA.
+  @param[in]  Dhcp6Event        The event that occurs in the current state, which usually means a state transition.
+  @param[in]  Packet            Pointer to the DHCPv6 packet that is about to be sent or has been received.
+                                The EFI DHCPv6 Protocol instance is responsible for freeing the buffer. 
+  @param[out] NewPacket         Pointer to the new DHCPv6 packet to overwrite the Packet. NewPacket can not 
+                                share the buffer with Packet. If *NewPacket is not NULL, the EFI DHCPv6 
+                                Protocol instance is responsible for freeing the buffer.
+
+  @retval EFI_SUCCESS           Tell the EFI DHCPv6 Protocol instance to continue the DHCPv6 S.A.R.R process.
+  @retval EFI_ABORTED           Tell the EFI DHCPv6 Protocol instance to abort the DHCPv6 S.A.R.R process, 
+                                and the state of the configured IA will be transferred to Dhcp6Init.
+
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_DHCP6_CALLBACK)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN VOID                      *Context,
+  IN EFI_DHCP6_STATE           CurrentState,
+  IN EFI_DHCP6_EVENT           Dhcp6Event,
+  IN EFI_DHCP6_PACKET          *Packet,        
+  OUT EFI_DHCP6_PACKET         **NewPacket OPTIONAL
+  );
+
+typedef struct {
+  ///
+  /// The callback function is to intercept various events that occur in the DHCPv6 S.A.R.R 
+  /// process. Set to NULL to ignore all those events.
+  ///
+  EFI_DHCP6_CALLBACK           Dhcp6Callback;
+  ///
+  /// Pointer to the context that will be passed to Dhcp6Callback.
+  ///
+  VOID                         *CallbackContext;
+  ///
+  /// Number of the DHCPv6 options in the OptionList.
+  ///
+  UINT32                       OptionCount;
+  ///
+  /// List of the DHCPv6 options to be included in Solicit and Request packet. The buffer 
+  /// can be freed after EFI_DHCP6_PROTOCOL.Configure() returns. Ignored if 
+  /// OptionCount is zero. OptionList should not contain Client Identifier option 
+  /// and any IA option, which will be appended by EFI DHCPv6 Protocol instance 
+  /// automatically. 
+  ///
+  EFI_DHCP6_PACKET_OPTION      **OptionList;
+  ///
+  /// The descriptor for the IA of the EFI DHCPv6 Protocol instance.
+  ///
+  EFI_DHCP6_IA_DESCRIPTOR      IaDescriptor;
+  ///
+  /// If not NULL, the event will be signaled when any IPv6 address information of the 
+  /// configured IA is updated, including IPv6 address, preferred lifetime and valid 
+  /// lifetime, or the DHCPv6 S.A.R.R process fails. Otherwise, Start(), 
+  /// renewrebind(), decline(), release() and stop() will be blocking 
+  /// operations, and they will wait for the exchange process completion or failure.
+  ///
+  EFI_EVENT                    IaInfoEvent;
+  ///
+  /// If TRUE, the EFI DHCPv6 Protocol instance is willing to accept Reconfigure packet. 
+  /// Otherwise, it will ignore it. Reconfigure Accept option can not be specified through 
+  /// OptionList parameter.
+  ///
+  BOOLEAN                      ReconfigureAccept;
+  ///
+  /// If TRUE, the EFI DHCPv6 Protocol instance will send Solicit packet with Rapid 
+  /// Commit option. Otherwise, Rapid Commit option will not be included in Solicit 
+  /// packet. Rapid Commit option can not be specified through OptionList parameter.
+  ///
+  BOOLEAN                      RapidCommit;
+  ///
+  /// Parameter to control Solicit packet retransmission behavior. The 
+  /// buffer can be freed after EFI_DHCP6_PROTOCOL.Configure() returns.
+  ///
+  EFI_DHCP6_RETRANSMISSION     *SolicitRetransmission;
+} EFI_DHCP6_CONFIG_DATA;
+
+/**
+  EFI_DHCP6_INFO_CALLBACK is provided by the consumer of the EFI DHCPv6 Protocol 
+  instance to intercept events that occurs in the DHCPv6 Information Request exchange process.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance that is used to configure this 
+                                callback function.
+  @param[in]  Context           Pointer to the context that is initialized in the EFI_DHCP6_PROTOCOL.InfoRequest().
+  @param[in]  Packet            Pointer to Reply packet that has been received. The EFI DHCPv6 Protocol instance is 
+                                responsible for freeing the buffer.
+
+  @retval EFI_SUCCESS           Tell the EFI DHCPv6 Protocol instance to finish Information Request exchange process.
+  @retval EFI_NOT_READY         Tell the EFI DHCPv6 Protocol instance to continue Information Request exchange process.
+  @retval EFI_ABORTED           Tell the EFI DHCPv6 Protocol instance to abort the Information Request exchange process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_INFO_CALLBACK)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN VOID                      *Context,
+  IN EFI_DHCP6_PACKET          *Packet
+  );
+
+/**
+  Retrieve the current operating mode data and configuration data for the EFI DHCPv6 Protocol instance.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+  @param[out] Dhcp6ModeData     Pointer to the DHCPv6 mode data structure. The caller is responsible for freeing this 
+                                structure and each reference buffer.
+  @param[out] Dhcp6ConfigData   Pointer to the DHCPv6 configuration data structure. The caller is responsible for 
+                                freeing this structure and each reference buffer.
+
+  @retval EFI_SUCCESS           The mode data was returned.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Protocol instance has not been configured when Dhcp6ConfigData is not NULL.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE:
+                                - This is NULL. 
+                                - Both Dhcp6ConfigData and Dhcp6ModeData are NULL.
+
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_DHCP6_GET_MODE_DATA)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  OUT EFI_DHCP6_MODE_DATA      *Dhcp6ModeData OPTIONAL,
+  OUT EFI_DHCP6_CONFIG_DATA    *Dhcp6ConfigData OPTIONAL
+  );
+
+/**
+  Initialize or clean up the configuration data for the EFI DHCPv6 Protocol instance.
+
+  The Configure() function is used to initialize or clean up the configuration data of the EFI 
+  DHCPv6 Protocol instance.
+  - When Dhcp6CfgData is not NULL and Configure() is called successfully, the 
+    configuration data will be initialized in the EFI DHCPv6 Protocol instance and the state of the 
+    configured IA will be transferred into Dhcp6Init.
+  - When Dhcp6CfgData is NULL and Configure() is called successfully, the configuration 
+    data will be cleaned up and no IA will be associated with the EFI DHCPv6 Protocol instance.
+
+  To update the configuration data for an EFI DCHPv6 Protocol instance, the original data must be 
+  cleaned up before setting the new configuration data.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+  @param[in]  Dhcp6CfgData      Pointer to the DHCPv6 configuration data structure.
+
+  @retval EFI_SUCCESS           The mode data was returned.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE
+                                - This is NULL. 
+                                - OptionCount > 0 and OptionList is NULL.
+                                - OptionList is not NULL, and Client Id option, Reconfigure Accept option,
+                                  Rapid Commit option or any IA option is specified in the OptionList.
+                                - IaDescriptor.Type is neither EFI_DHCP6_IA_TYPE_NA nor EFI_DHCP6_IA_TYPE_NA.
+                                - IaDescriptor is not unique.
+                                - Both IaInfoEvent and SolicitRetransimssion are NULL.
+                                - SolicitRetransmission is not NULL, and both SolicitRetransimssion->Mrc and 
+                                  SolicitRetransmission->Mrd are zero.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Protocol instance has been already configured 
+                                when Dhcp6CfgData is not NULL.
+                                The EFI DHCPv6 Protocol instance has already started the 
+                                DHCPv6 S.A.R.R when Dhcp6CfgData is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_CONFIGURE)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN EFI_DHCP6_CONFIG_DATA     *Dhcp6CfgData OPTIONAL
+  );
+
+/**
+  Start the DHCPv6 S.A.R.R process.
+
+  The Start() function starts the DHCPv6 S.A.R.R process. This function can be called only when 
+  the state of the configured IA is in the Dhcp6Init state. If the DHCPv6 S.A.R.R process completes
+  successfully, the state of the configured IA will be transferred through Dhcp6Selecting and 
+  Dhcp6Requesting to Dhcp6Bound state. The update of the IPv6 addresses will be notified through 
+  EFI_DHCP6_CONFIG_DATA.IaInfoEvent. At the time when each event occurs in this process, the 
+  callback function set by EFI_DHCP6_PROTOCOL.Configure() will be called and the user can take 
+  this opportunity to control the process. If EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL, the 
+  Start() function call is a blocking operation. It will return after the DHCPv6 S.A.R.R process
+  completes or aborted by users. If the process is aborted by system or network error, the state of
+  the configured IA will be transferred to Dhcp6Init. The Start() function can be called again to
+  restart the process.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The DHCPv6 S.A.R.R process is completed and at least one IPv6 
+                                address has been bound to the configured IA when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL. 
+                                The DHCPv6 S.A.R.R process is started when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is not NULL.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Child instance hasn't been configured.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_ALREADY_STARTED   The DHCPv6 S.A.R.R process has already started.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_NO_RESPONSE       The DHCPv6 S.A.R.R process failed because of no response.
+  @retval EFI_NO_MAPPING        No IPv6 address has been bound to the configured IA after the 
+                                DHCPv6 S.A.R.R process.
+  @retval EFI_ABORTED           The DHCPv6 S.A.R.R process aborted by user.
+  @retval EFI_NO_MEDIA          There was a media error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_START)(
+  IN EFI_DHCP6_PROTOCOL        *This
+  );
+
+/**
+  Request configuration information without the assignment of any IA addresses of the client.
+
+  The InfoRequest() function is used to request configuration information without the assignment
+  of any IPv6 address of the client. Client sends out Information Request packet to obtain 
+  the required configuration information, and DHCPv6 server responds with Reply packet containing 
+  the information for the client. The received Reply packet will be passed to the user by 
+  ReplyCallback function. If user returns EFI_NOT_READY from ReplyCallback, the EFI DHCPv6
+  Protocol instance will continue to receive other Reply packets unless timeout according to 
+  the Retransmission parameter. Otherwise, the Information Request exchange process will be 
+  finished successfully if user returns EFI_SUCCESS from ReplyCallback.
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+  @param[in]  SendClientId      If TRUE, the EFI DHCPv6 Protocol instance will build Client
+                                Identifier option and include it into Information Request
+                                packet. If FALSE, Client Identifier option will not be included.
+                                Client Identifier option can not be specified through OptionList 
+                                parameter.
+  @param[in]  OptionRequest     Pointer to the Option Request option in the Information Request
+                                packet. Option Request option can not be specified through
+                                OptionList parameter.
+  @param[in]  OptionCount       Number of options in OptionList.
+  @param[in]  OptionList        List of other DHCPv6 options. These options will be appended
+                                to the Option Request option. The caller is responsible for
+                                freeing this buffer. Type is defined in EFI_DHCP6_PROTOCOL.GetModeData().
+  @param[in]  Retransmission    Parameter to control Information Request packet retransmission
+                                behavior. The buffer can be freed after EFI_DHCP6_PROTOCOL.InfoRequest()
+                                returns.
+  @param[in]  TimeoutEvent      If not NULL, this event is signaled when the information request
+                                exchange aborted because of no response. If NULL, the function
+                                call is a blocking operation; and it will return after the 
+                                information-request exchange process finish or aborted by users.
+  @param[in]  ReplyCallback     The callback function is to intercept various events that occur
+                                in the Information Request exchange process. It should not be
+                                set to NULL.
+  @param[in]  CallbackContext   Pointer to the context that will be passed to ReplyCallback.
+
+  @retval EFI_SUCCESS           The DHCPv6 S.A.R.R process is completed and at least one IPv6 
+  @retval EFI_SUCCESS           The DHCPv6 information request exchange process completed 
+                                when TimeoutEvent is NULL. Information Request packet has been
+                                sent to DHCPv6 server when TimeoutEvent is not NULL.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE:
+                                - This is NULL. 
+                                - OptionRequest is NULL or OptionRequest->OpCode is invalid.
+                                - OptionCount > 0 and OptionList is NULL.
+                                - OptionList is not NULL, and Client Identify option or 
+                                  Option Request option is specified in the OptionList.
+                                - Retransimssion is NULL.
+                                - Both Retransimssion->Mrc and Retransmission->Mrd are zero.
+                                - ReplyCallback is NULL.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_NO_RESPONSE       The DHCPv6 information request exchange process failed 
+                                because of no response, or not all requested-options are 
+                                responded by DHCPv6 servers when Timeout happened.
+  @retval EFI_ABORTED           The DHCPv6 information request exchange process aborted by user.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_INFO_REQUEST)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN BOOLEAN                   SendClientId,
+  IN EFI_DHCP6_PACKET_OPTION   *OptionRequest,
+  IN UINT32                    OptionCount,
+  IN EFI_DHCP6_PACKET_OPTION   *OptionList[] OPTIONAL,
+  IN EFI_DHCP6_RETRANSMISSION  *Retransmission, 
+  IN EFI_EVENT                 TimeoutEvent OPTIONAL,
+  IN EFI_DHCP6_INFO_CALLBACK   ReplyCallback,
+  IN VOID                      *CallbackContext OPTIONAL
+  );
+
+/**
+  Manually extend the valid and preferred lifetimes for the IPv6 addresses of the configured
+  IA and update other configuration parameters by sending Renew or Rebind packet.
+
+  The RenewRebind() function is used to manually extend the valid and preferred lifetimes for the 
+  IPv6 addresses of the configured IA and update other configuration parameters by sending Renew or 
+  Rebind packet. 
+  - When RebindRequest is FALSE and the state of the configured IA is Dhcp6Bound, it 
+  will send Renew packet to the previously DHCPv6 server and transfer the state of the configured 
+  IA to Dhcp6Renewing. If valid Reply packet received, the state transfers to Dhcp6Bound 
+  and the valid and preferred timer restarts. If fails, the state transfers to Dhcp6Bound but the 
+  timer continues. 
+  - When RebindRequest is TRUE and the state of the configured IA is Dhcp6Bound, it will 
+  send Rebind packet. If valid Reply packet received, the state transfers to Dhcp6Bound and the 
+  valid and preferred timer restarts. If fails, the state transfers to Dhcp6Init and the IA can't
+  be used.
+
+  @param[in]  This              Pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param[in]  RebindRequest     If TRUE, it will send Rebind packet and enter the Dhcp6Rebinding state. 
+                                Otherwise, it will send Renew packet and enter the Dhcp6Renewing state.
+
+  @retval EFI_SUCCESS           The DHCPv6 renew/rebind exchange process has completed and at 
+                                least one IPv6 address of the configured IA has been bound again
+                                when EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL. 
+                                The EFI DHCPv6 Protocol instance has sent Renew or Rebind packet 
+                                when EFI_DHCP6_CONFIG_DATA.IaInfoEvent is not NULL.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Child instance hasn't been configured, or the state
+                                of the configured IA is not in Dhcp6Bound.
+  @retval EFI_ALREADY_STARTED   The state of the configured IA has already entered Dhcp6Renewing 
+                                when RebindRequest is FALSE. 
+                                The state of the configured IA has already entered Dhcp6Rebinding 
+                                when RebindRequest is TRUE.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_DEVICE_ERROR      An unexpected system or system error occurred.
+  @retval EFI_NO_RESPONSE       The DHCPv6 renew/rebind exchange process failed because of no response.
+  @retval EFI_NO_MAPPING        No IPv6 address has been bound to the configured IA after the DHCPv6 
+                                renew/rebind exchange process.
+  @retval EFI_ABORTED           The DHCPv6 renew/rebind exchange process aborted by user.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_RENEW_REBIND)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN BOOLEAN                   RebindRequest
+  );
+
+/**
+  Inform that one or more IPv6 addresses assigned by a server are already in use by
+  another node.
+
+  The Decline() function is used to manually decline the assignment of IPv6 addresses, which 
+  have been already used by another node. If all IPv6 addresses of the configured IA are declined 
+  through this function, the state of the IA will switch through Dhcp6Declining to Dhcp6Init, 
+  otherwise, the state of the IA will restore to Dhcp6Bound after the declining process. The 
+  Decline() can only be called when the IA is in Dhcp6Bound state. If the 
+  EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL, this function is a blocking operation. It 
+  will return after the declining process finishes, or aborted by user.
+
+  @param[in]  This              Pointer to the EFI_DHCP4_PROTOCOL instance.
+  @param[in]  AddressCount      Number of declining IPv6 addresses. 
+  @param[in]  Addresses         Pointer to the buffer stored all the declining IPv6 addresses.
+
+  @retval EFI_SUCCESS           The DHCPv6 decline exchange process has completed when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL.
+                                The EFI DHCPv6 Protocol instance has sent Decline packet when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is not NULL.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE
+                                - This is NULL.  
+                                - AddressCount is zero or Addresses is NULL.
+  @retval EFI_NOT_FOUND         Any specified IPv6 address is not correlated with the configured IA 
+                                for this instance.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Child instance hasn't been configured, or the 
+                                state of the configured IA is not in Dhcp6Bound.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_ABORTED           The DHCPv6 decline exchange process aborted by user.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_DECLINE)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN UINT32                    AddressCount,
+  IN EFI_IPv6_ADDRESS          *Addresses
+  );
+
+/**
+  Release one or more IPv6 addresses associated with the configured IA for current instance.
+
+  The Release() function is used to manually release the one or more IPv6 address. If AddressCount
+  is zero, it will release all IPv6 addresses of the configured IA. If all IPv6 addresses of the IA
+  are released through this function, the state of the IA will switch through Dhcp6Releasing to 
+  Dhcp6Init, otherwise, the state of the IA will restore to Dhcp6Bound after the releasing process.
+  The Release() can only be called when the IA is in Dhcp6Bound state. If the
+  EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL, the function is a blocking operation. It will return
+  after the releasing process finishes, or aborted by user. 
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+  @param[in]  AddressCount      Number of releasing IPv6 addresses. 
+  @param[in]  Addresses         Pointer to the buffer stored all the releasing IPv6 addresses.
+                                Ignored if AddressCount is zero.
+  @retval EFI_SUCCESS           The DHCPv6 release exchange process has completed when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL.
+                                The EFI DHCPv6 Protocol instance has sent Release packet when 
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is not NULL.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE
+                                - This is NULL.  
+                                - AddressCount is not zero or Addresses is NULL.
+  @retval EFI_NOT_FOUND         Any specified IPv6 address is not correlated with the configured
+                                IA for this instance.
+  @retval EFI_ACCESS_DENIED     The EFI DHCPv6 Child instance hasn't been configured, or the 
+                                state of the configured IA is not in Dhcp6Bound.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_ABORTED           The DHCPv6 release exchange process aborted by user. 
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_RELEASE)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN UINT32                    AddressCount,
+  IN EFI_IPv6_ADDRESS          *Addresses
+  );
+
+/**
+  Stop the DHCPv6 S.A.R.R process.
+
+  The Stop() function is used to stop the DHCPv6 S.A.R.R process. If this function is called
+  successfully, all the IPv6 addresses of the configured IA will be released and the state of
+  the configured IA will be transferred to Dhcp6Init.   
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The DHCPv6 S.A.R.R process has been stopped when
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is NULL.
+                                The EFI DHCPv6 Protocol instance has sent Release packet if
+                                need release or has been stopped if needn't, when
+                                EFI_DHCP6_CONFIG_DATA.IaInfoEvent is not NULL.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_STOP)(
+  IN EFI_DHCP6_PROTOCOL        *This
+  );
+
+/**
+  Parse the option data in the DHCPv6 packet.
+
+  The Parse() function is used to retrieve the option list in the DHCPv6 packet. 
+
+  @param[in]  This              Pointer to the EFI_DHCP6_PROTOCOL instance.
+
+  @param[in]  Packet            Pointer to packet to be parsed.
+  @param[in]  OptionCount       On input, the number of entries in the PacketOptionList.
+                                On output, the number of DHCPv6 options in the Packet.
+  @param[in]  PacketOptionList  List of pointers to the DHCPv6 options in the Packet.
+                                The OpCode and OpLen in EFI_DHCP6_PACKET_OPTION are
+                                both stored in network byte order.
+  @retval EFI_SUCCESS           The packet was successfully parsed.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE
+                                - This is NULL.
+                                - Packet is NULL.
+                                - Packet is not a well-formed DHCPv6 packet.
+                                - OptionCount is NULL.
+                                - *OptionCount is not zero and PacketOptionList is NULL.
+  @retval EFI_BUFFER_TOO_SMALL  *OptionCount is smaller than the number of options that were 
+                                found in the Packet.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DHCP6_PARSE)(
+  IN EFI_DHCP6_PROTOCOL        *This,
+  IN EFI_DHCP6_PACKET          *Packet,
+  IN OUT UINT32                *OptionCount,
+  OUT EFI_DHCP6_PACKET_OPTION  *PacketOptionList[] OPTIONAL
+);
+
+///
+/// The EFI DHCPv6 Protocol is used to get IPv6 addresses and other configuration parameters
+/// from DHCPv6 servers.
+///
+struct _EFI_DHCP6_PROTOCOL {
+  EFI_DHCP6_GET_MODE_DATA      GetModeData;
+  EFI_DHCP6_CONFIGURE          Configure;
+  EFI_DHCP6_START              Start;
+  EFI_DHCP6_INFO_REQUEST       InfoRequest;
+  EFI_DHCP6_RENEW_REBIND       RenewRebind;
+  EFI_DHCP6_DECLINE            Decline;
+  EFI_DHCP6_RELEASE            Release;
+  EFI_DHCP6_STOP               Stop;
+  EFI_DHCP6_PARSE              Parse;
+};
+
+extern EFI_GUID gEfiDhcp6ProtocolGuid;
+extern EFI_GUID gEfiDhcp6ServiceBindingProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DiskInfo.h b/MdePkg/Include/Protocol/DiskInfo.h
new file mode 100644
index 000000000000..e60ae0e98921
--- /dev/null
+++ b/MdePkg/Include/Protocol/DiskInfo.h
@@ -0,0 +1,218 @@
+/** @file
+  Provides the basic interfaces to abstract platform information regarding an 
+  IDE controller.  
+
+  Copyright (c) 2006 - 2014, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+  
+**/
+
+#ifndef __DISK_INFO_H__
+#define __DISK_INFO_H__
+
+///
+/// Global ID for EFI_DISK_INFO_PROTOCOL
+///
+#define EFI_DISK_INFO_PROTOCOL_GUID \
+  { \
+    0xd432a67f, 0x14dc, 0x484b, {0xb3, 0xbb, 0x3f, 0x2, 0x91, 0x84, 0x93, 0x27 } \
+  }
+
+///
+/// Forward declaration for EFI_DISK_INFO_PROTOCOL
+///
+typedef struct _EFI_DISK_INFO_PROTOCOL  EFI_DISK_INFO_PROTOCOL;
+
+///
+/// Global ID for an IDE interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_IDE_INTERFACE_GUID \
+  { \
+    0x5e948fe3, 0x26d3, 0x42b5, {0xaf, 0x17, 0x61, 0x2, 0x87, 0x18, 0x8d, 0xec } \
+  }
+
+///
+/// Global ID for a SCSI interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_SCSI_INTERFACE_GUID \
+  { \
+    0x8f74baa, 0xea36, 0x41d9, {0x95, 0x21, 0x21, 0xa7, 0xf, 0x87, 0x80, 0xbc } \
+  }
+
+///
+/// Global ID for a USB interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_USB_INTERFACE_GUID \
+  { \
+    0xcb871572, 0xc11a, 0x47b5, {0xb4, 0x92, 0x67, 0x5e, 0xaf, 0xa7, 0x77, 0x27 } \
+  }
+
+///
+/// Global ID for an AHCI interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_AHCI_INTERFACE_GUID \
+  { \
+    0x9e498932, 0x4abc, 0x45af, {0xa3, 0x4d, 0x2, 0x47, 0x78, 0x7b, 0xe7, 0xc6 } \
+  }
+
+///
+/// Global ID for a NVME interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_NVME_INTERFACE_GUID \
+  { \
+    0x3ab14680, 0x5d3f, 0x4a4d, {0xbc, 0xdc, 0xcc, 0x38, 0x0, 0x18, 0xc7, 0xf7 } \
+  }
+
+///
+/// Global ID for a UFS interface.  Used to fill in EFI_DISK_INFO_PROTOCOL.Interface
+///
+#define EFI_DISK_INFO_UFS_INTERFACE_GUID \
+  { \
+    0x4b3029cc, 0x6b98, 0x47fb, { 0xbc, 0x96, 0x76, 0xdc, 0xb8, 0x4, 0x41, 0xf0 } \
+  }
+
+/**
+  Provides inquiry information for the controller type.
+  
+  This function is used by the IDE bus driver to get inquiry data.  Data format
+  of Identify data is defined by the Interface GUID.
+
+  @param[in]     This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
+  @param[in,out] InquiryData       Pointer to a buffer for the inquiry data.
+  @param[in,out] InquiryDataSize   Pointer to the value for the inquiry data size.
+
+  @retval EFI_SUCCESS            The command was accepted without any errors.
+  @retval EFI_NOT_FOUND          Device does not support this data class 
+  @retval EFI_DEVICE_ERROR       Error reading InquiryData from device 
+  @retval EFI_BUFFER_TOO_SMALL   InquiryDataSize not big enough 
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_INFO_INQUIRY)(
+  IN     EFI_DISK_INFO_PROTOCOL  *This,
+  IN OUT VOID                    *InquiryData,
+  IN OUT UINT32                  *InquiryDataSize
+  );
+
+/**
+  Provides identify information for the controller type.
+
+  This function is used by the IDE bus driver to get identify data.  Data format
+  of Identify data is defined by the Interface GUID.
+
+  @param[in]     This               Pointer to the EFI_DISK_INFO_PROTOCOL 
+                                    instance.
+  @param[in,out] IdentifyData       Pointer to a buffer for the identify data.
+  @param[in,out] IdentifyDataSize   Pointer to the value for the identify data
+                                    size.
+
+  @retval EFI_SUCCESS            The command was accepted without any errors.
+  @retval EFI_NOT_FOUND          Device does not support this data class 
+  @retval EFI_DEVICE_ERROR       Error reading IdentifyData from device 
+  @retval EFI_BUFFER_TOO_SMALL   IdentifyDataSize not big enough 
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_INFO_IDENTIFY)(
+  IN     EFI_DISK_INFO_PROTOCOL  *This,
+  IN OUT VOID                    *IdentifyData,
+  IN OUT UINT32                  *IdentifyDataSize
+  );
+
+/**
+  Provides sense data information for the controller type.
+  
+  This function is used by the IDE bus driver to get sense data. 
+  Data format of Sense data is defined by the Interface GUID.
+
+  @param[in]     This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
+  @param[in,out] SenseData         Pointer to the SenseData.
+  @param[in,out] SenseDataSize     Size of SenseData in bytes.
+  @param[out]    SenseDataNumber   Pointer to the value for the sense data size.
+
+  @retval EFI_SUCCESS            The command was accepted without any errors.
+  @retval EFI_NOT_FOUND          Device does not support this data class.
+  @retval EFI_DEVICE_ERROR       Error reading SenseData from device.
+  @retval EFI_BUFFER_TOO_SMALL   SenseDataSize not big enough.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_INFO_SENSE_DATA)(
+  IN     EFI_DISK_INFO_PROTOCOL  *This,
+  IN OUT VOID                    *SenseData,
+  IN OUT UINT32                  *SenseDataSize,
+  OUT    UINT8                   *SenseDataNumber
+  );
+
+/**
+  This function is used by the IDE bus driver to get controller information.
+
+  @param[in]  This         Pointer to the EFI_DISK_INFO_PROTOCOL instance. 
+  @param[out] IdeChannel   Pointer to the Ide Channel number.  Primary or secondary.
+  @param[out] IdeDevice    Pointer to the Ide Device number.  Master or slave.
+
+  @retval EFI_SUCCESS       IdeChannel and IdeDevice are valid.
+  @retval EFI_UNSUPPORTED   This is not an IDE device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_INFO_WHICH_IDE)(
+  IN  EFI_DISK_INFO_PROTOCOL  *This,
+  OUT UINT32                  *IdeChannel,
+  OUT UINT32                  *IdeDevice
+  );
+
+///
+/// The EFI_DISK_INFO_PROTOCOL provides controller specific information.
+///
+struct _EFI_DISK_INFO_PROTOCOL {
+  ///
+  /// A GUID that defines the format of buffers for the other member functions 
+  /// of this protocol.
+  ///
+  EFI_GUID                  Interface;
+  ///
+  /// Return the results of the Inquiry command to a drive in InquiryData. Data
+  /// format of Inquiry data is defined by the Interface GUID.
+  ///
+  EFI_DISK_INFO_INQUIRY     Inquiry;
+  ///
+  /// Return the results of the Identify command to a drive in IdentifyData. Data
+  /// format of Identify data is defined by the Interface GUID.
+  ///
+  EFI_DISK_INFO_IDENTIFY    Identify;
+  ///
+  /// Return the results of the Request Sense command to a drive in SenseData. Data
+  /// format of Sense data is defined by the Interface GUID.
+  ///
+  EFI_DISK_INFO_SENSE_DATA  SenseData;
+  ///
+  /// Specific controller. 
+  ///
+  EFI_DISK_INFO_WHICH_IDE   WhichIde;
+};
+
+extern EFI_GUID gEfiDiskInfoProtocolGuid;
+
+extern EFI_GUID gEfiDiskInfoIdeInterfaceGuid;
+extern EFI_GUID gEfiDiskInfoScsiInterfaceGuid;
+extern EFI_GUID gEfiDiskInfoUsbInterfaceGuid;
+extern EFI_GUID gEfiDiskInfoAhciInterfaceGuid;
+extern EFI_GUID gEfiDiskInfoNvmeInterfaceGuid;
+extern EFI_GUID gEfiDiskInfoUfsInterfaceGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DiskIo.h b/MdePkg/Include/Protocol/DiskIo.h
new file mode 100644
index 000000000000..9f2526161c7c
--- /dev/null
+++ b/MdePkg/Include/Protocol/DiskIo.h
@@ -0,0 +1,117 @@
+/** @file
+  Disk IO protocol as defined in the UEFI 2.0 specification.
+
+  The Disk IO protocol is used to convert block oriented devices into byte
+  oriented devices. The Disk IO protocol is intended to layer on top of the
+  Block IO protocol.
+
+  Copyright (c) 2006 - 2008, 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 __DISK_IO_H__
+#define __DISK_IO_H__
+
+#define EFI_DISK_IO_PROTOCOL_GUID \
+  { \
+    0xce345171, 0xba0b, 0x11d2, {0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+///
+/// Protocol GUID name defined in EFI1.1.
+/// 
+#define DISK_IO_PROTOCOL  EFI_DISK_IO_PROTOCOL_GUID
+
+typedef struct _EFI_DISK_IO_PROTOCOL EFI_DISK_IO_PROTOCOL;
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_DISK_IO_PROTOCOL  EFI_DISK_IO;
+
+/**
+  Read BufferSize bytes from Offset into Buffer.
+
+  @param  This                  Protocol instance pointer.
+  @param  MediaId               Id of the media, changes every time the media is replaced.
+  @param  Offset                The starting byte offset to read from
+  @param  BufferSize            Size of Buffer
+  @param  Buffer                Buffer containing read data
+
+  @retval EFI_SUCCESS           The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
+  @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
+                                valid for the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_READ)(
+  IN EFI_DISK_IO_PROTOCOL         *This,
+  IN UINT32                       MediaId,
+  IN UINT64                       Offset,
+  IN UINTN                        BufferSize,
+  OUT VOID                        *Buffer
+  );
+
+/**
+  Writes a specified number of bytes to a device.
+
+  @param  This       Indicates a pointer to the calling context.
+  @param  MediaId    ID of the medium to be written.
+  @param  Offset     The starting byte offset on the logical block I/O device to write.
+  @param  BufferSize The size in bytes of Buffer. The number of bytes to write to the device.
+  @param  Buffer     A pointer to the buffer containing the data to be written.
+
+  @retval EFI_SUCCESS           The data was written correctly to the device.
+  @retval EFI_WRITE_PROTECTED   The device can not be written to.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
+  @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
+                                 valid for the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_WRITE)(
+  IN EFI_DISK_IO_PROTOCOL         *This,
+  IN UINT32                       MediaId,
+  IN UINT64                       Offset,
+  IN UINTN                        BufferSize,
+  IN VOID                         *Buffer
+  );
+
+#define EFI_DISK_IO_PROTOCOL_REVISION 0x00010000
+
+///
+/// Revision defined in EFI1.1
+/// 
+#define EFI_DISK_IO_INTERFACE_REVISION  EFI_DISK_IO_PROTOCOL_REVISION
+
+///
+/// This protocol is used to abstract Block I/O interfaces.
+///
+struct _EFI_DISK_IO_PROTOCOL {
+  ///
+  /// The revision to which the disk I/O interface adheres. All future
+  /// revisions must be backwards compatible. If a future version is not
+  /// backwards compatible, it is not the same GUID.
+  ///
+  UINT64          Revision;
+  EFI_DISK_READ   ReadDisk;
+  EFI_DISK_WRITE  WriteDisk;
+};
+
+extern EFI_GUID gEfiDiskIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DiskIo2.h b/MdePkg/Include/Protocol/DiskIo2.h
new file mode 100644
index 000000000000..c2994c2facd5
--- /dev/null
+++ b/MdePkg/Include/Protocol/DiskIo2.h
@@ -0,0 +1,172 @@
+/** @file
+  Disk I/O 2 protocol as defined in the UEFI 2.4 specification.
+
+  The Disk I/O 2 protocol defines an extension to the Disk I/O protocol to enable
+  non-blocking / asynchronous byte-oriented disk operation.
+
+  Copyright (c) 2013, 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 __DISK_IO2_H__
+#define __DISK_IO2_H__
+
+#define EFI_DISK_IO2_PROTOCOL_GUID \
+  { \
+    0x151c8eae, 0x7f2c, 0x472c, 0x9e, 0x54, 0x98, 0x28, 0x19, 0x4f, 0x6a, 0x88 \
+  }
+
+typedef struct _EFI_DISK_IO2_PROTOCOL EFI_DISK_IO2_PROTOCOL;
+
+/**
+  The struct of Disk IO2 Token.
+**/
+typedef struct {
+  //
+  // If Event is NULL, then blocking I/O is performed.
+  // If Event is not NULL and non-blocking I/O is supported, then non-blocking I/O is performed,
+  // and Event will be signaled when the I/O request is completed.
+  // The caller must be prepared to handle the case where the callback associated with Event occurs
+  // before the original asynchronous I/O request call returns.
+  //
+  EFI_EVENT  Event;
+
+  //
+  // Defines whether or not the signaled event encountered an error.
+  //
+  EFI_STATUS TransactionStatus;
+} EFI_DISK_IO2_TOKEN;
+
+/**
+  Terminate outstanding asynchronous requests to a device.
+
+  @param This                   Indicates a pointer to the calling context.
+
+  @retval EFI_SUCCESS           All outstanding requests were successfully terminated.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the cancel
+                                operation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_CANCEL_EX) (
+  IN EFI_DISK_IO2_PROTOCOL *This
+  );
+
+/**
+  Reads a specified number of bytes from a device.
+
+  @param This                   Indicates a pointer to the calling context.
+  @param MediaId                ID of the medium to be read.
+  @param Offset                 The starting byte offset on the logical block I/O device to read from.
+  @param Token                  A pointer to the token associated with the transaction.
+                                If this field is NULL, synchronous/blocking IO is performed.
+  @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
+  @param  Buffer                A pointer to the destination buffer for the data.
+                                The caller is responsible either having implicit or explicit ownership of the buffer.
+
+  @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was read correctly from the device.
+                                If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
+                                                                         Event will be signaled upon completion.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
+  @retval EFI_NO_MEDIA          There is no medium in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
+  @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not valid for the device.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_READ_EX) (
+  IN EFI_DISK_IO2_PROTOCOL        *This,
+  IN UINT32                       MediaId,
+  IN UINT64                       Offset,
+  IN OUT EFI_DISK_IO2_TOKEN       *Token,
+  IN UINTN                        BufferSize,
+  OUT VOID                        *Buffer
+  );
+
+/**
+  Writes a specified number of bytes to a device.
+
+  @param This        Indicates a pointer to the calling context.
+  @param MediaId     ID of the medium to be written.
+  @param Offset      The starting byte offset on the logical block I/O device to write to.
+  @param Token       A pointer to the token associated with the transaction.
+                     If this field is NULL, synchronous/blocking IO is performed.
+  @param BufferSize  The size in bytes of Buffer. The number of bytes to write to the device.
+  @param Buffer      A pointer to the buffer containing the data to be written.
+
+  @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was written correctly to the device.
+                                If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
+                                                                         Event will be signaled upon completion.
+  @retval EFI_WRITE_PROTECTED   The device cannot be written to.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
+  @retval EFI_NO_MEDIA          There is no medium in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
+  @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not valid for the device.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_WRITE_EX) (
+  IN EFI_DISK_IO2_PROTOCOL        *This,
+  IN UINT32                       MediaId,
+  IN UINT64                       Offset,
+  IN OUT EFI_DISK_IO2_TOKEN       *Token,
+  IN UINTN                        BufferSize,
+  IN VOID                         *Buffer
+  );
+
+/**
+  Flushes all modified data to the physical device.
+
+  @param This        Indicates a pointer to the calling context.
+  @param MediaId     ID of the medium to be written.
+  @param Token       A pointer to the token associated with the transaction.
+                     If this field is NULL, synchronous/blocking IO is performed.
+
+  @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was flushed successfully to the device.
+                                If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
+                                                                         Event will be signaled upon completion.
+  @retval EFI_WRITE_PROTECTED   The device cannot be written to.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
+  @retval EFI_NO_MEDIA          There is no medium in the device.
+  @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISK_FLUSH_EX) (
+  IN EFI_DISK_IO2_PROTOCOL        *This,
+  IN OUT EFI_DISK_IO2_TOKEN       *Token
+  );
+
+#define EFI_DISK_IO2_PROTOCOL_REVISION 0x00020000
+
+///
+/// This protocol is used to abstract Block I/O interfaces.
+///
+struct _EFI_DISK_IO2_PROTOCOL {
+  ///
+  /// The revision to which the disk I/O interface adheres. All future
+  /// revisions must be backwards compatible. If a future version is not
+  /// backwards compatible, it is not the same GUID.
+  ///
+  UINT64             Revision;
+  EFI_DISK_CANCEL_EX Cancel;
+  EFI_DISK_READ_EX   ReadDiskEx;
+  EFI_DISK_WRITE_EX  WriteDiskEx;
+  EFI_DISK_FLUSH_EX  FlushDiskEx;
+};
+
+extern EFI_GUID gEfiDiskIo2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Dns4.h b/MdePkg/Include/Protocol/Dns4.h
new file mode 100644
index 000000000000..61c8e5c38ad5
--- /dev/null
+++ b/MdePkg/Include/Protocol/Dns4.h
@@ -0,0 +1,543 @@
+/** @file
+  This file defines the EFI Domain Name Service Binding Protocol interface. It is split
+  into the following two main sections:
+  DNSv4 Service Binding Protocol (DNSv4SB)
+  DNSv4 Protocol (DNSv4)
+
+  Copyright (c) 2015 - 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_DNS4_PROTOCOL_H__
+#define __EFI_DNS4_PROTOCOL_H__
+
+#define EFI_DNS4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xb625b186, 0xe063, 0x44f7, {0x89, 0x5, 0x6a, 0x74, 0xdc, 0x6f, 0x52, 0xb4 } \
+  }
+
+#define EFI_DNS4_PROTOCOL_GUID \
+  { \
+    0xae3d28cc, 0xe05b, 0x4fa1, {0xa0, 0x11, 0x7e, 0xb5, 0x5a, 0x3f, 0x14, 0x1 } \
+  }
+
+typedef struct _EFI_DNS4_PROTOCOL EFI_DNS4_PROTOCOL;
+
+///
+/// EFI_DNS4_CONFIG_DATA
+///
+typedef struct {
+  ///
+  /// Count of the DNS servers. When used with GetModeData(), 
+  /// this field is the count of originally configured servers when 
+  /// Configure() was called for this instance. When used with 
+  /// Configure() this is the count of caller-supplied servers. If the 
+  /// DnsServerListCount is zero, the DNS server configuration 
+  /// will be retrieved from DHCP server automatically.
+  ///
+  UINTN                         DnsServerListCount;
+  ///
+  /// Pointer to DNS server list containing DnsServerListCount entries or NULL 
+  /// if DnsServerListCountis 0. For Configure(), this will be NULL when there are 
+  /// no caller supplied server addresses, and, the DNS instance will retrieve 
+  /// DNS server from DHCP Server. The provided DNS server list is 
+  /// recommended to be filled up in the sequence of preference. When 
+  /// used with GetModeData(), the buffer containing the list will 
+  /// be allocated by the driver implementing this protocol and must be 
+  /// freed by the caller. When used with Configure(), the buffer 
+  /// containing the list will be allocated and released by the caller.
+  ///
+  EFI_IPv4_ADDRESS              *DnsServerList;
+  ///
+  /// Set to TRUE to use the default IP address/subnet mask and default routing table.
+  ///
+  BOOLEAN                       UseDefaultSetting;
+  ///
+  /// If TRUE, enable DNS cache function for this DNS instance. If FALSE, all DNS
+  /// query will not lookup local DNS cache.
+  ///
+  BOOLEAN                       EnableDnsCache;
+  ///
+  /// Use the protocol number defined in "Links to UEFI-Related 
+  /// Documents"(http://uefi.org/uefi) under the heading "IANA 
+  /// Protocol Numbers". Only TCP or UDP are supported, and other 
+  /// protocol values are invalid. An implementation can choose to 
+  /// support only UDP, or both TCP and UDP.
+  ///
+  UINT8                         Protocol;
+  ///
+  /// If UseDefaultSetting is FALSE indicates the station address to use.
+  ///
+  EFI_IPv4_ADDRESS              StationIp;
+  ///
+  /// If UseDefaultSetting is FALSE indicates the subnet mask to use.
+  ///
+  EFI_IPv4_ADDRESS              SubnetMask;
+  ///
+  /// Local port number. Set to zero to use the automatically assigned port number.
+  ///
+  UINT16                        LocalPort;
+  ///
+  /// Retry number if no response received after RetryInterval.
+  ///
+  UINT32                        RetryCount;
+  ///
+  /// Minimum interval of retry is 2 second. If the retry interval is less than 2
+  /// seconds, then use the 2 seconds.
+  ///
+  UINT32                        RetryInterval;
+} EFI_DNS4_CONFIG_DATA;
+
+
+///
+/// EFI_DNS4_CACHE_ENTRY
+///
+typedef struct {
+  ///
+  /// Host name.
+  ///
+  CHAR16                        *HostName;
+  ///
+  /// IP address of this host.
+  ///
+  EFI_IPv4_ADDRESS              *IpAddress;
+  ///
+  /// Time in second unit that this entry will remain in DNS cache. A value of zero
+  /// means that this entry is permanent. A nonzero value will override the existing
+  /// one if this entry to be added is dynamic entry. Implementations may set its
+  /// default timeout value for the dynamically created DNS cache entry after one DNS
+  /// resolve succeeds.
+  ///
+  UINT32                        Timeout;
+} EFI_DNS4_CACHE_ENTRY;
+
+///
+/// EFI_DNS4_MODE_DATA
+///
+typedef struct {
+  ///
+  /// The configuration data of this instance.
+  ///
+  EFI_DNS4_CONFIG_DATA          DnsConfigData;
+  ///
+  /// Number of configured DNS server. Each DNS instance has its own DNS server
+  /// configuration.
+  ///
+  UINT32                        DnsServerCount;
+  ///
+  /// Pointer to common list of addresses of all configured DNS server 
+  /// used by EFI_DNS4_PROTOCOL instances. List will include 
+  /// DNS servers configured by this or any other EFI_DNS4_PROTOCOL instance. 
+  /// The storage for this list is allocated by the driver publishing this 
+  /// protocol, and must be freed by the caller.
+  ///
+  EFI_IPv4_ADDRESS              *DnsServerList;
+  ///
+  /// Number of DNS Cache entries. The DNS Cache is shared among all DNS instances.
+  ///
+  UINT32                        DnsCacheCount;
+  ///
+  /// Pointer to a buffer containing DnsCacheCount DNS Cache 
+  /// entry structures. The storage for this list is allocated by the driver 
+  /// publishing this protocol and must be freed by caller.
+  ///
+  EFI_DNS4_CACHE_ENTRY          *DnsCacheList;
+} EFI_DNS4_MODE_DATA;
+
+///
+/// DNS_HOST_TO_ADDR_DATA
+///
+typedef struct {
+  ///
+  /// Number of the returned IP addresses.
+  ///
+  UINT32                        IpCount;
+  ///
+  /// Pointer to the all the returned IP addresses.
+  ///
+  EFI_IPv4_ADDRESS              *IpList;
+} DNS_HOST_TO_ADDR_DATA;
+
+///
+/// DNS_ADDR_TO_HOST_DATA
+///
+typedef struct {
+  ///
+  /// Pointer to the primary name for this host address. It's the caller's
+  /// responsibility to free the response memory.
+  ///
+  CHAR16                        *HostName;
+} DNS_ADDR_TO_HOST_DATA;
+
+///
+/// DNS_RESOURCE_RECORD
+///
+typedef struct {
+  ///
+  /// The Owner name.
+  ///
+  CHAR8                         *QName;
+  ///
+  /// The Type Code of this RR.
+  ///
+  UINT16                        QType;
+  ///
+  /// The CLASS code of this RR.
+  ///
+  UINT16                        QClass;
+  ///
+  /// 32 bit integer which specify the time interval that the resource record may be
+  /// cached before the source of the information should again be consulted. Zero means
+  /// this RR can not be cached.
+  ///
+  UINT32                        TTL;
+  ///
+  /// 16 big integer which specify the length of RData.
+  ///
+  UINT16                        DataLength;
+  ///
+  /// A string of octets that describe the resource, the format of this information
+  /// varies according to QType and QClass difference.
+  ///
+  CHAR8                         *RData;
+} DNS_RESOURCE_RECORD;
+
+///
+/// DNS_GENERAL_LOOKUP_DATA
+///
+typedef struct {
+  ///
+  /// Number of returned matching RRs.
+  ///
+  UINTN                         RRCount;
+  ///
+  /// Pointer to the all the returned matching RRs. It's caller responsibility to free
+  /// the allocated memory to hold the returned RRs.
+  ///
+  DNS_RESOURCE_RECORD           *RRList;
+} DNS_GENERAL_LOOKUP_DATA;
+
+///
+/// EFI_DNS4_COMPLETION_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI DNS
+  /// protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                               Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:      The host name to address translation completed successfully.
+  ///   EFI_NOT_FOUND:    No matching Resource Record (RR) is found.
+  ///   EFI_TIMEOUT:      No DNS server reachable, or RetryCount was exhausted without
+  ///                     response from all specified DNS servers.
+  ///   EFI_DEVICE_ERROR: An unexpected system or network error occurred.
+  ///   EFI_NO_MEDIA:     There was a media error.
+  ///
+  EFI_STATUS                              Status;
+  ///
+  /// Retry number if no response received after RetryInterval. If zero, use the
+  /// parameter configured through Dns.Configure() interface.
+  ///
+  UINT32                                  RetryCount;
+  ///
+  /// Minimum interval of retry is 2 second. If the retry interval is less than 2
+  /// seconds, then use the 2 seconds. If zero, use the parameter configured through
+  /// Dns.Configure() interface.
+  UINT32                                  RetryInterval;
+  ///
+  /// DNSv4 completion token data
+  ///
+  union {
+    ///
+    /// When the Token is used for host name to address translation, H2AData is a pointer
+    /// to the DNS_HOST_TO_ADDR_DATA.
+    ///
+    DNS_HOST_TO_ADDR_DATA         *H2AData;
+    ///
+    /// When the Token is used for host address to host name translation, A2HData is a
+    /// pointer to the DNS_ADDR_TO_HOST_DATA.
+    ///
+    DNS_ADDR_TO_HOST_DATA         *A2HData;
+    ///
+    /// When the Token is used for a general lookup function, GLookupDATA is a pointer to
+    /// the DNS_GENERAL_LOOKUP_DATA.
+    ///
+    DNS_GENERAL_LOOKUP_DATA       *GLookupData;
+  } RspData;
+} EFI_DNS4_COMPLETION_TOKEN;
+
+/**
+  Retrieve mode data of this DNS instance.
+
+  This function is used to retrieve DNS mode data for this DNS instance.
+
+  @param[in]   This               Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[out]  DnsModeData        Point to the mode data.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_NOT_STARTED         When DnsConfigData is queried, no configuration data
+                                  is available because this instance has not been
+                                  configured.
+  @retval EFI_INVALID_PARAMETER   This is NULL or DnsModeData is NULL.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_GET_MODE_DATA) (
+  IN  EFI_DNS4_PROTOCOL          *This,
+  OUT EFI_DNS4_MODE_DATA         *DnsModeData
+  );
+
+/**
+  Configure this DNS instance.
+
+  This function is used to configure DNS mode data for this DNS instance.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  DnsConfigData       Point to the Configuration data.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_UNSUPPORTED         The designated protocol is not supported.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+                                  The StationIp address provided in DnsConfigData is not a 
+                                  valid unicast.
+                                  DnsServerList is NULL while DnsServerListCount
+                                  is not ZERO.
+                                  DnsServerListCount is ZERO while DnsServerList
+                                  is not NULL
+  @retval EFI_OUT_OF_RESOURCES    The DNS instance data or required space could not be
+                                  allocated.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred. The
+                                  EFI DNSv4 Protocol instance is not configured.
+  @retval EFI_ALREADY_STARTED     Second call to Configure() with DnsConfigData. To 
+                                  reconfigure the instance the caller must call Configure() 
+                                  with NULL first to return driver to unconfigured state.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_CONFIGURE) (
+  IN EFI_DNS4_PROTOCOL          *This,
+  IN EFI_DNS4_CONFIG_DATA       *DnsConfigData
+  );
+
+/**
+  Host name to host address translation.
+
+  The HostNameToIp () function is used to translate the host name to host IP address. A
+  type A query is used to get the one or more IP addresses for this host.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  HostName            Host name.
+  @param[in]  Token               Point to the completion token to translate host name
+                                  to host address.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  HostName is NULL. HostName string is unsupported format.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_NOT_STARTED         This instance has not been started.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_HOST_NAME_TO_IP) (
+   IN EFI_DNS4_PROTOCOL         *This,
+   IN CHAR16                    *HostName,
+   IN EFI_DNS4_COMPLETION_TOKEN *Token
+  );
+
+/**
+  IPv4 address to host name translation also known as Reverse DNS lookup.
+
+  The IpToHostName() function is used to translate the host address to host name. A type PTR 
+  query is used to get the primary name of the host. Support of this function is optional.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  IpAddress           Ip Address.
+  @param[in]  Token               Point to the completion token to translate host
+                                  address to host name.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_UNSUPPORTED         This function is not supported.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  IpAddress is not valid IP address .
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_ALREADY_STARTED     This Token is being used in another DNS session.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_IP_TO_HOST_NAME) (
+   IN EFI_DNS4_PROTOCOL         *This,
+   IN EFI_IPv4_ADDRESS          IpAddress,
+   IN EFI_DNS4_COMPLETION_TOKEN *Token
+  );
+
+/**
+  Retrieve arbitrary information from the DNS server. 
+
+  This GeneralLookup() function retrieves arbitrary information from the DNS. The caller
+  supplies a QNAME, QTYPE, and QCLASS, and all of the matching RRs are returned. All
+  RR content (e.g., TTL) was returned. The caller need parse the returned RR to get
+  required information. The function is optional.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  QName               Pointer to Query Name.
+  @param[in]  QType               Query Type.
+  @param[in]  QClass              Query Name.
+  @param[in]  Token               Point to the completion token to retrieve arbitrary
+                                  information.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_UNSUPPORTED         This function is not supported. Or the requested
+                                  QType is not supported
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  QName is NULL.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_ALREADY_STARTED     This Token is being used in another DNS session.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_GENERAL_LOOKUP) (
+  IN EFI_DNS4_PROTOCOL          *This,
+  IN CHAR8                      *QName,
+  IN UINT16                     QType,
+  IN UINT16                     QClass,
+  IN EFI_DNS4_COMPLETION_TOKEN  *Token
+  );
+
+/**
+  This function is to update the DNS Cache.
+
+  The UpdateDnsCache() function is used to add/delete/modify DNS cache entry. DNS cache
+  can be normally dynamically updated after the DNS resolve succeeds. This function
+  provided capability to manually add/delete/modify the DNS cache.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  DeleteFlag          If FALSE, this function is to add one entry to the
+                                  DNS Cahce. If TRUE, this function will delete
+                                  matching DNS Cache entry.
+  @param[in]  Override            If TRUE, the maching DNS cache entry will be
+                                  overwritten with the supplied parameter. If FALSE,
+                                  EFI_ACCESS_DENIED will be returned if the entry to
+                                  be added is already existed.
+  @param[in]  DnsCacheEntry       Pointer to DNS Cache entry.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  DnsCacheEntry.HostName is NULL.
+                                  DnsCacheEntry.IpAddress is NULL.
+                                  DnsCacheEntry.Timeout is zero.
+  @retval EFI_ACCESS_DENIED       The DNS cache entry already exists and Override is
+                                  not TRUE.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_UPDATE_DNS_CACHE) (
+  IN EFI_DNS4_PROTOCOL          *This,
+  IN BOOLEAN                    DeleteFlag,
+  IN BOOLEAN                    Override,
+  IN EFI_DNS4_CACHE_ENTRY       DnsCacheEntry
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  The Poll() function can be used by network drivers and applications to increase the
+  rate that data packets are moved between the communications device and the transmit
+  and receive queues.
+  In some systems, the periodic timer event in the managed network driver may not poll
+  the underlying communications device fast enough to transmit and/or receive all data
+  packets without missing incoming packets or dropping outgoing packets. Drivers and
+  applications that are experiencing packet loss should try calling the Poll()
+  function more often.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+
+  @retval EFI_SUCCESS             Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED         This EFI DNS Protocol instance has not been started.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+  @retval EFI_TIMEOUT             Data was dropped out of the transmit and/or receive
+                                  queue. Consider increasing the polling rate.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_POLL) (
+  IN  EFI_DNS4_PROTOCOL         *This
+  );
+
+/**
+  Abort an asynchronous DNS operation, including translation between IP and Host, and
+  general look up behavior.
+
+  The Cancel() function is used to abort a pending resolution request. After calling
+  this function, Token.Status will be set to EFI_ABORTED and then Token.Event will be
+  signaled. If the token is not in one of the queues, which usually means that the
+  asynchronous operation has completed, this function will not signal the token and
+  EFI_NOT_FOUND is returned.
+
+  @param[in]  This                Pointer to EFI_DNS4_PROTOCOL instance.
+  @param[in]  Token               Pointer to a token that has been issued by
+                                  EFI_DNS4_PROTOCOL.HostNameToIp (),
+                                  EFI_DNS4_PROTOCOL.IpToHostName() or
+                                  EFI_DNS4_PROTOCOL.GeneralLookup().
+                                  If NULL, all pending tokens are aborted.
+
+  @retval EFI_SUCCESS             Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED         This EFI DNS4 Protocol instance has not been started.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_NOT_FOUND           When Token is not NULL, and the asynchronous DNS
+                                  operation was not found in the transmit queue. It
+                                  was either completed or was not issued by
+                                  HostNameToIp(), IpToHostName() or GeneralLookup().
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS4_CANCEL) (
+  IN  EFI_DNS4_PROTOCOL         *This,
+  IN  EFI_DNS4_COMPLETION_TOKEN *Token
+  );
+
+///
+/// The EFI_DNS4_Protocol provides the function to get the host name and address
+/// mapping, also provides pass through interface to retrieve arbitrary information
+/// from DNS.
+///
+struct _EFI_DNS4_PROTOCOL {
+  EFI_DNS4_GET_MODE_DATA        GetModeData;
+  EFI_DNS4_CONFIGURE            Configure;
+  EFI_DNS4_HOST_NAME_TO_IP      HostNameToIp;
+  EFI_DNS4_IP_TO_HOST_NAME      IpToHostName;
+  EFI_DNS4_GENERAL_LOOKUP       GeneralLookUp;
+  EFI_DNS4_UPDATE_DNS_CACHE     UpdateDnsCache;
+  EFI_DNS4_POLL                 Poll;
+  EFI_DNS4_CANCEL               Cancel;
+};
+
+extern EFI_GUID gEfiDns4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiDns4ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Dns6.h b/MdePkg/Include/Protocol/Dns6.h
new file mode 100644
index 000000000000..bf8814606e4d
--- /dev/null
+++ b/MdePkg/Include/Protocol/Dns6.h
@@ -0,0 +1,539 @@
+/** @file
+  This file defines the EFI DNSv6 (Domain Name Service version 6) Protocol. It is split
+  into the following two main sections:
+  DNSv6 Service Binding Protocol (DNSv6SB)
+  DNSv6 Protocol (DNSv6)
+
+  Copyright (c) 2015 - 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_DNS6_PROTOCOL_H__
+#define __EFI_DNS6_PROTOCOL_H__
+
+#define EFI_DNS6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x7f1647c8, 0xb76e, 0x44b2, {0xa5, 0x65, 0xf7, 0xf, 0xf1, 0x9c, 0xd1, 0x9e } \
+  }
+
+#define EFI_DNS6_PROTOCOL_GUID \
+  { \
+    0xca37bc1f, 0xa327, 0x4ae9, {0x82, 0x8a, 0x8c, 0x40, 0xd8, 0x50, 0x6a, 0x17 } \
+  }
+
+typedef struct _EFI_DNS6_PROTOCOL EFI_DNS6_PROTOCOL;
+
+///
+/// EFI_DNS6_CONFIG_DATA
+///
+typedef struct {
+  ///
+  /// If TRUE, enable DNS cache function for this DNS instance. If FALSE, all DNS query
+  /// will not lookup local DNS cache.
+  ///
+  BOOLEAN                       EnableDnsCache;
+  ///
+  /// Use the protocol number defined in
+  /// http://www.iana.org/assignments/protocol-numbers. Beside TCP/UDP, Other protocol
+  /// is invalid value. An implementation can choose to support UDP, or both TCP and UDP.
+  ///
+  UINT8                         Protocol;
+  ///
+  /// The local IP address to use. Set to zero to let the underlying IPv6 
+  /// driver choose a source address. If not zero it must be one of the 
+  /// configured IP addresses in the underlying IPv6 driver.
+  ///
+  EFI_IPv6_ADDRESS              StationIp;
+  ///
+  /// Local port number. Set to zero to use the automatically assigned port number.
+  ///
+  UINT16                        LocalPort;
+  ///
+  /// Count of the DNS servers. When used with GetModeData(), 
+  /// this field is the count of originally configured servers when 
+  /// Configure() was called for this instance. When used with 
+  /// Configure() this is the count of caller-supplied servers. If the 
+  /// DnsServerListCount is zero, the DNS server configuration 
+  /// will be retrieved from DHCP server automatically.
+  ///
+  UINT32                        DnsServerCount;
+  ///
+  /// Pointer to DNS server list containing DnsServerListCount
+  /// entries or NULL if DnsServerListCount is 0. For Configure(), 
+  /// this will be NULL when there are no caller supplied server addresses 
+  /// and the DNS instance will retrieve DNS server from DHCP Server. 
+  /// The provided DNS server list is recommended to be filled up in the sequence 
+  /// of preference. When used with GetModeData(), the buffer containing the list 
+  /// will be allocated by the driver implementing this protocol and must be 
+  /// freed by the caller. When used with Configure(), the buffer 
+  /// containing the list will be allocated and released by the caller.
+  ///
+  EFI_IPv6_ADDRESS              *DnsServerList;
+  ///
+  /// Retry number if no response received after RetryInterval.
+  ///
+  UINT32                        RetryCount;
+  ///
+  /// Minimum interval of retry is 2 second. If the retry interval is less than 2
+  /// seconds, then use the 2 seconds.
+  UINT32                        RetryInterval;
+} EFI_DNS6_CONFIG_DATA;
+
+///
+/// EFI_DNS6_CACHE_ENTRY
+///
+typedef struct {
+  ///
+  /// Host name. This should be interpreted as Unicode characters.
+  ///
+  CHAR16                        *HostName;
+  ///
+  /// IP address of this host.
+  ///
+  EFI_IPv6_ADDRESS              *IpAddress;
+  ///
+  /// Time in second unit that this entry will remain in DNS cache. A value of zero means
+  /// that this entry is permanent. A nonzero value will override the existing one if
+  /// this entry to be added is dynamic entry. Implementations may set its default
+  /// timeout value for the dynamically created DNS cache entry after one DNS resolve
+  /// succeeds.
+  UINT32                        Timeout;
+} EFI_DNS6_CACHE_ENTRY;
+
+///
+/// EFI_DNS6_MODE_DATA
+///
+typedef struct {
+  ///
+  /// The configuration data of this instance.
+  ///
+  EFI_DNS6_CONFIG_DATA          DnsConfigData;
+  ///
+  /// Number of configured DNS6 servers.
+  ///
+  UINT32               	        DnsServerCount;
+  ///
+  /// Pointer to common list of addresses of all configured DNS server used by EFI_DNS6_PROTOCOL 
+  /// instances. List will include DNS servers configured by this or any other EFI_DNS6_PROTOCOL 
+  /// instance. The storage for this list is allocated by the driver publishing this protocol, 
+  /// and must be freed by the caller.
+  ///
+  EFI_IPv6_ADDRESS     	        *DnsServerList;
+  ///
+  /// Number of DNS Cache entries. The DNS Cache is shared among all DNS instances.
+  ///
+  UINT32                        DnsCacheCount;
+  ///
+  /// Pointer to a buffer containing DnsCacheCount DNS Cache 
+  /// entry structures. The storage for thislist is allocated by the driver 
+  /// publishing this protocol and must be freed by caller.
+  ///
+  EFI_DNS6_CACHE_ENTRY          *DnsCacheList;
+} EFI_DNS6_MODE_DATA;
+
+///
+/// DNS6_HOST_TO_ADDR_DATA
+///
+typedef struct {
+  ///
+  /// Number of the returned IP address.
+  ///
+  UINT32                        IpCount;
+  ///
+  /// Pointer to the all the returned IP address.
+  ///
+  EFI_IPv6_ADDRESS              *IpList;
+} DNS6_HOST_TO_ADDR_DATA;
+
+///
+/// DNS6_ADDR_TO_HOST_DATA
+///
+typedef struct {
+  ///
+  /// Pointer to the primary name for this host address. It's the caller's
+  /// responsibility to free the response memory.
+  ///
+  CHAR16                        *HostName;
+} DNS6_ADDR_TO_HOST_DATA;
+
+///
+/// DNS6_RESOURCE_RECORD
+///
+typedef struct {
+  ///
+  /// The Owner name.
+  ///
+  CHAR8                         *QName;
+  ///
+  /// The Type Code of this RR.
+  ///
+  UINT16                        QType;
+  ///
+  /// The CLASS code of this RR.
+  ///
+  UINT16                        QClass;
+  ///
+  /// 32 bit integer which specify the time interval that the resource record may be
+  /// cached before the source of the information should again be consulted. Zero means
+  /// this RR cannot be cached.
+  ///
+  UINT32                        TTL;
+  ///
+  /// 16 big integer which specify the length of RData.
+  ///
+  UINT16                        DataLength;
+  ///
+  /// A string of octets that describe the resource, the format of this information
+  /// varies according to QType and QClass difference.
+  ///
+  CHAR8                         *RData;
+} DNS6_RESOURCE_RECORD;
+
+///
+/// DNS6_GENERAL_LOOKUP_DATA
+///
+typedef struct {
+  ///
+  /// Number of returned matching RRs.
+  ///
+  UINTN                         RRCount;
+  ///
+  /// Pointer to the all the returned matching RRs. It's caller responsibility to free
+  /// the allocated memory to hold the returned RRs.
+  ///
+  DNS6_RESOURCE_RECORD          *RRList;
+} DNS6_GENERAL_LOOKUP_DATA;
+
+///
+/// EFI_DNS6_COMPLETION_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI DNSv6
+  /// protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                               Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:      The host name to address translation completed successfully.
+  ///   EFI_NOT_FOUND:    No matching Resource Record (RR) is found.
+  ///   EFI_TIMEOUT:      No DNS server reachable, or RetryCount was exhausted without
+  ///                     response from all specified DNS servers.
+  ///   EFI_DEVICE_ERROR: An unexpected system or network error occurred.
+  ///   EFI_NO_MEDIA:     There was a media error.
+  ///
+  EFI_STATUS                              Status;
+  ///
+  /// The parameter configured through DNSv6.Configure() interface. Retry number if no
+  /// response received after RetryInterval.
+  ///
+  UINT32                                  RetryCount;
+  ///
+  /// The parameter configured through DNSv6.Configure() interface. Minimum interval of
+  /// retry is 2 seconds. If the retry interval is less than 2 seconds, then use the 2
+  /// seconds.
+  ///
+  UINT32                                  RetryInterval;
+  ///
+  /// DNSv6 completion token data
+  ///
+  union {
+    ///
+    /// When the Token is used for host name to address translation, H2AData is a pointer
+    /// to the DNS6_HOST_TO_ADDR_DATA.
+    ///
+    DNS6_HOST_TO_ADDR_DATA      *H2AData;
+    ///
+    /// When the Token is used for host address to host name translation, A2HData is a
+    /// pointer to the DNS6_ADDR_TO_HOST_DATA.
+    ///
+    DNS6_ADDR_TO_HOST_DATA      *A2HData;
+    ///
+    /// When the Token is used for a general lookup function, GLookupDATA is a pointer to
+    /// the DNS6_GENERAL_LOOKUP_DATA.
+    ///
+    DNS6_GENERAL_LOOKUP_DATA    *GLookupData;
+  } RspData;
+} EFI_DNS6_COMPLETION_TOKEN;
+
+/**
+  Retrieve mode data of this DNS instance.
+
+  This function is used to retrieve DNS mode data for this DNS instance.
+
+  @param[in]   This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[out]  DnsModeData         Pointer to the caller-allocated storage for the 
+                                   EFI_DNS6_MODE_DATA data.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_NOT_STARTED         When DnsConfigData is queried, no configuration data
+                                  is available because this instance has not been
+                                  configured.
+  @retval EFI_INVALID_PARAMETER   This is NULL or DnsModeData is NULL.
+  @retval EFI_OUT_OF_RESOURCE     Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_DNS6_GET_MODE_DATA)(
+  IN  EFI_DNS6_PROTOCOL         *This,
+  OUT EFI_DNS6_MODE_DATA        *DnsModeData
+  );
+
+/**
+  Configure this DNS instance.
+
+  The Configure() function is used to set and change the configuration data for this
+  EFI DNSv6 Protocol driver instance. Reset the DNS instance if DnsConfigData is NULL.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  DnsConfigData       Pointer to the configuration data structure. All associated 
+                                  storage to be allocated and released by caller.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+                                  The StationIp address provided in DnsConfigData is not zero and not a valid unicast.
+                                  DnsServerList is NULL while DnsServerList Count is not ZERO.
+                                  DnsServerList Count is ZERO while DnsServerList is not NULL.
+  @retval EFI_OUT_OF_RESOURCES    The DNS instance data or required space could not be allocated.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred. The
+                                  EFI DNSv6 Protocol instance is not configured.
+  @retval EFI_UNSUPPORTED         The designated protocol is not supported.
+  @retval EFI_ALREADY_STARTED     Second call to Configure() with DnsConfigData. To 
+                                  reconfigure the instance the caller must call Configure() with 
+                                  NULL first to return driver to unconfigured state.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_DNS6_CONFIGURE)(
+  IN EFI_DNS6_PROTOCOL          *This,
+  IN EFI_DNS6_CONFIG_DATA       *DnsConfigData
+  );
+
+/**
+  Host name to host address translation.
+
+  The HostNameToIp () function is used to translate the host name to host IP address. A
+  type AAAA query is used to get the one or more IPv6 addresses for this host.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  HostName            Host name.
+  @param[in]  Token               Point to the completion token to translate host name
+                                  to host address.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  HostName is NULL or buffer contained unsupported characters.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_ALREADY_STARTED     This Token is being used in another DNS session.
+  @retval EFI_NOT_STARTED         This instance has not been started.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_HOST_NAME_TO_IP) (
+  IN  EFI_DNS6_PROTOCOL         *This,
+  IN  CHAR16                    *HostName,
+  IN  EFI_DNS6_COMPLETION_TOKEN *Token
+  );
+
+/**
+  Host address to host name translation.
+
+  The IpToHostName () function is used to translate the host address to host name. A
+  type PTR query is used to get the primary name of the host. Implementation can choose
+  to support this function or not.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  IpAddress           Ip Address.
+  @param[in]  Token               Point to the completion token to translate host
+                                  address to host name.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_UNSUPPORTED         This function is not supported.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  IpAddress is not valid IP address.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_NOT_STARTED         This instance has not been started.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_IP_TO_HOST_NAME) (
+  IN  EFI_DNS6_PROTOCOL         *This,
+  IN  EFI_IPv6_ADDRESS          IpAddress,
+  IN  EFI_DNS6_COMPLETION_TOKEN *Token
+  );
+
+/**
+  This function provides capability to retrieve arbitrary information from the DNS
+  server.
+
+  This GeneralLookup() function retrieves arbitrary information from the DNS. The caller
+  supplies a QNAME, QTYPE, and QCLASS, and all of the matching RRs are returned. All
+  RR content (e.g., TTL) was returned. The caller need parse the returned RR to get
+  required information. The function is optional. Implementation can choose to support
+  it or not.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  QName               Pointer to Query Name.
+  @param[in]  QType               Query Type.
+  @param[in]  QClass              Query Name.
+  @param[in]  Token               Point to the completion token to retrieve arbitrary
+                                  information.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_UNSUPPORTED         This function is not supported. Or the requested
+                                  QType is not supported
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token.Event is NULL.
+                                  QName is NULL.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_NOT_STARTED         This instance has not been started.
+  @retval EFI_OUT_OF_RESOURCES    Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_GENERAL_LOOKUP) (
+  IN  EFI_DNS6_PROTOCOL         *This,
+  IN  CHAR8                     *QName,
+  IN  UINT16                    QType,
+  IN  UINT16                    QClass,
+  IN  EFI_DNS6_COMPLETION_TOKEN *Token
+  );
+
+/**
+  This function is to update the DNS Cache.
+
+  The UpdateDnsCache() function is used to add/delete/modify DNS cache entry. DNS cache
+  can be normally dynamically updated after the DNS resolve succeeds. This function
+  provided capability to manually add/delete/modify the DNS cache.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  DeleteFlag          If FALSE, this function is to add one entry to the
+                                  DNS Cahce. If TRUE, this function will delete
+                                  matching DNS Cache entry.
+  @param[in]  Override            If TRUE, the maching DNS cache entry will be
+                                  overwritten with the supplied parameter. If FALSE,
+                                  EFI_ACCESS_DENIED will be returned if the entry to
+                                  be added is already existed.
+  @param[in]  DnsCacheEntry       Pointer to DNS Cache entry.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  DnsCacheEntry.HostName is NULL.
+                                  DnsCacheEntry.IpAddress is NULL.
+                                  DnsCacheEntry.Timeout is zero.
+  @retval EFI_ACCESS_DENIED       The DNS cache entry already exists and Override is
+                                  not TRUE.
+  @retval EFI_OUT_OF_RESOURCE     Failed to allocate needed resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_UPDATE_DNS_CACHE) (
+  IN EFI_DNS6_PROTOCOL          *This,
+  IN BOOLEAN                    DeleteFlag,
+  IN BOOLEAN                    Override,
+  IN EFI_DNS6_CACHE_ENTRY       DnsCacheEntry
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  The Poll() function can be used by network drivers and applications to increase the
+  rate that data packets are moved between the communications device and the transmit
+  and receive queues.
+
+  In some systems, the periodic timer event in the managed network driver may not poll
+  the underlying communications device fast enough to transmit and/or receive all data
+  packets without missing incoming packets or dropping outgoing packets. Drivers and
+  applications that are experiencing packet loss should try calling the Poll()
+  function more often.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+
+  @retval EFI_SUCCESS             Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED         This EFI DNS Protocol instance has not been started.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_NO_MAPPING          There is no source address is available for use.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+  @retval EFI_TIMEOUT             Data was dropped out of the transmit and/or receive
+                                  queue. Consider increasing the polling rate.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_POLL) (
+  IN  EFI_DNS6_PROTOCOL         *This
+  );
+
+/**
+  Abort an asynchronous DNS operation, including translation between IP and Host, and
+  general look up behavior.
+
+  The Cancel() function is used to abort a pending resolution request. After calling
+  this function, Token.Status will be set to EFI_ABORTED and then Token.Event will be
+  signaled. If the token is not in one of the queues, which usually means that the
+  asynchronous operation has completed, this function will not signal the token and
+  EFI_NOT_FOUND is returned.
+
+  @param[in]  This                Pointer to EFI_DNS6_PROTOCOL instance.
+  @param[in]  Token               Pointer to a token that has been issued by
+                                  EFI_DNS6_PROTOCOL.HostNameToIp (),
+                                  EFI_DNS6_PROTOCOL.IpToHostName() or
+                                  EFI_DNS6_PROTOCOL.GeneralLookup().
+                                  If NULL, all pending tokens are aborted.
+
+  @retval EFI_SUCCESS             Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED         This EFI DNS6 Protocol instance has not been started.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_NO_MAPPING          There's no source address is available for use.
+  @retval EFI_NOT_FOUND           When Token is not NULL, and the asynchronous DNS
+                                  operation was not found in the transmit queue. It
+                                  was either completed or was not issued by
+                                  HostNameToIp(), IpToHostName() or GeneralLookup().
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DNS6_CANCEL) (
+  IN  EFI_DNS6_PROTOCOL         *This,
+  IN  EFI_DNS6_COMPLETION_TOKEN *Token
+  );
+
+///
+/// The EFI_DNS6_PROTOCOL provides the function to get the host name and address
+/// mapping, also provide pass through interface to retrieve arbitrary information from
+/// DNSv6.
+///
+struct _EFI_DNS6_PROTOCOL {
+  EFI_DNS6_GET_MODE_DATA        GetModeData;
+  EFI_DNS6_CONFIGURE            Configure;
+  EFI_DNS6_HOST_NAME_TO_IP      HostNameToIp;
+  EFI_DNS6_IP_TO_HOST_NAME      IpToHostName;
+  EFI_DNS6_GENERAL_LOOKUP       GeneralLookUp;
+  EFI_DNS6_UPDATE_DNS_CACHE     UpdateDnsCache;
+  EFI_DNS6_POLL                 Poll;
+  EFI_DNS6_CANCEL               Cancel;
+};
+
+extern EFI_GUID gEfiDns6ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiDns6ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverBinding.h b/MdePkg/Include/Protocol/DriverBinding.h
new file mode 100644
index 000000000000..b325c0ccf7a3
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverBinding.h
@@ -0,0 +1,201 @@
+/** @file
+  UEFI DriverBinding Protocol is defined in UEFI specification.
+  
+  This protocol is produced by every driver that follows the UEFI Driver Model, 
+  and it is the central component that allows drivers and controllers to be managed.
+
+Copyright (c) 2006 - 2010, 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_DRIVER_BINDING_H__
+#define __EFI_DRIVER_BINDING_H__
+
+///
+/// The global ID for the ControllerHandle Driver Protocol.
+///
+#define EFI_DRIVER_BINDING_PROTOCOL_GUID \
+  { \
+    0x18a031ab, 0xb443, 0x4d1a, {0xa5, 0xc0, 0xc, 0x9, 0x26, 0x1e, 0x9f, 0x71 } \
+  }
+
+typedef struct _EFI_DRIVER_BINDING_PROTOCOL  EFI_DRIVER_BINDING_PROTOCOL;
+
+/**
+  Tests to see if this driver supports a given controller. If a child device is provided, 
+  it further tests to see if this driver supports creating a handle for the specified child device.
+
+  This function checks to see if the driver specified by This supports the device specified by 
+  ControllerHandle. Drivers will typically use the device path attached to 
+  ControllerHandle and/or the services from the bus I/O abstraction attached to 
+  ControllerHandle to determine if the driver supports ControllerHandle. This function 
+  may be called many times during platform initialization. In order to reduce boot times, the tests 
+  performed by this function must be very small, and take as little time as possible to execute. This 
+  function must not change the state of any hardware devices, and this function must be aware that the 
+  device specified by ControllerHandle may already be managed by the same driver or a 
+  different driver. This function must match its calls to AllocatePages() with FreePages(), 
+  AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().  
+  Because ControllerHandle may have been previously started by the same driver, if a protocol is 
+  already in the opened state, then it must not be closed with CloseProtocol(). This is required 
+  to guarantee the state of ControllerHandle is not modified by this function.
+
+  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
+  @param[in]  ControllerHandle     The handle of the controller to test. This handle 
+                                   must support a protocol interface that supplies 
+                                   an I/O abstraction to the driver.
+  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This 
+                                   parameter is ignored by device drivers, and is optional for bus 
+                                   drivers. For bus drivers, if this parameter is not NULL, then 
+                                   the bus driver must determine if the bus controller specified 
+                                   by ControllerHandle and the child controller specified 
+                                   by RemainingDevicePath are both supported by this 
+                                   bus driver.
+
+  @retval EFI_SUCCESS              The device specified by ControllerHandle and
+                                   RemainingDevicePath is supported by the driver specified by This.
+  @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
+                                   RemainingDevicePath is already being managed by the driver
+                                   specified by This.
+  @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
+                                   RemainingDevicePath is already being managed by a different
+                                   driver or an application that requires exclusive access.
+                                   Currently not implemented.
+  @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
+                                   RemainingDevicePath is not supported by the driver specified by This.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_BINDING_SUPPORTED)(
+  IN EFI_DRIVER_BINDING_PROTOCOL            *This,
+  IN EFI_HANDLE                             ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath OPTIONAL
+  );
+
+/**
+  Starts a device controller or a bus controller.
+
+  The Start() function is designed to be invoked from the EFI boot service ConnectController().
+  As a result, much of the error checking on the parameters to Start() has been moved into this 
+  common boot service. It is legal to call Start() from other locations, 
+  but the following calling restrictions must be followed, or the system behavior will not be deterministic.
+  1. ControllerHandle must be a valid EFI_HANDLE.
+  2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
+     EFI_DEVICE_PATH_PROTOCOL.
+  3. Prior to calling Start(), the Supported() function for the driver specified by This must
+     have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.  
+
+  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
+  @param[in]  ControllerHandle     The handle of the controller to start. This handle 
+                                   must support a protocol interface that supplies 
+                                   an I/O abstraction to the driver.
+  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This 
+                                   parameter is ignored by device drivers, and is optional for bus 
+                                   drivers. For a bus driver, if this parameter is NULL, then handles 
+                                   for all the children of Controller are created by this driver.  
+                                   If this parameter is not NULL and the first Device Path Node is 
+                                   not the End of Device Path Node, then only the handle for the 
+                                   child device specified by the first Device Path Node of 
+                                   RemainingDevicePath is created by this driver.
+                                   If the first Device Path Node of RemainingDevicePath is 
+                                   the End of Device Path Node, no child handle is created by this
+                                   driver.
+
+  @retval EFI_SUCCESS              The device was started.
+  @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
+  @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
+  @retval Others                   The driver failded to start the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_BINDING_START)(
+  IN EFI_DRIVER_BINDING_PROTOCOL            *This,
+  IN EFI_HANDLE                             ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath OPTIONAL
+  );
+
+/**
+  Stops a device controller or a bus controller.
+  
+  The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). 
+  As a result, much of the error checking on the parameters to Stop() has been moved 
+  into this common boot service. It is legal to call Stop() from other locations, 
+  but the following calling restrictions must be followed, or the system behavior will not be deterministic.
+  1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
+     same driver's Start() function.
+  2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
+     EFI_HANDLE. In addition, all of these handles must have been created in this driver's
+     Start() function, and the Start() function must have called OpenProtocol() on
+     ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
+  
+  @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
+  @param[in]  ControllerHandle  A handle to the device being stopped. The handle must 
+                                support a bus specific I/O protocol for the driver 
+                                to use to stop the device.
+  @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
+  @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL 
+                                if NumberOfChildren is 0.
+
+  @retval EFI_SUCCESS           The device was stopped.
+  @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_BINDING_STOP)(
+  IN EFI_DRIVER_BINDING_PROTOCOL            *This,
+  IN  EFI_HANDLE                            ControllerHandle,
+  IN  UINTN                                 NumberOfChildren,
+  IN  EFI_HANDLE                            *ChildHandleBuffer OPTIONAL
+  );
+
+///
+/// This protocol provides the services required to determine if a driver supports a given controller. 
+/// If a controller is supported, then it also provides routines to start and stop the controller.
+///
+struct _EFI_DRIVER_BINDING_PROTOCOL {
+  EFI_DRIVER_BINDING_SUPPORTED  Supported;
+  EFI_DRIVER_BINDING_START      Start;
+  EFI_DRIVER_BINDING_STOP       Stop;
+  
+  ///
+  /// The version number of the UEFI driver that produced the
+  /// EFI_DRIVER_BINDING_PROTOCOL. This field is used by
+  /// the EFI boot service ConnectController() to determine
+  /// the order that driver's Supported() service will be used when
+  /// a controller needs to be started. EFI Driver Binding Protocol
+  /// instances with higher Version values will be used before ones
+  /// with lower Version values. The Version values of 0x0-
+  /// 0x0f and 0xfffffff0-0xffffffff are reserved for
+  /// platform/OEM specific drivers. The Version values of 0x10-
+  /// 0xffffffef are reserved for IHV-developed drivers.
+  ///
+  UINT32                        Version;
+  
+  ///
+  /// The image handle of the UEFI driver that produced this instance
+  /// of the EFI_DRIVER_BINDING_PROTOCOL.
+  ///
+  EFI_HANDLE                    ImageHandle;
+  
+  ///
+  /// The handle on which this instance of the
+  /// EFI_DRIVER_BINDING_PROTOCOL is installed. In most
+  /// cases, this is the same handle as ImageHandle. However, for
+  /// UEFI drivers that produce more than one instance of the
+  /// EFI_DRIVER_BINDING_PROTOCOL, this value may not be
+  /// the same as ImageHandle.  
+  ///
+  EFI_HANDLE                    DriverBindingHandle;
+};
+
+extern EFI_GUID gEfiDriverBindingProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverConfiguration.h b/MdePkg/Include/Protocol/DriverConfiguration.h
new file mode 100644
index 000000000000..53c5296720b1
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverConfiguration.h
@@ -0,0 +1,167 @@
+/** @file
+  EFI Driver Configuration Protocol
+
+  Copyright (c) 2006 - 2008, 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 __EFI_DRIVER_CONFIGURATION_H__
+#define __EFI_DRIVER_CONFIGURATION_H__
+
+#include <Protocol/DriverConfiguration2.h>
+
+///
+/// Global ID for the Driver Configuration Protocol defined in EFI 1.1
+///
+#define EFI_DRIVER_CONFIGURATION_PROTOCOL_GUID \
+  { \
+    0x107a772b, 0xd5e1, 0x11d4, {0x9a, 0x46, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+ 
+typedef struct _EFI_DRIVER_CONFIGURATION_PROTOCOL  EFI_DRIVER_CONFIGURATION_PROTOCOL;
+
+/**
+  Allows the user to set controller specific options for a controller that a 
+  driver is currently managing.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to set options on.
+  @param  ChildHandle      The handle of the child controller to set options on.  This
+                           is an optional parameter that may be NULL.  It will be NULL
+                           for device drivers, and for bus drivers that wish to set
+                           options for the bus controller.  It will not be NULL for a
+                           bus driver that wishes to set options for one of its child
+                           controllers.
+  @param  Language         A pointer to a three character ISO 639-2 language identifier.
+                           This is the language of the user interface that should be
+                           presented to the user, and it must match one of the languages
+                           specified in SupportedLanguages.  The number of languages
+                           supported by a driver is up to the driver writer.
+  @param  ActionRequired   A pointer to the action that the calling agent is required
+                           to perform when this function returns.  See "Related
+                           Definitions" for a list of the actions that the calling
+                           agent is required to perform prior to accessing
+                           ControllerHandle again.
+
+  @retval EFI_SUCCESS           The driver specified by This successfully set the
+                                configuration options for the controller specified
+                                by ControllerHandle..
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ActionRequired is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support setting
+                                configuration options for the controller specified by
+                                ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempt to set the
+                                configuration options for the controller specified
+                                by ControllerHandle and ChildHandle.
+  @retval EFI_OUT_RESOURCES     There are not enough resources available to set the
+                                configuration options for the controller specified
+                                by ControllerHandle and ChildHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION_SET_OPTIONS)(
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL                        *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL,
+  IN  CHAR8                                                   *Language,
+  OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED                *ActionRequired
+  );
+
+/**
+  Tests to see if a controller's current configuration options are valid.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to test if it's current
+                           configuration options are valid.
+  @param  ChildHandle      The handle of the child controller to test if it's current
+                           configuration options are valid.  This is an optional
+                           parameter that may be NULL.  It will be NULL for device
+                           drivers.  It will also be NULL for bus drivers that wish
+                           to test the configuration options for the bus controller.
+                           It will not be NULL for a bus driver that wishes to test
+                           configuration options for one of its child controllers.
+
+  @retval EFI_SUCCESS           The controller specified by ControllerHandle and
+                                ChildHandle that is being managed by the driver
+                                specified by This has a valid set of  configuration
+                                options.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by ControllerHandle
+                                and ChildHandle.
+  @retval EFI_DEVICE_ERROR      The controller specified by ControllerHandle and
+                                ChildHandle that is being managed by the driver
+                                specified by This has an invalid set of configuration
+                                options.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION_OPTIONS_VALID)(
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL                        *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL
+  );
+
+/**
+  Forces a driver to set the default configuration options for a controller.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to force default configuration options on.
+  @param  ChildHandle      The handle of the child controller to force default configuration options on  This is an optional parameter that may be NULL.  It will be NULL for device drivers.  It will also be NULL for bus drivers that wish to force default configuration options for the bus controller.  It will not be NULL for a bus driver that wishes to force default configuration options for one of its child controllers.
+  @param  DefaultType      The type of default configuration options to force on the controller specified by ControllerHandle and ChildHandle.  See Table 9-1 for legal values.  A DefaultType of 0x00000000 must be supported by this protocol.
+  @param  ActionRequired   A pointer to the action that the calling agent is required to perform when this function returns.  See "Related Definitions" in Section 9.1 for a list of the actions that the calling agent is required to perform prior to accessing ControllerHandle again.
+
+  @retval EFI_SUCCESS           The driver specified by This successfully forced the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ActionRequired is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support forcing the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the configuration type specified by DefaultType.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempt to force the default configuration options on the controller specified by  ControllerHandle and ChildHandle.
+  @retval EFI_OUT_RESOURCES     There are not enough resources available to force the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION_FORCE_DEFAULTS)(
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL                        *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL,
+  IN  UINT32                                                  DefaultType,
+  OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED                *ActionRequired
+  );
+
+
+///
+/// Used to set configuration options for a controller that an EFI Driver is managing.
+///
+struct _EFI_DRIVER_CONFIGURATION_PROTOCOL {
+  EFI_DRIVER_CONFIGURATION_SET_OPTIONS    SetOptions;
+  EFI_DRIVER_CONFIGURATION_OPTIONS_VALID  OptionsValid;
+  EFI_DRIVER_CONFIGURATION_FORCE_DEFAULTS ForceDefaults;
+  ///
+  /// A Null-terminated ASCII string that contains one or more 
+  /// ISO 639-2 language codes.  This is the list of language 
+  /// codes that this protocol supports.  
+  ///
+  CHAR8                                   *SupportedLanguages;
+};
+
+
+extern EFI_GUID gEfiDriverConfigurationProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverConfiguration2.h b/MdePkg/Include/Protocol/DriverConfiguration2.h
new file mode 100644
index 000000000000..1610eb4741af
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverConfiguration2.h
@@ -0,0 +1,190 @@
+/** @file
+  UEFI Driver Configuration2 Protocol
+
+  Copyright (c) 2006 - 2008, 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 __EFI_DRIVER_CONFIGURATION2_H__
+#define __EFI_DRIVER_CONFIGURATION2_H__
+
+///
+/// Global ID for the Driver Configuration Protocol defined in UEFI 2.0
+///
+#define EFI_DRIVER_CONFIGURATION2_PROTOCOL_GUID \
+  { \
+    0xbfd7dc1d, 0x24f1, 0x40d9, {0x82, 0xe7, 0x2e, 0x09, 0xbb, 0x6b, 0x4e, 0xbe } \
+  }
+  
+typedef struct _EFI_DRIVER_CONFIGURATION2_PROTOCOL  EFI_DRIVER_CONFIGURATION2_PROTOCOL;
+
+typedef enum {
+  ///
+  /// The controller is still in a usable state. No actions
+  /// are required before this controller can be used again.
+  ///
+  EfiDriverConfigurationActionNone              = 0,
+  ///
+  /// The driver has detected that the controller is not in a
+  /// usable state, and it needs to be stopped.
+  ///
+  EfiDriverConfigurationActionStopController    = 1,
+  ///
+  /// This controller needs to be stopped and restarted
+  /// before it can be used again.
+  ///
+  EfiDriverConfigurationActionRestartController = 2,
+  ///
+  /// A configuration change has been made that requires the platform to be restarted before
+  /// the controller can be used again.
+  ///
+  EfiDriverConfigurationActionRestartPlatform   = 3,
+  EfiDriverConfigurationActionMaximum
+} EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED;
+
+#define EFI_DRIVER_CONFIGURATION_SAFE_DEFAULTS          0x00000000
+#define EFI_DRIVER_CONFIGURATION_MANUFACTURING_DEFAULTS 0x00000001
+#define EFI_DRIVER_CONFIGURATION_CUSTOM_DEFAULTS        0x00000002
+#define EFI_DRIVER_CONFIGURATION_PERORMANCE_DEFAULTS    0x00000003
+
+/**
+  Allows the user to set controller specific options for a controller that a 
+  driver is currently managing.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION2_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to set options on.
+  @param  ChildHandle      The handle of the child controller to set options on.  This
+                           is an optional parameter that may be NULL.  It will be NULL
+                           for device drivers, and for bus drivers that wish to set
+                           options for the bus controller.  It will not be NULL for a
+                           bus driver that wishes to set options for one of its child
+                           controllers.
+  @param  Language         A Null-terminated ASCII string that contains one or more RFC 4646
+                           language codes. This is the list of language codes that this
+                           protocol supports. The number of languages
+                           supported by a driver is up to the driver writer.
+  @param  ActionRequired   A pointer to the action that the calling agent is required
+                           to perform when this function returns.  See "Related
+                           Definitions" for a list of the actions that the calling
+                           agent is required to perform prior to accessing
+                           ControllerHandle again.
+
+  @retval EFI_SUCCESS           The driver specified by This successfully set the
+                                configuration options for the controller specified
+                                by ControllerHandle.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ActionRequired is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support setting
+                                configuration options for the controller specified by
+                                ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to set the
+                                configuration options for the controller specified
+                                by ControllerHandle and ChildHandle.
+  @retval EFI_OUT_RESOURCES     There are not enough resources available to set the
+                                configuration options for the controller specified
+                                by ControllerHandle and ChildHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION2_SET_OPTIONS)(
+  IN EFI_DRIVER_CONFIGURATION2_PROTOCOL                       *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL,
+  IN  CHAR8                                                   *Language,
+  OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED                *ActionRequired
+  );
+
+/**
+  Tests to see if a controller's current configuration options are valid.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION2_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to test if it's current
+                           configuration options are valid.
+  @param  ChildHandle      The handle of the child controller to test if it's current
+                           configuration options are valid.  This is an optional
+                           parameter that may be NULL.  It will be NULL for device
+                           drivers.  It will also be NULL for bus drivers that wish
+                           to test the configuration options for the bus controller.
+                           It will not be NULL for a bus driver that wishes to test
+                           configuration options for one of its child controllers.
+
+  @retval EFI_SUCCESS           The controller specified by ControllerHandle and
+                                ChildHandle that is being managed by the driver
+                                specified by This has a valid set of  configuration
+                                options.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by ControllerHandle
+                                and ChildHandle.
+  @retval EFI_DEVICE_ERROR      The controller specified by ControllerHandle and
+                                ChildHandle that is being managed by the driver
+                                specified by This has an invalid set of configuration
+                                options.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION2_OPTIONS_VALID)(
+  IN EFI_DRIVER_CONFIGURATION2_PROTOCOL                       *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL
+  );
+
+/**
+  Forces a driver to set the default configuration options for a controller.
+
+  @param  This             A pointer to the EFI_DRIVER_CONFIGURATION2_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to force default configuration options on.
+  @param  ChildHandle      The handle of the child controller to force default configuration options on  This is an optional parameter that may be NULL.  It will be NULL for device drivers.  It will also be NULL for bus drivers that wish to force default configuration options for the bus controller.  It will not be NULL for a bus driver that wishes to force default configuration options for one of its child controllers.
+  @param  DefaultType      The type of default configuration options to force on the controller specified by ControllerHandle and ChildHandle.  See Table 9-1 for legal values.  A DefaultType of 0x00000000 must be supported by this protocol.
+  @param  ActionRequired   A pointer to the action that the calling agent is required to perform when this function returns.  See "Related Definitions" in Section 9.1 for a list of the actions that the calling agent is required to perform prior to accessing ControllerHandle again.
+
+  @retval EFI_SUCCESS           The driver specified by This successfully forced the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ActionRequired is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support forcing the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the configuration type specified by DefaultType.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempt to force the default configuration options on the controller specified by  ControllerHandle and ChildHandle.
+  @retval EFI_OUT_RESOURCES     There are not enough resources available to force the default configuration options on the controller specified by ControllerHandle and ChildHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_CONFIGURATION2_FORCE_DEFAULTS)(
+  IN EFI_DRIVER_CONFIGURATION2_PROTOCOL                        *This,
+  IN  EFI_HANDLE                                              ControllerHandle,
+  IN  EFI_HANDLE                                              ChildHandle  OPTIONAL,
+  IN  UINT32                                                  DefaultType,
+  OUT EFI_DRIVER_CONFIGURATION_ACTION_REQUIRED                *ActionRequired
+  );
+
+///
+/// Used to set configuration options for a controller that an EFI Driver is managing.
+///
+struct _EFI_DRIVER_CONFIGURATION2_PROTOCOL {
+  EFI_DRIVER_CONFIGURATION2_SET_OPTIONS     SetOptions;
+  EFI_DRIVER_CONFIGURATION2_OPTIONS_VALID   OptionsValid;
+  EFI_DRIVER_CONFIGURATION2_FORCE_DEFAULTS  ForceDefaults;
+  ///
+  /// A Null-terminated ASCII string that contains one or more RFC 4646
+  /// language codes.  This is the list of language codes that this protocol supports.  
+  ///
+  CHAR8                                     *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiDriverConfiguration2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverDiagnostics.h b/MdePkg/Include/Protocol/DriverDiagnostics.h
new file mode 100644
index 000000000000..431b649223e5
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverDiagnostics.h
@@ -0,0 +1,131 @@
+/** @file
+  EFI Driver Diagnostics Protocol
+
+Copyright (c) 2006 - 2013, 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_DRIVER_DIAGNOSTICS_H__
+#define __EFI_DRIVER_DIAGNOSTICS_H__
+
+///
+/// The global ID for the Driver Diagnostics Protocol as defined in EFI 1.1.
+///
+#define EFI_DRIVER_DIAGNOSTICS_PROTOCOL_GUID \
+  { \
+    0x0784924f, 0xe296, 0x11d4, {0x9a, 0x49, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_DRIVER_DIAGNOSTICS_PROTOCOL  EFI_DRIVER_DIAGNOSTICS_PROTOCOL;
+
+typedef enum {
+  ///
+  /// Performs standard diagnostics on the controller.
+  ///
+  EfiDriverDiagnosticTypeStandard     = 0,
+  ///
+  /// This is an optional diagnostic type that performs diagnostics on the controller that may
+  /// take an extended amount of time to execute.
+  ///
+  EfiDriverDiagnosticTypeExtended     = 1,
+  ///
+  /// This is an optional diagnostic type that performs diagnostics on the controller that are
+  /// suitable for a manufacturing and test environment.
+  ///
+  EfiDriverDiagnosticTypeManufacturing= 2,
+  ///
+  /// This is an optional diagnostic type that would only be used in the situation where an 
+  /// EFI_NOT_READY had been returned by a previous call to RunDiagnostics()
+  /// and there is a desire to cancel the current running diagnostics operation.
+  ///
+  EfiDriverDiagnosticTypeCancel       = 3,
+  EfiDriverDiagnosticTypeMaximum
+} EFI_DRIVER_DIAGNOSTIC_TYPE;
+
+/**
+  Runs diagnostics on a controller.
+
+  @param  This             A pointer to the EFI_DRIVER_DIAGNOSTICS_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to run diagnostics on.
+  @param  ChildHandle      The handle of the child controller to run diagnostics on
+                           This is an optional parameter that may be NULL.  It will
+                           be NULL for device drivers.  It will also be NULL for a
+                           bus drivers that wish to run diagnostics on the bus
+                           controller.  It will not be NULL for a bus driver that
+                           wishes to run diagnostics on one of its child controllers.
+  @param  DiagnosticType   Indicates type of diagnostics to perform on the controller
+                           specified by ControllerHandle and ChildHandle.   See
+                           "Related Definitions" for the list of supported types.
+  @param  Language         A pointer to a three character ISO 639-2 language
+                           identifier.  This is the language in which the optional
+                           error message should be returned in Buffer, and it must
+                           match one of the languages specified in SupportedLanguages.
+                           The number of languages supported by a driver is up to
+                           the driver writer.
+  @param  ErrorType        A GUID that defines the format of the data returned in Buffer.
+  @param  BufferSize       The size, in bytes, of the data returned in Buffer.
+  @param  Buffer           A buffer that contains a Null-terminated string
+                           plus some additional data whose format is defined by
+                           ErrorType.  Buffer is allocated by this function with
+                           AllocatePool(), and it is the caller's responsibility
+                           to free it with a call to FreePool().
+
+  @retval EFI_SUCCESS           The controller specified by ControllerHandle and
+                                ChildHandle passed the diagnostic.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+  @retval EFI_INVALID_PARAMETER ErrorType is NULL.
+  @retval EFI_INVALID_PARAMETER BufferType is NULL.
+  @retval EFI_INVALID_PARAMETER Buffer is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                running diagnostics for the controller specified
+                                by ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                type of diagnostic specified by DiagnosticType.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to complete
+                                the diagnostics.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to return
+                                the status information in ErrorType, BufferSize,
+                                and Buffer.
+  @retval EFI_DEVICE_ERROR      The controller specified by ControllerHandle and
+                                ChildHandle did not pass the diagnostic.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_DIAGNOSTICS_RUN_DIAGNOSTICS)(
+  IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL                        *This,
+  IN  EFI_HANDLE                                            ControllerHandle,
+  IN  EFI_HANDLE                                            ChildHandle  OPTIONAL,
+  IN  EFI_DRIVER_DIAGNOSTIC_TYPE                            DiagnosticType,
+  IN  CHAR8                                                 *Language,
+  OUT EFI_GUID                                              **ErrorType,
+  OUT UINTN                                                 *BufferSize,
+  OUT CHAR16                                                **Buffer
+  );
+
+///
+/// Used to perform diagnostics on a controller that an EFI Driver is managing.
+///
+struct _EFI_DRIVER_DIAGNOSTICS_PROTOCOL {
+  EFI_DRIVER_DIAGNOSTICS_RUN_DIAGNOSTICS  RunDiagnostics;
+  ///
+  /// A Null-terminated ASCII string that contains one or more ISO 639-2
+  /// language codes.  This is the list of language codes that this protocol supports.  
+  ///  
+  CHAR8                                   *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiDriverDiagnosticsProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverDiagnostics2.h b/MdePkg/Include/Protocol/DriverDiagnostics2.h
new file mode 100644
index 000000000000..78d5ec6fe93e
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverDiagnostics2.h
@@ -0,0 +1,111 @@
+/** @file
+  UEFI Driver Diagnostics2 Protocol
+
+  Copyright (c) 2006 - 2011, 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 __EFI_DRIVER_DIAGNOSTICS2_H__
+#define __EFI_DRIVER_DIAGNOSTICS2_H__
+
+#include <Protocol/DriverDiagnostics.h>
+
+#define EFI_DRIVER_DIAGNOSTICS2_PROTOCOL_GUID \
+  { \
+    0x4d330321, 0x025f, 0x4aac, {0x90, 0xd8, 0x5e, 0xd9, 0x00, 0x17, 0x3b, 0x63 } \
+  }
+  
+typedef struct _EFI_DRIVER_DIAGNOSTICS2_PROTOCOL  EFI_DRIVER_DIAGNOSTICS2_PROTOCOL;
+
+/**
+  Runs diagnostics on a controller.
+
+  @param  This             A pointer to the EFI_DRIVER_DIAGNOSTICS2_PROTOCOL instance.
+  @param  ControllerHandle The handle of the controller to run diagnostics on.
+  @param  ChildHandle      The handle of the child controller to run diagnostics on
+                           This is an optional parameter that may be NULL.  It will
+                           be NULL for device drivers.  It will also be NULL for 
+                           bus drivers that wish to run diagnostics on the bus
+                           controller.  It will not be NULL for a bus driver that
+                           wishes to run diagnostics on one of its child controllers.
+  @param  DiagnosticType   Indicates the type of diagnostics to perform on the controller
+                           specified by ControllerHandle and ChildHandle.   See
+                           "Related Definitions" for the list of supported types.
+  @param  Language         A pointer to a Null-terminated ASCII string
+                           array indicating the language. This is the
+                           language of the driver name that the caller
+                           is requesting, and it must match one of the
+                           languages specified in SupportedLanguages.
+                           The number of languages supported by a
+                           driver is up to the driver writer. Language
+                           is specified in RFC 4646 language code format.
+  @param  ErrorType        A GUID that defines the format of the data returned in Buffer.
+  @param  BufferSize       The size, in bytes, of the data returned in Buffer.
+  @param  Buffer           A buffer that contains a Null-terminated Unicode string
+                           plus some additional data whose format is defined by
+                           ErrorType.  Buffer is allocated by this function with
+                           AllocatePool(), and it is the caller's responsibility
+                           to free it with a call to FreePool().
+
+  @retval EFI_SUCCESS           The controller specified by ControllerHandle and
+                                ChildHandle passed the diagnostic.
+  @retval EFI_ACCESS_DENIED     The request for initiating diagnostics was unable
+                                to be complete due to some underlying hardware or
+                                software state.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+  @retval EFI_INVALID_PARAMETER ErrorType is NULL.
+  @retval EFI_INVALID_PARAMETER BufferType is NULL.
+  @retval EFI_INVALID_PARAMETER Buffer is NULL.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                running diagnostics for the controller specified
+                                by ControllerHandle and ChildHandle.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                type of diagnostic specified by DiagnosticType.
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support the
+                                language specified by Language.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to complete
+                                the diagnostics.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to return
+                                the status information in ErrorType, BufferSize,
+                                and Buffer.
+  @retval EFI_DEVICE_ERROR      The controller specified by ControllerHandle and
+                                ChildHandle did not pass the diagnostic.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_DIAGNOSTICS2_RUN_DIAGNOSTICS)(
+  IN EFI_DRIVER_DIAGNOSTICS2_PROTOCOL                       *This,
+  IN  EFI_HANDLE                                            ControllerHandle,
+  IN  EFI_HANDLE                                            ChildHandle  OPTIONAL,
+  IN  EFI_DRIVER_DIAGNOSTIC_TYPE                            DiagnosticType,
+  IN  CHAR8                                                 *Language,
+  OUT EFI_GUID                                              **ErrorType,
+  OUT UINTN                                                 *BufferSize,
+  OUT CHAR16                                                **Buffer
+  );
+
+///
+/// Used to perform diagnostics on a controller that an EFI Driver is managing.
+///
+struct _EFI_DRIVER_DIAGNOSTICS2_PROTOCOL {
+  EFI_DRIVER_DIAGNOSTICS2_RUN_DIAGNOSTICS RunDiagnostics;
+  ///
+  /// A Null-terminated ASCII string that contains one or more RFC 4646
+  /// language codes.  This is the list of language codes that this protocol supports.  
+  ///    
+  CHAR8                                   *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiDriverDiagnostics2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverFamilyOverride.h b/MdePkg/Include/Protocol/DriverFamilyOverride.h
new file mode 100644
index 000000000000..868c7734117a
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverFamilyOverride.h
@@ -0,0 +1,66 @@
+/** @file
+  UEFI Driver Family Protocol
+
+Copyright (c) 2007 - 2010, 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_DRIVER_FAMILY_OVERRIDE_H__
+#define __EFI_DRIVER_FAMILY_OVERRIDE_H__
+
+#define EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL_GUID \
+  { \
+    0xb1ee129e, 0xda36, 0x4181, { 0x91, 0xf8, 0x4, 0xa4, 0x92, 0x37, 0x66, 0xa7 } \
+  }
+  
+typedef struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL  EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL;
+
+//
+// Prototypes for the Driver Family Override Protocol
+//
+// 
+/**                                                                 
+  This function returns the version value associated with the driver specified by This.
+
+  Retrieves the version of the driver that is used by the EFI Boot Service ConnectController()
+  to sort the set of Driver Binding Protocols in order from highest priority to lowest priority.
+  For drivers that support the Driver Family Override Protocol, those drivers are sorted so that
+  the drivers with higher values returned by GetVersion() are higher priority than drivers that
+  return lower values from GetVersion().
+
+  @param  This                  A pointer to the EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL instance.                            
+                                
+  @return The version value associated with the driver specified by This.                                  
+                                   
+**/
+typedef
+UINT32
+(EFIAPI *EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION)(
+  IN EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL    *This
+  );
+
+///
+/// When installed, the Driver Family Override Protocol produces a GUID that represents 
+/// a family of drivers.  Drivers with the same GUID are members of the same family 
+/// When drivers are connected to controllers, drivers with a higher revision value 
+/// in the same driver family are connected with a higher priority than drivers 
+/// with a lower revision value in the same driver family.  The EFI Boot Service
+/// Connect Controller uses five rules to build a prioritized list of drivers when 
+/// a request is made to connect a driver to a controller.  The Driver Family Protocol
+/// rule is between the Platform Specific Driver Override Protocol and above the 
+/// Bus Specific Driver Override Protocol.  
+///
+struct _EFI_DRIVER_FAMILY_OVERRIDE_PROTOCOL {
+  EFI_DRIVER_FAMILY_OVERRIDE_GET_VERSION GetVersion;
+};
+
+extern EFI_GUID gEfiDriverFamilyOverrideProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DriverHealth.h b/MdePkg/Include/Protocol/DriverHealth.h
new file mode 100644
index 000000000000..d23140d20bd1
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverHealth.h
@@ -0,0 +1,247 @@
+/** @file
+  EFI Driver Health Protocol definitions.
+
+  When installed, the Driver Health Protocol produces a collection of services that allow
+  the health status for a controller to be retrieved. If a controller is not in a usable
+  state, status messages may be reported to the user, repair operations can be invoked,
+  and the user may be asked to make software and/or hardware configuration changes.
+  
+  The Driver Health Protocol is optionally produced by a driver that follows the 
+  EFI Driver Model.  If an EFI Driver needs to report health status to the platform, 
+  provide warning or error messages to the user, perform length repair operations, 
+  or request the user to make hardware or software configuration changes, then the 
+  Driver Health Protocol must be produced.
+ 
+  A controller that is managed by driver that follows the EFI Driver Model and 
+  produces the Driver Health Protocol must report the current health of the 
+  controllers that the driver is currently managing.  The controller can initially 
+  be healthy, failed, require repair, or require configuration.  If a controller 
+  requires configuration, and the user make configuration changes, the controller 
+  may then need to be reconnected or the system may need to be rebooted for the 
+  configuration changes to take affect. 
+
+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<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.             
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Specification 2.3d 
+
+**/
+
+#ifndef __EFI_DRIVER_HEALTH_H__
+#define __EFI_DRIVER_HEALTH_H__
+
+#define EFI_DRIVER_HEALTH_PROTOCOL_GUID \
+  { \
+    0x2a534210, 0x9280, 0x41d8, { 0xae, 0x79, 0xca, 0xda, 0x1, 0xa2, 0xb1, 0x27 } \
+  }
+  
+typedef struct _EFI_DRIVER_HEALTH_PROTOCOL  EFI_DRIVER_HEALTH_PROTOCOL;
+
+///
+/// EFI_DRIVER_HEALTH_HEALTH_STATUS
+///
+typedef enum {
+  EfiDriverHealthStatusHealthy,
+  EfiDriverHealthStatusRepairRequired,
+  EfiDriverHealthStatusConfigurationRequired,
+  EfiDriverHealthStatusFailed,
+  EfiDriverHealthStatusReconnectRequired,
+  EfiDriverHealthStatusRebootRequired
+} EFI_DRIVER_HEALTH_STATUS;
+
+///
+/// EFI_DRIVER_HEALTH_HII_MESSAGE
+///
+typedef struct {
+  EFI_HII_HANDLE  HiiHandle;
+  EFI_STRING_ID   StringId;
+  
+  ///
+  /// 64-bit numeric value of the warning/error specified by this message. 
+  ///   A value of 0x0000000000000000 is used to indicate that MessageCode is not specified. 
+  ///   The values  0x0000000000000001 to 0x0fffffffffffffff are reserved for allocation by the UEFI Specification.
+  ///   The values  0x1000000000000000 to 0x1fffffffffffffff are reserved for IHV-developed drivers. 
+  ///   The values 0x8000000000000000 to 0x8fffffffffffffff is reserved for platform/OEM drivers.
+  ///   All other values are reserved and should not be used.
+  ///
+  UINT64          MessageCode;
+} EFI_DRIVER_HEALTH_HII_MESSAGE;
+
+/**
+  Reports the progress of a repair operation
+
+  @param[in]  Value             A value between 0 and Limit that identifies the current 
+                                progress of the repair operation.
+  
+  @param[in]  Limit             The maximum value of Value for the current repair operation.
+                                For example, a driver that wants to specify progress in 
+                                percent would use a Limit value of 100.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_HEALTH_REPAIR_NOTIFY)(
+  IN UINTN  Value,
+  IN UINTN  Limit
+  );
+
+/**
+  Retrieves the health status of a controller in the platform.  This function can also 
+  optionally return warning messages, error messages, and a set of HII Forms that may 
+  be repair a controller that is not proper configured. 
+  
+  @param[in] This             A pointer to the EFI_DRIVER_HEALTH_PROTOCOL instance.
+
+  @param[in] ControllerHandle The handle of the controller to retrieve the health status 
+                              on.  This is an optional parameter that may be NULL.  If 
+                              this parameter is NULL, then the value of ChildHandle is 
+                              ignored, and the combined health status of all the devices 
+                              that the driver is managing is returned.
+
+  @param[in] ChildHandle      The handle of the child controller to retrieve the health 
+                              status on.  This is an optional parameter that may be NULL.  
+                              This parameter is ignored of ControllerHandle is NULL.  It 
+                              will be NULL for device drivers.  It will also be NULL for 
+                              bus drivers when an attempt is made to collect the health 
+                              status of the bus controller.  If will not be NULL when an 
+                              attempt is made to collect the health status for a child 
+                              controller produced by the driver.
+
+  @param[out] HealthStatus    A pointer to the health status that is returned by this 
+                              function.  This is an optional parameter that may be NULL.  
+                              This parameter is ignored of ControllerHandle is NULL.  
+                              The health status for the controller specified by 
+                              ControllerHandle and ChildHandle is returned. 
+
+  @param[out] MessageList     A pointer to an array of warning or error messages associated 
+                              with the controller specified by ControllerHandle and 
+                              ChildHandle.  This is an optional parameter that may be NULL.  
+                              MessageList is allocated by this function with the EFI Boot 
+                              Service AllocatePool(), and it is the caller's responsibility 
+                              to free MessageList with the EFI Boot Service FreePool().  
+                              Each message is specified by tuple of an EFI_HII_HANDLE and 
+                              an EFI_STRING_ID.  The array of messages is terminated by tuple 
+                              containing a EFI_HII_HANDLE with a value of NULL.  The 
+                              EFI_HII_STRING_PROTOCOL.GetString() function can be used to 
+                              retrieve the warning or error message as a Null-terminated 
+                              string in a specific language.  Messages may be 
+                              returned for any of the HealthStatus values except 
+                              EfiDriverHealthStatusReconnectRequired and 
+                              EfiDriverHealthStatusRebootRequired.
+
+  @param[out] FormHiiHandle   A pointer to the HII handle containing the HII form used when 
+                              configuration is required. The HII handle is associated with 
+                              the controller specified by ControllerHandle and ChildHandle.
+                              If this is NULL, then no HII form is available. An HII handle
+                              will only be returned with a HealthStatus value of 
+                              EfiDriverHealthStatusConfigurationRequired.
+
+  @retval EFI_SUCCESS           ControllerHandle is NULL, and all the controllers 
+                                managed by this driver specified by This have a health 
+                                status of EfiDriverHealthStatusHealthy with no warning 
+                                messages to be returned.  The ChildHandle, HealthStatus, 
+                                MessageList, and FormList parameters are ignored.
+
+  @retval EFI_DEVICE_ERROR      ControllerHandle is NULL, and one or more of the 
+                                controllers managed by this driver specified by This 
+                                do not have a health status of EfiDriverHealthStatusHealthy.  
+                                The ChildHandle, HealthStatus, MessageList, and 
+                                FormList parameters are ignored.
+
+  @retval EFI_DEVICE_ERROR      ControllerHandle is NULL, and one or more of the 
+                                controllers managed by this driver specified by This 
+                                have one or more warning and/or error messages.  
+                                The ChildHandle, HealthStatus, MessageList, and 
+                                FormList parameters are ignored.
+
+  @retval EFI_SUCCESS           ControllerHandle is not NULL and the health status 
+                                of the controller specified by ControllerHandle and 
+                                ChildHandle was returned in HealthStatus.  A list 
+                                of warning and error messages may be optionally 
+                                returned in MessageList, and a list of HII Forms 
+                                may be optionally returned in FormList.
+
+  @retval EFI_UNSUPPORTED       ControllerHandle is not NULL, and the controller 
+                                specified by ControllerHandle and ChildHandle is not 
+                                currently being managed by the driver specified by This.
+
+  @retval EFI_INVALID_PARAMETER HealthStatus is NULL.
+
+  @retval EFI_OUT_OF_RESOURCES  MessageList is not NULL, and there are not enough 
+                                resource available to allocate memory for MessageList.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_HEALTH_GET_HEALTH_STATUS)(
+  IN  EFI_DRIVER_HEALTH_PROTOCOL       *This,
+  IN  EFI_HANDLE                       ControllerHandle OPTIONAL,
+  IN  EFI_HANDLE                       ChildHandle      OPTIONAL,
+  OUT EFI_DRIVER_HEALTH_STATUS         *HealthStatus,
+  OUT EFI_DRIVER_HEALTH_HII_MESSAGE    **MessageList    OPTIONAL,
+  OUT EFI_HII_HANDLE                   *FormHiiHandle   OPTIONAL
+  );
+
+/**
+  Performs a repair operation on a controller in the platform.  This function can 
+  optionally report repair progress information back to the platform. 
+  
+  @param[in] This              A pointer to the EFI_DRIVER_HEALTH_PROTOCOL instance.
+  @param[in] ControllerHandle  The handle of the controller to repair.
+  @param[in] ChildHandle       The handle of the child controller to repair.  This is 
+                               an optional parameter that may be NULL.  It will be NULL 
+                               for device drivers.  It will also be NULL for bus 
+                               drivers when an attempt is made to repair a bus controller.
+                               If will not be NULL when an attempt is made to repair a 
+                               child controller produced by the driver.
+  @param[in] RepairNotify      A notification function that may be used by a driver to 
+                               report the progress of the repair operation.  This is 
+                               an optional parameter that may be NULL.  
+
+
+  @retval EFI_SUCCESS           An attempt to repair the controller specified by 
+                                ControllerHandle and ChildHandle was performed.  
+                                The result of the repair operation can bet 
+                                determined by calling GetHealthStatus().
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently 
+                                managing the controller specified by ControllerHandle 
+                                and ChildHandle.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to perform the 
+                                repair operation.
+
+*/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DRIVER_HEALTH_REPAIR)(
+  IN  EFI_DRIVER_HEALTH_PROTOCOL                *This,
+  IN  EFI_HANDLE                                ControllerHandle,
+  IN  EFI_HANDLE                                ChildHandle       OPTIONAL,
+  IN  EFI_DRIVER_HEALTH_REPAIR_NOTIFY           RepairNotify      OPTIONAL
+  );
+
+///
+/// When installed, the Driver Health Protocol produces a collection of services
+/// that allow the health status for a controller to be retrieved.  If a controller 
+/// is not in a usable state, status messages may be reported to the user, repair 
+/// operations can be invoked, and the user may be asked to make software and/or 
+/// hardware configuration changes. 
+///
+struct _EFI_DRIVER_HEALTH_PROTOCOL {
+  EFI_DRIVER_HEALTH_GET_HEALTH_STATUS  GetHealthStatus;
+  EFI_DRIVER_HEALTH_REPAIR             Repair;
+};
+
+extern EFI_GUID gEfiDriverHealthProtocolGuid;
+
+#endif
+
+
+
+
diff --git a/MdePkg/Include/Protocol/DriverSupportedEfiVersion.h b/MdePkg/Include/Protocol/DriverSupportedEfiVersion.h
new file mode 100644
index 000000000000..2689ddd7f957
--- /dev/null
+++ b/MdePkg/Include/Protocol/DriverSupportedEfiVersion.h
@@ -0,0 +1,46 @@
+/** @file
+  The protocol provides information about the version of the EFI
+  specification that a driver is following. This protocol is
+  required for EFI drivers that are on PCI and other plug-in
+  cards.
+
+  Copyright (c) 2006 - 2015, 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 __DRIVER_SUPPORTED_EFI_VERSION_H__
+#define __DRIVER_SUPPORTED_EFI_VERSION_H__
+
+#define EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL_GUID  \
+  { 0x5c198761, 0x16a8, 0x4e69, { 0x97, 0x2c, 0x89, 0xd6, 0x79, 0x54, 0xf8, 0x1d } }
+
+
+///
+/// The EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL provides a
+/// mechanism for an EFI driver to publish the version of the EFI   
+/// specification it conforms to. This protocol must be placed on   
+/// the driver's image handle when the driver's entry point is   
+/// called.
+///
+typedef struct _EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL {
+  ///
+  /// The size, in bytes, of the entire structure. Future versions of this 
+  /// specification may grow the size of the structure.
+  /// 
+  UINT32 Length;
+  ///
+  /// The latest version of the UEFI specification that this driver conforms to.
+  ///
+  UINT32 FirmwareVersion;
+} EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL;
+
+extern EFI_GUID gEfiDriverSupportedEfiVersionProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/DxeSmmReadyToLock.h b/MdePkg/Include/Protocol/DxeSmmReadyToLock.h
new file mode 100644
index 000000000000..540f4cf5e204
--- /dev/null
+++ b/MdePkg/Include/Protocol/DxeSmmReadyToLock.h
@@ -0,0 +1,41 @@
+/** @file
+  DXE SMM Ready To Lock protocol introduced in the PI 1.2 specification.
+
+  According to PI 1.4a specification, this UEFI protocol indicates that
+  resources and services that should not be used by the third party code
+  are about to be locked.
+  This protocol is a mandatory protocol published by PI platform code.
+  This protocol in tandem with the End of DXE Event facilitates transition
+  of the platform from the environment where all of the components are
+  under the authority of the platform manufacturer to the environment where
+  third party extensible modules such as UEFI drivers and UEFI applications
+  are executed. The protocol is published immediately after signaling of the
+  End of DXE Event. PI modules that need to lock or protect their resources
+  in anticipation of the invocation of 3rd party extensible modules should
+  register for notification on installation of this protocol and effect the
+  appropriate protections in their notification handlers. For example, PI
+  platform code may choose to use notification handler to lock SMM by invoking
+  EFI_SMM_ACCESS2_PROTOCOL.Lock() function.
+
+  Copyright (c) 2009 - 2016, 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 _DXE_SMM_READY_TO_LOCK_H_
+#define _DXE_SMM_READY_TO_LOCK_H_
+
+#define EFI_DXE_SMM_READY_TO_LOCK_PROTOCOL_GUID \
+  { \
+    0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e } \
+  }
+
+extern EFI_GUID gEfiDxeSmmReadyToLockProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Eap.h b/MdePkg/Include/Protocol/Eap.h
new file mode 100644
index 000000000000..e91deb867006
--- /dev/null
+++ b/MdePkg/Include/Protocol/Eap.h
@@ -0,0 +1,162 @@
+/** @file
+  EFI EAP(Extended Authenticaton Protocol) Protocol Definition
+  The EFI EAP Protocol is used to abstract the ability to configure and extend the
+  EAP framework. 
+  The definitions in this file are defined in UEFI Specification 2.3.1B, which have
+  not been verified by one implementation yet.
+
+  Copyright (c) 2009 - 2015, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_EAP_PROTOCOL_H__
+#define __EFI_EAP_PROTOCOL_H__
+
+
+#define EFI_EAP_PROTOCOL_GUID \
+  { \
+    0x5d9f96db, 0xe731, 0x4caa, {0xa0, 0xd, 0x72, 0xe1, 0x87, 0xcd, 0x77, 0x62 } \
+  }
+
+typedef struct _EFI_EAP_PROTOCOL EFI_EAP_PROTOCOL;
+
+///
+/// Type for the identification number assigned to the Port by the  
+/// System in which the Port resides.
+///
+typedef VOID *  EFI_PORT_HANDLE;
+
+///
+/// EAP Authentication Method Type (RFC 3748)
+///@{
+#define EFI_EAP_TYPE_TLS 13 ///< REQUIRED - RFC 5216
+///@}
+
+//
+// EAP_TYPE MD5, OTP and TOEKN_CARD has been removed from UEFI2.3.1B.
+// Definitions are kept for backward compatibility.
+//
+#define EFI_EAP_TYPE_MD5                4
+#define EFI_EAP_TYPE_OTP                5
+#define EFI_EAP_TYPE_TOKEN_CARD         6
+
+/**
+  One user provided EAP authentication method.
+
+  Build EAP response packet in response to the EAP request packet specified by
+  (RequestBuffer, RequestSize).
+
+  @param[in]      PortNumber     Specified the Port where the EAP request packet comes.
+  @param[in]      RequestBuffer  Pointer to the most recently received EAP- Request packet.
+  @param[in]      RequestSize    Packet size in bytes for the most recently received
+                                 EAP-Request packet.
+  @param[in]      Buffer         Pointer to the buffer to hold the built packet.
+  @param[in, out] BufferSize     Pointer to the buffer size in bytes. 
+                                 On input, it is the buffer size provided by the caller.
+                                 On output, it is the buffer size in fact needed to contain
+                                 the packet.
+
+  @retval EFI_SUCCESS            The required EAP response packet is built successfully.
+  @retval others                 Failures are encountered during the packet building process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_BUILD_RESPONSE_PACKET)(
+  IN EFI_PORT_HANDLE        PortNumber,
+  IN UINT8                  *RequestBuffer, 
+  IN UINTN                  RequestSize, 
+  IN UINT8                  *Buffer, 
+  IN OUT UINTN              *BufferSize
+  );
+
+/**
+  Set the desired EAP authentication method for the Port.
+
+  The SetDesiredAuthMethod() function sets the desired EAP authentication method indicated 
+  by EapAuthType for the Port.
+  
+  If EapAuthType is an invalid EAP authentication type, then EFI_INVALID_PARAMETER is 
+  returned.
+  If the EAP authentication method of EapAuthType is unsupported by the Ports, then it will
+  return EFI_UNSUPPORTED.
+  The cryptographic strength of EFI_EAP_TYPE_TLS shall be at least of hash strength 
+  SHA-256 and RSA key length of at least 2048 bits.
+  
+  @param[in] This                A pointer to the EFI_EAP_PROTOCOL instance that indicates 
+                                 the calling context.
+  @param[in] EapAuthType         The type of the EAP authentication method to register. It should 
+                                 be the type value defined by RFC. See RFC 2284 for details.
+  @param[in] Handler             The handler of the EAP authentication method to register.
+
+  @retval EFI_SUCCESS            The EAP authentication method of EapAuthType is 
+                                 registered successfully.
+  @retval EFI_INVALID_PARAMETER  EapAuthType is an invalid EAP authentication type.
+  @retval EFI_UNSUPPORTED        The EAP authentication method of EapAuthType is
+                                 unsupported by the Port.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_SET_DESIRED_AUTHENTICATION_METHOD)(
+  IN EFI_EAP_PROTOCOL            *This, 
+  IN UINT8                       EapAuthType
+  );
+
+/**
+  Register an EAP authentication method. 
+
+  The RegisterAuthMethod() function registers the user provided EAP authentication method, 
+  the type of which is EapAuthType and the handler of which is Handler. 
+  
+  If EapAuthType is an invalid EAP authentication type, then EFI_INVALID_PARAMETER is 
+  returned.
+  If there is not enough system memory to perform the registration, then 
+  EFI_OUT_OF_RESOURCES is returned.
+
+  @param[in] This                A pointer to the EFI_EAP_PROTOCOL instance that indicates 
+                                 the calling context.
+  @param[in] EapAuthType         The type of the EAP authentication method to register. It should 
+                                 be the type value defined by RFC. See RFC 2284 for details.
+  @param[in] Handler             The handler of the EAP authentication method to register.
+
+  @retval EFI_SUCCESS            The EAP authentication method of EapAuthType is 
+                                 registered successfully.
+  @retval EFI_INVALID_PARAMETER  EapAuthType is an invalid EAP authentication type.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough system memory to perform the registration.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_REGISTER_AUTHENTICATION_METHOD)(
+  IN EFI_EAP_PROTOCOL                     *This, 
+  IN UINT8                                EapAuthType, 
+  IN EFI_EAP_BUILD_RESPONSE_PACKET        Handler
+  );
+
+///
+/// EFI_EAP_PROTOCOL 
+/// is used to configure the desired EAP authentication method for the EAP 
+/// framework and extend the EAP framework by registering new EAP authentication
+/// method on a Port. The EAP framework is built on a per-Port basis. Herein, a
+/// Port means a NIC. For the details of EAP protocol, please refer to RFC 2284. 
+///
+struct _EFI_EAP_PROTOCOL {
+  EFI_EAP_SET_DESIRED_AUTHENTICATION_METHOD   SetDesiredAuthMethod;
+  EFI_EAP_REGISTER_AUTHENTICATION_METHOD      RegisterAuthMethod;
+};
+
+extern EFI_GUID gEfiEapProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/EapConfiguration.h b/MdePkg/Include/Protocol/EapConfiguration.h
new file mode 100644
index 000000000000..dc30e62ad033
--- /dev/null
+++ b/MdePkg/Include/Protocol/EapConfiguration.h
@@ -0,0 +1,159 @@
+/** @file
+  This file defines the EFI EAP Configuration protocol.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_EAP_CONFIGURATION_PROTOCOL_H__
+#define __EFI_EAP_CONFIGURATION_PROTOCOL_H__
+
+///
+/// EFI EAP Configuration protocol provides a way to set and get EAP configuration.
+///
+#define EFI_EAP_CONFIGURATION_PROTOCOL_GUID \
+  { \
+    0xe5b58dbb, 0x7688, 0x44b4, {0x97, 0xbf, 0x5f, 0x1d, 0x4b, 0x7c, 0xc8, 0xdb } \
+  }
+
+typedef struct _EFI_EAP_CONFIGURATION_PROTOCOL EFI_EAP_CONFIGURATION_PROTOCOL;
+
+///
+/// Make sure it not conflict with any real EapTypeXXX
+///
+#define EFI_EAP_TYPE_ATTRIBUTE 0
+
+typedef enum {
+  ///
+  /// EFI_EAP_TYPE_ATTRIBUTE
+  ///
+  EfiEapConfigEapAuthMethod,
+  EfiEapConfigEapSupportedAuthMethod,
+  ///
+  /// EapTypeIdentity
+  ///
+  EfiEapConfigIdentityString,
+  ///
+  /// EapTypeEAPTLS/EapTypePEAP
+  ///
+  EfiEapConfigEapTlsCACert,
+  EfiEapConfigEapTlsClientCert,
+  EfiEapConfigEapTlsClientPrivateKeyFile,
+  EfiEapConfigEapTlsClientPrivateKeyFilePassword, // ASCII format, Volatile
+  EfiEapConfigEapTlsCipherSuite,
+  EfiEapConfigEapTlsSupportedCipherSuite,
+  ///
+  /// EapTypeMSChapV2
+  ///
+  EfiEapConfigEapMSChapV2Password, // UNICODE format, Volatile
+  ///
+  /// EapTypePEAP
+  ///
+  EfiEapConfigEap2ndAuthMethod,
+  ///
+  /// More...
+  ///
+} EFI_EAP_CONFIG_DATA_TYPE;
+
+///
+/// EFI_EAP_TYPE
+///
+typedef UINT8 EFI_EAP_TYPE;
+#define EFI_EAP_TYPE_ATTRIBUTE      0
+#define EFI_EAP_TYPE_IDENTITY       1
+#define EFI_EAP_TYPE_NOTIFICATION   2
+#define EFI_EAP_TYPE_NAK            3
+#define EFI_EAP_TYPE_MD5CHALLENGE   4
+#define EFI_EAP_TYPE_OTP            5
+#define EFI_EAP_TYPE_GTC            6
+#define EFI_EAP_TYPE_EAPTLS         13
+#define EFI_EAP_TYPE_EAPSIM         18
+#define EFI_EAP_TYPE_TTLS           21
+#define EFI_EAP_TYPE_PEAP           25
+#define EFI_EAP_TYPE_MSCHAPV2       26
+#define EFI_EAP_TYPE_EAP_EXTENSION  33
+
+/**
+  Set EAP configuration data.
+
+  The SetData() function sets EAP configuration to non-volatile storage or volatile
+  storage.
+
+  @param[in]  This                Pointer to the EFI_EAP_CONFIGURATION_PROTOCOL instance.
+  @param[in]  EapType             EAP type.
+  @param[in]  DataType            Configuration data type.
+  @param[in]  Data                Pointer to configuration data.
+  @param[in]  DataSize            Total size of configuration data.
+
+  @retval EFI_SUCCESS             The EAP configuration data is set successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  Data is NULL.
+                                  DataSize is 0.
+  @retval EFI_UNSUPPORTED         The EapType or DataType is unsupported.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_CONFIGURATION_SET_DATA) (
+  IN EFI_EAP_CONFIGURATION_PROTOCOL       *This,
+  IN EFI_EAP_TYPE                         EapType,
+  IN EFI_EAP_CONFIG_DATA_TYPE             DataType,
+  IN VOID                                 *Data,
+  IN UINTN                                DataSize
+  );
+
+/**
+  Get EAP configuration data.
+
+  The GetData() function gets EAP configuration.
+
+  @param[in]       This           Pointer to the EFI_EAP_CONFIGURATION_PROTOCOL instance.
+  @param[in]       EapType        EAP type.
+  @param[in]       DataType       Configuration data type.
+  @param[in, out]  Data           Pointer to configuration data.
+  @param[in, out]  DataSize       Total size of configuration data. On input, it means
+                                  the size of Data buffer. On output, it means the size
+                                  of copied Data buffer if EFI_SUCCESS, and means the
+                                  size of desired Data buffer if EFI_BUFFER_TOO_SMALL.
+
+  @retval EFI_SUCCESS             The EAP configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  Data is NULL.
+                                  DataSize is NULL.
+  @retval EFI_UNSUPPORTED         The EapType or DataType is unsupported.
+  @retval EFI_NOT_FOUND           The EAP configuration data is not found.
+  @retval EFI_BUFFER_TOO_SMALL    The buffer is too small to hold the buffer.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_CONFIGURATION_GET_DATA) (
+  IN EFI_EAP_CONFIGURATION_PROTOCOL       *This,
+  IN EFI_EAP_TYPE                         EapType,
+  IN EFI_EAP_CONFIG_DATA_TYPE             DataType,
+  IN OUT VOID                             *Data,
+  IN OUT UINTN                            *DataSize
+  );
+
+///
+/// The EFI_EAP_CONFIGURATION_PROTOCOL
+/// is designed to provide a way to set and get EAP configuration, such as Certificate,
+/// private key file.
+///
+struct _EFI_EAP_CONFIGURATION_PROTOCOL {
+  EFI_EAP_CONFIGURATION_SET_DATA          SetData;
+  EFI_EAP_CONFIGURATION_GET_DATA          GetData;
+};
+
+extern EFI_GUID gEfiEapConfigurationProtocolGuid;
+
+#endif
\ No newline at end of file
diff --git a/MdePkg/Include/Protocol/EapManagement.h b/MdePkg/Include/Protocol/EapManagement.h
new file mode 100644
index 000000000000..8fe4afb2a17d
--- /dev/null
+++ b/MdePkg/Include/Protocol/EapManagement.h
@@ -0,0 +1,403 @@
+/** @file
+  EFI EAP Management Protocol Definition
+  The EFI EAP Management Protocol is designed to provide ease of management and
+  ease of test for EAPOL state machine. It is intended for the supplicant side. 
+  It conforms to IEEE 802.1x specification. 
+  The definitions in this file are defined in UEFI Specification 2.2, which have
+  not been verified by one implementation yet.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_EAP_MANAGEMENT_PROTOCOL_H__
+#define __EFI_EAP_MANAGEMENT_PROTOCOL_H__
+
+#include <Protocol/Eap.h>
+
+#define EFI_EAP_MANAGEMENT_PROTOCOL_GUID \
+  { \
+    0xbb62e663, 0x625d, 0x40b2, {0xa0, 0x88, 0xbb, 0xe8, 0x36, 0x23, 0xa2, 0x45 } \
+  }
+
+typedef struct _EFI_EAP_MANAGEMENT_PROTOCOL EFI_EAP_MANAGEMENT_PROTOCOL;
+
+///
+/// PAE Capabilities
+///
+///@{
+#define PAE_SUPPORT_AUTHENTICATOR       0x01
+#define PAE_SUPPORT_SUPPLICANT          0x02
+///@}
+
+///
+/// EFI_EAPOL_PORT_INFO
+///
+typedef struct _EFI_EAPOL_PORT_INFO {      
+  /// 
+  /// The identification number assigned to the Port by the System in 
+  /// which the Port resides.
+  /// 
+  EFI_PORT_HANDLE     PortNumber;
+  /// 
+  /// The protocol version number of the EAPOL implementation 
+  /// supported by the Port. 
+  /// 
+  UINT8               ProtocolVersion;
+  /// 
+  /// The capabilities of the PAE associated with the Port. This field 
+  /// indicates whether Authenticator functionality, Supplicant 
+  /// functionality, both, or neither, is supported by the Port's PAE.
+  /// 
+  UINT8               PaeCapabilities;
+} EFI_EAPOL_PORT_INFO;
+
+///
+/// Supplicant PAE state machine (IEEE Std 802.1X Section 8.5.10)
+///
+typedef enum _EFI_EAPOL_SUPPLICANT_PAE_STATE {
+  Logoff,
+  Disconnected,
+  Connecting,
+  Acquired,
+  Authenticating,
+  Held,
+  Authenticated,
+  MaxSupplicantPaeState
+} EFI_EAPOL_SUPPLICANT_PAE_STATE;
+
+///
+/// Definitions for ValidFieldMask 
+///
+///@{
+#define AUTH_PERIOD_FIELD_VALID       0x01
+#define HELD_PERIOD_FIELD_VALID       0x02
+#define START_PERIOD_FIELD_VALID      0x04
+#define MAX_START_FIELD_VALID         0x08
+///@}
+
+///
+/// EFI_EAPOL_SUPPLICANT_PAE_CONFIGURATION
+///
+typedef struct _EFI_EAPOL_SUPPLICANT_PAE_CONFIGURATION {
+  /// 
+  /// Indicates which of the following fields are valid.
+  /// 
+  UINT8       ValidFieldMask;  
+  ///
+  /// The initial value for the authWhile timer. Its default value is 30s.
+  ///
+  UINTN       AuthPeriod;   
+  ///
+  /// The initial value for the heldWhile timer. Its default value is 60s. 
+  ///
+  UINTN       HeldPeriod;    
+  ///
+  /// The initial value for the startWhen timer. Its default value is 30s. 
+  ///
+  UINTN       StartPeriod;    
+  ///   
+  /// The maximum number of successive EAPOL-Start messages will 
+  /// be sent before the Supplicant assumes that there is no 
+  /// Authenticator present. Its default value is 3.
+  /// 
+  UINTN       MaxStart;
+} EFI_EAPOL_SUPPLICANT_PAE_CONFIGURATION;
+
+///
+/// Supplicant Statistics (IEEE Std 802.1X Section 9.5.2)
+///
+typedef struct _EFI_EAPOL_SUPPLICANT_PAE_STATISTICS {
+  ///
+  /// The number of EAPOL frames of any type that have been received by this Supplican.
+  /// 
+  UINTN     EapolFramesReceived;
+  ///
+  /// The number of EAPOL frames of any type that have been transmitted by this Supplicant. 
+  ///
+  UINTN     EapolFramesTransmitted;
+  /// 
+  /// The number of EAPOL Start frames that have been transmitted by this Supplicant. 
+  /// 
+  UINTN     EapolStartFramesTransmitted;
+  /// 
+  /// The number of EAPOL Logoff frames that have been transmitted by this Supplicant.
+  ///
+  UINTN     EapolLogoffFramesTransmitted;
+  ///
+  /// The number of EAP Resp/Id frames that have been transmitted by this Supplicant.
+  ///
+  UINTN     EapRespIdFramesTransmitted;
+  ///   
+  /// The number of valid EAP Response frames (other than Resp/Id frames) that have been 
+  /// transmitted by this Supplicant.
+  ///
+  UINTN     EapResponseFramesTransmitted;
+  /// 
+  /// The number of EAP Req/Id frames that have been received by this Supplicant.
+  /// 
+  UINTN     EapReqIdFramesReceived;
+  ///
+  /// The number of EAP Request frames (other than Rq/Id frames) that have been received 
+  /// by this Supplicant.
+  ///
+  UINTN     EapRequestFramesReceived;
+  ///
+  /// The number of EAPOL frames that have been received by this Supplicant in which the 
+  /// frame type is not recognized.
+  ///
+  UINTN     InvalidEapolFramesReceived;
+  /// 
+  /// The number of EAPOL frames that have been received by this Supplicant in which the 
+  /// Packet Body Length field (7.5.5) is invalid.
+  /// 
+  UINTN     EapLengthErrorFramesReceived;
+  /// 
+  /// The protocol version number carried in the most recently received EAPOL frame.
+  /// 
+  UINTN     LastEapolFrameVersion;
+  /// 
+  /// The source MAC address carried in the most recently received EAPOL frame.
+  /// 
+  UINTN     LastEapolFrameSource;
+} EFI_EAPOL_SUPPLICANT_PAE_STATISTICS;
+
+/**
+  Read the system configuration information associated with the Port. 
+
+  The GetSystemConfiguration() function reads the system configuration
+  information associated with the Port, including the value of the 
+  SystemAuthControl parameter of the System is returned in SystemAuthControl
+  and the Port's information is returned in the buffer pointed to by PortInfo.
+  The Port's information is optional. 
+  If PortInfo is NULL, then reading the Port's information is ignored.
+
+  If SystemAuthControl is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in]  This               A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+  @param[out] SystemAuthControl  Returns the value of the SystemAuthControl
+                                 parameter of the System. 
+                                 TRUE means Enabled. FALSE means Disabled.
+  @param[out] PortInfo           Returns EFI_EAPOL_PORT_INFO structure to describe
+                                 the Port's information. This parameter can be NULL
+                                 to ignore reading the Port's information.
+
+  @retval EFI_SUCCESS            The system configuration information of the
+                                 Port is read successfully.
+  @retval EFI_INVALID_PARAMETER  SystemAuthControl is NULL.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_GET_SYSTEM_CONFIGURATION)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL          *This, 
+  OUT BOOLEAN                             *SystemAuthControl, 
+  OUT EFI_EAPOL_PORT_INFO                 *PortInfo OPTIONAL
+  );
+
+/**
+  Set the system configuration information associated with the Port. 
+
+  The SetSystemConfiguration() function sets the value of the SystemAuthControl 
+  parameter of the System to SystemAuthControl.
+
+  @param[in] This                A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+  @param[in] SystemAuthControl   The desired value of the SystemAuthControl 
+                                 parameter of the System. 
+                                 TRUE means Enabled. FALSE means Disabled.
+
+  @retval EFI_SUCCESS            The system configuration information of the
+                                 Port is set successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_SET_SYSTEM_CONFIGURATION)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL          *This, 
+  IN BOOLEAN                              SystemAuthControl
+  );
+
+/**
+  Cause the EAPOL state machines for the Port to be initialized.
+
+  The InitializePort() function causes the EAPOL state machines for the Port.
+
+  @param[in] This                A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+
+  @retval EFI_SUCCESS            The Port is initialized successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_INITIALIZE_PORT)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL            *This
+  );
+
+/**
+  Notify the EAPOL state machines for the Port that the user of the System has
+  logged on.
+
+  The UserLogon() function notifies the EAPOL state machines for the Port.
+
+  @param[in] This                A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+
+  @retval EFI_SUCCESS            The Port is notified successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_USER_LOGON)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL          *This
+  );
+
+/**
+  Notify the EAPOL state machines for the Port that the user of the System has 
+  logged off.
+
+  The UserLogoff() function notifies the EAPOL state machines for the Port.
+
+  @param[in] This                A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+
+  @retval EFI_SUCCESS            The Port is notified successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_USER_LOGOFF)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL          *This
+  );
+
+/**
+  Read the status of the Supplicant PAE state machine for the Port, including the
+  current state and the configuration of the operational parameters.
+
+  The GetSupplicantStatus() function reads the status of the Supplicant PAE state
+  machine for the Port, including the current state CurrentState  and the configuration
+  of the operational parameters Configuration. The configuration of the operational
+  parameters is optional. If Configuration is NULL, then reading the configuration 
+  is ignored. The operational parameters in Configuration to be read can also be 
+  specified by Configuration.ValidFieldMask.
+
+  If CurrentState is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in]      This           A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+  @param[out]     CurrentState   Returns the current state of the Supplicant PAE
+                                 state machine for the Port.
+  @param[in, out] Configuration  Returns the configuration of the operational
+                                 parameters of the Supplicant PAE state machine
+                                 for the Port as required. This parameter can be
+                                 NULL to ignore reading the configuration. 
+                                 On input, Configuration.ValidFieldMask specifies the 
+                                 operational parameters to be read.
+                                 On output, Configuration returns the configuration
+                                 of the required operational parameters. 
+
+  @retval EFI_SUCCESS            The configuration of the operational parameter
+                                 of the Supplicant PAE state machine for the Port
+                                 is set successfully.
+  @retval EFI_INVALID_PARAMETER  CurrentState is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_GET_SUPPLICANT_STATUS)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL                  *This, 
+  OUT EFI_EAPOL_SUPPLICANT_PAE_STATE              *CurrentState, 
+  IN OUT EFI_EAPOL_SUPPLICANT_PAE_CONFIGURATION   *Configuration  OPTIONAL
+  );
+
+/**
+  Set the configuration of the operational parameter of the Supplicant PAE 
+  state machine for the Port.
+
+  The SetSupplicantConfiguration() function sets the configuration of the 
+  operational Parameter of the Supplicant PAE state machine for the Port to
+  Configuration. The operational parameters in Configuration to be set can be
+  specified by Configuration.ValidFieldMask.
+
+  If Configuration is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in] This                A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+  @param[in] Configuration       The desired configuration of the operational 
+                                 parameters of the Supplicant PAE state machine
+                                 for the Port as required.
+
+  @retval EFI_SUCCESS            The configuration of the operational parameter
+                                 of the Supplicant PAE state machine for the Port
+                                 is set successfully.
+  @retval EFI_INVALID_PARAMETER  Configuration is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_SET_SUPPLICANT_CONFIGURATION)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL              *This, 
+  IN EFI_EAPOL_SUPPLICANT_PAE_CONFIGURATION   *Configuration
+  );
+
+/**
+  Read the statistical information regarding the operation of the Supplicant
+  associated with the Port. 
+
+  The GetSupplicantStatistics() function reads the statistical information 
+  Statistics regarding the operation of the Supplicant associated with the Port.
+  
+  If Statistics is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in]  This               A pointer to the EFI_EAP_MANAGEMENT_PROTOCOL
+                                 instance that indicates the calling context.
+  @param[out] Statistics         Returns the statistical information regarding the 
+                                 operation of the Supplicant for the Port. 
+
+  @retval EFI_SUCCESS            The statistical information regarding the operation
+                                 of the Supplicant for the Port is read successfully.
+  @retval EFI_INVALID_PARAMETER  Statistics is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_GET_SUPPLICANT_STATISTICS)(
+  IN EFI_EAP_MANAGEMENT_PROTOCOL              *This, 
+  OUT EFI_EAPOL_SUPPLICANT_PAE_STATISTICS     *Statistics
+  );
+
+///
+/// EFI_EAP_MANAGEMENT_PROTOCOL 
+/// is used to control, configure and monitor EAPOL state machine on
+/// a Port. EAPOL state machine is built on a per-Port basis. Herein,
+/// a Port means a NIC. For the details of EAPOL, please refer to 
+/// IEEE 802.1x specification.
+///
+struct _EFI_EAP_MANAGEMENT_PROTOCOL {
+  EFI_EAP_GET_SYSTEM_CONFIGURATION        GetSystemConfiguration;
+  EFI_EAP_SET_SYSTEM_CONFIGURATION        SetSystemConfiguration;
+  EFI_EAP_INITIALIZE_PORT                 InitializePort;
+  EFI_EAP_USER_LOGON                      UserLogon;
+  EFI_EAP_USER_LOGOFF                     UserLogoff;
+  EFI_EAP_GET_SUPPLICANT_STATUS           GetSupplicantStatus;
+  EFI_EAP_SET_SUPPLICANT_CONFIGURATION    SetSupplicantConfiguration;
+  EFI_EAP_GET_SUPPLICANT_STATISTICS       GetSupplicantStatistics;
+};
+
+extern EFI_GUID gEfiEapManagementProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/EapManagement2.h b/MdePkg/Include/Protocol/EapManagement2.h
new file mode 100644
index 000000000000..d1e5981d0374
--- /dev/null
+++ b/MdePkg/Include/Protocol/EapManagement2.h
@@ -0,0 +1,87 @@
+/** @file
+  This file defines the EFI EAP Management2 protocol.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_EAP_MANAGEMENT2_PROTOCOL_H__
+#define __EFI_EAP_MANAGEMENT2_PROTOCOL_H__
+
+#include <Protocol/EapManagement.h>
+
+///
+/// This EFI EAP Management2 protocol provides the ability to configure and control EAPOL
+/// state machine, and retrieve the information, status and the statistics information of
+/// EAPOL state machine.
+///
+#define EFI_EAP_MANAGEMENT2_PROTOCOL_GUID \
+  { \
+    0x5e93c847, 0x456d, 0x40b3, {0xa6, 0xb4, 0x78, 0xb0, 0xc9, 0xcf, 0x7f, 0x20 } \
+  }
+
+typedef struct _EFI_EAP_MANAGEMENT2_PROTOCOL EFI_EAP_MANAGEMENT2_PROTOCOL;
+
+/**
+  Return key generated through EAP process.
+
+  The GetKey() function return the key generated through EAP process, so that the 802.11
+  MAC layer driver can use MSK to derive more keys, e.g. PMK (Pairwise Master Key).
+
+  @param[in]       This           Pointer to the EFI_EAP_MANAGEMENT2_PROTOCOL instance.
+  @param[in, out]  Msk            Pointer to MSK (Master Session Key) buffer.
+  @param[in, out]  MskSize        MSK buffer size.
+  @param[in, out]  Emsk           Pointer to EMSK (Extended Master Session Key) buffer.
+  @param[in, out]  EmskSize       EMSK buffer size.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  Msk is NULL.
+                                  MskSize is NULL.
+                                  Emsk is NULL.
+                                  EmskSize is NULL.
+  @retval EFI_NOT_READY           MSK and EMSK are not generated in current session yet.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EAP_GET_KEY) (
+  IN EFI_EAP_MANAGEMENT2_PROTOCOL         *This,
+  IN OUT UINT8                            *Msk,
+  IN OUT UINTN                            *MskSize,
+  IN OUT UINT8                            *Emsk,
+  IN OUT UINT8                            *EmskSize
+  );
+
+///
+/// The EFI_EAP_MANAGEMENT2_PROTOCOL
+/// is used to control, configure and monitor EAPOL state machine on a Port, and return
+/// information of the Port. EAPOL state machine is built on a per-Port basis. Herein, a
+/// Port means a NIC. For the details of EAPOL, please refer to IEEE 802.1x
+/// specification.
+///
+struct _EFI_EAP_MANAGEMENT2_PROTOCOL {
+  EFI_EAP_GET_SYSTEM_CONFIGURATION        GetSystemConfiguration;
+  EFI_EAP_SET_SYSTEM_CONFIGURATION        SetSystemConfiguration;
+  EFI_EAP_INITIALIZE_PORT                 InitializePort;
+  EFI_EAP_USER_LOGON                      UserLogon;
+  EFI_EAP_USER_LOGOFF                     UserLogoff;
+  EFI_EAP_GET_SUPPLICANT_STATUS           GetSupplicantStatus;
+  EFI_EAP_SET_SUPPLICANT_CONFIGURATION    SetSupplicantConfiguration;
+  EFI_EAP_GET_SUPPLICANT_STATISTICS       GetSupplicantStatistics;
+  EFI_EAP_GET_KEY                         GetKey;
+};
+
+extern EFI_GUID gEfiEapManagement2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Ebc.h b/MdePkg/Include/Protocol/Ebc.h
new file mode 100644
index 000000000000..dd6320d61cf4
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ebc.h
@@ -0,0 +1,314 @@
+/** @file
+  Describes the protocol interface to the EBC interpreter.
+
+  Copyright (c) 2006 - 2008, 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 __EFI_EBC_PROTOCOL_H__
+#define __EFI_EBC_PROTOCOL_H__
+
+#define EFI_EBC_INTERPRETER_PROTOCOL_GUID \
+  { \
+    0x13AC6DD1, 0x73D0, 0x11D4, {0xB0, 0x6B, 0x00, 0xAA, 0x00, 0xBD, 0x6D, 0xE7 } \
+  }
+
+//
+// Define OPCODES
+//
+#define OPCODE_BREAK    0x00
+#define OPCODE_JMP      0x01
+#define OPCODE_JMP8     0x02
+#define OPCODE_CALL     0x03
+#define OPCODE_RET      0x04
+#define OPCODE_CMPEQ    0x05
+#define OPCODE_CMPLTE   0x06
+#define OPCODE_CMPGTE   0x07
+#define OPCODE_CMPULTE  0x08
+#define OPCODE_CMPUGTE  0x09
+#define OPCODE_NOT      0x0A
+#define OPCODE_NEG      0x0B
+#define OPCODE_ADD      0x0C
+#define OPCODE_SUB      0x0D
+#define OPCODE_MUL      0x0E
+#define OPCODE_MULU     0x0F
+#define OPCODE_DIV      0x10
+#define OPCODE_DIVU     0x11
+#define OPCODE_MOD      0x12
+#define OPCODE_MODU     0x13
+#define OPCODE_AND      0x14
+#define OPCODE_OR       0x15
+#define OPCODE_XOR      0x16
+#define OPCODE_SHL      0x17
+#define OPCODE_SHR      0x18
+#define OPCODE_ASHR     0x19
+#define OPCODE_EXTNDB   0x1A
+#define OPCODE_EXTNDW   0x1B
+#define OPCODE_EXTNDD   0x1C
+#define OPCODE_MOVBW    0x1D
+#define OPCODE_MOVWW    0x1E
+#define OPCODE_MOVDW    0x1F
+#define OPCODE_MOVQW    0x20
+#define OPCODE_MOVBD    0x21
+#define OPCODE_MOVWD    0x22
+#define OPCODE_MOVDD    0x23
+#define OPCODE_MOVQD    0x24
+#define OPCODE_MOVSNW   0x25  // Move signed natural with word index
+#define OPCODE_MOVSND   0x26  // Move signed natural with dword index
+//
+// #define OPCODE_27         0x27
+//
+#define OPCODE_MOVQQ    0x28  // Does this go away?
+#define OPCODE_LOADSP   0x29
+#define OPCODE_STORESP  0x2A
+#define OPCODE_PUSH     0x2B
+#define OPCODE_POP      0x2C
+#define OPCODE_CMPIEQ   0x2D
+#define OPCODE_CMPILTE  0x2E
+#define OPCODE_CMPIGTE  0x2F
+#define OPCODE_CMPIULTE 0x30
+#define OPCODE_CMPIUGTE 0x31
+#define OPCODE_MOVNW    0x32
+#define OPCODE_MOVND    0x33
+//
+// #define OPCODE_34         0x34
+//
+#define OPCODE_PUSHN  0x35
+#define OPCODE_POPN   0x36
+#define OPCODE_MOVI   0x37
+#define OPCODE_MOVIN  0x38
+#define OPCODE_MOVREL 0x39
+
+//
+// Bit masks for opcode encodings
+//
+#define OPCODE_M_OPCODE       0x3F  // bits of interest for first level decode
+#define OPCODE_M_IMMDATA      0x80
+#define OPCODE_M_IMMDATA64    0x40
+#define OPCODE_M_64BIT        0x40  // for CMP
+#define OPCODE_M_RELADDR      0x10  // for CALL instruction
+#define OPCODE_M_CMPI32_DATA  0x80  // for CMPI
+#define OPCODE_M_CMPI64       0x40  // for CMPI 32 or 64 bit comparison
+#define OPERAND_M_MOVIN_N     0x80
+#define OPERAND_M_CMPI_INDEX  0x10
+
+//
+// Masks for instructions that encode presence of indexes for operand1 and/or
+// operand2.
+//
+#define OPCODE_M_IMMED_OP1  0x80
+#define OPCODE_M_IMMED_OP2  0x40
+
+//
+// Bit masks for operand encodings
+//
+#define OPERAND_M_INDIRECT1 0x08
+#define OPERAND_M_INDIRECT2 0x80
+#define OPERAND_M_OP1       0x07
+#define OPERAND_M_OP2       0x70
+
+//
+// Masks for data manipulation instructions
+//
+#define DATAMANIP_M_64      0x40  // 64-bit width operation
+#define DATAMANIP_M_IMMDATA 0x80
+
+//
+// For MOV instructions, need a mask for the opcode when immediate
+// data applies to R2.
+//
+#define OPCODE_M_IMMED_OP2  0x40
+
+//
+// The MOVI/MOVIn instructions use bit 6 of operands byte to indicate
+// if an index is present. Then bits 4 and 5 are used to indicate the width
+// of the move.
+//
+#define MOVI_M_IMMDATA    0x40
+#define MOVI_M_DATAWIDTH  0xC0
+#define MOVI_DATAWIDTH16  0x40
+#define MOVI_DATAWIDTH32  0x80
+#define MOVI_DATAWIDTH64  0xC0
+#define MOVI_M_MOVEWIDTH  0x30
+#define MOVI_MOVEWIDTH8   0x00
+#define MOVI_MOVEWIDTH16  0x10
+#define MOVI_MOVEWIDTH32  0x20
+#define MOVI_MOVEWIDTH64  0x30
+
+//
+// Masks for CALL instruction encodings
+//
+#define OPERAND_M_RELATIVE_ADDR 0x10
+#define OPERAND_M_NATIVE_CALL   0x20
+
+//
+// Masks for decoding push/pop instructions
+//
+#define PUSHPOP_M_IMMDATA 0x80  // opcode bit indicating immediate data
+#define PUSHPOP_M_64      0x40  // opcode bit indicating 64-bit operation
+//
+// Mask for operand of JMP instruction
+//
+#define JMP_M_RELATIVE    0x10
+#define JMP_M_CONDITIONAL 0x80
+#define JMP_M_CS          0x40
+
+//
+// Macros to determine if a given operand is indirect
+//
+#define OPERAND1_INDIRECT(op) ((op) & OPERAND_M_INDIRECT1)
+#define OPERAND2_INDIRECT(op) ((op) & OPERAND_M_INDIRECT2)
+
+//
+// Macros to extract the operands from second byte of instructions
+//
+#define OPERAND1_REGNUM(op)       ((op) & OPERAND_M_OP1)
+#define OPERAND2_REGNUM(op)       (((op) & OPERAND_M_OP2) >> 4)
+
+#define OPERAND1_CHAR(op)         ('0' + OPERAND1_REGNUM (op))
+#define OPERAND2_CHAR(op)         ('0' + OPERAND2_REGNUM (op))
+
+//
+// Condition masks usually for byte 1 encodings of code
+//
+#define CONDITION_M_CONDITIONAL 0x80
+#define CONDITION_M_CS          0x40
+
+///
+/// Protocol Guid Name defined in spec.
+///
+#define EFI_EBC_PROTOCOL_GUID EFI_EBC_INTERPRETER_PROTOCOL_GUID
+
+///
+/// Define for forward reference.
+///
+typedef struct _EFI_EBC_PROTOCOL EFI_EBC_PROTOCOL;
+
+/**
+  Creates a thunk for an EBC entry point, returning the address of the thunk.
+  
+  A PE32+ EBC image, like any other PE32+ image, contains an optional header that specifies the
+  entry point for image execution. However, for EBC images, this is the entry point of EBC
+  instructions, so is not directly executable by the native processor. Therefore, when an EBC image is
+  loaded, the loader must call this service to get a pointer to native code (thunk) that can be executed,
+  which will invoke the interpreter to begin execution at the original EBC entry point.
+
+  @param  This          A pointer to the EFI_EBC_PROTOCOL instance.
+  @param  ImageHandle   Handle of image for which the thunk is being created.
+  @param  EbcEntryPoint Address of the actual EBC entry point or protocol service the thunk should call.
+  @param  Thunk         Returned pointer to a thunk created.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_INVALID_PARAMETER  Image entry point is not 2-byte aligned.
+  @retval EFI_OUT_OF_RESOURCES   Memory could not be allocated for the thunk.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EBC_CREATE_THUNK)(
+  IN EFI_EBC_PROTOCOL           *This,
+  IN EFI_HANDLE                 ImageHandle,
+  IN VOID                       *EbcEntryPoint,
+  OUT VOID                      **Thunk
+  );
+
+/**
+  Called prior to unloading an EBC image from memory.
+
+  This function is called after an EBC image has exited, but before the image is actually unloaded. It
+  is intended to provide the interpreter with the opportunity to perform any cleanup that may be
+  necessary as a result of loading and executing the image.
+
+  @param  This          A pointer to the EFI_EBC_PROTOCOL instance.
+  @param  ImageHandle   Image handle of the EBC image that is being unloaded from memory.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_INVALID_PARAMETER  Image handle is not recognized as belonging 
+                                 to an EBC image that has been executed.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EBC_UNLOAD_IMAGE)(
+  IN EFI_EBC_PROTOCOL           *This,
+  IN EFI_HANDLE                 ImageHandle
+  );
+
+/**
+  This is the prototype for the Flush callback routine. A pointer to a routine 
+  of this type is passed to the EBC EFI_EBC_REGISTER_ICACHE_FLUSH protocol service.
+
+  @param  Start  The beginning physical address to flush from the processor's instruction cache.
+  @param  Length The number of bytes to flush from the processor's instruction cache.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EBC_ICACHE_FLUSH)(
+  IN EFI_PHYSICAL_ADDRESS     Start,
+  IN UINT64                   Length
+  );
+
+/**
+  Registers a callback function that the EBC interpreter calls to flush 
+  the processor instruction cache following creation of thunks.
+
+  @param  This       A pointer to the EFI_EBC_PROTOCOL instance.
+  @param  Flush      Pointer to a function of type EBC_ICACH_FLUSH.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EBC_REGISTER_ICACHE_FLUSH)(
+  IN EFI_EBC_PROTOCOL           *This,
+  IN EBC_ICACHE_FLUSH           Flush
+  );
+
+/**
+  Called to get the version of the interpreter.
+
+  This function is called to get the version of the loaded EBC interpreter. The value and format of the
+  returned version is identical to that returned by the EBC BREAK 1 instruction.
+
+  @param  This       A pointer to the EFI_EBC_PROTOCOL instance.  
+  @param  Version    Pointer to where to store the returned version of the interpreter.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_INVALID_PARAMETER  Version pointer is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EBC_GET_VERSION)(
+  IN EFI_EBC_PROTOCOL           *This,
+  IN OUT UINT64                 *Version
+  );
+
+///
+/// The EFI EBC protocol provides services to load and execute EBC images, which will typically be
+/// loaded into option ROMs. The image loader will load the EBC image, perform standard relocations,
+/// and invoke the CreateThunk() service to create a thunk for the EBC image's entry point. The
+/// image can then be run using the standard EFI start image services.
+///
+struct _EFI_EBC_PROTOCOL {
+  EFI_EBC_CREATE_THUNK          CreateThunk;
+  EFI_EBC_UNLOAD_IMAGE          UnloadImage;
+  EFI_EBC_REGISTER_ICACHE_FLUSH RegisterICacheFlush;
+  EFI_EBC_GET_VERSION           GetVersion;
+};
+
+//
+// Extern the global EBC protocol GUID
+//
+extern EFI_GUID gEfiEbcProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/EdidActive.h b/MdePkg/Include/Protocol/EdidActive.h
new file mode 100644
index 000000000000..8e1ec8426288
--- /dev/null
+++ b/MdePkg/Include/Protocol/EdidActive.h
@@ -0,0 +1,52 @@
+/** @file
+  EDID Active Protocol from the UEFI 2.0 specification.
+
+  Placed on the video output device child handle that is actively displaying output.
+
+  Copyright (c) 2006 - 2012, 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 __EDID_ACTIVE_H__
+#define __EDID_ACTIVE_H__
+
+#define EFI_EDID_ACTIVE_PROTOCOL_GUID \
+  { \
+    0xbd8c1056, 0x9f36, 0x44ec, {0x92, 0xa8, 0xa6, 0x33, 0x7f, 0x81, 0x79, 0x86 } \
+  }
+
+///
+/// This protocol contains the EDID information for an active video output device. This is either the
+/// EDID information retrieved from the EFI_EDID_OVERRIDE_PROTOCOL if an override is
+/// available, or an identical copy of the EDID information from the
+/// EFI_EDID_DISCOVERED_PROTOCOL if no overrides are available.
+///
+typedef struct {
+  ///
+  /// The size, in bytes, of the Edid buffer. 0 if no EDID information
+  /// is available from the video output device. Otherwise, it must be a
+  /// minimum of 128 bytes.
+  ///
+  UINT32   SizeOfEdid;
+
+  ///
+  /// A pointer to a read-only array of bytes that contains the EDID
+  /// information for an active video output device. This pointer is
+  /// NULL if no EDID information is available for the video output
+  /// device. The minimum size of a valid Edid buffer is 128 bytes.
+  /// EDID information is defined in the E-EDID EEPROM
+  /// specification published by VESA (www.vesa.org).
+  ///
+  UINT8    *Edid;
+} EFI_EDID_ACTIVE_PROTOCOL;
+
+extern EFI_GUID gEfiEdidActiveProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/EdidDiscovered.h b/MdePkg/Include/Protocol/EdidDiscovered.h
new file mode 100644
index 000000000000..ccaae1bbb353
--- /dev/null
+++ b/MdePkg/Include/Protocol/EdidDiscovered.h
@@ -0,0 +1,50 @@
+/** @file
+  EDID Discovered Protocol from the UEFI 2.0 specification.
+
+  This protocol is placed on the video output device child handle. It represents
+  the EDID information being used for the output device represented by the child handle.
+
+  Copyright (c) 2006 - 2012, 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 __EDID_DISCOVERED_H__
+#define __EDID_DISCOVERED_H__
+
+#define EFI_EDID_DISCOVERED_PROTOCOL_GUID \
+  { \
+    0x1c0c34f6, 0xd380, 0x41fa, {0xa0, 0x49, 0x8a, 0xd0, 0x6c, 0x1a, 0x66, 0xaa } \
+  }
+
+///
+/// This protocol contains the EDID information retrieved from a video output device.
+///
+typedef struct {
+  ///
+  /// The size, in bytes, of the Edid buffer. 0 if no EDID information
+  /// is available from the video output device. Otherwise, it must be a
+  /// minimum of 128 bytes.
+  ///
+  UINT32   SizeOfEdid;
+  
+  ///
+  /// A pointer to a read-only array of bytes that contains the EDID
+  /// information for an active video output device. This pointer is
+  /// NULL if no EDID information is available for the video output
+  /// device. The minimum size of a valid Edid buffer is 128 bytes.
+  /// EDID information is defined in the E-EDID EEPROM
+  /// specification published by VESA (www.vesa.org).
+  ///  
+  UINT8    *Edid;
+} EFI_EDID_DISCOVERED_PROTOCOL;
+
+extern EFI_GUID gEfiEdidDiscoveredProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/EdidOverride.h b/MdePkg/Include/Protocol/EdidOverride.h
new file mode 100644
index 000000000000..cd847b666d75
--- /dev/null
+++ b/MdePkg/Include/Protocol/EdidOverride.h
@@ -0,0 +1,67 @@
+/** @file
+  EDID Override Protocol from the UEFI 2.0 specification.
+
+  Allow platform to provide EDID information to the producer of the Graphics Output
+  protocol.
+
+  Copyright (c) 2006 - 2008, 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 __EDID_OVERRIDE_H__
+#define __EDID_OVERRIDE_H__
+
+#define EFI_EDID_OVERRIDE_PROTOCOL_GUID \
+  { \
+    0x48ecb431, 0xfb72, 0x45c0, {0xa9, 0x22, 0xf4, 0x58, 0xfe, 0x4, 0xb, 0xd5 } \
+  }
+
+typedef struct _EFI_EDID_OVERRIDE_PROTOCOL EFI_EDID_OVERRIDE_PROTOCOL;
+
+#define EFI_EDID_OVERRIDE_DONT_OVERRIDE   0x01
+#define EFI_EDID_OVERRIDE_ENABLE_HOT_PLUG 0x02
+
+/**
+  Returns policy information and potentially a replacement EDID for the specified video output device.
+
+  @param  This              The EFI_EDID_OVERRIDE_PROTOCOL instance.
+  @param  ChildHandle       A child handle produced by the Graphics Output EFI
+                            driver that represents a video output device.
+  @param  Attributes        The attributes associated with ChildHandle video output device.
+  @param  EdidSize          A pointer to the size, in bytes, of the Edid buffer.
+  @param  Edid              A pointer to callee allocated buffer that contains the EDID that
+                            should be used for ChildHandle. A value of NULL
+                            represents no EDID override for ChildHandle.
+
+  @retval EFI_SUCCESS       Valid overrides returned for ChildHandle.
+  @retval EFI_UNSUPPORTED   ChildHandle has no overrides.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID)(
+  IN  EFI_EDID_OVERRIDE_PROTOCOL          *This,
+  IN  EFI_HANDLE                          *ChildHandle,
+  OUT UINT32                              *Attributes,
+  IN OUT UINTN                            *EdidSize,
+  IN OUT UINT8                            **Edid
+  );
+
+///
+/// This protocol is produced by the platform to allow the platform to provide 
+/// EDID information to the producer of the Graphics Output protocol.
+///
+struct _EFI_EDID_OVERRIDE_PROTOCOL {
+  EFI_EDID_OVERRIDE_PROTOCOL_GET_EDID   GetEdid;
+};
+                                             
+extern EFI_GUID gEfiEdidOverrideProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/EraseBlock.h b/MdePkg/Include/Protocol/EraseBlock.h
new file mode 100644
index 000000000000..d136ccee24a8
--- /dev/null
+++ b/MdePkg/Include/Protocol/EraseBlock.h
@@ -0,0 +1,105 @@
+/** @file
+  This file defines the EFI Erase Block Protocol.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.6
+
+**/
+
+#ifndef __EFI_ERASE_BLOCK_PROTOCOL_H__
+#define __EFI_ERASE_BLOCK_PROTOCOL_H__
+
+#define EFI_ERASE_BLOCK_PROTOCOL_GUID \
+  { \
+    0x95a9a93e, 0xa86e, 0x4926, { 0xaa, 0xef, 0x99, 0x18, 0xe7, 0x72, 0xd9, 0x87 } \
+  }
+
+typedef struct _EFI_ERASE_BLOCK_PROTOCOL EFI_ERASE_BLOCK_PROTOCOL;
+
+#define EFI_ERASE_BLOCK_PROTOCOL_REVISION ((2<<16) | (60))
+
+///
+/// EFI_ERASE_BLOCK_TOKEN
+///
+typedef struct {
+  //
+  // If Event is NULL, then blocking I/O is performed. If Event is not NULL and
+  // non-blocking I/O is supported, then non-blocking I/O is performed, and
+  // Event will be signaled when the erase request is completed.
+  //
+  EFI_EVENT             Event;
+  //
+  // Defines whether the signaled event encountered an error.
+  //
+  EFI_STATUS            TransactionStatus;
+} EFI_ERASE_BLOCK_TOKEN;
+
+/**
+  Erase a specified number of device blocks.
+
+  @param[in]       This           Indicates a pointer to the calling context.
+  @param[in]       MediaId        The media ID that the erase request is for.
+  @param[in]       LBA            The starting logical block address to be
+                                  erased. The caller is responsible for erasing
+                                  only legitimate locations.
+  @param[in, out]  Token          A pointer to the token associated with the
+                                  transaction.
+  @param[in]       Size           The size in bytes to be erased. This must be
+                                  a multiple of the physical block size of the
+                                  device.
+
+  @retval EFI_SUCCESS             The erase request was queued if Event is not
+                                  NULL. The data was erased correctly to the
+                                  device if the Event is NULL.to the device.
+  @retval EFI_WRITE_PROTECTED     The device cannot be erased due to write
+                                  protection.
+  @retval EFI_DEVICE_ERROR        The device reported an error while attempting
+                                  to perform the erase operation.
+  @retval EFI_INVALID_PARAMETER   The erase request contains LBAs that are not
+                                  valid.
+  @retval EFI_NO_MEDIA            There is no media in the device.
+  @retval EFI_MEDIA_CHANGED       The MediaId is not for the current media.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BLOCK_ERASE) (
+  IN     EFI_ERASE_BLOCK_PROTOCOL      *This,
+  IN     UINT32                        MediaId,
+  IN     EFI_LBA                       LBA,
+  IN OUT EFI_ERASE_BLOCK_TOKEN         *Token,
+  IN     UINTN                         Size
+  );
+
+///
+/// The EFI Erase Block Protocol provides the ability for a device to expose
+/// erase functionality. This optional protocol is installed on the same handle
+/// as the EFI_BLOCK_IO_PROTOCOL or EFI_BLOCK_IO2_PROTOCOL.
+///
+struct _EFI_ERASE_BLOCK_PROTOCOL {
+  //
+  // The revision to which the EFI_ERASE_BLOCK_PROTOCOL adheres. All future
+  // revisions must be backwards compatible. If a future version is not
+  // backwards compatible, it is not the same GUID.
+  //
+  UINT64                     Revision;
+  //
+  // Returns the erase length granularity as a number of logical blocks. A
+  // value of 1 means the erase granularity is one logical block.
+  //
+  UINT32                     EraseLengthGranularity;
+  EFI_BLOCK_ERASE            EraseBlocks;
+};
+
+extern EFI_GUID gEfiEraseBlockProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ExtendedSalBootService.h b/MdePkg/Include/Protocol/ExtendedSalBootService.h
new file mode 100644
index 000000000000..167201d85a95
--- /dev/null
+++ b/MdePkg/Include/Protocol/ExtendedSalBootService.h
@@ -0,0 +1,214 @@
+/** @file
+  Definition of Extended SAL Boot Service Protocol
+
+  The Extended SAL Boot Service Protocol provides a mechanisms for platform specific 
+  drivers to update the SAL System Table and register Extended SAL Procedures that are
+  callable in physical or virtual mode using the SAL calling convention.
+
+  Copyright (c) 2009 - 2010, 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 _EXTENDED_SAL_BOOT_SERVICE_PROTOCOL_H_
+#define _EXTENDED_SAL_BOOT_SERVICE_PROTOCOL_H_
+
+#include <IndustryStandard/Sal.h>
+
+#define EXTENDED_SAL_BOOT_SERVICE_PROTOCOL_GUID   \
+  { 0xde0ee9a4, 0x3c7a, 0x44f2, {0xb7, 0x8b, 0xe3, 0xcc, 0xd6, 0x9c, 0x3a, 0xf7 } }
+
+typedef struct _EXTENDED_SAL_BOOT_SERVICE_PROTOCOL EXTENDED_SAL_BOOT_SERVICE_PROTOCOL;
+
+/**
+  Adds platform specific information to the to the header of the SAL System Table.
+
+  @param  This                  A pointer to the EXTENDED_SAL_BOOT_SERVICE_PROTOCOL instance.
+  @param  SalAVersion           Version of recovery SAL PEIM(s) in BCD format. Higher byte contains
+                                the major revision and the lower byte contains the minor revision.
+  @param  SalBVersion           Version of DXE SAL Driver in BCD format. Higher byte contains
+                                the major revision and the lower byte contains the minor revision.
+  @param  OemId                 A pointer to a Null-terminated ASCII string that contains OEM unique string.
+                                The string cannot be longer than 32 bytes in total length
+  @param  ProductId             A pointer to a Null-terminated ASCII string that uniquely identifies a family of 
+                                compatible products. The string cannot be longer than 32 bytes in total length.
+
+  @retval EFI_SUCCESS           The SAL System Table header was updated successfully.
+  @retval EFI_INVALID_PARAMETER OemId is NULL.
+  @retval EFI_INVALID_PARAMETER ProductId is NULL.
+  @retval EFI_INVALID_PARAMETER The length of OemId is greater than 32 characters.
+  @retval EFI_INVALID_PARAMETER The length of ProductId is greater than 32 characters.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EXTENDED_SAL_ADD_SST_INFO)(
+  IN EXTENDED_SAL_BOOT_SERVICE_PROTOCOL  *This,
+  IN UINT16                              SalAVersion,
+  IN UINT16                              SalBVersion,
+  IN CHAR8                               *OemId,
+  IN CHAR8                               *ProductId
+  );
+
+/**
+  Adds an entry to the SAL System Table.
+
+  This function adds the SAL System Table Entry specified by TableEntry and EntrySize
+  to the SAL System Table.
+
+  @param  This         A pointer to the EXTENDED_SAL_BOOT_SERVICE_PROTOCOL instance.
+  @param  TableEntry   Pointer to a buffer containing a SAL System Table entry that is EntrySize bytes 
+                       in length. The first byte of the TableEntry describes the type of entry.
+  @param  EntrySize    The size, in bytes, of TableEntry.
+
+  @retval EFI_SUCCESSThe        SAL System Table was updated successfully.
+  @retval EFI_INVALID_PARAMETER TableEntry is NULL.
+  @retval EFI_INVALID_PARAMETER TableEntry specifies an invalid entry type.
+  @retval EFI_INVALID_PARAMETER EntrySize is not valid for this type of entry.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EXTENDED_SAL_ADD_SST_ENTRY)(
+  IN EXTENDED_SAL_BOOT_SERVICE_PROTOCOL  *This,
+  IN UINT8                               *TableEntry,
+  IN UINTN                               EntrySize
+  );
+
+/**
+  Internal ESAL procedures.
+
+  This is prototype of internal Extended SAL procedures, which is registerd by
+  EXTENDED_SAL_REGISTER_INTERNAL_PROC service.
+
+  @param  FunctionId         The Function ID associated with this Extended SAL Procedure.
+  @param  Arg2               Second argument to the Extended SAL procedure.
+  @param  Arg3               Third argument to the Extended SAL procedure.
+  @param  Arg4               Fourth argument to the Extended SAL procedure.
+  @param  Arg5               Fifth argument to the Extended SAL procedure.
+  @param  Arg6               Sixth argument to the Extended SAL procedure.
+  @param  Arg7               Seventh argument to the Extended SAL procedure.
+  @param  Arg8               Eighth argument to the Extended SAL procedure.
+  @param  VirtualMode        TRUE if the Extended SAL Procedure is being invoked in virtual mode.
+                             FALSE if the Extended SAL Procedure is being invoked in physical mode.
+  @param  ModuleGlobal       A pointer to the global context associated with this Extended SAL Procedure. 
+
+  @return The result returned from the specified Extended SAL Procedure
+
+**/
+typedef
+SAL_RETURN_REGS
+(EFIAPI *SAL_INTERNAL_EXTENDED_SAL_PROC)(
+  IN  UINT64   FunctionId,
+  IN  UINT64   Arg2,
+  IN  UINT64   Arg3,
+  IN  UINT64   Arg4,
+  IN  UINT64   Arg5,
+  IN  UINT64   Arg6,
+  IN  UINT64   Arg7,
+  IN  UINT64   Arg8,
+  IN  BOOLEAN  VirtualMode,
+  IN  VOID     *ModuleGlobal  OPTIONAL
+  ); 
+
+/**
+  Registers an Extended SAL Procedure.
+
+  The Extended SAL Procedure specified by InternalSalProc and named by ClassGuidLo,
+  ClassGuidHi, and FunctionId is added to the set of available Extended SAL Procedures.
+
+  @param  This                   A pointer to the EXTENDED_SAL_BOOT_SERVICE_PROTOCOL instance.
+  @param  ClassGuidLo            The lower 64-bits of  the class GUID for the Extended SAL Procedure being added.  
+                                 Each class GUID contains one or more functions specified by a Function ID.
+  @param  ClassGuidHi            The upper 64-bits of  the class GUID for the Extended SAL Procedure being added.  
+                                 Each class GUID contains one or more functions specified by a Function ID.
+  @param  FunctionId             The Function ID for the Extended SAL Procedure that is being added.  This Function 
+                                 ID is a member of the Extended SAL Procedure class specified by ClassGuidLo 
+                                 and ClassGuidHi.
+  @param  InternalSalProc        A pointer to the Extended SAL Procedure being added.
+  @param  PhysicalModuleGlobal   Pointer to a  module global structure. This is a physical mode pointer.
+                                 This pointer is passed to the Extended SAL Procedure specified by ClassGuidLo, 
+                                 ClassGuidHi, FunctionId, and InternalSalProc.  If the system is in physical mode,
+                                 then this pointer is passed unmodified to InternalSalProc.  If the system is in
+                                 virtual mode, then the virtual address associated with this pointer is passed to
+                                 InternalSalProc.
+
+  @retval EFI_SUCCESS            The Extended SAL Procedure was added.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources available to add the Extended SAL Procedure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EXTENDED_SAL_REGISTER_INTERNAL_PROC)(
+  IN EXTENDED_SAL_BOOT_SERVICE_PROTOCOL  *This,
+  IN UINT64                              ClassGuidLo,
+  IN UINT64                              ClassGuidHi,
+  IN UINT64                              FunctionId,
+  IN SAL_INTERNAL_EXTENDED_SAL_PROC      InternalSalProc,
+  IN VOID                                *PhysicalModuleGlobal  OPTIONAL
+  );
+
+/**
+  Calls a previously registered Extended SAL Procedure.
+
+  This function calls the Extended SAL Procedure specified by ClassGuidLo, ClassGuidHi, 
+  and FunctionId.  The set of previously registered Extended SAL Procedures is searched for a 
+  matching ClassGuidLo, ClassGuidHi, and FunctionId.  If a match is not found, then 
+  EFI_SAL_NOT_IMPLEMENTED is returned.
+
+  @param  ClassGuidLo        The lower 64-bits of the class GUID for the Extended SAL Procedure
+                             that is being called.
+  @param  ClassGuidHi        The upper 64-bits of the class GUID for the Extended SAL Procedure
+                             that is being called.
+  @param  FunctionId         Function ID for the Extended SAL Procedure being called.
+  @param  Arg2               Second argument to the Extended SAL procedure.
+  @param  Arg3               Third argument to the Extended SAL procedure.
+  @param  Arg4               Fourth argument to the Extended SAL procedure.
+  @param  Arg5               Fifth argument to the Extended SAL procedure.
+  @param  Arg6               Sixth argument to the Extended SAL procedure.
+  @param  Arg7               Seventh argument to the Extended SAL procedure.
+  @param  Arg8               Eighth argument to the Extended SAL procedure.
+
+  @retval EFI_SAL_NOT_IMPLEMENTED        The Extended SAL Procedure specified by ClassGuidLo, 
+                                         ClassGuidHi, and FunctionId has not been registered.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before virtual mappings 
+                                         for the specified Extended SAL Procedure are available.
+  @retval Other                          The result returned from the specified Extended SAL Procedure
+
+**/
+typedef
+SAL_RETURN_REGS
+(EFIAPI *EXTENDED_SAL_PROC)(
+  IN UINT64  ClassGuidLo,
+  IN UINT64  ClassGuidHi,
+  IN UINT64  FunctionId,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  );
+
+///
+/// The EXTENDED_SAL_BOOT_SERVICE_PROTOCOL provides a mechanisms for platform specific 
+/// drivers to update the SAL System Table and register Extended SAL Procedures that are
+/// callable in physical or virtual mode using the SAL calling convention.
+///
+struct _EXTENDED_SAL_BOOT_SERVICE_PROTOCOL {
+  EXTENDED_SAL_ADD_SST_INFO            AddSalSystemTableInfo;
+  EXTENDED_SAL_ADD_SST_ENTRY           AddSalSystemTableEntry;
+  EXTENDED_SAL_REGISTER_INTERNAL_PROC  RegisterExtendedSalProc;   
+  EXTENDED_SAL_PROC                    ExtendedSalProc;
+};
+
+extern EFI_GUID  gEfiExtendedSalBootServiceProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ExtendedSalServiceClasses.h b/MdePkg/Include/Protocol/ExtendedSalServiceClasses.h
new file mode 100644
index 000000000000..126beedacf2e
--- /dev/null
+++ b/MdePkg/Include/Protocol/ExtendedSalServiceClasses.h
@@ -0,0 +1,275 @@
+/** @file
+  The standard set of Extended SAL service classes.
+
+  Copyright (c) 2009, 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 _EXTENDED_SAL_SERVICE_CLASSES_H_
+#define _EXTENDED_SAL_SERVICE_CLASSES_H_
+
+///
+/// Extended SAL Base I/O Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO 0x451531e15aea42b5
+#define EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI 0xa6657525d5b831bc
+#define EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID \
+  { 0x5aea42b5, 0x31e1, 0x4515, {0xbc, 0x31, 0xb8, 0xd5, 0x25, 0x75, 0x65, 0xa6 } }
+
+typedef enum {
+  IoReadFunctionId,
+  IoWriteFunctionId,
+  MemReadFunctionId,
+  MemWriteFunctionId
+} EFI_EXTENDED_SAL_BASE_IO_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Stall Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_LO 0x4d8cac2753a58d06
+#define EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_HI 0x704165808af0e9b5
+#define EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID \
+  { 0x53a58d06, 0xac27, 0x4d8c, {0xb5, 0xe9, 0xf0, 0x8a, 0x80, 0x65, 0x41, 0x70 } }
+
+typedef enum {
+  StallFunctionId
+} EFI_EXTENDED_SAL_STALL_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Real Time Clock Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_RTC_SERVICES_PROTOCOL_GUID_LO 0x4d02efdb7e97a470
+#define EFI_EXTENDED_SAL_RTC_SERVICES_PROTOCOL_GUID_HI 0x96a27bd29061ce8f 
+#define EFI_EXTENDED_SAL_RTC_SERVICES_PROTOCOL_GUID  \
+  { 0x7e97a470, 0xefdb, 0x4d02, {0x8f, 0xce, 0x61, 0x90, 0xd2, 0x7b, 0xa2, 0x96 } }
+
+typedef enum {
+  GetTimeFunctionId,
+  SetTimeFunctionId,
+  GetWakeupTimeFunctionId,
+  SetWakeupTimeFunctionId,
+  GetRtcFreqFunctionId,
+  InitializeThresholdFunctionId,
+  BumpThresholdCountFunctionId,
+  GetThresholdCountFunctionId
+} EFI_EXTENDED_SAL_RTC_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Variable Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_VARIABLE_SERVICES_PROTOCOL_GUID_LO 0x4370c6414ecb6c53 
+#define EFI_EXTENDED_SAL_VARIABLE_SERVICES_PROTOCOL_GUID_HI 0x78836e490e3bb28c
+#define EFI_EXTENDED_SAL_VARIABLE_SERVICES_PROTOCOL_GUID  \
+  { 0x4ecb6c53, 0xc641, 0x4370, {0x8c, 0xb2, 0x3b, 0x0e, 0x49, 0x6e, 0x83, 0x78 } }
+
+typedef enum {
+  EsalGetVariableFunctionId,
+  EsalGetNextVariableNameFunctionId,
+  EsalSetVariableFunctionId,
+  EsalQueryVariableInfoFunctionId
+} EFI_EXTENDED_SAL_VARIABLE_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Monotonic Counter Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_MTC_SERVICES_PROTOCOL_GUID_LO 0x408b75e8899afd18
+#define EFI_EXTENDED_SAL_MTC_SERVICES_PROTOCOL_GUID_HI 0x54f4cd7e2e6e1aa4
+#define EFI_EXTENDED_SAL_MTC_SERVICES_PROTOCOL_GUID  \
+  { 0x899afd18, 0x75e8, 0x408b, {0xa4, 0x1a, 0x6e, 0x2e, 0x7e, 0xcd, 0xf4, 0x54 } }
+
+typedef enum {
+  GetNextHighMonotonicCountFunctionId
+} EFI_EXTENDED_SAL_MTC_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Reset Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_RESET_SERVICES_PROTOCOL_GUID_LO  0x46f58ce17d019990
+#define EFI_EXTENDED_SAL_RESET_SERVICES_PROTOCOL_GUID_HI  0xa06a6798513c76a7
+#define EFI_EXTENDED_SAL_RESET_SERVICES_PROTOCOL_GUID  \
+  { 0x7d019990, 0x8ce1, 0x46f5, {0xa7, 0x76, 0x3c, 0x51, 0x98, 0x67, 0x6a, 0xa0 } }
+
+typedef enum {
+  ResetSystemFunctionId
+} EFI_EXTENDED_SAL_RESET_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Status Code Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_STATUS_CODE_SERVICES_PROTOCOL_GUID_LO 0x420f55e9dbd91d
+#define EFI_EXTENDED_SAL_STATUS_CODE_SERVICES_PROTOCOL_GUID_HI 0x4fb437849f5e3996
+#define EFI_EXTENDED_SAL_STATUS_CODE_SERVICES_PROTOCOL_GUID  \
+  { 0xdbd91d, 0x55e9, 0x420f, {0x96, 0x39, 0x5e, 0x9f, 0x84, 0x37, 0xb4, 0x4f } }
+
+typedef enum {
+  ReportStatusCodeServiceFunctionId
+} EFI_EXTENDED_SAL_STATUS_CODE_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Firmware Volume Block Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_FV_BLOCK_SERVICES_PROTOCOL_GUID_LO 0x4f1dbcbba2271df1
+#define EFI_EXTENDED_SAL_FV_BLOCK_SERVICES_PROTOCOL_GUID_HI 0x1a072f17bc06a998
+#define EFI_EXTENDED_SAL_FV_BLOCK_SERVICES_PROTOCOL_GUID \
+  { 0xa2271df1, 0xbcbb, 0x4f1d, {0x98, 0xa9, 0x06, 0xbc, 0x17, 0x2f, 0x07, 0x1a } }
+
+typedef enum {
+  ReadFunctionId,
+  WriteFunctionId,
+  EraseBlockFunctionId,
+  GetVolumeAttributesFunctionId,
+  SetVolumeAttributesFunctionId,
+  GetPhysicalAddressFunctionId,
+  GetBlockSizeFunctionId,
+} EFI_EXTENDED_SAL_FV_BLOCK_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL MP Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO 0x4dc0cf18697d81a2
+#define EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI 0x3f8a613b11060d9e
+#define EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID \
+  { 0x697d81a2, 0xcf18, 0x4dc0, {0x9e, 0x0d, 0x06, 0x11, 0x3b, 0x61, 0x8a, 0x3f } }
+
+typedef enum {
+  AddCpuDataFunctionId,
+  RemoveCpuDataFunctionId,
+  ModifyCpuDataFunctionId,
+  GetCpuDataByIDFunctionId,
+  GetCpuDataByIndexFunctionId,
+  SendIpiFunctionId,
+  CurrentProcInfoFunctionId,
+  NumProcessorsFunctionId,
+  SetMinStateFunctionId,
+  GetMinStateFunctionId               
+} EFI_EXTENDED_SAL_MP_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL PAL Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO 0x438d0fc2e1cd9d21
+#define EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI 0x571e966de6040397
+#define EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID \
+  { 0xe1cd9d21, 0x0fc2, 0x438d, {0x97, 0x03, 0x04, 0xe6, 0x6d, 0x96, 0x1e, 0x57 } }
+
+typedef enum {
+  PalProcFunctionId,
+  SetNewPalEntryFunctionId,
+  GetNewPalEntryFunctionId,
+  EsalUpdatePalFunctionId
+} EFI_EXTENDED_SAL_PAL_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Base Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO 0x41c30fe0d9e9fa06
+#define EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI 0xf894335a4283fb96
+#define EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID \
+  { 0xd9e9fa06, 0x0fe0, 0x41c3, {0x96, 0xfb, 0x83, 0x42, 0x5a, 0x33, 0x94, 0xf8 } }
+
+typedef enum {
+  SalSetVectorsFunctionId,
+  SalMcRendezFunctionId,
+  SalMcSetParamsFunctionId,
+  EsalGetVectorsFunctionId,
+  EsalMcGetParamsFunctionId,
+  EsalMcGetMcParamsFunctionId,
+  EsalGetMcCheckinFlagsFunctionId,
+  EsalGetPlatformBaseFreqFunctionId,
+  EsalPhysicalIdInfoFunctionId, 
+  EsalRegisterPhysicalAddrFunctionId
+} EFI_EXTENDED_SAL_BASE_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL MCA Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_LO 0x42b16cc72a591128
+#define EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_HI 0xbb2d683b9358f08a
+#define EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID \
+  { 0x2a591128, 0x6cc7, 0x42b1, {0x8a, 0xf0, 0x58, 0x93, 0x3b, 0x68, 0x2d, 0xbb } }
+
+typedef enum {
+  McaGetStateInfoFunctionId,
+  McaRegisterCpuFunctionId
+} EFI_EXTENDED_SAL_MCA_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL PCI Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO 0x4905ad66a46b1a31
+#define EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI 0x6330dc59462bf692
+#define EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID \
+  { 0xa46b1a31, 0xad66, 0x4905, {0x92, 0xf6, 0x2b, 0x46, 0x59, 0xdc, 0x30, 0x63 } }
+
+typedef enum {
+  SalPciConfigReadFunctionId,
+  SalPciConfigWriteFunctionId
+} EFI_EXTENDED_SAL_PCI_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL Cache Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_LO 0x4ba52743edc9494
+#define EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_HI 0x88f11352ef0a1888
+#define EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID \
+  { 0xedc9494, 0x2743, 0x4ba5, { 0x88, 0x18, 0x0a, 0xef, 0x52, 0x13, 0xf1, 0x88 } }
+
+typedef enum {
+  SalCacheInitFunctionId,
+  SalCacheFlushFunctionId
+} EFI_EXTENDED_SAL_CACHE_SERVICES_FUNC_ID;
+///@}
+
+///
+/// Extended SAL MCA Log Services Class
+///
+///@{
+#define EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO 0x4c0338a3cb3fd86e
+#define EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI 0x7aaba2a3cf905c9a
+#define EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID \
+  { 0xcb3fd86e, 0x38a3, 0x4c03, {0x9a, 0x5c, 0x90, 0xcf, 0xa3, 0xa2, 0xab, 0x7a } }
+
+typedef enum {
+  SalGetStateInfoFunctionId,
+  SalGetStateInfoSizeFunctionId,
+  SalClearStateInfoFunctionId,
+  EsalGetStateBufferFunctionId,
+  EsalSaveStateBufferFunctionId
+} EFI_EXTENDED_SAL_MCA_LOG_SERVICES_FUNC_ID;
+///@}
+
+#endif
diff --git a/MdePkg/Include/Protocol/FirmwareManagement.h b/MdePkg/Include/Protocol/FirmwareManagement.h
new file mode 100644
index 000000000000..e9a9e04ea0c3
--- /dev/null
+++ b/MdePkg/Include/Protocol/FirmwareManagement.h
@@ -0,0 +1,538 @@
+/** @file
+  UEFI Firmware Management Protocol definition
+  Firmware Management Protocol provides an abstraction for device to provide firmware
+  management support. The base requirements for managing device firmware images include
+  identifying firmware image revision level and programming the image into the device.
+
+  GetImageInfo() is the only required function. GetImage(), SetImage(),
+  CheckImage(), GetPackageInfo(), and SetPackageInfo() shall return
+  EFI_UNSUPPORTED if not supported by the driver.
+
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.<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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.3
+
+**/
+
+#ifndef __EFI_FIRMWARE_MANAGEMENT_PROTOCOL_H__
+#define __EFI_FIRMWARE_MANAGEMENT_PROTOCOL_H__
+
+
+#define EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GUID \
+  { \
+    0x86c77a67, 0xb97, 0x4633, {0xa1, 0x87, 0x49, 0x10, 0x4d, 0x6, 0x85, 0xc7 } \
+  }
+
+typedef struct _EFI_FIRMWARE_MANAGEMENT_PROTOCOL EFI_FIRMWARE_MANAGEMENT_PROTOCOL;
+
+///
+/// EFI_FIRMWARE_IMAGE_DESCRIPTOR
+///
+typedef struct {
+  ///
+  /// A unique number identifying the firmware image within the device. The number is
+  /// between 1 and DescriptorCount.
+  ///
+  UINT8                            ImageIndex;
+  ///
+  /// A unique GUID identifying the firmware image type.
+  ///
+  EFI_GUID                         ImageTypeId;
+  ///
+  /// A unique number identifying the firmware image.
+  ///
+  UINT64                           ImageId;
+  ///
+  /// A pointer to a null-terminated string representing the firmware image name.
+  ///
+  CHAR16                           *ImageIdName;
+  ///
+  /// Identifies the version of the device firmware. The format is vendor specific and new
+  /// version must have a greater value than an old version.
+  ///
+  UINT32                           Version;
+  ///
+  /// A pointer to a null-terminated string representing the firmware image version name.
+  ///
+  CHAR16                           *VersionName;
+  ///
+  /// Size of the image in bytes. If size=0, then only ImageIndex and ImageTypeId are valid.
+  ///
+  UINTN                            Size;
+  ///
+  /// Image attributes that are supported by this device. See 'Image Attribute Definitions'
+  /// for possible returned values of this parameter. A value of 1 indicates the attribute is
+  /// supported and the current setting value is indicated in AttributesSetting. A
+  /// value of 0 indicates the attribute is not supported and the current setting value in
+  /// AttributesSetting is meaningless.
+  ///
+  UINT64                           AttributesSupported;
+  ///
+  /// Image attributes. See 'Image Attribute Definitions' for possible returned values of
+  /// this parameter.
+  ///
+  UINT64                           AttributesSetting;
+  ///
+  /// Image compatibilities. See 'Image Compatibility Definitions' for possible returned
+  /// values of this parameter.
+  ///
+  UINT64                           Compatibilities;
+  ///
+  /// Describes the lowest ImageDescriptor version that the device will accept. Only
+  /// present in version 2 or higher.
+  ///
+  UINT32                           LowestSupportedImageVersion;
+  ///
+  /// Describes the version that was last attempted to update. If no update attempted the
+  /// value will be 0. If the update attempted was improperly formatted and no version
+  /// number was available then the value will be zero. Only present in version 3 or higher.
+  UINT32                           LastAttemptVersion;
+  ///
+  /// Describes the status that was last attempted to update. If no update has been attempted
+  /// the value will be LAST_ATTEMPT_STATUS_SUCCESS. Only present in version 3 or higher.
+  ///
+  UINT32                           LastAttemptStatus;
+  ///
+  /// An optional number to identify the unique hardware instance within the system for
+  /// devices that may have multiple instances (Example: a plug in pci network card). This
+  /// number must be unique within the namespace of the ImageTypeId GUID and
+  /// ImageIndex. For FMP instances that have multiple descriptors for a single
+  /// hardware instance, all descriptors must have the same HardwareInstance value.
+  /// This number must be consistent between boots and should be based on some sort of
+  /// hardware identified unique id (serial number, etc) whenever possible. If a hardware
+  /// based number is not available the FMP provider may use some other characteristic
+  /// such as device path, bus/dev/function, slot num, etc for generating the
+  /// HardwareInstance. For implementations that will never have more than one
+  /// instance a zero can be used. A zero means the FMP provider is not able to determine a
+  /// unique hardware instance number or a hardware instance number is not needed. Only
+  /// present in version 3 or higher.
+  ///
+  UINT64                           HardwareInstance;
+} EFI_FIRMWARE_IMAGE_DESCRIPTOR;
+
+
+//
+// Image Attribute Definitions
+//
+///
+/// The attribute IMAGE_ATTRIBUTE_IMAGE_UPDATABLE indicates this device supports firmware
+/// image update.
+///
+#define    IMAGE_ATTRIBUTE_IMAGE_UPDATABLE         0x0000000000000001
+///
+/// The attribute IMAGE_ATTRIBUTE_RESET_REQUIRED indicates a reset of the device is required
+/// for the new firmware image to take effect after a firmware update. The device is the device hosting
+/// the firmware image.
+///
+#define    IMAGE_ATTRIBUTE_RESET_REQUIRED          0x0000000000000002
+///
+/// The attribute IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED indicates authentication is
+/// required to perform the following image operations: GetImage(), SetImage(), and
+/// CheckImage(). See 'Image Attribute - Authentication'.
+///
+#define    IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED 0x0000000000000004
+///
+/// The attribute IMAGE_ATTRIBUTE_IN_USE indicates the current state of the firmware image.
+/// This distinguishes firmware images in a device that supports redundant images.
+///
+#define    IMAGE_ATTRIBUTE_IN_USE                  0x0000000000000008
+///
+/// The attribute IMAGE_ATTRIBUTE_UEFI_IMAGE indicates that this image is an EFI compatible image.
+///
+#define    IMAGE_ATTRIBUTE_UEFI_IMAGE              0x0000000000000010
+
+
+//
+// Image Compatibility Definitions
+//
+/// Values from 0x0000000000000002 thru 0x000000000000FFFF are reserved for future assignments.
+/// Values from 0x0000000000010000 thru 0xFFFFFFFFFFFFFFFF are used by firmware vendor for
+/// compatibility check.
+///
+#define   IMAGE_COMPATIBILITY_CHECK_SUPPORTED      0x0000000000000001
+
+///
+/// Descriptor Version exposed by GetImageInfo() function
+///
+#define   EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION   3
+
+
+///
+/// Image Attribute -Authentication Required
+///
+typedef struct {
+  ///
+  /// It is included in the signature of AuthInfo. It is used to ensure freshness/no replay.
+  /// It is incremented during each firmware image operation.
+  ///
+  UINT64                                  MonotonicCount;
+  ///
+  /// Provides the authorization for the firmware image operations. It is a signature across
+  /// the image data and the Monotonic Count value. Caller uses the private key that is
+  /// associated with a public key that has been provisioned via the key exchange.
+  /// Because this is defined as a signature, WIN_CERTIFICATE_UEFI_GUID.CertType must
+  /// be EFI_CERT_TYPE_PKCS7_GUID.
+  ///
+  WIN_CERTIFICATE_UEFI_GUID               AuthInfo;
+} EFI_FIRMWARE_IMAGE_AUTHENTICATION;
+
+
+//
+// ImageUpdatable Definitions
+//
+///
+/// IMAGE_UPDATABLE_VALID indicates SetImage() will accept the new image and update the
+/// device with the new image. The version of the new image could be higher or lower than
+/// the current image. SetImage VendorCode is optional but can be used for vendor
+/// specific action.
+///
+#define  IMAGE_UPDATABLE_VALID                     0x0000000000000001
+///
+/// IMAGE_UPDATABLE_INVALID indicates SetImage() will reject the new image. No additional
+/// information is provided for the rejection.
+///
+#define  IMAGE_UPDATABLE_INVALID                   0x0000000000000002
+///
+/// IMAGE_UPDATABLE_INVALID_TYPE indicates SetImage() will reject the new image. The
+/// rejection is due to the new image is not a firmware image recognized for this device.
+///
+#define  IMAGE_UPDATABLE_INVALID_TYPE              0x0000000000000004
+///
+/// IMAGE_UPDATABLE_INVALID_OLD indicates SetImage() will reject the new image. The
+/// rejection is due to the new image version is older than the current firmware image
+/// version in the device. The device firmware update policy does not support firmware
+/// version downgrade.
+///
+#define  IMAGE_UPDATABLE_INVALID_OLD               0x0000000000000008
+///
+/// IMAGE_UPDATABLE_VALID_WITH_VENDOR_CODE indicates SetImage() will accept and update
+/// the new image only if a correct VendorCode is provided or else image would be
+/// rejected and SetImage will return appropriate error.
+///
+#define IMAGE_UPDATABLE_VALID_WITH_VENDOR_CODE     0x0000000000000010
+
+
+//
+// Package Attribute Definitions
+//
+///
+/// The attribute PACKAGE_ATTRIBUTE_VERSION_UPDATABLE indicates this device supports the
+/// update of the firmware package version.
+///
+#define  PACKAGE_ATTRIBUTE_VERSION_UPDATABLE       0x0000000000000001
+///
+/// The attribute PACKAGE_ATTRIBUTE_RESET_REQUIRED indicates a reset of the device is
+/// required for the new package info to take effect after an update.
+///
+#define  PACKAGE_ATTRIBUTE_RESET_REQUIRED          0x0000000000000002
+///
+/// The attribute PACKAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED indicates authentication
+/// is required to update the package info.
+///
+#define  PACKAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED 0x0000000000000004
+
+/**
+  Callback function to report the process of the firmware updating.
+
+  @param[in]  Completion    A value between 1 and 100 indicating the current completion
+                            progress of the firmware update. Completion progress is
+                            reported as from 1 to 100 percent. A value of 0 is used by
+                            the driver to indicate that progress reporting is not supported.
+
+  @retval EFI_SUCCESS       SetImage() continues to do the callback if supported.
+  @retval other             SetImage() discontinues the callback and completes
+                            the update and returns.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS)(
+  IN  UINTN                          Completion
+  );
+
+/**
+  Returns information about the current firmware image(s) of the device.
+
+  This function allows a copy of the current firmware image to be created and saved.
+  The saved copy could later been used, for example, in firmware image recovery or rollback.
+
+  @param[in]      This               A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[in, out] ImageInfoSize      A pointer to the size, in bytes, of the ImageInfo buffer.
+                                     On input, this is the size of the buffer allocated by the caller.
+                                     On output, it is the size of the buffer returned by the firmware
+                                     if the buffer was large enough, or the size of the buffer needed
+                                     to contain the image(s) information if the buffer was too small.
+  @param[in, out] ImageInfo          A pointer to the buffer in which firmware places the current image(s)
+                                     information. The information is an array of EFI_FIRMWARE_IMAGE_DESCRIPTORs.
+  @param[out]     DescriptorVersion  A pointer to the location in which firmware returns the version number
+                                     associated with the EFI_FIRMWARE_IMAGE_DESCRIPTOR.
+  @param[out]     DescriptorCount    A pointer to the location in which firmware returns the number of
+                                     descriptors or firmware images within this device.
+  @param[out]     DescriptorSize     A pointer to the location in which firmware returns the size, in bytes,
+                                     of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR.
+  @param[out]     PackageVersion     A version number that represents all the firmware images in the device.
+                                     The format is vendor specific and new version must have a greater value
+                                     than the old version. If PackageVersion is not supported, the value is
+                                     0xFFFFFFFF. A value of 0xFFFFFFFE indicates that package version comparison
+                                     is to be performed using PackageVersionName. A value of 0xFFFFFFFD indicates
+                                     that package version update is in progress.
+  @param[out]     PackageVersionName A pointer to a pointer to a null-terminated string representing the
+                                     package version name. The buffer is allocated by this function with
+                                     AllocatePool(), and it is the caller's responsibility to free it with a call
+                                     to FreePool().
+
+  @retval EFI_SUCCESS                The device was successfully updated with the new image.
+  @retval EFI_BUFFER_TOO_SMALL       The ImageInfo buffer was too small. The current buffer size
+                                     needed to hold the image(s) information is returned in ImageInfoSize.
+  @retval EFI_INVALID_PARAMETER      ImageInfoSize is NULL.
+  @retval EFI_DEVICE_ERROR           Valid information could not be returned. Possible corrupted image.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_IMAGE_INFO)(
+  IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL       *This,
+  IN OUT    UINTN                           *ImageInfoSize,
+  IN OUT    EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,
+  OUT       UINT32                          *DescriptorVersion,
+  OUT       UINT8                           *DescriptorCount,
+  OUT       UINTN                           *DescriptorSize,
+  OUT       UINT32                          *PackageVersion,
+  OUT       CHAR16                          **PackageVersionName
+  );
+
+/**
+  Retrieves a copy of the current firmware image of the device.
+
+  This function allows a copy of the current firmware image to be created and saved.
+  The saved copy could later been used, for example, in firmware image recovery or rollback.
+
+  @param[in]  This               A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[in]  ImageIndex         A unique number identifying the firmware image(s) within the device.
+                                 The number is between 1 and DescriptorCount.
+  @param[out] Image              Points to the buffer where the current image is copied to.
+  @param[out] ImageSize          On entry, points to the size of the buffer pointed to by Image, in bytes.
+                                 On return, points to the length of the image, in bytes.
+
+  @retval EFI_SUCCESS            The device was successfully updated with the new image.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to hold the
+                                 image. The current buffer size needed to hold the image is returned
+                                 in ImageSize.
+  @retval EFI_INVALID_PARAMETER  The Image was NULL.
+  @retval EFI_NOT_FOUND          The current image is not copied to the buffer.
+  @retval EFI_UNSUPPORTED        The operation is not supported.
+  @retval EFI_SECURITY_VIOLATIO  The operation could not be performed due to an authentication failure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_IMAGE)(
+  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL  *This,
+  IN  UINT8                             ImageIndex,
+  IN  OUT  VOID                         *Image,
+  IN  OUT  UINTN                        *ImageSize
+  );
+
+/**
+  Updates the firmware image of the device.
+
+  This function updates the hardware with the new firmware image.
+  This function returns EFI_UNSUPPORTED if the firmware image is not updatable.
+  If the firmware image is updatable, the function should perform the following minimal validations
+  before proceeding to do the firmware image update.
+  - Validate the image authentication if image has attribute
+    IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED. The function returns
+    EFI_SECURITY_VIOLATION if the validation fails.
+  - Validate the image is a supported image for this device. The function returns EFI_ABORTED if
+    the image is unsupported. The function can optionally provide more detailed information on
+    why the image is not a supported image.
+  - Validate the data from VendorCode if not null. Image validation must be performed before
+    VendorCode data validation. VendorCode data is ignored or considered invalid if image
+    validation failed. The function returns EFI_ABORTED if the data is invalid.
+
+  VendorCode enables vendor to implement vendor-specific firmware image update policy. Null if
+  the caller did not specify the policy or use the default policy. As an example, vendor can implement
+  a policy to allow an option to force a firmware image update when the abort reason is due to the new
+  firmware image version is older than the current firmware image version or bad image checksum.
+  Sensitive operations such as those wiping the entire firmware image and render the device to be
+  non-functional should be encoded in the image itself rather than passed with the VendorCode.
+  AbortReason enables vendor to have the option to provide a more detailed description of the abort
+  reason to the caller.
+
+  @param[in]  This               A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[in]  ImageIndex         A unique number identifying the firmware image(s) within the device.
+                                 The number is between 1 and DescriptorCount.
+  @param[in]  Image              Points to the new image.
+  @param[in]  ImageSize          Size of the new image in bytes.
+  @param[in]  VendorCode         This enables vendor to implement vendor-specific firmware image update policy.
+                                 Null indicates the caller did not specify the policy or use the default policy.
+  @param[in]  Progress           A function used by the driver to report the progress of the firmware update.
+  @param[out] AbortReason        A pointer to a pointer to a null-terminated string providing more
+                                 details for the aborted operation. The buffer is allocated by this function
+                                 with AllocatePool(), and it is the caller's responsibility to free it with a
+                                 call to FreePool().
+
+  @retval EFI_SUCCESS            The device was successfully updated with the new image.
+  @retval EFI_ABORTED            The operation is aborted.
+  @retval EFI_INVALID_PARAMETER  The Image was NULL.
+  @retval EFI_UNSUPPORTED        The operation is not supported.
+  @retval EFI_SECURITY_VIOLATIO  The operation could not be performed due to an authentication failure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_SET_IMAGE)(
+  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL                 *This,
+  IN  UINT8                                            ImageIndex,
+  IN  CONST VOID                                       *Image,
+  IN  UINTN                                            ImageSize,
+  IN  CONST VOID                                       *VendorCode,
+  IN  EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS    Progress,
+  OUT CHAR16                                           **AbortReason
+  );
+
+/**
+  Checks if the firmware image is valid for the device.
+
+  This function allows firmware update application to validate the firmware image without
+  invoking the SetImage() first.
+
+  @param[in]  This               A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[in]  ImageIndex         A unique number identifying the firmware image(s) within the device.
+                                 The number is between 1 and DescriptorCount.
+  @param[in]  Image              Points to the new image.
+  @param[in]  ImageSize          Size of the new image in bytes.
+  @param[out] ImageUpdatable     Indicates if the new image is valid for update. It also provides,
+                                 if available, additional information if the image is invalid.
+
+  @retval EFI_SUCCESS            The image was successfully checked.
+  @retval EFI_INVALID_PARAMETER  The Image was NULL.
+  @retval EFI_UNSUPPORTED        The operation is not supported.
+  @retval EFI_SECURITY_VIOLATIO  The operation could not be performed due to an authentication failure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_CHECK_IMAGE)(
+  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL  *This,
+  IN  UINT8                             ImageIndex,
+  IN  CONST VOID                        *Image,
+  IN  UINTN                             ImageSize,
+  OUT UINT32                            *ImageUpdatable
+  );
+
+/**
+  Returns information about the firmware package.
+
+  This function returns package information.
+
+  @param[in]  This                     A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[out] PackageVersion           A version number that represents all the firmware images in the device.
+                                       The format is vendor specific and new version must have a greater value
+                                       than the old version. If PackageVersion is not supported, the value is
+                                       0xFFFFFFFF. A value of 0xFFFFFFFE indicates that package version
+                                       comparison is to be performed using PackageVersionName. A value of
+                                       0xFFFFFFFD indicates that package version update is in progress.
+  @param[out] PackageVersionName       A pointer to a pointer to a null-terminated string representing
+                                       the package version name. The buffer is allocated by this function with
+                                       AllocatePool(), and it is the caller's responsibility to free it with a
+                                       call to FreePool().
+  @param[out] PackageVersionNameMaxLen The maximum length of package version name if device supports update of
+                                       package version name. A value of 0 indicates the device does not support
+                                       update of package version name. Length is the number of Unicode characters,
+                                       including the terminating null character.
+  @param[out] AttributesSupported      Package attributes that are supported by this device. See 'Package Attribute
+                                       Definitions' for possible returned values of this parameter. A value of 1
+                                       indicates the attribute is supported and the current setting value is
+                                       indicated in AttributesSetting. A value of 0 indicates the attribute is not
+                                       supported and the current setting value in AttributesSetting is meaningless.
+  @param[out] AttributesSetting        Package attributes. See 'Package Attribute Definitions' for possible returned
+                                       values of this parameter
+
+  @retval EFI_SUCCESS                  The package information was successfully returned.
+  @retval EFI_UNSUPPORTED              The operation is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_PACKAGE_INFO)(
+  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
+  OUT UINT32                           *PackageVersion,
+  OUT CHAR16                           **PackageVersionName,
+  OUT UINT32                           *PackageVersionNameMaxLen,
+  OUT UINT64                           *AttributesSupported,
+  OUT UINT64                           *AttributesSetting
+  );
+
+/**
+  Updates information about the firmware package.
+
+  This function updates package information.
+  This function returns EFI_UNSUPPORTED if the package information is not updatable.
+  VendorCode enables vendor to implement vendor-specific package information update policy.
+  Null if the caller did not specify this policy or use the default policy.
+
+  @param[in]  This               A pointer to the EFI_FIRMWARE_MANAGEMENT_PROTOCOL instance.
+  @param[in]  Image              Points to the authentication image.
+                                 Null if authentication is not required.
+  @param[in]  ImageSize          Size of the authentication image in bytes.
+                                 0 if authentication is not required.
+  @param[in]  VendorCode         This enables vendor to implement vendor-specific firmware
+                                 image update policy.
+                                 Null indicates the caller did not specify this policy or use
+                                 the default policy.
+  @param[in]  PackageVersion     The new package version.
+  @param[in]  PackageVersionName A pointer to the new null-terminated Unicode string representing
+                                 the package version name.
+                                 The string length is equal to or less than the value returned in
+                                 PackageVersionNameMaxLen.
+
+  @retval EFI_SUCCESS            The device was successfully updated with the new package
+                                 information.
+  @retval EFI_INVALID_PARAMETER  The PackageVersionName length is longer than the value
+                                 returned in PackageVersionNameMaxLen.
+  @retval EFI_UNSUPPORTED        The operation is not supported.
+  @retval EFI_SECURITY_VIOLATIO  The operation could not be performed due to an authentication failure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FIRMWARE_MANAGEMENT_PROTOCOL_SET_PACKAGE_INFO)(
+  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL   *This,
+  IN  CONST VOID                         *Image,
+  IN  UINTN                              ImageSize,
+  IN  CONST VOID                         *VendorCode,
+  IN  UINT32                             PackageVersion,
+  IN  CONST CHAR16                       *PackageVersionName
+  );
+
+///
+/// EFI_FIRMWARE_MANAGEMENT_PROTOCOL
+/// The protocol for managing firmware provides the following services.
+/// - Get the attributes of the current firmware image. Attributes include revision level.
+/// - Get a copy of the current firmware image. As an example, this service could be used by a
+///   management application to facilitate a firmware roll-back.
+/// - Program the device with a firmware image supplied by the user.
+/// - Label all the firmware images within a device with a single version.
+///
+struct _EFI_FIRMWARE_MANAGEMENT_PROTOCOL {
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_IMAGE_INFO    GetImageInfo;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_IMAGE         GetImage;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_SET_IMAGE         SetImage;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_CHECK_IMAGE       CheckImage;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GET_PACKAGE_INFO  GetPackageInfo;
+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL_SET_PACKAGE_INFO  SetPackageInfo;
+};
+
+extern EFI_GUID gEfiFirmwareManagementProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/FirmwareVolume2.h b/MdePkg/Include/Protocol/FirmwareVolume2.h
new file mode 100644
index 000000000000..00523bf0837e
--- /dev/null
+++ b/MdePkg/Include/Protocol/FirmwareVolume2.h
@@ -0,0 +1,762 @@
+/** @file
+  The Firmware Volume Protocol provides file-level access to the firmware volume. 
+  Each firmware volume driver must produce an instance of the 
+  Firmware Volume Protocol if the firmware volume is to be visible to
+  the system during the DXE phase. The Firmware Volume Protocol also provides
+  mechanisms for determining and modifying some attributes of the firmware volume.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference: PI
+  Version 1.00.
+
+**/
+
+#ifndef __FIRMWARE_VOLUME2_H__
+#define __FIRMWARE_VOLUME2_H__
+
+#define EFI_FIRMWARE_VOLUME2_PROTOCOL_GUID \
+  { 0x220e73b6, 0x6bdb, 0x4413, { 0x84, 0x5, 0xb9, 0x74, 0xb1, 0x8, 0x61, 0x9a } }
+
+typedef struct _EFI_FIRMWARE_VOLUME2_PROTOCOL EFI_FIRMWARE_VOLUME2_PROTOCOL;
+
+
+///
+/// EFI_FV_ATTRIBUTES
+///
+typedef UINT64  EFI_FV_ATTRIBUTES;
+
+//
+// EFI_FV_ATTRIBUTES bit definitions
+//
+// EFI_FV_ATTRIBUTES bit semantics
+#define EFI_FV2_READ_DISABLE_CAP        0x0000000000000001ULL
+#define EFI_FV2_READ_ENABLE_CAP         0x0000000000000002ULL
+#define EFI_FV2_READ_STATUS             0x0000000000000004ULL
+#define EFI_FV2_WRITE_DISABLE_CAP       0x0000000000000008ULL
+#define EFI_FV2_WRITE_ENABLE_CAP        0x0000000000000010ULL
+#define EFI_FV2_WRITE_STATUS            0x0000000000000020ULL
+#define EFI_FV2_LOCK_CAP                0x0000000000000040ULL
+#define EFI_FV2_LOCK_STATUS             0x0000000000000080ULL
+#define EFI_FV2_WRITE_POLICY_RELIABLE   0x0000000000000100ULL
+#define EFI_FV2_READ_LOCK_CAP           0x0000000000001000ULL
+#define EFI_FV2_READ_LOCK_STATUS        0x0000000000002000ULL
+#define EFI_FV2_WRITE_LOCK_CAP          0x0000000000004000ULL
+#define EFI_FV2_WRITE_LOCK_STATUS       0x0000000000008000ULL
+#define EFI_FV2_ALIGNMENT               0x00000000001F0000ULL
+#define EFI_FV2_ALIGNMENT_1             0x0000000000000000ULL
+#define EFI_FV2_ALIGNMENT_2             0x0000000000010000ULL
+#define EFI_FV2_ALIGNMENT_4             0x0000000000020000ULL
+#define EFI_FV2_ALIGNMENT_8             0x0000000000030000ULL
+#define EFI_FV2_ALIGNMENT_16            0x0000000000040000ULL
+#define EFI_FV2_ALIGNMENT_32            0x0000000000050000ULL
+#define EFI_FV2_ALIGNMENT_64            0x0000000000060000ULL
+#define EFI_FV2_ALIGNMENT_128           0x0000000000070000ULL
+#define EFI_FV2_ALIGNMENT_256           0x0000000000080000ULL
+#define EFI_FV2_ALIGNMENT_512           0x0000000000090000ULL
+#define EFI_FV2_ALIGNMENT_1K            0x00000000000A0000ULL
+#define EFI_FV2_ALIGNMENT_2K            0x00000000000B0000ULL
+#define EFI_FV2_ALIGNMENT_4K            0x00000000000C0000ULL
+#define EFI_FV2_ALIGNMENT_8K            0x00000000000D0000ULL
+#define EFI_FV2_ALIGNMENT_16K           0x00000000000E0000ULL
+#define EFI_FV2_ALIGNMENT_32K           0x00000000000F0000ULL
+#define EFI_FV2_ALIGNMENT_64K           0x0000000000100000ULL
+#define EFI_FV2_ALIGNMENT_128K          0x0000000000110000ULL
+#define EFI_FV2_ALIGNMENT_256K          0x0000000000120000ULL
+#define EFI_FV2_ALIGNMENT_512K          0x0000000000130000ULL
+#define EFI_FV2_ALIGNMENT_1M            0x0000000000140000ULL
+#define EFI_FV2_ALIGNMENT_2M            0x0000000000150000ULL
+#define EFI_FV2_ALIGNMENT_4M            0x0000000000160000ULL
+#define EFI_FV2_ALIGNMENT_8M            0x0000000000170000ULL
+#define EFI_FV2_ALIGNMENT_16M           0x0000000000180000ULL
+#define EFI_FV2_ALIGNMENT_32M           0x0000000000190000ULL
+#define EFI_FV2_ALIGNMENT_64M           0x00000000001A0000ULL
+#define EFI_FV2_ALIGNMENT_128M          0x00000000001B0000ULL
+#define EFI_FV2_ALIGNMENT_256M          0x00000000001C0000ULL
+#define EFI_FV2_ALIGNMENT_512M          0x00000000001D0000ULL
+#define EFI_FV2_ALIGNMENT_1G            0x00000000001E0000ULL
+#define EFI_FV2_ALIGNMENT_2G            0x00000000001F0000ULL
+
+/**
+  Returns the attributes and current settings of the firmware volume.
+
+  Because of constraints imposed by the underlying firmware
+  storage, an instance of the Firmware Volume Protocol may not
+  be to able to support all possible variations of this
+  architecture. These constraints and the current state of the
+  firmware volume are exposed to the caller using the
+  GetVolumeAttributes() function. GetVolumeAttributes() is
+  callable only from TPL_NOTIFY and below. Behavior of
+  GetVolumeAttributes() at any EFI_TPL above TPL_NOTIFY is
+  undefined.
+
+  @param  This          Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+  
+  @param  FvAttributes  Pointer to an EFI_FV_ATTRIBUTES in which
+                        the attributes and current settings are
+                        returned.
+
+
+  @retval EFI_SUCCESS   The firmware volume attributes were
+                        returned.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FV_GET_ATTRIBUTES)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  OUT       EFI_FV_ATTRIBUTES             *FvAttributes
+);
+
+
+/**
+  Modifies the current settings of the firmware volume according to the input parameter.
+  
+  The SetVolumeAttributes() function is used to set configurable
+  firmware volume attributes. Only EFI_FV_READ_STATUS,
+  EFI_FV_WRITE_STATUS, and EFI_FV_LOCK_STATUS may be modified, and
+   then only in accordance with the declared capabilities. All
+  other bits of FvAttributes are ignored on input. On successful
+  return, all bits of *FvAttributes are valid and it contains the
+  completed EFI_FV_ATTRIBUTES for the volume. To modify an
+  attribute, the corresponding status bit in the EFI_FV_ATTRIBUTES
+  is set to the desired value on input. The EFI_FV_LOCK_STATUS bit
+  does not affect the ability to read or write the firmware
+  volume. Rather, once the EFI_FV_LOCK_STATUS bit is set, it
+  prevents further modification to all the attribute bits.
+  SetVolumeAttributes() is callable only from TPL_NOTIFY and
+  below. Behavior of SetVolumeAttributes() at any EFI_TPL above
+  TPL_NOTIFY is undefined.
+
+  @param  This          Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+  
+  @param  FvAttributes  On input, FvAttributes is a pointer to
+                        an EFI_FV_ATTRIBUTES containing the
+                        desired firmware volume settings. On
+                        successful return, it contains the new
+                        settings of the firmware volume. On
+                        unsuccessful return, FvAttributes is not
+                        modified and the firmware volume
+                        settings are not changed.
+  
+  @retval EFI_SUCCESS           The requested firmware volume attributes
+                                were set and the resulting
+                                EFI_FV_ATTRIBUTES is returned in
+                                FvAttributes.
+
+  @retval EFI_INVALID_PARAMETER FvAttributes:EFI_FV_READ_STATUS
+                                is set to 1 on input, but the
+                                device does not support enabling
+                                reads
+                                (FvAttributes:EFI_FV_READ_ENABLE
+                                is clear on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+  @retval EFI_INVALID_PARAMETER FvAttributes:EFI_FV_READ_STATUS
+                                is cleared to 0 on input, but
+                                the device does not support
+                                disabling reads
+                                (FvAttributes:EFI_FV_READ_DISABL
+                                is clear on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+  @retval EFI_INVALID_PARAMETER FvAttributes:EFI_FV_WRITE_STATUS
+                                is set to 1 on input, but the
+                                device does not support enabling
+                                writes
+                                (FvAttributes:EFI_FV_WRITE_ENABL
+                                is clear on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+  @retval EFI_INVALID_PARAMETER FvAttributes:EFI_FV_WRITE_STATUS
+                                is cleared to 0 on input, but
+                                the device does not support
+                                disabling writes
+                                (FvAttributes:EFI_FV_WRITE_DISAB
+                                is clear on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+  @retval EFI_INVALID_PARAMETER FvAttributes:EFI_FV_LOCK_STATUS
+                                is set on input, but the device
+                                does not support locking
+                                (FvAttributes:EFI_FV_LOCK_CAP is
+                                clear on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+  @retval EFI_ACCESS_DENIED     Device is locked and does not
+                                allow attribute modification
+                                (FvAttributes:EFI_FV_LOCK_STATUS
+                                is set on return from
+                                GetVolumeAttributes()). Actual
+                                volume attributes are unchanged.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FV_SET_ATTRIBUTES)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN OUT    EFI_FV_ATTRIBUTES             *FvAttributes
+);
+
+
+/**
+  Retrieves a file and/or file information from the firmware volume.
+
+  ReadFile() is used to retrieve any file from a firmware volume
+  during the DXE phase. The actual binary encoding of the file in
+  the firmware volume media may be in any arbitrary format as long
+  as it does the following: It is accessed using the Firmware
+  Volume Protocol. The image that is returned follows the image
+  format defined in Code Definitions: PI Firmware File Format.
+  If the input value of Buffer==NULL, it indicates the caller is
+  requesting only that the type, attributes, and size of the
+  file be returned and that there is no output buffer. In this
+  case, the following occurs:
+  - BufferSize is returned with the size that is required to
+    successfully complete the read.
+  - The output parameters FoundType and *FileAttributes are
+  returned with valid values.
+  - The returned value of *AuthenticationStatus is undefined.
+
+  If the input value of Buffer!=NULL, the output buffer is
+  specified by a double indirection of the Buffer parameter. The
+  input value of *Buffer is used to determine if the output
+  buffer is caller allocated or is dynamically allocated by
+  ReadFile(). If the input value of *Buffer!=NULL, it indicates
+  the output buffer is caller allocated. In this case, the input
+   value of *BufferSize indicates the size of the
+  caller-allocated output buffer. If the output buffer is not
+  large enough to contain the entire requested output, it is
+  filled up to the point that the output buffer is exhausted and
+  EFI_WARN_BUFFER_TOO_SMALL is returned, and then BufferSize is
+   returned with the size required to successfully complete the
+  read. All other output parameters are returned with valid
+  values. If the input value of *Buffer==NULL, it indicates the
+  output buffer is to be allocated by ReadFile(). In this case,
+  ReadFile() will allocate an appropriately sized buffer from
+  boot services pool memory, which will be returned in Buffer.
+  The size of the new buffer is returned in BufferSize and all
+  other output parameters are returned with valid values.
+  ReadFile() is callable only from TPL_NOTIFY and below.
+  Behavior of ReadFile() at any EFI_TPL above TPL_NOTIFY is
+  undefined.
+
+  @param  This                  Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+  
+  @param  NameGuid              Pointer to an EFI_GUID, which is the file
+                                name. All firmware file names are EFI_GUIDs.
+                                A single firmware volume must not have two
+                                valid files with the same file name
+                                EFI_GUID.
+  
+  @param  Buffer                Pointer to a pointer to a buffer in which the
+                                file contents are returned, not including the
+                                file header.
+
+  @param  BufferSize            Pointer to a caller-allocated UINTN. It
+                                indicates the size of the memory
+                                represented by Buffer.
+  
+  @param  FoundType             Pointer to a caller-allocated EFI_FV_FILETYPE.
+  
+  @param  FileAttributes        Pointer to a  caller-allocated
+                                EFI_FV_FILE_ATTRIBUTES.
+  
+  @param  AuthenticationStatus  Pointer to a caller-allocated
+                                UINT32 in which the
+                                authentication status is
+                                returned.
+  
+  @retval EFI_SUCCESS                 The call completed successfully.
+  
+  @retval EFI_WARN_BUFFER_TOO_SMALL   The buffer is too small to
+                                      contain the requested
+                                      output. The buffer is
+                                      filled and the output is
+                                      truncated.
+
+  @retval EFI_OUT_OF_RESOURCES        An allocation failure occurred.
+
+  @retval EFI_NOT_FOUND               Name was not found in the firmware volume.
+
+  @retval EFI_DEVICE_ERROR            A hardware error occurred when
+                                      attempting to access the firmware volume.
+
+  @retval EFI_ACCESS_DENIED           The firmware volume is configured to
+                                      disallow reads.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FV_READ_FILE)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN CONST  EFI_GUID                      *NameGuid,
+  IN OUT    VOID                          **Buffer,
+  IN OUT    UINTN                         *BufferSize,
+  OUT       EFI_FV_FILETYPE               *FoundType,
+  OUT       EFI_FV_FILE_ATTRIBUTES        *FileAttributes,
+  OUT       UINT32                        *AuthenticationStatus
+);
+
+
+
+/**
+  Locates the requested section within a file and returns it in a buffer.
+
+  ReadSection() is used to retrieve a specific section from a file
+  within a firmware volume. The section returned is determined
+  using a depth-first, left-to-right search algorithm through all
+  sections found in the specified file. The output buffer is specified by a double indirection
+  of the Buffer parameter. The input value of Buffer is used to
+  determine if the output buffer is caller allocated or is
+  dynamically allocated by ReadSection(). If the input value of
+  Buffer!=NULL, it indicates that the output buffer is caller
+  allocated. In this case, the input value of *BufferSize
+  indicates the size of the caller-allocated output buffer. If
+  the output buffer is not large enough to contain the entire
+  requested output, it is filled up to the point that the output
+  buffer is exhausted and EFI_WARN_BUFFER_TOO_SMALL is returned,
+  and then BufferSize is returned with the size that is required
+  to successfully complete the read. All other
+  output parameters are returned with valid values. If the input
+  value of *Buffer==NULL, it indicates the output buffer is to
+  be allocated by ReadSection(). In this case, ReadSection()
+  will allocate an appropriately sized buffer from boot services
+  pool memory, which will be returned in *Buffer. The size of
+  the new buffer is returned in *BufferSize and all other output
+  parameters are returned with valid values. ReadSection() is
+  callable only from TPL_NOTIFY and below. Behavior of
+  ReadSection() at any EFI_TPL above TPL_NOTIFY is
+  undefined.
+
+  @param  This                Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+ 
+  @param NameGuid             Pointer to an EFI_GUID, which indicates the
+                              file name from which the requested section
+                              will be read.
+  
+  @param SectionType          Indicates the section type to return.
+                              SectionType in conjunction with
+                              SectionInstance indicates which section to
+                              return.
+  
+  @param SectionInstance      Indicates which instance of sections
+                              with a type of SectionType to return.
+                              SectionType in conjunction with
+                              SectionInstance indicates which
+                              section to return. SectionInstance is
+                              zero based.
+  
+  @param Buffer               Pointer to a pointer to a buffer in which the
+                              section contents are returned, not including
+                              the section header.
+  
+  @param BufferSize           Pointer to a caller-allocated UINTN. It
+                              indicates the size of the memory
+                              represented by Buffer.
+  
+  @param AuthenticationStatus Pointer to a caller-allocated
+                              UINT32 in which the authentication
+                              status is returned.
+  
+  
+  @retval EFI_SUCCESS   The call completed successfully.
+  
+  @retval EFI_WARN_BUFFER_TOO_SMALL   The caller-allocated
+                                      buffer is too small to
+                                      contain the requested
+                                      output. The buffer is
+                                      filled and the output is
+                                      truncated.
+  
+  @retval EFI_OUT_OF_RESOURCES  An allocation failure occurred.
+  
+  @retval EFI_NOT_FOUND   The requested file was not found in
+                          the firmware volume. EFI_NOT_FOUND The
+                          requested section was not found in the
+                          specified file.
+  
+  @retval EFI_DEVICE_ERROR  A hardware error occurred when
+                            attempting to access the firmware
+                            volume.
+  
+  @retval EFI_ACCESS_DENIED The firmware volume is configured to
+                            disallow reads. EFI_PROTOCOL_ERROR
+                            The requested section was not found,
+                            but the file could not be fully
+                            parsed because a required
+                            GUIDED_SECTION_EXTRACTION_PROTOCOL
+                            was not found. It is possible the
+                            requested section exists within the
+                            file and could be successfully
+                            extracted once the required
+                            GUIDED_SECTION_EXTRACTION_PROTOCOL
+                            is published.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FV_READ_SECTION)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN CONST  EFI_GUID                      *NameGuid,
+  IN        EFI_SECTION_TYPE              SectionType,
+  IN        UINTN                         SectionInstance,
+  IN OUT    VOID                          **Buffer,
+  IN OUT    UINTN                         *BufferSize,
+  OUT       UINT32                        *AuthenticationStatus
+);
+
+///
+/// EFI_FV_WRITE_POLICY, two policies (unreliable write and reliable write) are defined.
+///
+typedef UINT32 EFI_FV_WRITE_POLICY;
+#define EFI_FV_UNRELIABLE_WRITE   0x00000000
+#define EFI_FV_RELIABLE_WRITE     0x00000001
+
+//
+// EFI_FV_WRITE_FILE_DATA
+//
+typedef struct {
+  ///
+  /// Pointer to a GUID, which is the file name to be written.
+  ///
+  EFI_GUID                *NameGuid;
+  ///
+  /// Indicates the type of file to be written.
+  ///
+  EFI_FV_FILETYPE         Type;
+  ///
+  /// Indicates the attributes for the file to be written.
+  ///
+  EFI_FV_FILE_ATTRIBUTES  FileAttributes;
+  ///
+  /// Pointer to a buffer containing the file to be written.
+  ///
+  VOID                    *Buffer;
+  ///
+  /// Indicates the size of the file image contained in Buffer.
+  ///
+  UINT32                  BufferSize;
+} EFI_FV_WRITE_FILE_DATA;
+
+/**
+  Locates the requested section within a file and returns it in a buffer.
+
+  WriteFile() is used to write one or more files to a firmware
+  volume. Each file to be written is described by an
+  EFI_FV_WRITE_FILE_DATA structure. The caller must ensure that
+  any required alignment for all files listed in the FileData
+  array is compatible with the firmware volume. Firmware volume
+  capabilities can be determined using the GetVolumeAttributes()
+  call. Similarly, if the WritePolicy is set to
+  EFI_FV_RELIABLE_WRITE, the caller must check the firmware volume
+  capabilities to ensure EFI_FV_RELIABLE_WRITE is supported by the
+  firmware volume. EFI_FV_UNRELIABLE_WRITE must always be
+  supported. Writing a file with a size of zero
+  (FileData[n].BufferSize == 0) deletes the file from the firmware
+  volume if it exists. Deleting a file must be done one at a time.
+  Deleting a file as part of a multiple file write is not allowed.
+  Platform Initialization Specification VOLUME 3 Shared
+  Architectural Elements 84 August 21, 2006 Version 1.0
+  WriteFile() is callable only from TPL_NOTIFY and below.
+  Behavior of WriteFile() at any EFI_TPL above TPL_NOTIFY is
+  undefined. 
+
+  @param This           Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+
+  @param NumberOfFiles  Indicates the number of elements in the array pointed to by FileData
+
+  @param WritePolicy    Indicates the level of reliability for the
+                        write in the event of a power failure or
+                        other system failure during the write
+                        operation.
+ 
+  @param FileData       Pointer to an array of
+                        EFI_FV_WRITE_FILE_DATA. Each element of
+                        FileData[] represents a file to be written.
+
+
+  @retval EFI_SUCCESS             The write completed successfully.
+  
+  @retval EFI_OUT_OF_RESOURCES    The firmware volume does not
+                                  have enough free space to
+                                  storefile(s).
+  
+  @retval EFI_DEVICE_ERROR        A hardware error occurred when
+                                  attempting to access the firmware volume.
+  
+  @retval EFI_WRITE_PROTECTED     The firmware volume is
+                                  configured to disallow writes.
+  
+  @retval EFI_NOT_FOUND           A delete was requested, but the
+                                  requested file was not found in the
+                                  firmware volume.
+  
+  @retval EFI_INVALID_PARAMETER   A delete was requested with a
+                                  multiple file write.
+  
+  @retval EFI_INVALID_PARAMETER   An unsupported WritePolicy was
+                                  requested.
+
+  @retval EFI_INVALID_PARAMETER   An unknown file type was
+                                  specified.
+
+  @retval EFI_INVALID_PARAMETER   A file system specific error
+                                  has occurred.
+  
+**/
+typedef
+EFI_STATUS 
+(EFIAPI * EFI_FV_WRITE_FILE)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN        UINT32                        NumberOfFiles,
+  IN        EFI_FV_WRITE_POLICY           WritePolicy,
+  IN        EFI_FV_WRITE_FILE_DATA        *FileData
+);
+
+
+/**
+  Retrieves information about the next file in the firmware volume store 
+  that matches the search criteria.
+
+  GetNextFile() is the interface that is used to search a firmware
+  volume for a particular file. It is called successively until
+  the desired file is located or the function returns
+   EFI_NOT_FOUND. To filter uninteresting files from the output,
+  the type of file to search for may be specified in FileType. For
+  example, if *FileType is EFI_FV_FILETYPE_DRIVER, only files of
+  this type will be returned in the output. If *FileType is
+  EFI_FV_FILETYPE_ALL, no filtering of file types is done. The Key
+  parameter is used to indicate a starting point of the search. If
+  the buffer *Key is completely initialized to zero, the search
+  re-initialized and starts at the beginning. Subsequent calls to
+  GetNextFile() must maintain the value of *Key returned by the
+  immediately previous call. The actual contents of *Key are
+  implementation specific and no semantic content is implied.
+  GetNextFile() is callable only from TPL_NOTIFY and below.
+  Behavior of GetNextFile() at any EFI_TPL above TPL_NOTIFY is
+  undefined. 
+
+  @param This       Indicates the EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+
+  @param Key        Pointer to a caller-allocated buffer that contains implementation-specific data that is
+                    used to track where to begin the search for the next file. The size of the buffer must be
+                    at least This->KeySize bytes long. To re-initialize the search and begin from the
+                    beginning of the firmware volume, the entire buffer must be cleared to zero. Other
+                    than clearing the buffer to initiate a new search, the caller must not modify the data in
+                    the buffer between calls to GetNextFile().
+
+  @param FileType   Pointer to a caller-allocated
+                    EFI_FV_FILETYPE. The GetNextFile() API can
+                    filter its search for files based on the
+                    value of the FileType input. A *FileType
+                    input of EFI_FV_FILETYPE_ALL causes
+                    GetNextFile() to search for files of all
+                    types. If a file is found, the file's type
+                    is returned in FileType. *FileType is not
+                    modified if no file is found.
+
+  @param NameGuid   Pointer to a caller-allocated EFI_GUID. If a
+                    matching file is found, the file's name is
+                    returned in NameGuid. If no matching file is
+                    found, *NameGuid is not modified.
+
+  @param Attributes Pointer to a caller-allocated
+                    EFI_FV_FILE_ATTRIBUTES. If a matching file
+                    is found, the file's attributes are returned
+                    in Attributes. If no matching file is found,
+                    Attributes is not modified. Type
+                    EFI_FV_FILE_ATTRIBUTES is defined in
+                    ReadFile().
+
+  @param Size       Pointer to a caller-allocated UINTN. If a
+                    matching file is found, the file's size is
+                    returned in *Size. If no matching file is found,
+                    Size is not modified.
+
+  @retval EFI_SUCCESS       The output parameters are filled with data
+                            obtained from the first matching file that
+                            was found.
+
+  @retval FI_NOT_FOUND      No files of type FileType were found.
+
+
+  @retval EFI_DEVICE_ERROR  A hardware error occurred when
+                            attempting to access the firmware
+                            volume.
+
+  @retval EFI_ACCESS_DENIED The firmware volume is configured to
+                            disallow reads.
+
+   
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FV_GET_NEXT_FILE)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN OUT    VOID                          *Key,
+  IN OUT    EFI_FV_FILETYPE               *FileType,
+  OUT       EFI_GUID                      *NameGuid,
+  OUT       EFI_FV_FILE_ATTRIBUTES        *Attributes,
+  OUT       UINTN                         *Size
+);
+
+/**
+  Return information about a firmware volume.
+
+  The GetInfo() function returns information of type
+  InformationType for the requested firmware volume. If the volume
+  does not support the requested information type, then
+  EFI_UNSUPPORTED is returned. If the buffer is not large enough
+  to hold the requested structure, EFI_BUFFER_TOO_SMALL is
+  returned and the BufferSize is set to the size of buffer that is
+  required to make the request. The information types defined by
+  this specification are required information types that all file
+  systems must support.
+
+  @param This             A pointer to the EFI_FIRMWARE_VOLUME2_PROTOCOL
+                          instance that is the file handle the requested
+                          information is for.
+  
+  @param InformationType  The type identifier for the
+                          information being requested.
+  
+  @param BufferSize       On input, the size of Buffer. On output,
+                          the amount of data returned in Buffer. In
+                          both cases, the size is measured in bytes.
+  
+  @param Buffer           A pointer to the data buffer to return. The
+                          buffer's type is indicated by InformationType.
+  
+  
+  @retval EFI_SUCCESS           The information was retrieved.
+  
+  @retval EFI_UNSUPPORTED       The InformationType is not known.
+  
+  @retval EFI_NO_MEDIA          The device has no medium.
+  
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are
+                                corrupted.
+  
+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to
+                                read the current directory
+                                entry. BufferSize has been
+                                updated with the size needed to
+                                complete the request.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FV_GET_INFO)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN CONST  EFI_GUID                      *InformationType,
+  IN OUT    UINTN                         *BufferSize,
+  OUT       VOID                          *Buffer
+);
+
+
+/**
+  Sets information about a firmware volume.
+
+  The SetInfo() function sets information of type InformationType
+  on the requested firmware volume.
+
+
+  @param This             A pointer to the EFI_FIRMWARE_VOLUME2_PROTOCOL
+                          instance that is the file handle the information
+                          is for.
+
+  @param InformationType  The type identifier for the
+                          information being set.
+
+  @param BufferSize       The size, in bytes, of Buffer.
+
+  @param Buffer           A pointer to the data buffer to write. The
+                          buffer's type is indicated by InformationType.
+
+  @retval EFI_SUCCESS           The information was set.
+
+  @retval EFI_UNSUPPORTED       The InformationType is not known.
+
+  @retval EFI_NO_MEDIA          The device has no medium.
+
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are
+                                corrupted.
+
+
+  @retval EFI_WRITE_PROTECTED   The media is read only.
+
+  @retval EFI_VOLUME_FULL       The volume is full.
+
+  @retval EFI_BAD_BUFFER_SIZE   BufferSize is smaller than the
+                                size of the type indicated by
+                                InformationType.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FV_SET_INFO)(
+  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL *This,
+  IN CONST  EFI_GUID                      *InformationType,
+  IN        UINTN                         BufferSize,
+  IN CONST  VOID                          *Buffer
+);
+
+
+///
+/// The Firmware Volume Protocol contains the file-level
+/// abstraction to the firmware volume as well as some firmware
+/// volume attribute reporting and configuration services. The
+/// Firmware Volume Protocol is the interface used by all parts of
+/// DXE that are not directly involved with managing the firmware
+/// volume itself. This abstraction allows many varied types of
+/// firmware volume implementations. A firmware volume may be a
+/// flash device or it may be a file in the UEFI system partition,
+/// for example. This level of firmware volume implementation
+/// detail is not visible to the consumers of the Firmware Volume
+/// Protocol.
+///
+struct _EFI_FIRMWARE_VOLUME2_PROTOCOL {
+  EFI_FV_GET_ATTRIBUTES   GetVolumeAttributes;
+  EFI_FV_SET_ATTRIBUTES   SetVolumeAttributes;
+  EFI_FV_READ_FILE        ReadFile;
+  EFI_FV_READ_SECTION     ReadSection;
+  EFI_FV_WRITE_FILE       WriteFile;
+  EFI_FV_GET_NEXT_FILE    GetNextFile;
+  
+  ///
+  /// Data field that indicates the size in bytes
+  /// of the Key input buffer for the
+  /// GetNextFile() API.  
+  ///
+  UINT32                  KeySize;
+  
+  ///
+  /// Handle of the parent firmware volume.
+  ///
+  EFI_HANDLE              ParentHandle;
+  EFI_FV_GET_INFO         GetInfo;
+  EFI_FV_SET_INFO         SetInfo;
+};
+
+
+extern EFI_GUID gEfiFirmwareVolume2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/FirmwareVolumeBlock.h b/MdePkg/Include/Protocol/FirmwareVolumeBlock.h
new file mode 100644
index 000000000000..48c06e143906
--- /dev/null
+++ b/MdePkg/Include/Protocol/FirmwareVolumeBlock.h
@@ -0,0 +1,366 @@
+/** @file
+  This file provides control over block-oriented firmware devices.
+
+Copyright (c) 2006 - 2011, 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.             
+
+  @par Revision Reference: PI
+  Version 1.0 and 1.2.
+
+**/
+
+#ifndef __FIRMWARE_VOLUME_BLOCK_H__
+#define __FIRMWARE_VOLUME_BLOCK_H__
+
+//
+// EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL is defined in PI 1.0 spec and its GUID value
+// is later updated to be the same as that of EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+// defined in PI 1.2 spec. 
+//
+#define EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID \
+  { 0x8f644fa9, 0xe850, 0x4db1, {0x9c, 0xe2, 0xb, 0x44, 0x69, 0x8e, 0x8d, 0xa4 } }
+
+#define EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL_GUID \
+  { 0x8f644fa9, 0xe850, 0x4db1, {0x9c, 0xe2, 0xb, 0x44, 0x69, 0x8e, 0x8d, 0xa4 } }
+
+typedef struct _EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL;
+
+typedef EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL;    
+
+/**
+  The GetAttributes() function retrieves the attributes and
+  current settings of the block.
+
+  @param This       Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+  @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the
+                    attributes and current settings are
+                    returned. Type EFI_FVB_ATTRIBUTES_2 is defined
+                    in EFI_FIRMWARE_VOLUME_HEADER.
+
+  @retval EFI_SUCCESS The firmware volume attributes were
+                      returned.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_GET_ATTRIBUTES)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  OUT       EFI_FVB_ATTRIBUTES_2                *Attributes
+);
+
+
+/**
+  The SetAttributes() function sets configurable firmware volume
+  attributes and returns the new settings of the firmware volume.
+
+  @param This         Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+  @param Attributes   On input, Attributes is a pointer to
+                      EFI_FVB_ATTRIBUTES_2 that contains the
+                      desired firmware volume settings. On
+                      successful return, it contains the new
+                      settings of the firmware volume. Type
+                      EFI_FVB_ATTRIBUTES_2 is defined in
+                      EFI_FIRMWARE_VOLUME_HEADER.
+  
+  @retval EFI_SUCCESS           The firmware volume attributes were returned.
+
+  @retval EFI_INVALID_PARAMETER The attributes requested are in
+                                conflict with the capabilities
+                                as declared in the firmware
+                                volume header.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_SET_ATTRIBUTES)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  IN OUT    EFI_FVB_ATTRIBUTES_2                *Attributes
+);
+
+
+/**
+  The GetPhysicalAddress() function retrieves the base address of
+  a memory-mapped firmware volume. This function should be called
+  only for memory-mapped firmware volumes.
+
+  @param This     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+  
+  @param Address  Pointer to a caller-allocated
+                  EFI_PHYSICAL_ADDRESS that, on successful
+                  return from GetPhysicalAddress(), contains the
+                  base address of the firmware volume.
+  
+  @retval EFI_SUCCESS       The firmware volume base address was returned.
+  
+  @retval EFI_UNSUPPORTED   The firmware volume is not memory mapped.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_GET_PHYSICAL_ADDRESS)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  OUT       EFI_PHYSICAL_ADDRESS                *Address
+);
+
+/**
+  The GetBlockSize() function retrieves the size of the requested
+  block. It also returns the number of additional blocks with
+  the identical size. The GetBlockSize() function is used to
+  retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
+
+
+  @param This           Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+  @param Lba            Indicates the block for which to return the size.
+
+  @param BlockSize      Pointer to a caller-allocated UINTN in which
+                        the size of the block is returned.
+
+  @param NumberOfBlocks Pointer to a caller-allocated UINTN in
+                        which the number of consecutive blocks,
+                        starting with Lba, is returned. All
+                        blocks in this range have a size of
+                        BlockSize.
+
+  
+  @retval EFI_SUCCESS             The firmware volume base address was returned.
+  
+  @retval EFI_INVALID_PARAMETER   The requested LBA is out of range.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_GET_BLOCK_SIZE)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  IN        EFI_LBA                             Lba,
+  OUT       UINTN                               *BlockSize,
+  OUT       UINTN                               *NumberOfBlocks
+);
+
+
+/**
+  Reads the specified number of bytes into a buffer from the specified block.
+
+  The Read() function reads the requested number of bytes from the
+  requested block and stores them in the provided buffer.
+  Implementations should be mindful that the firmware volume
+  might be in the ReadDisabled state. If it is in this state,
+  the Read() function must return the status code
+  EFI_ACCESS_DENIED without modifying the contents of the
+  buffer. The Read() function must also prevent spanning block
+  boundaries. If a read is requested that would span a block
+  boundary, the read must read up to the boundary but not
+  beyond. The output parameter NumBytes must be set to correctly
+  indicate the number of bytes actually read. The caller must be
+  aware that a read may be partially completed.
+
+  @param This     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+  
+  @param Lba      The starting logical block index
+                  from which to read.
+
+  @param Offset   Offset into the block at which to begin reading.
+
+  @param NumBytes Pointer to a UINTN. At entry, *NumBytes
+                  contains the total size of the buffer. At
+                  exit, *NumBytes contains the total number of
+                  bytes read.
+
+  @param Buffer   Pointer to a caller-allocated buffer that will
+                  be used to hold the data that is read.
+
+  @retval EFI_SUCCESS         The firmware volume was read successfully,
+                              and contents are in Buffer.
+  
+  @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA
+                              boundary. On output, NumBytes
+                              contains the total number of bytes
+                              returned in Buffer.
+  
+  @retval EFI_ACCESS_DENIED   The firmware volume is in the
+                              ReadDisabled state.
+  
+  @retval EFI_DEVICE_ERROR    The block device is not
+                              functioning correctly and could
+                              not be read.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FVB_READ)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  IN        EFI_LBA                             Lba,
+  IN        UINTN                               Offset,
+  IN OUT    UINTN                               *NumBytes,
+  IN OUT    UINT8                               *Buffer
+);
+
+/**
+  Writes the specified number of bytes from the input buffer to the block.
+
+  The Write() function writes the specified number of bytes from
+  the provided buffer to the specified block and offset. If the
+  firmware volume is sticky write, the caller must ensure that
+  all the bits of the specified range to write are in the
+  EFI_FVB_ERASE_POLARITY state before calling the Write()
+  function, or else the result will be unpredictable. This
+  unpredictability arises because, for a sticky-write firmware
+  volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY
+  state but cannot flip it back again.  Before calling the
+  Write() function,  it is recommended for the caller to first call 
+  the EraseBlocks() function to erase the specified block to
+  write. A block erase cycle will transition bits from the
+  (NOT)EFI_FVB_ERASE_POLARITY state back to the
+  EFI_FVB_ERASE_POLARITY state. Implementations should be
+  mindful that the firmware volume might be in the WriteDisabled
+  state. If it is in this state, the Write() function must
+  return the status code EFI_ACCESS_DENIED without modifying the
+  contents of the firmware volume. The Write() function must
+  also prevent spanning block boundaries. If a write is
+  requested that spans a block boundary, the write must store up
+  to the boundary but not beyond. The output parameter NumBytes
+  must be set to correctly indicate the number of bytes actually
+  written. The caller must be aware that a write may be
+  partially completed. All writes, partial or otherwise, must be
+  fully flushed to the hardware before the Write() service
+  returns.
+
+  @param This     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+  
+  @param Lba      The starting logical block index to write to.
+  
+  @param Offset   Offset into the block at which to begin writing.
+  
+  @param NumBytes The pointer to a UINTN. At entry, *NumBytes
+                  contains the total size of the buffer. At
+                  exit, *NumBytes contains the total number of
+                  bytes actually written.
+  
+  @param Buffer   The pointer to a caller-allocated buffer that
+                  contains the source for the write.
+  
+  @retval EFI_SUCCESS         The firmware volume was written successfully.
+  
+  @retval EFI_BAD_BUFFER_SIZE The write was attempted across an
+                              LBA boundary. On output, NumBytes
+                              contains the total number of bytes
+                              actually written.
+  
+  @retval EFI_ACCESS_DENIED   The firmware volume is in the
+                              WriteDisabled state.
+  
+  @retval EFI_DEVICE_ERROR    The block device is malfunctioning
+                              and could not be written.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_WRITE)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  IN        EFI_LBA                             Lba,
+  IN        UINTN                               Offset,
+  IN OUT    UINTN                               *NumBytes,
+  IN        UINT8                               *Buffer
+);
+
+
+
+
+///
+/// EFI_LBA_LIST_TERMINATOR
+///
+#define EFI_LBA_LIST_TERMINATOR   0xFFFFFFFFFFFFFFFFULL
+
+
+/**
+  Erases and initializes a firmware volume block.
+
+  The EraseBlocks() function erases one or more blocks as denoted
+  by the variable argument list. The entire parameter list of
+  blocks must be verified before erasing any blocks. If a block is
+  requested that does not exist within the associated firmware
+  volume (it has a larger index than the last block of the
+  firmware volume), the EraseBlocks() function must return the
+  status code EFI_INVALID_PARAMETER without modifying the contents
+  of the firmware volume. Implementations should be mindful that
+  the firmware volume might be in the WriteDisabled state. If it
+  is in this state, the EraseBlocks() function must return the
+  status code EFI_ACCESS_DENIED without modifying the contents of
+  the firmware volume. All calls to EraseBlocks() must be fully
+  flushed to the hardware before the EraseBlocks() service
+  returns.
+
+  @param This   Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+                instance.
+
+  @param ...    The variable argument list is a list of tuples.
+                Each tuple describes a range of LBAs to erase
+                and consists of the following:
+                - An EFI_LBA that indicates the starting LBA
+                - A UINTN that indicates the number of blocks to
+                  erase.
+
+                The list is terminated with an
+                EFI_LBA_LIST_TERMINATOR. For example, the
+                following indicates that two ranges of blocks
+                (5-7 and 10-11) are to be erased: EraseBlocks
+                (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);
+
+  @retval EFI_SUCCESS The erase request successfully
+                      completed.
+  
+  @retval EFI_ACCESS_DENIED   The firmware volume is in the
+                              WriteDisabled state.
+  @retval EFI_DEVICE_ERROR  The block device is not functioning
+                            correctly and could not be written.
+                            The firmware device may have been
+                            partially erased.
+  @retval EFI_INVALID_PARAMETER One or more of the LBAs listed
+                                in the variable argument list do
+                                not exist in the firmware volume.  
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_FVB_ERASE_BLOCKS)(
+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+  ...
+);
+
+///
+/// The Firmware Volume Block Protocol is the low-level interface
+/// to a firmware volume. File-level access to a firmware volume
+/// should not be done using the Firmware Volume Block Protocol.
+/// Normal access to a firmware volume must use the Firmware
+/// Volume Protocol. Typically, only the file system driver that
+/// produces the Firmware Volume Protocol will bind to the
+/// Firmware Volume Block Protocol.
+///
+struct _EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL{
+  EFI_FVB_GET_ATTRIBUTES        GetAttributes;
+  EFI_FVB_SET_ATTRIBUTES        SetAttributes;
+  EFI_FVB_GET_PHYSICAL_ADDRESS  GetPhysicalAddress;
+  EFI_FVB_GET_BLOCK_SIZE        GetBlockSize;
+  EFI_FVB_READ                  Read;
+  EFI_FVB_WRITE                 Write;
+  EFI_FVB_ERASE_BLOCKS          EraseBlocks;
+  ///
+  /// The handle of the parent firmware volume.
+  ///  
+  EFI_HANDLE                    ParentHandle;
+};
+
+
+extern EFI_GUID gEfiFirmwareVolumeBlockProtocolGuid;
+extern EFI_GUID gEfiFirmwareVolumeBlock2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/FormBrowser2.h b/MdePkg/Include/Protocol/FormBrowser2.h
new file mode 100644
index 000000000000..de132f88c062
--- /dev/null
+++ b/MdePkg/Include/Protocol/FormBrowser2.h
@@ -0,0 +1,180 @@
+/** @file
+  This protocol is defined in UEFI spec.
+  
+  The EFI_FORM_BROWSER2_PROTOCOL is the interface to call for drivers to 
+  leverage the EFI configuration driver interface.
+  
+Copyright (c) 2006 - 2015, 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_FORM_BROWSER2_H__
+#define __EFI_FORM_BROWSER2_H__
+
+#include <Guid/HiiPlatformSetupFormset.h>
+
+#define EFI_FORM_BROWSER2_PROTOCOL_GUID \
+  {0xb9d4c360, 0xbcfb, 0x4f9b, {0x92, 0x98, 0x53, 0xc1, 0x36, 0x98, 0x22, 0x58 }}
+
+
+typedef struct _EFI_FORM_BROWSER2_PROTOCOL   EFI_FORM_BROWSER2_PROTOCOL;
+
+
+
+/**
+   
+  @param LeftColumn   The value that designates the text column
+                      where the browser window will begin from
+                      the left-hand side of the screen
+                      
+  @param RightColumn  The value that designates the text
+                      column where the browser window will end
+                      on the right-hand side of the screen.
+
+  @param TopRow       The value that designates the text row from the
+                      top of the screen where the browser window
+                      will start.
+
+  @param BottomRow    The value that designates the text row from the
+                      bottom of the screen where the browser
+                      window will end. 
+**/
+typedef struct {
+  UINTN   LeftColumn;
+  UINTN   RightColumn;
+  UINTN   TopRow;
+  UINTN   BottomRow;
+} EFI_SCREEN_DESCRIPTOR;
+
+typedef UINTN EFI_BROWSER_ACTION_REQUEST;
+
+#define EFI_BROWSER_ACTION_REQUEST_NONE   0
+#define EFI_BROWSER_ACTION_REQUEST_RESET  1
+#define EFI_BROWSER_ACTION_REQUEST_SUBMIT 2
+#define EFI_BROWSER_ACTION_REQUEST_EXIT   3
+#define EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT  4
+#define EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT 5
+#define EFI_BROWSER_ACTION_REQUEST_FORM_APPLY        6
+#define EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD      7
+#define EFI_BROWSER_ACTION_REQUEST_RECONNECT         8
+
+
+/**
+  Initialize the browser to display the specified configuration forms.
+
+  This function is the primary interface to the internal forms-based browser. 
+  The forms browser will display forms associated with the specified Handles. 
+  The browser will select all forms in packages which have the specified Type 
+  and (for EFI_HII_PACKAGE_TYPE_GUID) the specified PackageGuid.
+
+  @param This            A pointer to the EFI_FORM_BROWSER2_PROTOCOL instance
+
+  @param Handles         A pointer to an array of Handles. This value should correspond 
+                         to the value of the HII form package that is required to be displayed.
+
+  @param HandleCount     The number of Handles specified in Handle.
+
+  @param FormSetGuid     This field points to the EFI_GUID which must match the Guid field or one of the
+                         elements of the ClassId field  in the EFI_IFR_FORM_SET op-code.  If
+                         FormsetGuid is NULL, then this function will display the form set class
+                         EFI_HII_PLATFORM_SETUP_FORMSET_GUID.
+
+  @param FormId          This field specifies the identifier of the form within the form set to render as the first
+                         displayable page. If this field has a value of 0x0000, then the Forms Browser will
+                         render the first enabled form in the form set.
+
+  @param ScreenDimensions Points to recommended form dimensions, including any non-content area, in 
+                          characters.
+
+  @param ActionRequest   Points to the action recommended by the form.
+
+  @retval EFI_SUCCESS           The function completed successfully
+  
+  @retval EFI_NOT_FOUND         The variable was not found.
+  
+  @retval EFI_INVALID_PARAMETER One of the parameters has an
+                                invalid value.  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SEND_FORM2)(
+  IN CONST  EFI_FORM_BROWSER2_PROTOCOL  *This,
+  IN        EFI_HII_HANDLE              *Handle,
+  IN        UINTN                      HandleCount,
+  IN        EFI_GUID                   *FormSetGuid, OPTIONAL
+  IN        EFI_FORM_ID                FormId, OPTIONAL
+  IN CONST  EFI_SCREEN_DESCRIPTOR      *ScreenDimensions, OPTIONAL
+  OUT       EFI_BROWSER_ACTION_REQUEST *ActionRequest  OPTIONAL
+);
+
+
+/**
+  This function is called by a callback handler to retrieve uncommitted state data from the browser.
+
+  This routine is called by a routine which was called by the
+  browser. This routine called this service in the browser to
+  retrieve or set certain uncommitted state information.
+
+  @param This           A pointer to the EFI_FORM_BROWSER2_PROTOCOL instance.
+
+  @param ResultsDataSize  A pointer to the size of the buffer
+                          associated with ResultsData. On input, the size in
+                          bytes of ResultsData. On output, the size of data 
+                          returned in ResultsData.
+
+  @param ResultsData    A string returned from an IFR browser or
+                        equivalent. The results string will have
+                        no routing information in them.
+
+  @param RetrieveData   A BOOLEAN field which allows an agent to
+                        retrieve (if RetrieveData = TRUE) data
+                        from the uncommitted browser state
+                        information or set (if RetrieveData =
+                        FALSE) data in the uncommitted browser
+                        state information.
+
+  @param VariableGuid   An optional field to indicate the target
+                        variable GUID name to use.
+
+  @param VariableName   An optional field to indicate the target
+                        human-readable variable name.
+
+  @retval EFI_SUCCESS           The results have been distributed or are
+                                awaiting distribution.
+  
+  @retval EFI_OUT_OF_RESOURCES  The ResultsDataSize specified
+                                was too small to contain the
+                                results data.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_BROWSER_CALLBACK2)(
+  IN CONST  EFI_FORM_BROWSER2_PROTOCOL *This,
+  IN OUT    UINTN                     *ResultsDataSize,
+  IN OUT    EFI_STRING                ResultsData,
+  IN CONST  BOOLEAN                   RetrieveData,
+  IN CONST  EFI_GUID                  *VariableGuid, OPTIONAL
+  IN CONST  CHAR16                    *VariableName OPTIONAL
+);
+
+///
+/// This interface will allow the caller to direct the configuration 
+/// driver to use either the HII database or use the passed-in packet of data.
+///
+struct _EFI_FORM_BROWSER2_PROTOCOL {
+  EFI_SEND_FORM2         SendForm;
+  EFI_BROWSER_CALLBACK2  BrowserCallback;
+} ;
+
+extern EFI_GUID gEfiFormBrowser2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Ftp4.h b/MdePkg/Include/Protocol/Ftp4.h
new file mode 100644
index 000000000000..939ea9e9c7a3
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ftp4.h
@@ -0,0 +1,524 @@
+/** @file
+  EFI FTPv4 (File Transfer Protocol version 4) Protocol Definition
+  The EFI FTPv4 Protocol is used to locate communication devices that are 
+  supported by an EFI FTPv4 Protocol driver and to create and destroy instances
+  of the EFI FTPv4 Protocol child protocol driver that can use the underlying
+  communication device.
+  The definitions in this file are defined in UEFI Specification 2.3, which have
+  not been verified by one implementation yet.
+
+  Copyright (c) 2009 - 2011, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_FTP4_PROTOCOL_H__
+#define __EFI_FTP4_PROTOCOL_H__
+
+
+#define EFI_FTP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xfaaecb1, 0x226e, 0x4782, {0xaa, 0xce, 0x7d, 0xb9, 0xbc, 0xbf, 0x4d, 0xaf } \
+  }
+
+#define EFI_FTP4_PROTOCOL_GUID \
+  { \
+    0xeb338826, 0x681b, 0x4295, {0xb3, 0x56, 0x2b, 0x36, 0x4c, 0x75, 0x7b, 0x9 } \
+  }
+
+typedef struct _EFI_FTP4_PROTOCOL EFI_FTP4_PROTOCOL;
+
+///
+/// EFI_FTP4_CONNECTION_TOKEN
+///
+typedef struct {
+  /// 
+  /// The Event to signal after the connection is established and Status field is updated 
+  /// by the EFI FTP v4 Protocol driver. The type of Event must be 
+  /// EVENT_NOTIFY_SIGNAL, and its Task Priority Level (TPL) must be lower than or 
+  /// equal to TPL_CALLBACK. If it is set to NULL, this function will not return  until the 
+  /// function completes.
+  /// 
+  EFI_EVENT                            Event; 
+  ///
+  /// The variable to receive the result of the completed operation.
+  /// EFI_SUCCESS:              The FTP connection is established successfully
+  /// EFI_ACCESS_DENIED:        The FTP server denied the access the user's request to access it. 
+  /// EFI_CONNECTION_RESET:     The connect fails because the connection is reset either by instance 
+  ///                           itself or communication peer.
+  /// EFI_TIMEOUT:              The connection establishment timer expired and no more specific 
+  ///                           information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The active open fails because an ICMP network unreachable error is 
+  ///                           received. 
+  /// EFI_HOST_UNREACHABLE:     The active open fails because an ICMP host unreachable error is 
+  ///                           received. 
+  /// EFI_PROTOCOL_UNREACHABLE: The active open fails because an ICMP protocol unreachable error is 
+  ///                           received.
+  /// EFI_PORT_UNREACHABLE:     The connection establishment timer times out and an ICMP port 
+  ///                           unreachable error is received.
+  /// EFI_ICMP_ERROR:           The connection establishment timer timeout and some other ICMP 
+  ///                           error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurred.
+  /// 
+  EFI_STATUS                           Status;
+} EFI_FTP4_CONNECTION_TOKEN;
+
+///
+/// EFI_FTP4_CONFIG_DATA 
+///
+typedef struct {
+  /// 
+  /// Pointer to a ASCII string that contains user name. The caller is 
+  /// responsible for freeing Username after GetModeData() is called.
+  /// 
+  UINT8                                *Username;
+  /// 
+  /// Pointer to a ASCII string that contains password. The caller is 
+  /// responsible for freeing Password after GetModeData() is called.
+  /// 
+  UINT8                                *Password;
+  /// 
+  /// Set it to TRUE to initiate an active data connection. Set it to 
+  /// FALSE to initiate a passive data connection.
+  /// 
+  BOOLEAN                              Active;
+  /// 
+  /// Boolean value indicating if default network settting used.
+  /// 
+  BOOLEAN                              UseDefaultSetting;
+  /// 
+  /// IP address of station if UseDefaultSetting is FALSE.
+  /// 
+  EFI_IPv4_ADDRESS                     StationIp;
+  /// 
+  /// Subnet mask of station if UseDefaultSetting is FALSE.
+  /// 
+  EFI_IPv4_ADDRESS                     SubnetMask;
+  /// 
+  /// IP address of gateway if UseDefaultSetting is FALSE.
+  /// 
+  EFI_IPv4_ADDRESS                     GatewayIp;
+  /// 
+  /// IP address of FTPv4 server.
+  /// 
+  EFI_IPv4_ADDRESS                     ServerIp;
+  /// 
+  /// FTPv4 server port number of control connection, and the default 
+  /// value is 21 as convention.
+  /// 
+  UINT16                               ServerPort;
+  /// 
+  /// FTPv4 server port number of data connection. If it is zero, use 
+  /// (ServerPort - 1) by convention. 
+  /// 
+  UINT16                               AltDataPort;
+  /// 
+  /// A byte indicate the representation type. The right 4 bit is used for 
+  /// first parameter, the left 4 bit is use for second parameter
+  /// - For the first parameter, 0x0 = image, 0x1 = EBCDIC, 0x2 = ASCII, 0x3 = local
+  /// - For the second parameter, 0x0 = Non-print, 0x1 = Telnet format effectors, 0x2 = 
+  ///   Carriage Control.
+  /// - If it is a local type, the second parameter is the local byte byte size.
+  /// - If it is a image type, the second parameter is undefined.
+  /// 
+  UINT8                                RepType;
+  /// 
+  /// Defines the file structure in FTP used. 0x00 = file, 0x01 = record, 0x02 = page.
+  /// 
+  UINT8                                FileStruct;
+  /// 
+  /// Defines the transifer mode used in FTP. 0x00 = stream, 0x01 = Block, 0x02 = Compressed.
+  /// 
+  UINT8                                TransMode;
+} EFI_FTP4_CONFIG_DATA;
+
+typedef struct _EFI_FTP4_COMMAND_TOKEN EFI_FTP4_COMMAND_TOKEN;
+
+/**
+  Callback function when process inbound or outbound data.
+
+  If it is receiving function that leads to inbound data, the callback function
+  is called when data buffer is full. Then, old data in the data buffer should be
+  flushed and new data is stored from the beginning of data buffer.
+  If it is a transmit function that lead to outbound data and the size of 
+  Data in daata buffer has been transmitted, this callback function is called to 
+  supply additional data to be transmitted. 
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token structure to provide the parameters that
+                                 are used in this operation.
+  @return  User defined Status.
+
+**/
+typedef
+EFI_STATUS 
+(EFIAPI *EFI_FTP4_DATA_CALLBACK)( 
+  IN EFI_FTP4_PROTOCOL           *This,
+  IN EFI_FTP4_COMMAND_TOKEN      *Token
+  );
+
+///
+/// EFI_FTP4_COMMAND_TOKEN
+///
+struct _EFI_FTP4_COMMAND_TOKEN {
+  /// 
+  /// The Event to signal after request is finished and Status field 
+  /// is updated by the EFI FTP v4 Protocol driver. The type of Event 
+  /// must be EVT_NOTIFY_SIGNAL, and its Task Priority Level 
+  /// (TPL) must be lower than or equal to TPL_CALLBACK. If it is 
+  /// set to NULL, related function must wait until the function 
+  /// completes.
+  /// 
+  EFI_EVENT                             Event; 
+  /// 
+  /// Pointer to a null-terminated ASCII name string. 
+  /// 
+  UINT8                                 *Pathname;
+  /// 
+  /// The size of data buffer in bytes.
+  /// 
+  UINT64                                DataBufferSize;        
+  /// 
+  /// Pointer to the data buffer. Data downloaded from FTP server 
+  /// through connection is downloaded here.
+  /// 
+  VOID                                  *DataBuffer;
+  /// 
+  /// Pointer to a callback function. If it is receiving function that leads 
+  /// to inbound data, the callback function is called when databuffer is 
+  /// full. Then, old data in the data buffer should be flushed and new 
+  /// data is stored from the beginning of data buffer. If it is a transmit 
+  /// function that lead to outbound data and DataBufferSize of 
+  /// Data in DataBuffer has been transmitted, this callback 
+  /// function is called to supply additional data to be transmitted. The 
+  /// size of additional data to be transmitted is indicated in 
+  /// DataBufferSize, again. If there is no data remained, 
+  /// DataBufferSize should be set to 0.
+  /// 
+  EFI_FTP4_DATA_CALLBACK                *DataCallback;
+  /// 
+  /// Pointer to the parameter for DataCallback.
+  /// 
+  VOID                                  *Context;
+  /// 
+  /// The variable to receive the result of the completed operation.
+  /// EFI_SUCCESS:              The FTP command is completed successfully.
+  /// EFI_ACCESS_DENIED:        The FTP server denied the access to the requested file.
+  /// EFI_CONNECTION_RESET:     The connect fails because the connection is reset either
+  ///                           by instance itself or communication peer.
+  /// EFI_TIMEOUT:              The connection establishment timer expired and no more 
+  ///                           specific information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The active open fails because an ICMP network unreachable
+  ///                           error is received. 
+  /// EFI_HOST_UNREACHABLE:     The active open fails because an ICMP host unreachable
+  ///                           error is received. 
+  /// EFI_PROTOCOL_UNREACHABLE: The active open fails because an ICMP protocol unreachable
+  ///                           error is received.
+  /// EFI_PORT_UNREACHABLE:     The connection establishment timer times out and an ICMP port
+  ///                           unreachable error is received.
+  /// EFI_ICMP_ERROR:           The connection establishment timer timeout and some other ICMP
+  ///                           error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurred.
+  ///
+  EFI_STATUS                            Status;
+};
+
+/**
+  Gets the current operational settings.
+
+  The GetModeData() function reads the current operational settings of this
+  EFI FTPv4 Protocol driver instance. EFI_FTP4_CONFIG_DATA  is defined in the 
+  EFI_FTP4_PROTOCOL.Configure.
+
+  @param[in]  This               Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[out] ModeData           Pointer to storage for the EFI FTPv4 Protocol driver 
+                                 mode data. The string buffers for Username and Password
+                                 in EFI_FTP4_CONFIG_DATA are allocated by the function,
+                                 and the caller should take the responsibility to free the 
+                                 buffer later.
+
+  @retval EFI_SUCCESS            This function is called successfully.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - ModeData is NULL.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started
+  @retval EFI_OUT_OF_RESOURCES   Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_FTP4_GET_MODE_DATA)(
+  IN EFI_FTP4_PROTOCOL        *This,
+  OUT EFI_FTP4_CONFIG_DATA    *ModeData
+  );
+
+/**
+  Disconnecting a FTP connection gracefully.
+
+  The Connect() function will initiate a connection request to the remote FTP server
+  with the corresponding connection token. If this function returns EFI_SUCCESS, the 
+  connection sequence is initiated successfully.  If the connection succeeds or faild
+  due to any error, the Token->Event will be signaled and Token->Status will be updated
+  accordingly.
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token used to establish control connection.
+
+  @retval EFI_SUCCESS            The connection sequence is successfully initiated.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token->Event is NULL.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES   Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FTP4_CONNECT)(
+  IN EFI_FTP4_PROTOCOL           *This,
+  IN EFI_FTP4_CONNECTION_TOKEN   *Token
+  );
+
+/**
+  Disconnecting a FTP connection gracefully.
+
+  The Close() function will initiate a close request to the remote FTP server with the
+  corresponding connection token. If this function returns EFI_SUCCESS, the control 
+  connection with the remote FTP server is closed.
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token used to close control connection.
+
+  @retval EFI_SUCCESS            The close request is successfully initiated.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token->Event is NULL.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES   Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FTP4_CLOSE)(
+  IN EFI_FTP4_PROTOCOL             *This,
+  IN EFI_FTP4_CONNECTION_TOKEN     *Token
+  );
+
+/**
+  Sets or clears the operational parameters for the FTP child driver.
+
+  The Configure() function will configure the connected FTP session with the 
+  configuration setting specified in  FtpConfigData. The configuration data can
+  be reset by calling Configure() with FtpConfigData set to NULL.
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] FtpConfigData       Pointer to configuration data that will be assigned to 
+                                 the FTP child driver instance. If NULL, the FTP child
+                                 driver instance is reset to startup defaults and all 
+                                 pending transmit and receive requests are flushed.
+
+  @retval EFI_SUCCESS            The FTPv4 driver was configured successfully.
+  @retval EFI_INVALID_PARAMETER  One or more following conditions are TRUE:
+                                 - This is NULL.
+                                 - FtpConfigData.RepType is invalid.
+                                 - FtpConfigData.FileStruct is invalid.
+                                 - FtpConfigData.TransMode is invalid.
+                                 - IP address in FtpConfigData is invalid.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_UNSUPPORTED        One or more of the configuration parameters are not supported
+                                 by this implementation. 
+  @retval EFI_OUT_OF_RESOURCES   The EFI FTPv4 Protocol driver instance data could not be 
+                                 allocated.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred. The EFI FTPv4 
+                                 Protocol driver instance is not configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FTP4_CONFIGURE)(
+  IN EFI_FTP4_PROTOCOL           *This,
+  IN EFI_FTP4_CONFIG_DATA        *FtpConfigData OPTIONAL
+  );
+
+
+/**
+  Downloads a file from an FTPv4 server. 
+
+  The ReadFile() function is used to initialize and start an FTPv4 download process
+  and optionally wait for completion. When the download operation completes, whether
+  successfully or not, the Token.Status field is updated by the EFI FTPv4 Protocol 
+  driver and then Token.Event is signaled (if it is not NULL).
+
+  Data will be downloaded from the FTPv4 server into Token.DataBuffer. If the file size
+  is larger than Token.DataBufferSize, Token.DataCallback will be called to allow for 
+  processing data and then new data will be placed at the beginning of Token.DataBuffer.
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token structure to provide the parameters that
+                                 are used in this operation.
+
+  @retval EFI_SUCCESS            The data file is being downloaded successfully.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters is not valid.
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Pathname is NULL.
+                                 - Token. DataBuffer is NULL.
+                                 - Token. DataBufferSize is 0.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES   Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR       An unexpected network error or system error occurred.
+
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_FTP4_READ_FILE)(
+  IN EFI_FTP4_PROTOCOL         *This,
+  IN EFI_FTP4_COMMAND_TOKEN    *Token
+  );
+
+/**
+  Uploads a file from an FTPv4 server. 
+
+  The WriteFile() function is used to initialize and start an FTPv4 upload process and
+  optionally wait for completion. When the upload operation completes, whether successfully
+  or not, the Token.Status field is updated by the EFI FTPv4 Protocol driver and then
+  Token.Event is signaled (if it is not NULL). Data to be  uploaded to server is stored
+  into Token.DataBuffer. Token.DataBufferSize is the number bytes to be transferred. 
+  If the file size is larger than Token.DataBufferSize, Token.DataCallback will be called
+  to allow for processing data and then new data will be placed at the beginning of 
+  Token.DataBuffer. Token.DataBufferSize is updated to reflect the actual number of bytes
+  to be transferred. Token.DataBufferSize is set to 0 by the call back to indicate the
+  completion of data transfer.
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token structure to provide the parameters that
+                                 are used in this operation.
+
+  @retval EFI_SUCCESS            TThe data file is being uploaded successfully.
+  @retval EFI_UNSUPPORTED        The operation is not supported by this implementation.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters is not valid.
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Pathname is NULL.
+                                 - Token. DataBuffer is NULL.
+                                 - Token. DataBufferSize is 0.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES   Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR       An unexpected network error or system error occurred.
+
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_FTP4_WRITE_FILE)(
+  IN EFI_FTP4_PROTOCOL         *This,
+  IN EFI_FTP4_COMMAND_TOKEN    *Token
+  );
+
+/**
+  Download a data file "directory" from a FTPv4 server. May be unsupported in some EFI 
+  implementations.
+
+  The ReadDirectory() function is used to return a list of files on the FTPv4 server that
+  logically (or operationally) related to Token.Pathname, and optionally wait for completion.
+  When the download operation completes, whether successfully or not, the Token.Status field 
+  is updated by the EFI FTPv4 Protocol driver and then Token.Event is signaled (if it is not
+  NULL). Data will be downloaded from the FTPv4 server into Token.DataBuffer. If the file size
+  is larger than Token.DataBufferSize, Token.DataCallback will be called to allow for processing
+  data and then new data will be placed at the beginning of Token.DataBuffer. 
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+  @param[in] Token               Pointer to the token structure to provide the parameters that
+                                 are used in this operation.
+
+  @retval EFI_SUCCESS            The file list information is being downloaded successfully.
+  @retval EFI_UNSUPPORTED        The operation is not supported by this implementation.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters is not valid.
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token. DataBuffer is NULL.
+                                 - Token. DataBufferSize is 0.
+  @retval EFI_NOT_STARTED        The EFI FTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING         When using a default address, configuration (DHCP, BOOTP, 
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES   Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR       An unexpected network error or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FTP4_READ_DIRECTORY)(
+  IN EFI_FTP4_PROTOCOL           *This,
+  IN EFI_FTP4_COMMAND_TOKEN      *Token
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets. 
+
+  The Poll() function can be used by network drivers and applications to increase the
+  rate that data packets are moved between the communications device and the transmit
+  and receive queues. In some systems, the periodic timer event in the managed network
+  driver may not poll the underlying communications device fast enough to transmit 
+  and/or receive all data packets without missing incoming packets or dropping outgoing
+  packets. Drivers and applications that are experiencing packet loss should try calling
+  the Poll() function more often. 
+
+  @param[in] This                Pointer to the EFI_FTP4_PROTOCOL instance.
+
+  @retval EFI_SUCCESS            Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED        This EFI FTPv4 Protocol instance has not been started.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_DEVICE_ERROR       EapAuthType An unexpected system or network error occurred.
+  @retval EFI_TIMEOUT            Data was dropped out of the transmit and/or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FTP4_POLL)(
+  IN EFI_FTP4_PROTOCOL        *This
+  );
+
+///
+/// EFI_FTP4_PROTOCOL 
+/// provides basic services for client-side FTP (File Transfer Protocol) 
+/// operations.
+///
+struct _EFI_FTP4_PROTOCOL {
+  EFI_FTP4_GET_MODE_DATA     GetModeData;
+  EFI_FTP4_CONNECT           Connect;
+  EFI_FTP4_CLOSE             Close;
+  EFI_FTP4_CONFIGURE         Configure;
+  EFI_FTP4_READ_FILE         ReadFile;
+  EFI_FTP4_WRITE_FILE        WriteFile;
+  EFI_FTP4_READ_DIRECTORY    ReadDirectory;
+  EFI_FTP4_POLL              Poll;
+};
+
+extern EFI_GUID gEfiFtp4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiFtp4ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/GraphicsOutput.h b/MdePkg/Include/Protocol/GraphicsOutput.h
new file mode 100644
index 000000000000..a3432ce1d6ef
--- /dev/null
+++ b/MdePkg/Include/Protocol/GraphicsOutput.h
@@ -0,0 +1,276 @@
+/** @file
+  Graphics Output Protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple graphics device.
+
+  Copyright (c) 2006 - 2012, 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 __GRAPHICS_OUTPUT_H__
+#define __GRAPHICS_OUTPUT_H__
+
+#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \
+  { \
+    0x9042a9de, 0x23dc, 0x4a38, {0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a } \
+  }
+
+typedef struct _EFI_GRAPHICS_OUTPUT_PROTOCOL EFI_GRAPHICS_OUTPUT_PROTOCOL;
+
+typedef struct {
+  UINT32            RedMask;
+  UINT32            GreenMask;
+  UINT32            BlueMask;
+  UINT32            ReservedMask;
+} EFI_PIXEL_BITMASK;
+
+typedef enum {
+  ///
+  /// A pixel is 32-bits and byte zero represents red, byte one represents green, 
+  /// byte two represents blue, and byte three is reserved. This is the definition 
+  /// for the physical frame buffer. The byte values for the red, green, and blue 
+  /// components represent the color intensity. This color intensity value range 
+  /// from a minimum intensity of 0 to maximum intensity of 255.
+  ///
+  PixelRedGreenBlueReserved8BitPerColor,
+  ///
+  /// A pixel is 32-bits and byte zero represents blue, byte one represents green, 
+  /// byte two represents red, and byte three is reserved. This is the definition 
+  /// for the physical frame buffer. The byte values for the red, green, and blue 
+  /// components represent the color intensity. This color intensity value range 
+  /// from a minimum intensity of 0 to maximum intensity of 255.
+  ///
+  PixelBlueGreenRedReserved8BitPerColor,
+  ///
+  /// The Pixel definition of the physical frame buffer.
+  ///
+  PixelBitMask,
+  ///
+  /// This mode does not support a physical frame buffer.
+  ///
+  PixelBltOnly,
+  ///
+  /// Valid EFI_GRAPHICS_PIXEL_FORMAT enum values are less than this value.
+  ///
+  PixelFormatMax
+} EFI_GRAPHICS_PIXEL_FORMAT;
+
+typedef struct {
+  ///
+  /// The version of this data structure. A value of zero represents the 
+  /// EFI_GRAPHICS_OUTPUT_MODE_INFORMATION structure as defined in this specification.
+  ///
+  UINT32                     Version;
+  ///
+  /// The size of video screen in pixels in the X dimension.
+  ///
+  UINT32                     HorizontalResolution;
+  ///
+  /// The size of video screen in pixels in the Y dimension.
+  ///
+  UINT32                     VerticalResolution;
+  ///
+  /// Enumeration that defines the physical format of the pixel. A value of PixelBltOnly 
+  /// implies that a linear frame buffer is not available for this mode.
+  ///
+  EFI_GRAPHICS_PIXEL_FORMAT  PixelFormat;
+  ///
+  /// This bit-mask is only valid if PixelFormat is set to PixelPixelBitMask. 
+  /// A bit being set defines what bits are used for what purpose such as Red, Green, Blue, or Reserved.
+  ///
+  EFI_PIXEL_BITMASK          PixelInformation;
+  ///
+  /// Defines the number of pixel elements per video memory line.
+  /// 
+  UINT32                     PixelsPerScanLine;
+} EFI_GRAPHICS_OUTPUT_MODE_INFORMATION;
+
+/**
+  Returns information for an available graphics mode that the graphics device
+  and the set of active video output devices supports.
+
+  @param  This                  The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber            The mode number to return information on.
+  @param  SizeOfInfo            A pointer to the size, in bytes, of the Info buffer.
+  @param  Info                  A pointer to callee allocated buffer that returns information about ModeNumber.
+
+  @retval EFI_SUCCESS           Valid mode information was returned.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the video mode.
+  @retval EFI_INVALID_PARAMETER ModeNumber is not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
+  IN  UINT32                                ModeNumber,
+  OUT UINTN                                 *SizeOfInfo,
+  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
+  );
+
+/**
+  Set the video device into the specified mode and clears the visible portions of 
+  the output display to black.
+
+  @param  This              The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber        Abstraction that defines the current video mode.
+
+  @retval EFI_SUCCESS       The graphics mode specified by ModeNumber was selected.
+  @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED   ModeNumber is not supported by this device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+  IN  UINT32                       ModeNumber
+  );
+
+typedef struct {
+  UINT8 Blue;
+  UINT8 Green;
+  UINT8 Red;
+  UINT8 Reserved;
+} EFI_GRAPHICS_OUTPUT_BLT_PIXEL;
+
+typedef union {
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL Pixel;
+  UINT32                        Raw;
+} EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION;
+
+///
+/// actions for BltOperations
+///
+typedef enum {
+  ///
+  /// Write data from the BltBuffer pixel (0, 0) 
+  /// directly to every pixel of the video display rectangle 
+  /// (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height). 
+  /// Only one pixel will be used from the BltBuffer. Delta is NOT used.  
+  ///
+  EfiBltVideoFill,
+  
+  ///
+  /// Read data from the video display rectangle 
+  /// (SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in 
+  /// the BltBuffer rectangle (DestinationX, DestinationY ) 
+  /// (DestinationX + Width, DestinationY + Height). If DestinationX or 
+  /// DestinationY is not zero then Delta must be set to the length in bytes 
+  /// of a row in the BltBuffer.  
+  ///
+  EfiBltVideoToBltBuffer,
+  
+  ///
+  /// Write data from the BltBuffer rectangle 
+  /// (SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the 
+  /// video display rectangle (DestinationX, DestinationY) 
+  /// (DestinationX + Width, DestinationY + Height). If SourceX or SourceY is 
+  /// not zero then Delta must be set to the length in bytes of a row in the 
+  /// BltBuffer.
+  ///
+  EfiBltBufferToVideo, 
+  
+  ///
+  /// Copy from the video display rectangle (SourceX, SourceY)
+  /// (SourceX + Width, SourceY + Height) to the video display rectangle 
+  /// (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height). 
+  /// The BltBuffer and Delta are not used in this mode.
+  ///
+  EfiBltVideoToVideo,
+  
+  EfiGraphicsOutputBltOperationMax
+} EFI_GRAPHICS_OUTPUT_BLT_OPERATION;
+
+/**
+  Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
+  
+  @param  This         Protocol instance pointer.
+  @param  BltBuffer    The data to transfer to the graphics screen.
+                       Size is at least Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL).
+  @param  BltOperation The operation to perform when copying BltBuffer on to the graphics screen.
+  @param  SourceX      The X coordinate of source for the BltOperation.
+  @param  SourceY      The Y coordinate of source for the BltOperation.
+  @param  DestinationX The X coordinate of destination for the BltOperation.
+  @param  DestinationY The Y coordinate of destination for the BltOperation.
+  @param  Width        The width of a rectangle in the blt rectangle in pixels.
+  @param  Height       The height of a rectangle in the blt rectangle in pixels.
+  @param  Delta        Not used for EfiBltVideoFill or the EfiBltVideoToVideo operation.
+                       If a Delta of zero is used, the entire BltBuffer is being operated on.
+                       If a subrectangle of the BltBuffer is being used then Delta
+                       represents the number of bytes in a row of the BltBuffer.
+
+  @retval EFI_SUCCESS           BltBuffer was drawn to the graphics screen.
+  @retval EFI_INVALID_PARAMETER BltOperation is not valid.
+  @retval EFI_DEVICE_ERROR      The device had an error and could not complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT)(
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
+  IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL           *BltBuffer,   OPTIONAL
+  IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION       BltOperation,
+  IN  UINTN                                   SourceX,
+  IN  UINTN                                   SourceY,
+  IN  UINTN                                   DestinationX,
+  IN  UINTN                                   DestinationY,
+  IN  UINTN                                   Width,
+  IN  UINTN                                   Height,
+  IN  UINTN                                   Delta         OPTIONAL
+  );
+
+typedef struct {
+  ///
+  /// The number of modes supported by QueryMode() and SetMode().
+  ///
+  UINT32                                 MaxMode;
+  ///
+  /// Current Mode of the graphics device. Valid mode numbers are 0 to MaxMode -1.
+  ///
+  UINT32                                 Mode;
+  ///
+  /// Pointer to read-only EFI_GRAPHICS_OUTPUT_MODE_INFORMATION data.
+  ///
+  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   *Info;
+  ///
+  /// Size of Info structure in bytes.
+  ///
+  UINTN                                  SizeOfInfo;
+  ///
+  /// Base address of graphics linear frame buffer.
+  /// Offset zero in FrameBufferBase represents the upper left pixel of the display.
+  ///
+  EFI_PHYSICAL_ADDRESS                   FrameBufferBase;
+  ///
+  /// Amount of frame buffer needed to support the active mode as defined by 
+  /// PixelsPerScanLine xVerticalResolution x PixelElementSize.
+  ///
+  UINTN                                  FrameBufferSize;
+} EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE;
+
+///
+/// Provides a basic abstraction to set video modes and copy pixels to and from 
+/// the graphics controller's frame buffer. The linear address of the hardware 
+/// frame buffer is also exposed so software can write directly to the video hardware.
+///
+struct _EFI_GRAPHICS_OUTPUT_PROTOCOL {
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_QUERY_MODE  QueryMode;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_SET_MODE    SetMode;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_BLT         Blt;
+  ///
+  /// Pointer to EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE data.
+  ///
+  EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE        *Mode;
+};
+
+extern EFI_GUID gEfiGraphicsOutputProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/GuidedSectionExtraction.h b/MdePkg/Include/Protocol/GuidedSectionExtraction.h
new file mode 100644
index 000000000000..8f35002cdd41
--- /dev/null
+++ b/MdePkg/Include/Protocol/GuidedSectionExtraction.h
@@ -0,0 +1,141 @@
+/** @file
+  If a GUID-defined section is encountered when doing section
+  extraction, the section extraction driver calls the appropriate
+  instance of the GUIDed Section Extraction Protocol to extract
+  the section stream contained therein.
+
+  Copyright (c) 2006 - 2008, 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.             
+
+  @par Revision Reference: PI
+  Version 1.00.
+
+**/
+
+#ifndef __GUID_SECTION_EXTRACTION_PROTOCOL_H__
+#define __GUID_SECTION_EXTRACTION_PROTOCOL_H__
+
+//
+// The protocol interface structures are identified by associating 
+// them with a GUID. Each instance of a protocol with a given 
+// GUID must have the same interface structure. While all instances 
+// of the GUIDed Section Extraction Protocol must have the same 
+// interface structure, they do not all have the same GUID. The 
+// GUID that is associated with an instance of the GUIDed Section 
+// Extraction Protocol is used to correlate it with the GUIDed 
+// section type that it is intended to process. 
+//
+
+typedef struct _EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL;
+
+
+/**
+  The ExtractSection() function processes the input section and
+  allocates a buffer from the pool in which it returns the section
+  contents. If the section being extracted contains
+  authentication information (the section's
+  GuidedSectionHeader.Attributes field has the
+  EFI_GUIDED_SECTION_AUTH_STATUS_VALID bit set), the values
+  returned in AuthenticationStatus must reflect the results of
+  the authentication operation. Depending on the algorithm and
+  size of the encapsulated data, the time that is required to do
+  a full authentication may be prohibitively long for some
+  classes of systems. To indicate this, use
+  EFI_SECURITY_POLICY_PROTOCOL_GUID, which may be published by
+  the security policy driver (see the Platform Initialization
+  Driver Execution Environment Core Interface Specification for
+  more details and the GUID definition). If the
+  EFI_SECURITY_POLICY_PROTOCOL_GUID exists in the handle
+  database, then, if possible, full authentication should be
+  skipped and the section contents simply returned in the
+  OutputBuffer. In this case, the
+  EFI_AUTH_STATUS_PLATFORM_OVERRIDE bit AuthenticationStatus
+  must be set on return. ExtractSection() is callable only from
+  TPL_NOTIFY and below. Behavior of ExtractSection() at any
+  EFI_TPL above TPL_NOTIFY is undefined. Type EFI_TPL is
+  defined in RaiseTPL() in the UEFI 2.0 specification.
+
+  
+  @param This         Indicates the EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL instance.
+  
+  @param InputSection Buffer containing the input GUIDed section
+                      to be processed. OutputBuffer OutputBuffer
+                      is allocated from boot services pool
+                      memory and contains the new section
+                      stream. The caller is responsible for
+                      freeing this buffer.
+
+  @param OutputSize   A pointer to a caller-allocated UINTN in
+                      which the size of OutputBuffer allocation
+                      is stored. If the function returns
+                      anything other than EFI_SUCCESS, the value
+                      of OutputSize is undefined.
+
+  @param AuthenticationStatus A pointer to a caller-allocated
+                              UINT32 that indicates the
+                              authentication status of the
+                              output buffer. If the input
+                              section's
+                              GuidedSectionHeader.Attributes
+                              field has the
+                              EFI_GUIDED_SECTION_AUTH_STATUS_VAL
+                              bit as clear, AuthenticationStatus
+                              must return zero. Both local bits
+                              (19:16) and aggregate bits (3:0)
+                              in AuthenticationStatus are
+                              returned by ExtractSection().
+                              These bits reflect the status of
+                              the extraction operation. The bit
+                              pattern in both regions must be
+                              the same, as the local and
+                              aggregate authentication statuses
+                              have equivalent meaning at this
+                              level. If the function returns
+                              anything other than EFI_SUCCESS,
+                              the value of AuthenticationStatus
+                              is undefined.
+
+  @retval EFI_SUCCESS           The InputSection was successfully
+                                processed and the section contents were
+                                returned.
+
+  @retval EFI_OUT_OF_RESOURCES  The system has insufficient
+                                resources to process the
+                                request.
+
+  @retval EFI_INVALID_PARAMETER The GUID in InputSection does
+                                not match this instance of the
+                                GUIDed Section Extraction
+                                Protocol.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXTRACT_GUIDED_SECTION)(
+  IN CONST  EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL  *This,
+  IN CONST  VOID                                    *InputSection,
+  OUT       VOID                                    **OutputBuffer,
+  OUT       UINTN                                   *OutputSize,
+  OUT       UINT32                                  *AuthenticationStatus
+);
+
+
+///
+/// Typically, protocol interface structures are identified by associating them with a GUID. Each
+/// instance of a protocol with a given GUID must have the same interface structure. While all instances
+/// of the GUIDed Section Extraction Protocol must have the same interface structure, they do not all
+/// have the same GUID. The GUID that is associated with an instance of the GUIDed Section
+/// Extraction Protocol is used to correlate it with the GUIDed section type that it is intended to process.
+///
+struct _EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL {
+  EFI_EXTRACT_GUIDED_SECTION  ExtractSection;
+};
+
+
+#endif
diff --git a/MdePkg/Include/Protocol/Hash.h b/MdePkg/Include/Protocol/Hash.h
new file mode 100644
index 000000000000..872dfb7abfd0
--- /dev/null
+++ b/MdePkg/Include/Protocol/Hash.h
@@ -0,0 +1,175 @@
+/** @file
+  EFI_HASH_SERVICE_BINDING_PROTOCOL as defined in UEFI 2.0.
+  EFI_HASH_PROTOCOL as defined in UEFI 2.0.
+  The EFI Hash Service Binding Protocol is used to locate hashing services support 
+  provided by a driver and to create and destroy instances of the EFI Hash Protocol 
+  so that a multiple drivers can use the underlying hashing services.
+
+Copyright (c) 2006 - 2014, 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_HASH_PROTOCOL_H__
+#define __EFI_HASH_PROTOCOL_H__
+
+#define EFI_HASH_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x42881c98, 0xa4f3, 0x44b0, {0xa3, 0x9d, 0xdf, 0xa1, 0x86, 0x67, 0xd8, 0xcd } \
+  }
+  
+#define EFI_HASH_PROTOCOL_GUID \
+  { \
+    0xc5184932, 0xdba5, 0x46db, {0xa5, 0xba, 0xcc, 0x0b, 0xda, 0x9c, 0x14, 0x35 } \
+  }
+
+#define EFI_HASH_ALGORITHM_SHA1_GUID \
+  { \
+    0x2ae9d80f, 0x3fb2, 0x4095, {0xb7, 0xb1, 0xe9, 0x31, 0x57, 0xb9, 0x46, 0xb6 } \
+  }
+
+#define EFI_HASH_ALGORITHM_SHA224_GUID \
+  { \
+    0x8df01a06, 0x9bd5, 0x4bf7, {0xb0, 0x21, 0xdb, 0x4f, 0xd9, 0xcc, 0xf4, 0x5b } \
+  } 
+
+#define EFI_HASH_ALGORITHM_SHA256_GUID \
+  { \
+    0x51aa59de, 0xfdf2, 0x4ea3, {0xbc, 0x63, 0x87, 0x5f, 0xb7, 0x84, 0x2e, 0xe9 } \
+  } 
+
+#define EFI_HASH_ALGORITHM_SHA384_GUID \
+  { \
+    0xefa96432, 0xde33, 0x4dd2, {0xae, 0xe6, 0x32, 0x8c, 0x33, 0xdf, 0x77, 0x7a } \
+  } 
+
+#define EFI_HASH_ALGORITHM_SHA512_GUID \
+  { \
+    0xcaa4381e, 0x750c, 0x4770, {0xb8, 0x70, 0x7a, 0x23, 0xb4, 0xe4, 0x21, 0x30 } \
+  }
+
+#define EFI_HASH_ALGORTIHM_MD5_GUID \
+  { \
+    0xaf7c79c, 0x65b5, 0x4319, {0xb0, 0xae, 0x44, 0xec, 0x48, 0x4e, 0x4a, 0xd7 } \
+  }
+
+#define EFI_HASH_ALGORITHM_SHA1_NOPAD_GUID \
+  { \
+    0x24c5dc2f, 0x53e2, 0x40ca, {0x9e, 0xd6, 0xa5, 0xd9, 0xa4, 0x9f, 0x46, 0x3b } \
+  }
+
+#define EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID \
+  { \
+    0x8628752a, 0x6cb7, 0x4814, {0x96, 0xfc, 0x24, 0xa8, 0x15, 0xac, 0x22, 0x26 } \
+  }
+
+//
+// Note: Use of the following algorithms with EFI_HASH_PROTOCOL is deprecated.
+//       EFI_HASH_ALGORITHM_SHA1_GUID
+//       EFI_HASH_ALGORITHM_SHA224_GUID
+//       EFI_HASH_ALGORITHM_SHA256_GUID
+//       EFI_HASH_ALGORITHM_SHA384_GUID
+//       EFI_HASH_ALGORITHM_SHA512_GUID
+//       EFI_HASH_ALGORTIHM_MD5_GUID
+//
+
+typedef struct _EFI_HASH_PROTOCOL EFI_HASH_PROTOCOL;
+
+typedef UINT8  EFI_MD5_HASH[16];
+typedef UINT8  EFI_SHA1_HASH[20];
+typedef UINT8  EFI_SHA224_HASH[28];
+typedef UINT8  EFI_SHA256_HASH[32];
+typedef UINT8  EFI_SHA384_HASH[48];
+typedef UINT8  EFI_SHA512_HASH[64];
+
+typedef union {
+  EFI_MD5_HASH     *Md5Hash;
+  EFI_SHA1_HASH    *Sha1Hash;
+  EFI_SHA224_HASH  *Sha224Hash;
+  EFI_SHA256_HASH  *Sha256Hash;
+  EFI_SHA384_HASH  *Sha384Hash;
+  EFI_SHA512_HASH  *Sha512Hash;
+} EFI_HASH_OUTPUT;
+
+/**
+  Returns the size of the hash which results from a specific algorithm.
+
+  @param[in]  This                  Points to this instance of EFI_HASH_PROTOCOL.
+  @param[in]  HashAlgorithm         Points to the EFI_GUID which identifies the algorithm to use.
+  @param[out] HashSize              Holds the returned size of the algorithm's hash.
+
+  @retval EFI_SUCCESS           Hash size returned successfully.
+  @retval EFI_INVALID_PARAMETER HashSize is NULL or HashAlgorithm is NULL.
+  @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported 
+                                by this driver.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH_GET_HASH_SIZE)(
+  IN  CONST EFI_HASH_PROTOCOL     *This,
+  IN  CONST EFI_GUID              *HashAlgorithm,
+  OUT UINTN                       *HashSize
+  );      
+
+/**
+  Creates a hash for the specified message text.
+
+  @param[in]  This          Points to this instance of EFI_HASH_PROTOCOL.
+  @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
+  @param[in]  Extend        Specifies whether to create a new hash (FALSE) or extend the specified
+                            existing hash (TRUE).
+  @param[in]  Message       Points to the start of the message.
+  @param[in]  MessageSize   The size of Message, in bytes.
+  @param[in,out]  Hash      On input, if Extend is TRUE, then this parameter holds a pointer 
+                            to a pointer to an array containing the hash to extend. If Extend 
+                            is FALSE, then this parameter holds a pointer to a pointer to a 
+                            caller-allocated array that will receive the result of the hash 
+                            computation. On output (regardless of the value of Extend), the 
+                            array will contain the result of the hash computation.
+  
+  @retval EFI_SUCCESS           Hash returned successfully.
+  @retval EFI_INVALID_PARAMETER Message or Hash, HashAlgorithm is NULL or MessageSize is 0.
+                                MessageSize is not an integer multiple of block size.
+  @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this
+                                 driver. Or, Extend is TRUE, and the algorithm doesn't support extending the hash.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH_HASH)(
+  IN CONST EFI_HASH_PROTOCOL      *This,
+  IN CONST EFI_GUID               *HashAlgorithm,
+  IN BOOLEAN                      Extend,
+  IN CONST UINT8                  *Message,
+  IN UINT64                       MessageSize,
+  IN OUT EFI_HASH_OUTPUT          *Hash
+  );    
+
+///
+/// This protocol allows creating a hash of an arbitrary message digest 
+/// using one or more hash algorithms.
+///
+struct _EFI_HASH_PROTOCOL {
+  EFI_HASH_GET_HASH_SIZE          GetHashSize;
+  EFI_HASH_HASH                   Hash;
+};
+
+extern EFI_GUID gEfiHashServiceBindingProtocolGuid;
+extern EFI_GUID gEfiHashProtocolGuid;
+extern EFI_GUID gEfiHashAlgorithmSha1Guid;
+extern EFI_GUID gEfiHashAlgorithmSha224Guid;
+extern EFI_GUID gEfiHashAlgorithmSha256Guid;
+extern EFI_GUID gEfiHashAlgorithmSha384Guid;
+extern EFI_GUID gEfiHashAlgorithmSha512Guid;
+extern EFI_GUID gEfiHashAlgorithmMD5Guid;
+extern EFI_GUID gEfiHashAlgorithmSha1NoPadGuid;
+extern EFI_GUID gEfiHashAlgorithmSha256NoPadGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Hash2.h b/MdePkg/Include/Protocol/Hash2.h
new file mode 100644
index 000000000000..d049e8faffa2
--- /dev/null
+++ b/MdePkg/Include/Protocol/Hash2.h
@@ -0,0 +1,202 @@
+/** @file
+  EFI_HASH2_SERVICE_BINDING_PROTOCOL as defined in UEFI 2.5.
+  EFI_HASH2_PROTOCOL as defined in UEFI 2.5.
+  The EFI Hash2 Service Binding Protocol is used to locate hashing services support
+  provided by a driver and to create and destroy instances of the EFI Hash2 Protocol
+  so that a multiple drivers can use the underlying hashing services.
+  EFI_HASH2_PROTOCOL describes hashing functions for which the algorithm-required
+  message padding and finalization are performed by the supporting driver.
+
+Copyright (c) 2015, 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_HASH2_PROTOCOL_H__
+#define __EFI_HASH2_PROTOCOL_H__
+
+#define EFI_HASH2_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xda836f8d, 0x217f, 0x4ca0, { 0x99, 0xc2, 0x1c, 0xa4, 0xe1, 0x60, 0x77, 0xea } \
+  }
+
+#define EFI_HASH2_PROTOCOL_GUID \
+  { \
+    0x55b1d734, 0xc5e1, 0x49db, { 0x96, 0x47, 0xb1, 0x6a, 0xfb, 0xe, 0x30, 0x5b } \
+  }
+
+#include <Protocol/Hash.h>
+
+//
+// NOTE:
+// Algorithms EFI_HASH_ALGORITHM_SHA1_NOPAD and
+// EFI_HASH_ALGORITHM_SHA256_NOPAD_GUID are not compatible with
+// EFI_HASH2_PROTOCOL and will return EFI_UNSUPPORTED if used with any
+// EFI_HASH2_PROTOCOL function.
+//
+
+//
+// Note: SHA-1 and MD5 are included for backwards compatibility.
+// New driver implementations are encouraged to consider stronger algorithms.
+//
+
+typedef struct _EFI_HASH2_PROTOCOL EFI_HASH2_PROTOCOL;
+
+typedef UINT8  EFI_MD5_HASH2[16];
+typedef UINT8  EFI_SHA1_HASH2[20];
+typedef UINT8  EFI_SHA224_HASH2[28];
+typedef UINT8  EFI_SHA256_HASH2[32];
+typedef UINT8  EFI_SHA384_HASH2[48];
+typedef UINT8  EFI_SHA512_HASH2[64];
+
+typedef union {
+  EFI_MD5_HASH2     Md5Hash;
+  EFI_SHA1_HASH2    Sha1Hash;
+  EFI_SHA224_HASH2  Sha224Hash;
+  EFI_SHA256_HASH2  Sha256Hash;
+  EFI_SHA384_HASH2  Sha384Hash;
+  EFI_SHA512_HASH2  Sha512Hash;
+} EFI_HASH2_OUTPUT;
+
+/**
+  Returns the size of the hash which results from a specific algorithm.
+
+  @param[in]  This                  Points to this instance of EFI_HASH2_PROTOCOL.
+  @param[in]  HashAlgorithm         Points to the EFI_GUID which identifies the algorithm to use.
+  @param[out] HashSize              Holds the returned size of the algorithm's hash.
+
+  @retval EFI_SUCCESS           Hash size returned successfully.
+  @retval EFI_INVALID_PARAMETER This or HashSize is NULL.
+  @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
+                                or HashAlgorithm is null.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH2_GET_HASH_SIZE)(
+  IN  CONST EFI_HASH2_PROTOCOL     *This,
+  IN  CONST EFI_GUID               *HashAlgorithm,
+  OUT UINTN                        *HashSize
+  );
+
+/**
+  Creates a hash for the specified message text. The hash is not extendable.
+  The output is final with any algorithm-required padding added by the function.
+
+  @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
+  @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
+  @param[in]  Message       Points to the start of the message.
+  @param[in]  MessageSize   The size of Message, in bytes.
+  @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
+                              returned by GetHashSize() for the specified HashAlgorithm.
+                            On output, the buffer holds the resulting hash computed from the message.
+
+  @retval EFI_SUCCESS           Hash returned successfully.
+  @retval EFI_INVALID_PARAMETER This or Hash is NULL.
+  @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
+                                or HashAlgorithm is Null.
+  @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
+                                or MessageSize is greater than platform maximum.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH2_HASH)(
+  IN CONST EFI_HASH2_PROTOCOL      *This,
+  IN CONST EFI_GUID                *HashAlgorithm,
+  IN CONST UINT8                   *Message,
+  IN UINTN                         MessageSize,
+  IN OUT EFI_HASH2_OUTPUT          *Hash
+  );
+
+/**
+  This function must be called to initialize a digest calculation to be subsequently performed using the
+  EFI_HASH2_PROTOCOL functions HashUpdate() and HashFinal().
+
+  @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
+  @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
+
+  @retval EFI_SUCCESS           Initialized successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
+                                or HashAlgorithm is Null.
+  @retval EFI_OUT_OF_RESOURCES  Process failed due to lack of required resource.
+  @retval EFI_ALREADY_STARTED   This function is called when the operation in progress is still in processing Hash(),
+                                or HashInit() is already called before and not terminated by HashFinal() yet on the same instance.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH2_HASH_INIT)(
+  IN CONST EFI_HASH2_PROTOCOL      *This,
+  IN CONST EFI_GUID                *HashAlgorithm
+  );
+
+/**
+  Updates the hash of a computation in progress by adding a message text.
+
+  @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
+  @param[in]  Message       Points to the start of the message.
+  @param[in]  MessageSize   The size of Message, in bytes.
+
+  @retval EFI_SUCCESS           Digest in progress updated successfully.
+  @retval EFI_INVALID_PARAMETER This or Hash is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
+                                or MessageSize is greater than platform maximum.
+  @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit(),
+                                or the operation in progress was terminated by a call to Hash() or HashFinal() on the same instance.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH2_HASH_UPDATE)(
+  IN CONST EFI_HASH2_PROTOCOL      *This,
+  IN CONST UINT8                   *Message,
+  IN UINTN                         MessageSize
+  );
+
+/**
+  Finalizes a hash operation in progress and returns calculation result.
+  The output is final with any necessary padding added by the function.
+  The hash may not be further updated or extended after HashFinal().
+
+  @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
+  @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
+                              returned by GetHashSize() for the specified HashAlgorithm specified in preceding HashInit().
+                            On output, the buffer holds the resulting hash computed from the message.
+
+  @retval EFI_SUCCESS           Hash returned successfully.
+  @retval EFI_INVALID_PARAMETER This or Hash is NULL.
+  @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit() and at least one call to HashUpdate(),
+                                or the operation in progress was canceled by a call to Hash() on the same instance.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HASH2_HASH_FINAL)(
+  IN CONST EFI_HASH2_PROTOCOL      *This,
+  IN OUT EFI_HASH2_OUTPUT          *Hash
+  );
+
+///
+/// This protocol describes hashing functions for which the algorithm-required message padding and
+/// finalization are performed by the supporting driver.
+///
+struct _EFI_HASH2_PROTOCOL {
+  EFI_HASH2_GET_HASH_SIZE          GetHashSize;
+  EFI_HASH2_HASH                   Hash;
+  EFI_HASH2_HASH_INIT              HashInit;
+  EFI_HASH2_HASH_UPDATE            HashUpdate;
+  EFI_HASH2_HASH_FINAL             HashFinal;
+};
+
+extern EFI_GUID gEfiHash2ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiHash2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/HiiConfigAccess.h b/MdePkg/Include/Protocol/HiiConfigAccess.h
new file mode 100644
index 000000000000..3b076511c6e2
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiConfigAccess.h
@@ -0,0 +1,223 @@
+/** @file
+
+  The EFI HII results processing protocol invokes this type of protocol 
+  when it needs to forward results to a driver's configuration handler. 
+  This protocol is published by drivers providing and requesting 
+  configuration data from HII. It may only be invoked by HII.
+  
+Copyright (c) 2006 - 2016, 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_HII_CONFIG_ACCESS_H__
+#define __EFI_HII_CONFIG_ACCESS_H__
+
+#include <Protocol/FormBrowser2.h>
+
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID  \
+  { 0x330d4706, 0xf2a0, 0x4e4f, { 0xa3, 0x69, 0xb6, 0x6f, 0xa8, 0xd5, 0x43, 0x85 } }
+
+typedef struct _EFI_HII_CONFIG_ACCESS_PROTOCOL  EFI_HII_CONFIG_ACCESS_PROTOCOL;
+
+typedef UINTN EFI_BROWSER_ACTION;
+
+#define EFI_BROWSER_ACTION_CHANGING   0
+#define EFI_BROWSER_ACTION_CHANGED    1
+#define EFI_BROWSER_ACTION_RETRIEVE   2
+#define EFI_BROWSER_ACTION_FORM_OPEN  3
+#define EFI_BROWSER_ACTION_FORM_CLOSE 4
+#define EFI_BROWSER_ACTION_SUBMITTED  5
+#define EFI_BROWSER_ACTION_DEFAULT_STANDARD      0x1000
+#define EFI_BROWSER_ACTION_DEFAULT_MANUFACTURING 0x1001
+#define EFI_BROWSER_ACTION_DEFAULT_SAFE          0x1002
+#define EFI_BROWSER_ACTION_DEFAULT_PLATFORM      0x2000
+#define EFI_BROWSER_ACTION_DEFAULT_HARDWARE      0x3000
+#define EFI_BROWSER_ACTION_DEFAULT_FIRMWARE      0x4000
+
+/**
+   
+  This function allows the caller to request the current
+  configuration for one or more named elements. The resulting
+  string is in <ConfigAltResp> format. Any and all alternative
+  configuration strings shall also be appended to the end of the
+  current configuration string. If they are, they must appear
+  after the current configuration. They must contain the same
+  routing (GUID, NAME, PATH) as the current configuration string.
+  They must have an additional description indicating the type of
+  alternative configuration the string represents,
+  "ALTCFG=<StringToken>". That <StringToken> (when
+  converted from Hex UNICODE to binary) is a reference to a
+  string in the associated string pack.
+
+  @param This       Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
+
+  @param Request    A null-terminated Unicode string in
+                    <ConfigRequest> format. Note that this
+                    includes the routing information as well as
+                    the configurable name / value pairs. It is
+                    invalid for this string to be in
+                    <MultiConfigRequest> format. 
+                    If a NULL is passed in for the Request field, 
+                    all of the settings being abstracted by this function 
+                    will be returned in the Results field.  In addition, 
+                    if a ConfigHdr is passed in with no request elements, 
+                    all of the settings being abstracted for that particular 
+                    ConfigHdr reference will be returned in the Results Field.
+
+  @param Progress   On return, points to a character in the
+                    Request string. Points to the string's null
+                    terminator if request was successful. Points
+                    to the most recent "&" before the first
+                    failing name / value pair (or the beginning
+                    of the string if the failure is in the first
+                    name / value pair) if the request was not
+                    successful.
+
+  @param Results    A null-terminated Unicode string in
+                    <MultiConfigAltResp> format which has all values
+                    filled in for the names in the Request string.
+                    String to be allocated by the called function.
+
+  @retval EFI_SUCCESS             The Results string is filled with the
+                                  values corresponding to all requested
+                                  names.
+
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
+                                  parts of the results that must be
+                                  stored awaiting possible future
+                                  protocols.
+
+  @retval EFI_NOT_FOUND           A configuration element matching 
+                                  the routing data is not found.
+                                  Progress set to the first character
+                                  in the routing header.
+
+  @retval EFI_INVALID_PARAMETER   Illegal syntax. Progress set
+                                  to most recent "&" before the
+                                  error or the beginning of the
+                                  string.
+
+  @retval EFI_INVALID_PARAMETER   Unknown name. Progress points
+                                  to the & before the name in
+                                  question.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_ACCESS_EXTRACT_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
+  IN CONST  EFI_STRING                      Request,
+  OUT       EFI_STRING                      *Progress,
+  OUT       EFI_STRING                      *Results
+);
+
+
+/**
+   
+  This function applies changes in a driver's configuration.
+  Input is a Configuration, which has the routing data for this
+  driver followed by name / value configuration pairs. The driver
+  must apply those pairs to its configurable storage. If the
+  driver's configuration is stored in a linear block of data
+  and the driver's name / value pairs are in <BlockConfig>
+  format, it may use the ConfigToBlock helper function (above) to
+  simplify the job.
+
+  @param This           Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
+
+  @param Configuration  A null-terminated Unicode string in
+                        <ConfigString> format. 
+  
+  @param Progress       A pointer to a string filled in with the
+                        offset of the most recent '&' before the
+                        first failing name / value pair (or the
+                        beginn ing of the string if the failure
+                        is in the first name / value pair) or
+                        the terminating NULL if all was
+                        successful.
+
+  @retval EFI_SUCCESS             The results have been distributed or are
+                                  awaiting distribution.
+  
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
+                                  parts of the results that must be
+                                  stored awaiting possible future
+                                  protocols.
+  
+  @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
+                                  Results parameter would result
+                                  in this type of error.
+  
+  @retval EFI_NOT_FOUND           Target for the specified routing data
+                                  was not found
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_ACCESS_ROUTE_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
+  IN CONST  EFI_STRING                      Configuration,
+  OUT       EFI_STRING                      *Progress
+);
+
+/**
+   
+  This function is called to provide results data to the driver.
+  This data consists of a unique key that is used to identify
+  which data is either being passed back or being asked for.
+
+  @param  This                   Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
+  @param  Action                 Specifies the type of action taken by the browser.
+  @param  QuestionId             A unique value which is sent to the original
+                                 exporting driver so that it can identify the type
+                                 of data to expect. The format of the data tends to 
+                                 vary based on the opcode that generated the callback.
+  @param  Type                   The type of value for the question.
+  @param  Value                  A pointer to the data being sent to the original
+                                 exporting driver.
+  @param  ActionRequest          On return, points to the action requested by the
+                                 callback function.
+
+  @retval EFI_SUCCESS            The callback successfully handled the action.
+  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the
+                                 variable and its data.
+  @retval EFI_DEVICE_ERROR       The variable could not be saved.
+  @retval EFI_UNSUPPORTED        The specified Action is not supported by the
+                                 callback.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_ACCESS_FORM_CALLBACK)(
+  IN     CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
+  IN     EFI_BROWSER_ACTION                     Action,
+  IN     EFI_QUESTION_ID                        QuestionId,
+  IN     UINT8                                  Type,
+  IN OUT EFI_IFR_TYPE_VALUE                     *Value,
+  OUT    EFI_BROWSER_ACTION_REQUEST             *ActionRequest
+  )
+  ;
+  
+///
+/// This protocol provides a callable interface between the HII and
+/// drivers. Only drivers which provide IFR data to HII are required
+/// to publish this protocol.
+///
+struct _EFI_HII_CONFIG_ACCESS_PROTOCOL {
+  EFI_HII_ACCESS_EXTRACT_CONFIG     ExtractConfig;
+  EFI_HII_ACCESS_ROUTE_CONFIG       RouteConfig;
+  EFI_HII_ACCESS_FORM_CALLBACK      Callback;
+} ;
+
+extern EFI_GUID gEfiHiiConfigAccessProtocolGuid;
+
+#endif
+
+
diff --git a/MdePkg/Include/Protocol/HiiConfigKeyword.h b/MdePkg/Include/Protocol/HiiConfigKeyword.h
new file mode 100644
index 000000000000..1c2d3c67dcac
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiConfigKeyword.h
@@ -0,0 +1,201 @@
+/** @file
+  The file provides the mechanism to set and get the values 
+  associated with a keyword exposed through a x-UEFI- prefixed 
+  configuration language namespace.
+  
+Copyright (c) 2015 - 2016, 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_CONFIG_KEYWORD_HANDLER_H__
+#define __EFI_CONFIG_KEYWORD_HANDLER_H__
+
+#define EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL_GUID \
+{ \
+  0x0a8badd5, 0x03b8, 0x4d19, {0xb1, 0x28, 0x7b, 0x8f, 0x0e, 0xda, 0xa5, 0x96 } \
+}
+
+//***********************************************************
+// Progress Errors
+//***********************************************************
+#define KEYWORD_HANDLER_NO_ERROR                       0x00000000
+#define KEYWORD_HANDLER_NAMESPACE_ID_NOT_FOUND         0x00000001
+#define KEYWORD_HANDLER_MALFORMED_STRING               0x00000002
+#define KEYWORD_HANDLER_KEYWORD_NOT_FOUND              0x00000004
+#define KEYWORD_HANDLER_INCOMPATIBLE_VALUE_DETECTED    0x00000008
+#define KEYWORD_HANDLER_ACCESS_NOT_PERMITTED           0x00000010
+#define KEYWORD_HANDLER_UNDEFINED_PROCESSING_ERROR     0x80000000
+
+typedef struct _EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL;
+
+/**
+
+  This function accepts a <MultiKeywordResp> formatted string, finds the associated
+  keyword owners, creates a <MultiConfigResp> string from it and forwards it to the
+  EFI_HII_ROUTING_PROTOCOL.RouteConfig function.
+  
+  If there is an issue in resolving the contents of the KeywordString, then the 
+  function returns an error and also sets the Progress and ProgressErr with the 
+  appropriate information about where the issue occurred and additional data about
+  the nature of the issue. 
+  
+  In the case when KeywordString containing multiple keywords, when an EFI_NOT_FOUND
+  error is generated during processing the second or later keyword element, the system
+  storage associated with earlier keywords is not modified. All elements of the 
+  KeywordString must successfully pass all tests for format and access prior to making
+  any modifications to storage.
+  
+  In the case when EFI_DEVICE_ERROR is returned from the processing of a KeywordString
+  containing multiple keywords, the state of storage associated with earlier keywords
+  is undefined.
+
+
+  @param This             Pointer to the EFI_KEYWORD_HANDLER _PROTOCOL instance.
+
+  @param KeywordString    A null-terminated string in <MultiKeywordResp> format. 
+
+  @param Progress         On return, points to a character in the KeywordString. 
+                          Points to the string's NULL terminator if the request 
+                          was successful. Points to the most recent '&' before 
+                          the first failing name / value pair (or the beginning
+                          of the string if the failure is in the first name / value
+                          pair) if the request was not successful.
+
+  @param ProgressErr      If during the processing of the KeywordString there was
+                          a failure, this parameter gives additional information 
+                          about the possible source of the problem. The various 
+                          errors are defined in "Related Definitions" below.
+
+
+  @retval EFI_SUCCESS             The specified action was completed successfully.
+
+  @retval EFI_INVALID_PARAMETER   One or more of the following are TRUE:
+                                  1. KeywordString is NULL.
+                                  2. Parsing of the KeywordString resulted in an 
+                                     error. See Progress and ProgressErr for more data.
+
+  @retval EFI_NOT_FOUND           An element of the KeywordString was not found. 
+                                  See ProgressErr for more data.
+
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.  
+                                  See ProgressErr for more data.
+                                  
+  @retval EFI_ACCESS_DENIED       The action violated system policy. See ProgressErr 
+                                  for more data.
+
+  @retval EFI_DEVICE_ERROR        An unexpected system error occurred. See ProgressErr
+                                  for more data.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_CONFIG_KEYWORD_HANDLER_SET_DATA) (
+  IN EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL *This,
+  IN CONST EFI_STRING                    KeywordString,
+  OUT EFI_STRING                         *Progress,
+  OUT UINT32                             *ProgressErr
+  );
+
+
+/**
+
+  This function accepts a <MultiKeywordRequest> formatted string, finds the underlying 
+  keyword owners, creates a <MultiConfigRequest> string from it and forwards it to the
+  EFI_HII_ROUTING_PROTOCOL.ExtractConfig function.
+  
+  If there is an issue in resolving the contents of the KeywordString, then the function
+  returns an EFI_INVALID_PARAMETER and also set the Progress and ProgressErr with the
+  appropriate information about where the issue occurred and additional data about the
+  nature of the issue.
+  
+  In the case when KeywordString is NULL, or contains multiple keywords, or when
+  EFI_NOT_FOUND is generated while processing the keyword elements, the Results string
+  contains values returned for all keywords processed prior to the keyword generating the 
+  error but no values for the keyword with error or any following keywords.
+
+  
+  @param This           Pointer to the EFI_KEYWORD_HANDLER _PROTOCOL instance.
+  
+  @param NameSpaceId    A null-terminated string containing the platform configuration
+                        language to search through in the system. If a NULL is passed
+                        in, then it is assumed that any platform configuration language
+                        with the prefix of "x-UEFI-" are searched.
+                        
+  @param KeywordString  A null-terminated string in <MultiKeywordRequest> format. If a
+                        NULL is passed in the KeywordString field, all of the known 
+                        keywords in the system for the NameSpaceId specified are 
+                        returned in the Results field.
+  
+  @param Progress       On return, points to a character in the KeywordString. Points
+                        to the string's NULL terminator if the request was successful. 
+                        Points to the most recent '&' before the first failing name / value
+                        pair (or the beginning of the string if the failure is in the first
+                        name / value pair) if the request was not successful.
+                        
+  @param ProgressErr    If during the processing of the KeywordString there was a
+                        failure, this parameter gives additional information about the 
+                        possible source of the problem. See the definitions in SetData()
+                        for valid value definitions.
+  
+  @param Results        A null-terminated string in <MultiKeywordResp> format is returned
+                        which has all the values filled in for the keywords in the 
+                        KeywordString. This is a callee-allocated field, and must be freed
+                        by the caller after being used. 
+
+  @retval EFI_SUCCESS             The specified action was completed successfully.
+  
+  @retval EFI_INVALID_PARAMETER   One or more of the following are TRUE:
+                                  1.Progress, ProgressErr, or Results is NULL.
+                                  2.Parsing of the KeywordString resulted in an error. See
+                                    Progress and ProgressErr for more data.
+  
+
+  @retval EFI_NOT_FOUND           An element of the KeywordString was not found. See
+                                  ProgressErr for more data.
+
+  @retval EFI_NOT_FOUND           The NamespaceId specified was not found.  See ProgressErr
+                                  for more data.
+
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.  See
+                                  ProgressErr for more data.
+                                  
+  @retval EFI_ACCESS_DENIED       The action violated system policy.  See ProgressErr for
+                                  more data.
+
+  @retval EFI_DEVICE_ERROR        An unexpected system error occurred.  See ProgressErr
+                                  for more data.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_CONFIG_KEYWORD_HANDLER_GET_DATA) (
+  IN EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL  *This,
+  IN CONST EFI_STRING                     NameSpaceId, OPTIONAL
+  IN CONST EFI_STRING                     KeywordString, OPTIONAL
+  OUT EFI_STRING                          *Progress, 
+  OUT UINT32                              *ProgressErr,
+  OUT EFI_STRING                          *Results
+  );
+
+///
+/// The EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL provides the mechanism 
+/// to set and get the values associated with a keyword exposed 
+/// through a x-UEFI- prefixed configuration language namespace
+///
+
+struct _EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL {
+  EFI_CONFIG_KEYWORD_HANDLER_SET_DATA  SetData;
+  EFI_CONFIG_KEYWORD_HANDLER_GET_DATA  GetData;
+};
+
+extern EFI_GUID gEfiConfigKeywordHandlerProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/HiiConfigRouting.h b/MdePkg/Include/Protocol/HiiConfigRouting.h
new file mode 100644
index 000000000000..89f3f9b2dbfd
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiConfigRouting.h
@@ -0,0 +1,419 @@
+/** @file
+  The file provides services to manage the movement of
+  configuration data from drivers to configuration applications.
+  It then serves as the single point to receive configuration
+  information from configuration applications, routing the
+  results to the appropriate drivers.
+  
+Copyright (c) 2006 - 2013, 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 __HII_CONFIG_ROUTING_H__
+#define __HII_CONFIG_ROUTING_H__
+
+#define EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID \
+  { 0x587e72d7, 0xcc50, 0x4f79, { 0x82, 0x09, 0xca, 0x29, 0x1f, 0xc1, 0xa1, 0x0f } }
+
+
+typedef struct _EFI_HII_CONFIG_ROUTING_PROTOCOL EFI_HII_CONFIG_ROUTING_PROTOCOL;
+
+/**
+   
+  This function allows the caller to request the current
+  configuration for one or more named elements from one or more
+  drivers. The resulting string is in the standard HII
+  configuration string format. If Successful, Results contains an
+  equivalent string with "=" and the values associated with all
+  names added in. The expected implementation is for each
+  <ConfigRequest> substring in the Request to call the HII
+  Configuration Routing Protocol ExtractProtocol function for the
+  driver corresponding to the <ConfigHdr> at the start of the
+  <ConfigRequest> substring. The request fails if no driver
+  matches the <ConfigRequest> substring. Note: Alternative
+  configuration strings may also be appended to the end of the
+  current configuration string. If they are, they must appear
+  after the current configuration. They must contain the same
+  routing (GUID, NAME, PATH) as the current configuration string.
+  They must have an additional description indicating the type of
+  alternative configuration the string represents,
+  "ALTCFG=<StringToken>". That <StringToken> (when converted from
+  hexadecimal (encoded as text) to binary) is a reference to a string in the
+  associated string pack. As an example, assume that the Request
+  string is:
+  GUID=...&NAME=00480050&PATH=...&Fred&George&Ron&Neville A result
+  might be:
+  GUID=...&NAME=00480050&PATH=...&Fred=16&George=16&Ron=12&Neville=11&
+  GUID=...&NAME=00480050&PATH=...&ALTCFG=0037&Fred=12&Neville=7
+
+  @param This       Points to the EFI_HII_CONFIG_ROUTING_PROTOCOL
+                    instance.
+
+  @param Request    A null-terminated string in <MultiConfigRequest> format.
+
+  @param Progress   On return, points to a character in the
+                    Request string. Points to the string's null
+                    terminator if the request was successful. Points
+                    to the most recent '&' before the first
+                    failing name / value pair (or the beginning
+                    of the string if the failure is in the first
+                    name / value pair) if the request was not
+                    successful
+
+  @param Results    A null-terminated string in <MultiConfigAltResp> format
+                    which has all values filled in for the names in the
+                    Request string.
+
+  @retval EFI_SUCCESS             The Results string is filled with the
+                                  values corresponding to all requested
+                                  names.
+
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
+                                  parts of the results that must be
+                                  stored awaiting possible future
+                                  protocols.
+
+  @retval EFI_INVALID_PARAMETER   For example, passing in a NULL
+                                  for the Request parameter
+                                  would result in this type of
+                                  error. The Progress parameter
+                                  is set to NULL. 
+  
+  @retval EFI_NOT_FOUND           Routing data doesn't match any
+                                  known driver. Progress set to
+                                  the "G" in "GUID" of the
+                                  routing header that doesn't
+                                  match. Note: There is no
+                                  requirement that all routing
+                                  data be validated before any
+                                  configuration extraction.
+
+  @retval EFI_INVALID_PARAMETER   Illegal syntax. Progress set
+                                  to the most recent & before the
+                                  error, or the beginning of the
+                                  string.
+  @retval EFI_INVALID_PARAMETER   The ExtractConfig function of the
+                                  underlying HII Configuration 
+                                  Access Protocol returned 
+                                  EFI_INVALID_PARAMETER. Progress
+                                  set to most recent & before the
+                                  error or the beginning of the
+                                  string.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_EXTRACT_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
+  IN CONST  EFI_STRING                      Request,
+  OUT       EFI_STRING                      *Progress,
+  OUT       EFI_STRING                      *Results
+);
+
+/**
+  This function allows the caller to request the current configuration 
+  for the entirety of the current HII database and returns the data in
+  a null-terminated string.
+
+  This function allows the caller to request the current
+  configuration for all of the current HII database. The results
+  include both the current and alternate configurations as
+  described in ExtractConfig() above. 
+  
+  @param This     Points to the EFI_HII_CONFIG_ROUTING_PROTOCOL instance.
+  
+  @param  Results Null-terminated Unicode string in
+                  <MultiConfigAltResp> format which has all values
+                  filled in for the entirety of the current HII 
+                  database. String to be allocated by the  called 
+                  function. De-allocation is up to the caller.
+  
+  @retval EFI_SUCCESS             The Results string is filled with the
+                                  values corresponding to all requested
+                                  names.
+  
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
+                                  parts of the results that must be
+                                  stored awaiting possible future
+                                  protocols.
+  
+  @retval EFI_INVALID_PARAMETERS  For example, passing in a NULL
+                                  for the Results parameter
+                                  would result in this type of
+                                  error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_EXPORT_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
+  OUT       EFI_STRING                      *Results
+);
+
+/**
+   
+  This function routes the results of processing forms to the
+  appropriate targets. It scans for <ConfigHdr> within the string
+  and passes the header and subsequent body to the driver whose
+  location is described in the <ConfigHdr>. Many <ConfigHdr>s may
+  appear as a single request. The expected implementation is to
+  hand off the various <ConfigResp> substrings to the
+  Configuration Access Protocol RouteConfig routine corresponding
+  to the driver whose routing information is defined by the
+  <ConfigHdr> in turn.
+
+  @param This           Points to the EFI_HII_CONFIG_ROUTING_PROTOCOL instance.
+
+  @param Configuration  A null-terminated string in <MulltiConfigResp> format.
+
+  @param Progress       A pointer to a string filled in with the
+                        offset of the most recent '&' before the
+                        first failing name / value pair (or the
+                        beginning of the string if the failure is in
+                        the first name / value pair), or the
+                        terminating NULL if all was successful.
+
+  @retval EFI_SUCCESS             The results have been distributed or are
+                                  awaiting distribution.
+  
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
+                                  parts of the results that must be
+                                  stored awaiting possible future
+                                  protocols.
+  
+  @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
+                                  Results parameter would result
+                                  in this type of error.
+  
+  @retval EFI_NOT_FOUND           The target for the specified routing data
+                                  was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_ROUTE_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
+  IN CONST  EFI_STRING                      Configuration,
+  OUT       EFI_STRING                      *Progress
+);
+
+
+/**
+   
+  This function extracts the current configuration from a block of
+  bytes. To do so, it requires that the ConfigRequest string
+  consists of a list of <BlockName> formatted names. It uses the
+  offset in the name to determine the index into the Block to
+  start the extraction and the width of each name to determine the
+  number of bytes to extract. These are mapped to a string
+  using the equivalent of the C "%x" format (with optional leading
+  spaces). The call fails if, for any (offset, width) pair in
+  ConfigRequest, offset+value >= BlockSize.
+
+  @param This      Points to the EFI_HII_CONFIG_ROUTING_PROTOCOL instance.
+
+  @param ConfigRequest  A null-terminated string in <ConfigRequest> format.
+
+  @param Block      An array of bytes defining the block's
+                    configuration.
+
+  @param BlockSize  The length in bytes of Block.
+
+  @param Config     The filled-in configuration string. String
+                    allocated by the function. Returned only if
+                    call is successful. The null-terminated string 
+                    will be <ConfigResp> format.
+
+  @param Progress   A pointer to a string filled in with the
+                    offset of the most recent '&' before the
+                    first failing name / value pair (or the
+                    beginning of the string if the failure is in
+                    the first name / value pair), or the
+                    terminating NULL if all was successful.
+
+  @retval EFI_SUCCESS             The request succeeded. Progress points
+                                  to the null terminator at the end of the
+                                  ConfigRequest string.
+
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to allocate
+                                  Config. Progress points to the
+                                  first character of ConfigRequest.
+
+  @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
+                                  ConfigRequest or Block
+                                  parameter would result in this
+                                  type of error. Progress points
+                                  to the first character of
+                                  ConfigRequest.
+
+  @retval EFI_NOT_FOUND           The target for the specified routing data
+                                  was not found. Progress points to the
+                                  'G' in "GUID" of the errant routing
+                                  data. 
+  @retval EFI_DEVICE_ERROR        The block is not large enough. Progress undefined.
+
+  @retval EFI_INVALID_PARAMETER   Encountered non <BlockName>
+                                  formatted string. Block is
+                                  left updated and Progress
+                                  points at the '&' preceding
+                                  the first non-<BlockName>.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_BLOCK_TO_CONFIG)(
+  IN CONST  EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
+  IN CONST  EFI_STRING                      ConfigRequest,
+  IN CONST  UINT8                           *Block,
+  IN CONST  UINTN                           BlockSize,
+  OUT       EFI_STRING                      *Config,
+  OUT       EFI_STRING                      *Progress
+);
+
+
+
+/**
+  This function maps a configuration containing a series of
+  <BlockConfig> formatted name value pairs in ConfigResp into a
+  Block so it may be stored in a linear mapped storage such as a
+  UEFI Variable. If present, the function skips GUID, NAME, and
+  PATH in <ConfigResp>. It stops when it finds a non-<BlockConfig>
+  name / value pair (after skipping the routing header) or when it
+  reaches the end of the string.
+  Example Assume an existing block containing: 00 01 02 03 04 05
+  And the ConfigResp string is:
+  OFFSET=4&WIDTH=1&VALUE=7&OFFSET=0&WIDTH=2&VALUE=AA55
+  The results are
+  55 AA 02 07 04 05
+
+  @param This           Points to the EFI_HII_CONFIG_ROUTING_PROTOCOL instance.
+
+  @param ConfigResp     A null-terminated string in <ConfigResp> format.
+
+  @param Block          A possibly null array of bytes
+                        representing the current block. Only
+                        bytes referenced in the ConfigResp
+                        string in the block are modified. If
+                        this parameter is null or if the
+                        BlockLength parameter is (on input)
+                        shorter than required by the
+                        Configuration string, only the BlockSize
+                        parameter is updated, and an appropriate
+                        status (see below) is returned.
+
+  @param BlockSize      The length of the Block in units of UINT8.
+                        On input, this is the size of the Block. On
+                        output, if successful, contains the largest 
+                        index of the modified byte in the Block, or
+                        the required buffer size if the Block is not
+                        large enough.
+
+  @param Progress       On return, points to an element of the
+                        ConfigResp string filled in with the offset
+                        of the most recent "&" before the first
+                        failing name / value pair (or the beginning
+                        of the string if the failure is in the first
+                        name / value pair), or the terminating NULL
+                        if all was successful.
+
+  @retval EFI_SUCCESS            The request succeeded. Progress points to the null
+                                 terminator at the end of the ConfigResp string.
+  @retval EFI_OUT_OF_RESOURCES   Not enough memory to allocate Config. Progress
+                                 points to the first character of ConfigResp.
+  @retval EFI_INVALID_PARAMETER  Passing in a NULL for the ConfigResp or
+                                 Block parameter would result in this type of
+                                 error. Progress points to the first character of
+                                         ConfigResp.
+  @retval EFI_INVALID_PARAMETER  Encountered non <BlockName> formatted name /
+                                 value pair. Block is left updated and
+                                 Progress points at the '&' preceding the first
+                                 non-<BlockName>.
+  @retval EFI_DEVICE_ERROR       Block not large enough. Progress undefined.
+  @retval EFI_NOT_FOUND          Target for the specified routing data was not found.
+                                 Progress points to the "G" in "GUID" of the errant
+                                 routing data.
+  @retval EFI_BUFFER_TOO_SMALL   Block not large enough. Progress undefined. 
+                                 BlockSize is updated with the required buffer size.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HII_CONFIG_TO_BLOCK)(
+  IN CONST  EFI_HII_CONFIG_ROUTING_PROTOCOL *This,
+  IN CONST  EFI_STRING                      ConfigResp,
+  IN OUT    UINT8                           *Block,
+  IN OUT    UINTN                           *BlockSize,
+  OUT       EFI_STRING                      *Progress
+);
+
+/**
+  This helper function is to be called by drivers to extract portions of 
+  a larger configuration string.
+          
+  @param This              A pointer to the EFI_HII_CONFIG_ROUTING_PROTOCOL instance.
+  @param ConfigResp        A null-terminated string in <ConfigAltResp> format.
+  @param Guid              A pointer to the GUID value to search for in the 
+                           routing portion of the ConfigResp string when retrieving 
+                           the requested data. If Guid is NULL, then all GUID 
+                           values will be searched for.
+  @param Name              A pointer to the NAME value to search for in the 
+                           routing portion of the ConfigResp string when retrieving 
+                           the requested data. If Name is NULL, then all Name 
+                           values will be searched for.                         
+  @param DevicePath        A pointer to the PATH value to search for in the 
+                           routing portion of the ConfigResp string when retrieving 
+                           the requested data. If DevicePath is NULL, then all 
+                           DevicePath values will be searched for.             
+  @param AltCfgId          A pointer to the ALTCFG value to search for in the 
+                           routing portion of the ConfigResp string when retrieving 
+                           the requested data.  If this parameter is NULL, 
+                           then the current setting will be retrieved.
+  @param AltCfgResp        A pointer to a buffer which will be allocated by the 
+                           function which contains the retrieved string as requested.  
+                           This buffer is only allocated if the call was successful. 
+                           The null-terminated string will be <ConfigResp> format.
+  
+  @retval EFI_SUCCESS             The request succeeded. The requested data was extracted 
+                                  and placed in the newly allocated AltCfgResp buffer.
+  @retval EFI_OUT_OF_RESOURCES    Not enough memory to allocate AltCfgResp.    
+  @retval EFI_INVALID_PARAMETER   Any parameter is invalid.
+  @retval EFI_NOT_FOUND           The target for the specified routing data was not found.
+**/
+typedef
+EFI_STATUS 
+(EFIAPI * EFI_HII_GET_ALT_CFG)(
+  IN  CONST EFI_HII_CONFIG_ROUTING_PROTOCOL    *This, 
+  IN  CONST EFI_STRING                         ConfigResp, 
+  IN  CONST EFI_GUID                           *Guid, 
+  IN  CONST EFI_STRING                         Name, 
+  IN  CONST EFI_DEVICE_PATH_PROTOCOL           *DevicePath,  
+  IN  CONST UINT16                             *AltCfgId,
+  OUT EFI_STRING                               *AltCfgResp 
+  );
+
+///
+/// This protocol defines the configuration routing interfaces
+/// between external applications and the HII. There may only be one
+/// instance of this protocol in the system.
+///
+struct _EFI_HII_CONFIG_ROUTING_PROTOCOL {
+  EFI_HII_EXTRACT_CONFIG  ExtractConfig;
+  EFI_HII_EXPORT_CONFIG   ExportConfig;
+  EFI_HII_ROUTE_CONFIG    RouteConfig;
+  EFI_HII_BLOCK_TO_CONFIG BlockToConfig;
+  EFI_HII_CONFIG_TO_BLOCK ConfigToBlock;
+  EFI_HII_GET_ALT_CFG     GetAltConfig;
+};
+
+extern EFI_GUID gEfiHiiConfigRoutingProtocolGuid;
+
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/HiiDatabase.h b/MdePkg/Include/Protocol/HiiDatabase.h
new file mode 100644
index 000000000000..435fe1be787a
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiDatabase.h
@@ -0,0 +1,531 @@
+/** @file
+  The file provides Database manager for HII-related data
+  structures.
+  
+Copyright (c) 2006 - 2010, 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 __HII_DATABASE_H__
+#define __HII_DATABASE_H__
+
+#define EFI_HII_DATABASE_PROTOCOL_GUID \
+  { 0xef9fc172, 0xa1b2, 0x4693, { 0xb3, 0x27, 0x6d, 0x32, 0xfc, 0x41, 0x60, 0x42 } }
+
+
+typedef struct _EFI_HII_DATABASE_PROTOCOL EFI_HII_DATABASE_PROTOCOL;
+
+
+///
+/// EFI_HII_DATABASE_NOTIFY_TYPE.
+/// 
+typedef UINTN   EFI_HII_DATABASE_NOTIFY_TYPE;
+
+#define EFI_HII_DATABASE_NOTIFY_NEW_PACK    0x00000001
+#define EFI_HII_DATABASE_NOTIFY_REMOVE_PACK 0x00000002
+#define EFI_HII_DATABASE_NOTIFY_EXPORT_PACK 0x00000004
+#define EFI_HII_DATABASE_NOTIFY_ADD_PACK    0x00000008
+/**
+   
+  Functions which are registered to receive notification of
+  database events have this prototype. The actual event is encoded
+  in NotifyType. The following table describes how PackageType,
+  PackageGuid, Handle, and Package are used for each of the
+  notification types.
+
+  @param PackageType  Package type of the notification.
+
+  @param PackageGuid  If PackageType is
+                      EFI_HII_PACKAGE_TYPE_GUID, then this is
+                      the pointer to the GUID from the Guid
+                      field of EFI_HII_PACKAGE_GUID_HEADER.
+                      Otherwise, it must be NULL.
+
+  @param Package      Points to the package referred to by the notification. 
+  
+  @param Handle       The handle of the package
+                      list which contains the specified package.
+
+  @param NotifyType   The type of change concerning the
+                      database. See
+                      EFI_HII_DATABASE_NOTIFY_TYPE.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_NOTIFY)(
+  IN        UINT8                         PackageType,
+  IN CONST  EFI_GUID                      *PackageGuid,
+  IN CONST  EFI_HII_PACKAGE_HEADER        *Package,
+  IN        EFI_HII_HANDLE                 Handle,
+  IN        EFI_HII_DATABASE_NOTIFY_TYPE  NotifyType
+);
+
+/**
+
+  This function adds the packages in the package list to the
+  database and returns a handle. If there is a
+  EFI_DEVICE_PATH_PROTOCOL associated with the DriverHandle, then
+  this function will create a package of type
+  EFI_PACKAGE_TYPE_DEVICE_PATH and add it to the package list. For
+  each package in the package list, registered functions with the
+  notification type NEW_PACK and having the same package type will
+  be called. For each call to NewPackageList(), there should be a
+  corresponding call to
+  EFI_HII_DATABASE_PROTOCOL.RemovePackageList().
+  
+  @param This           A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+
+  @param PackageList    A pointer to an EFI_HII_PACKAGE_LIST_HEADER structure.
+
+  @param DriverHandle   Associate the package list with this EFI handle.
+                        If a NULL is specified, this data will not be associate
+                        with any drivers and cannot have a callback induced.
+  
+  @param Handle         A pointer to the EFI_HII_HANDLE instance.
+
+  @retval EFI_SUCCESS           The package list associated with the
+                                Handle was added to the HII database.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate necessary
+                                resources for the new database
+                                contents.
+
+  @retval EFI_INVALID_PARAMETER PackageList is NULL, or Handle is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_NEW_PACK)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL   *This,
+  IN CONST  EFI_HII_PACKAGE_LIST_HEADER *PackageList,
+  IN        EFI_HANDLE                  DriverHandle, OPTIONAL
+  OUT       EFI_HII_HANDLE               *Handle
+);
+
+
+/**
+
+  This function removes the package list that is associated with a
+  handle Handle from the HII database. Before removing the
+  package, any registered functions with the notification type
+  REMOVE_PACK and the same package type will be called. For each
+  call to EFI_HII_DATABASE_PROTOCOL.NewPackageList(), there should
+  be a corresponding call to RemovePackageList.
+
+  @param This             A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+  
+  @param Handle           The handle that was registered to the data
+                          that is requested for removal.
+  
+  @retval EFI_SUCCESS     The data associated with the Handle was
+                          removed from the HII database.
+  @retval EFI_NOT_FOUND   The specified Handle is not in database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_REMOVE_PACK)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN        EFI_HII_HANDLE             Handle
+);
+
+
+/**
+   
+  This function updates the existing package list (which has the
+  specified Handle) in the HII databases, using the new package
+  list specified by PackageList. The update process has the
+  following steps: Collect all the package types in the package
+  list specified by PackageList. A package type consists of the
+  Type field of EFI_HII_PACKAGE_HEADER and, if the Type is
+  EFI_HII_PACKAGE_TYPE_GUID, the Guid field, as defined in
+  EFI_HII_PACKAGE_GUID_HEADER. Iterate through the packages within
+  the existing package list in the HII database specified by
+  Handle. If a package's type matches one of the collected types collected
+  in step 1, then perform the following steps:
+  - Call any functions registered with the notification type
+  REMOVE_PACK.
+  - Remove the package from the package list and the HII
+  database.
+  Add all of the packages within the new package list specified
+  by PackageList, using the following steps:
+  - Add the package to the package list and the HII database.
+  - Call any functions registered with the notification type
+  ADD_PACK.
+
+  @param This         A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+  
+  @param Handle       The handle that was registered to the data
+                      that is requested for removal.
+  
+  @param PackageList  A pointer to an EFI_HII_PACKAGE_LIST
+                      package.
+  
+  @retval EFI_SUCCESS            The HII database was successfully updated.
+  
+  @retval EFI_OUT_OF_RESOURCES   Unable to allocate enough memory
+                                 for the updated database.
+  
+  @retval EFI_INVALID_PARAMETER  PackageList was NULL.
+  @retval EFI_NOT_FOUND          The specified Handle is not in database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_UPDATE_PACK)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL   *This,
+  IN        EFI_HII_HANDLE               Handle,
+  IN CONST  EFI_HII_PACKAGE_LIST_HEADER *PackageList
+);
+
+
+/**
+  
+  This function returns a list of the package handles of the   
+  specified type that are currently active in the database. The   
+  pseudo-type EFI_HII_PACKAGE_TYPE_ALL will cause all package   
+  handles to be listed.
+  
+  @param This                 A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+  
+  @param PackageType          Specifies the package type of the packages
+                              to list or EFI_HII_PACKAGE_TYPE_ALL for
+                              all packages to be listed.
+  
+  @param PackageGuid          If PackageType is
+                              EFI_HII_PACKAGE_TYPE_GUID, then this is
+                              the pointer to the GUID which must match
+                              the Guid field of
+                              EFI_HII_PACKAGE_GUID_HEADER. Otherwise, it
+                              must be NULL.
+  
+  @param HandleBufferLength   On input, a pointer to the length
+                              of the handle buffer. On output,
+                              the length of the handle buffer
+                              that is required for the handles found.
+
+  @param Handle               An array of EFI_HII_HANDLE instances returned.
+
+  @retval EFI_SUCCESS           The matching handles are outputted successfully.
+                                HandleBufferLength is updated with the actual length.
+  @retval EFI_BUFFER_TOO_SMALL  The HandleBufferLength parameter
+                                indicates that Handle is too
+                                small to support the number of
+                                handles. HandleBufferLength is
+                                updated with a value that will
+                                enable the data to fit.
+  @retval EFI_NOT_FOUND         No matching handle could be found in database.
+  @retval EFI_INVALID_PARAMETER HandleBufferLength was NULL.
+  @retval EFI_INVALID_PARAMETER The value referenced by HandleBufferLength was not
+                                zero and Handle was NULL.
+  @retval EFI_INVALID_PARAMETER PackageType is not a EFI_HII_PACKAGE_TYPE_GUID but
+                                PackageGuid is not NULL, PackageType is a EFI_HII_
+                                PACKAGE_TYPE_GUID but PackageGuid is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_LIST_PACKS)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN        UINT8                     PackageType,
+  IN CONST  EFI_GUID                  *PackageGuid,
+  IN OUT    UINTN                     *HandleBufferLength,
+  OUT       EFI_HII_HANDLE            *Handle
+);
+
+/**
+
+  This function will export one or all package lists in the
+  database to a buffer. For each package list exported, this
+  function will call functions registered with EXPORT_PACK and
+  then copy the package list to the buffer. The registered
+  functions may call EFI_HII_DATABASE_PROTOCOL.UpdatePackageList()
+  to modify the package list before it is copied to the buffer. If
+  the specified BufferSize is too small, then the status
+  EFI_OUT_OF_RESOURCES will be returned and the actual package
+  size will be returned in BufferSize.
+
+  @param This         A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+
+
+  @param Handle       An EFI_HII_HANDLE  that corresponds to the
+                      desired package list in the HII database to
+                      export or NULL to indicate all package lists
+                      should be exported. 
+
+  @param BufferSize   On input, a pointer to the length of the
+                      buffer. On output, the length of the
+                      buffer that is required for the exported
+                      data.
+
+  @param Buffer       A pointer to a buffer that will contain the
+                      results of the export function.
+  
+  
+  @retval EFI_SUCCESS           Package exported.
+  
+  @retval EFI_OUT_OF_RESOURCES  BufferSize is too small to hold the package.
+
+  @retval EFI_NOT_FOUND         The specified Handle could not be found in the
+                                current database.
+  
+  @retval EFI_INVALID_PARAMETER BufferSize was NULL.
+  
+  @retval EFI_INVALID_PARAMETER The value referenced by BufferSize was not zero 
+                                and Buffer was NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_EXPORT_PACKS)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL      *This,
+  IN        EFI_HII_HANDLE                 Handle,
+  IN OUT    UINTN                          *BufferSize,
+  OUT       EFI_HII_PACKAGE_LIST_HEADER    *Buffer
+);
+
+
+/**
+   
+  
+  This function registers a function which will be called when
+  specified actions related to packages of the specified type
+  occur in the HII database. By registering a function, other
+  HII-related drivers are notified when specific package types
+  are added, removed or updated in the HII database. Each driver
+  or application which registers a notification should use
+  EFI_HII_DATABASE_PROTOCOL.UnregisterPackageNotify() before
+  exiting.
+  
+  
+  @param This             A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+
+  @param PackageType      The package type. See
+                          EFI_HII_PACKAGE_TYPE_x in EFI_HII_PACKAGE_HEADER. 
+
+  @param PackageGuid      If PackageType is
+                          EFI_HII_PACKAGE_TYPE_GUID, then this is
+                          the pointer to the GUID which must match
+                          the Guid field of
+                          EFI_HII_PACKAGE_GUID_HEADER. Otherwise, it
+                          must be NULL.
+
+  @param PackageNotifyFn  Points to the function to be called
+                          when the event specified by
+                          NotificationType occurs. See
+                          EFI_HII_DATABASE_NOTIFY.
+
+  @param NotifyType       Describes the types of notification which
+                          this function will be receiving. See
+                          EFI_HII_DATABASE_NOTIFY_TYPE for a
+                          list of types.
+
+  @param NotifyHandle     Points to the unique handle assigned to
+                          the registered notification. Can be used
+                          in EFI_HII_DATABASE_PROTOCOL.UnregisterPack
+                          to stop notifications.
+
+
+  @retval EFI_SUCCESS           Notification registered successfully.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate necessary
+                                data structures.
+
+  @retval EFI_INVALID_PARAMETER PackageGuid is not NULL when
+                                PackageType is not
+                                EFI_HII_PACKAGE_TYPE_GUID.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_REGISTER_NOTIFY)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL     *This,
+  IN        UINT8                         PackageType,
+  IN CONST  EFI_GUID                      *PackageGuid,
+  IN        EFI_HII_DATABASE_NOTIFY       PackageNotifyFn,
+  IN        EFI_HII_DATABASE_NOTIFY_TYPE  NotifyType,
+  OUT       EFI_HANDLE                    *NotifyHandle
+);
+
+
+/**
+   
+  Removes the specified HII database package-related notification.
+  
+  @param This                 A pointer to the EFI_HII_DATABASE_PROTOCOL instance.
+
+  @param NotificationHandle   The handle of the notification
+                              function being unregistered.
+  
+  @retval EFI_SUCCESS   Successsfully unregistered the notification. 
+  
+  @retval EFI_NOT_FOUND The incoming notification handle does not exist 
+                        in the current hii database.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_UNREGISTER_NOTIFY)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN        EFI_HANDLE                NotificationHandle
+);
+
+
+/**
+   
+  This routine retrieves an array of GUID values for each keyboard
+  layout that was previously registered in the system.
+
+  @param This                 A pointer to the EFI_HII_PROTOCOL instance.
+
+  @param KeyGuidBufferLength  On input, a pointer to the length
+                              of the keyboard GUID buffer. On
+                              output, the length of the handle
+                              buffer that is required for the
+                              handles found. 
+  
+  @param KeyGuidBuffer        An array of keyboard layout GUID
+                              instances returned.
+
+  @retval EFI_SUCCESS           KeyGuidBuffer was updated successfully.
+  
+  @retval EFI_BUFFER_TOO_SMALL  The KeyGuidBufferLength
+                                parameter indicates that
+                                KeyGuidBuffer is too small to
+                                support the number of GUIDs.
+                                KeyGuidBufferLength is updated
+                                with a value that will enable
+                                the data to fit.
+  @retval EFI_INVALID_PARAMETER The KeyGuidBufferLength is NULL.
+  @retval EFI_INVALID_PARAMETER The value referenced by 
+                                KeyGuidBufferLength is not
+                                zero and KeyGuidBuffer is NULL.
+  @retval EFI_NOT_FOUND         There was no keyboard layout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_FIND_KEYBOARD_LAYOUTS)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN OUT    UINT16                    *KeyGuidBufferLength,
+  OUT       EFI_GUID                  *KeyGuidBuffer
+);
+
+
+/**
+   
+  This routine retrieves the requested keyboard layout. The layout
+  is a physical description of the keys on a keyboard, and the
+  character(s) that are associated with a particular set of key
+  strokes.
+
+  @param This                   A pointer to the EFI_HII_PROTOCOL instance.
+  
+  @param KeyGuid                A pointer to the unique ID associated with a
+                                given keyboard layout. If KeyGuid is NULL then
+                                the current layout will be retrieved.
+
+  @param KeyboardLayoutLength   On input, a pointer to the length of the
+                                KeyboardLayout buffer.  On output, the length of
+                                the data placed into KeyboardLayout.
+  
+  @param KeyboardLayout         A pointer to a buffer containing the
+                                retrieved keyboard layout.
+  
+  @retval EFI_SUCCESS   The keyboard layout was retrieved
+                        successfully.
+  
+  @retval EFI_NOT_FOUND The requested keyboard layout was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_KEYBOARD_LAYOUT)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN CONST  EFI_GUID                  *KeyGuid,
+  IN OUT UINT16                       *KeyboardLayoutLength,
+  OUT       EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout
+);
+
+/**
+   
+  This routine sets the default keyboard layout to the one
+  referenced by KeyGuid. When this routine is called, an event
+  will be signaled of the EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID
+  group type. This is so that agents which are sensitive to the
+  current keyboard layout being changed can be notified of this
+  change.
+
+  @param This      A pointer to the EFI_HII_PROTOCOL instance.
+
+  @param KeyGuid   A pointer to the unique ID associated with a
+                   given keyboard layout.
+
+  @retval EFI_SUCCESS    The current keyboard layout was successfully set.
+
+  @retval EFI_NOT_FOUND  The referenced keyboard layout was not
+                         found, so action was taken.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_SET_KEYBOARD_LAYOUT)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN CONST  EFI_GUID                  *KeyGuid
+);
+
+/**
+   
+  Return the EFI handle associated with a package list.
+  
+  @param This               A pointer to the EFI_HII_PROTOCOL instance.
+  
+  @param PackageListHandle  An EFI_HII_HANDLE  that corresponds
+                            to the desired package list in the
+                            HIIdatabase.
+  
+  @param DriverHandle       On return, contains the EFI_HANDLE which
+                            was registered with the package list in
+                            NewPackageList().
+  
+  @retval EFI_SUCCESS            The DriverHandle was returned successfully.
+  
+  @retval EFI_INVALID_PARAMETER  The PackageListHandle was not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DATABASE_GET_PACK_HANDLE)(
+  IN CONST  EFI_HII_DATABASE_PROTOCOL *This,
+  IN        EFI_HII_HANDLE             PackageListHandle,
+  OUT       EFI_HANDLE                *DriverHandle
+);
+
+///
+/// Database manager for HII-related data structures.
+///
+struct _EFI_HII_DATABASE_PROTOCOL {
+  EFI_HII_DATABASE_NEW_PACK           NewPackageList;
+  EFI_HII_DATABASE_REMOVE_PACK        RemovePackageList;
+  EFI_HII_DATABASE_UPDATE_PACK        UpdatePackageList;
+  EFI_HII_DATABASE_LIST_PACKS         ListPackageLists;
+  EFI_HII_DATABASE_EXPORT_PACKS       ExportPackageLists;
+  EFI_HII_DATABASE_REGISTER_NOTIFY    RegisterPackageNotify;
+  EFI_HII_DATABASE_UNREGISTER_NOTIFY  UnregisterPackageNotify;
+  EFI_HII_FIND_KEYBOARD_LAYOUTS       FindKeyboardLayouts;
+  EFI_HII_GET_KEYBOARD_LAYOUT         GetKeyboardLayout;
+  EFI_HII_SET_KEYBOARD_LAYOUT         SetKeyboardLayout;
+  EFI_HII_DATABASE_GET_PACK_HANDLE    GetPackageListHandle;
+};
+
+extern EFI_GUID gEfiHiiDatabaseProtocolGuid;
+
+#endif
+
+
diff --git a/MdePkg/Include/Protocol/HiiFont.h b/MdePkg/Include/Protocol/HiiFont.h
new file mode 100644
index 000000000000..b94073449611
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiFont.h
@@ -0,0 +1,472 @@
+/** @file
+  The file provides services to retrieve font information.
+  
+Copyright (c) 2006 - 2010, 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 __HII_FONT_H__
+#define __HII_FONT_H__
+
+#include <Protocol/GraphicsOutput.h>
+#include <Protocol/HiiImage.h>
+
+#define EFI_HII_FONT_PROTOCOL_GUID \
+{ 0xe9ca4775, 0x8657, 0x47fc, { 0x97, 0xe7, 0x7e, 0xd6, 0x5a, 0x8, 0x43, 0x24 } }
+
+typedef struct _EFI_HII_FONT_PROTOCOL EFI_HII_FONT_PROTOCOL;
+
+typedef VOID    *EFI_FONT_HANDLE;
+
+///
+/// EFI_HII_OUT_FLAGS.
+/// 
+typedef UINT32  EFI_HII_OUT_FLAGS;
+
+#define EFI_HII_OUT_FLAG_CLIP         0x00000001
+#define EFI_HII_OUT_FLAG_WRAP         0x00000002
+#define EFI_HII_OUT_FLAG_CLIP_CLEAN_Y 0x00000004
+#define EFI_HII_OUT_FLAG_CLIP_CLEAN_X 0x00000008
+#define EFI_HII_OUT_FLAG_TRANSPARENT  0x00000010
+#define EFI_HII_IGNORE_IF_NO_GLYPH    0x00000020
+#define EFI_HII_IGNORE_LINE_BREAK     0x00000040
+#define EFI_HII_DIRECT_TO_SCREEN      0x00000080
+
+/**
+  Definition of EFI_HII_ROW_INFO.
+**/
+typedef struct _EFI_HII_ROW_INFO {
+  ///
+  /// The index of the first character in the string which is displayed on the line.
+  ///
+  UINTN   StartIndex;
+  ///
+  /// The index of the last character in the string which is displayed on the line.
+  /// If this is the same as StartIndex, then no characters are displayed.  
+  ///
+  UINTN   EndIndex;
+  UINTN   LineHeight; ///< The height of the line, in pixels.
+  UINTN   LineWidth;  ///< The width of the text on the line, in pixels.
+  
+  ///
+  /// The font baseline offset in pixels from the bottom of the row, or 0 if none.
+  ///
+  UINTN   BaselineOffset;
+} EFI_HII_ROW_INFO;
+
+///
+/// Font info flag. All flags (FONT, SIZE, STYLE, and COLOR) are defined.
+/// They are defined as EFI_FONT_INFO_***
+///
+typedef UINT32  EFI_FONT_INFO_MASK;
+
+#define EFI_FONT_INFO_SYS_FONT        0x00000001
+#define EFI_FONT_INFO_SYS_SIZE        0x00000002
+#define EFI_FONT_INFO_SYS_STYLE       0x00000004
+#define EFI_FONT_INFO_SYS_FORE_COLOR  0x00000010
+#define EFI_FONT_INFO_SYS_BACK_COLOR  0x00000020
+#define EFI_FONT_INFO_RESIZE          0x00001000
+#define EFI_FONT_INFO_RESTYLE         0x00002000
+#define EFI_FONT_INFO_ANY_FONT        0x00010000
+#define EFI_FONT_INFO_ANY_SIZE        0x00020000
+#define EFI_FONT_INFO_ANY_STYLE       0x00040000
+
+//
+// EFI_FONT_INFO
+// 
+typedef struct {
+  EFI_HII_FONT_STYLE FontStyle;
+  UINT16             FontSize;      ///< character cell height in pixels
+  CHAR16             FontName[1];
+} EFI_FONT_INFO;
+
+/**
+  Describes font output-related information.
+
+  This structure is used for describing the way in which a string
+  should be rendered in a particular font. FontInfo specifies the
+  basic font information and ForegroundColor and BackgroundColor
+  specify the color in which they should be displayed. The flags
+  in FontInfoMask describe where the system default should be
+  supplied instead of the specified information. The flags also
+  describe what options can be used to make a match between the
+  font requested and the font available.
+**/
+typedef struct _EFI_FONT_DISPLAY_INFO {
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL ForegroundColor;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL BackgroundColor;
+  EFI_FONT_INFO_MASK            FontInfoMask;
+  EFI_FONT_INFO                 FontInfo;  
+} EFI_FONT_DISPLAY_INFO;
+
+/**
+
+  This function renders a string to a bitmap or the screen using
+  the specified font, color and options. It either draws the
+  string and glyphs on an existing bitmap, allocates a new bitmap,
+  or uses the screen. The strings can be clipped or wrapped.
+  Optionally, the function also returns the information about each
+  row and the character position on that row. If
+  EFI_HII_OUT_FLAG_CLIP is set, then text will be formatted only
+  based on explicit line breaks and all pixels which would lie
+  outside the bounding box specified by Width and Height are
+  ignored. The information in the RowInfoArray only describes
+  characters which are at least partially displayed. For the final
+  row, the LineHeight and BaseLine may describe pixels that are
+  outside the limit specified by Height (unless
+  EFI_HII_OUT_FLAG_CLIP_CLEAN_Y is specified) even though those
+  pixels were not drawn. The LineWidth may describe pixels which
+  are outside the limit specified by Width (unless
+  EFI_HII_OUT_FLAG_CLIP_CLEAN_X is specified) even though those
+  pixels were not drawn. If EFI_HII_OUT_FLAG_CLIP_CLEAN_X is set,
+  then it modifies the behavior of EFI_HII_OUT_FLAG_CLIP so that
+  if a character's right-most on pixel cannot fit, then it will
+  not be drawn at all. This flag requires that
+  EFI_HII_OUT_FLAG_CLIP be set. If EFI_HII_OUT_FLAG_CLIP_CLEAN_Y
+  is set, then it modifies the behavior of EFI_HII_OUT_FLAG_CLIP
+  so that if a row's bottom-most pixel cannot fit, then it will
+  not be drawn at all. This flag requires that
+  EFI_HII_OUT_FLAG_CLIP be set. If EFI_HII_OUT_FLAG_WRAP is set,
+  then text will be wrapped at the right-most line-break
+  opportunity prior to a character whose right-most extent would
+  exceed Width. If no line-break opportunity can be found, then
+  the text will behave as if EFI_HII_OUT_FLAG_CLIP_CLEAN_X is set.
+  This flag cannot be used with EFI_HII_OUT_FLAG_CLIP_CLEAN_X. If
+  EFI_HII_OUT_FLAG_TRANSPARENT is set, then BackgroundColor is
+  ignored and all 'off' pixels in the character's drawn
+  will use the pixel value from Blt. This flag cannot be used if
+  Blt is NULL upon entry. If EFI_HII_IGNORE_IF_NO_GLYPH is set,
+  then characters which have no glyphs are not drawn. Otherwise,
+  they are replaced with Unicode character code 0xFFFD (REPLACEMENT
+  CHARACTER). If EFI_HII_IGNORE_LINE_BREAK is set, then explicit
+  line break characters will be ignored. If
+  EFI_HII_DIRECT_TO_SCREEN is set, then the string will be written
+  directly to the output device specified by Screen. Otherwise the
+  string will be rendered to the bitmap specified by Bitmap.
+
+  @param This             A pointer to the EFI_HII_FONT_PROTOCOL instance.
+
+  @param Flags            Describes how the string is to be drawn.
+
+  @param String           Points to the null-terminated string to be 
+
+  @param StringInfo       Points to the string output information,
+                          including the color and font. If NULL, then
+                          the string will be output in the default
+                          system font and color.
+
+  @param Blt              If this points to a non-NULL on entry, this points
+                          to the image, which is Width pixels wide and
+                          Height pixels high. The string will be drawn onto
+                          this image and EFI_HII_OUT_FLAG_CLIP is implied.
+                          If this points to a NULL on entry, then a buffer
+                          will be allocated to hold the generated image and
+                          the pointer updated on exit. It is the caller's
+                          responsibility to free this buffer.
+
+  @param BltX, BltY       Specifies the offset from the left and top
+                          edge of the image of the first character
+                          cell in the image.
+
+  @param RowInfoArray     If this is non-NULL on entry, then on
+                          exit, this will point to an allocated buffer
+                          containing row information and
+                          RowInfoArraySize will be updated to contain
+                          the number of elements. This array describes
+                          the characters that were at least partially
+                          drawn and the heights of the rows. It is the
+                          caller's responsibility to free this buffer.
+
+  @param RowInfoArraySize If this is non-NULL on entry, then on
+                          exit it contains the number of
+                          elements in RowInfoArray.
+
+  @param ColumnInfoArray  If this is non-NULL, then on return it
+                          will be filled with the horizontal
+                          offset for each character in the
+                          string on the row where it is
+                          displayed. Non-printing characters
+                          will have the offset ~0. The caller is
+                          responsible for allocating a buffer large
+                          enough so that there is one entry for
+                          each character in the string, not
+                          including the null-terminator. It is
+                          possible when character display is
+                          normalized that some character cells
+                          overlap.
+
+  @retval EFI_SUCCESS           The string was successfully updated.
+  
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate an output buffer for RowInfoArray or Blt.
+  
+  @retval EFI_INVALID_PARAMETER The String or Blt was NULL.
+
+  @retval EFI_INVALID_PARAMETER Flags were invalid combination.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_STRING_TO_IMAGE)(
+  IN CONST  EFI_HII_FONT_PROTOCOL *This,
+  IN        EFI_HII_OUT_FLAGS     Flags,
+  IN CONST  EFI_STRING            String,
+  IN CONST  EFI_FONT_DISPLAY_INFO *StringInfo,
+  IN OUT    EFI_IMAGE_OUTPUT      **Blt,
+  IN        UINTN                 BltX,
+  IN        UINTN                 BltY,
+  OUT       EFI_HII_ROW_INFO      **RowInfoArray OPTIONAL,
+  OUT       UINTN                 *RowInfoArraySize OPTIONAL,
+  OUT       UINTN                 *ColumnInfoArray OPTIONAL
+);
+
+
+
+/**
+
+  This function renders a string as a bitmap or to the screen
+  and can clip or wrap the string. The bitmap is either supplied
+  by the caller or allocated by the function. The
+  strings are drawn with the font, size and style specified and
+  can be drawn transparently or opaquely. The function can also
+  return information about each row and each character's
+  position on the row. If EFI_HII_OUT_FLAG_CLIP is set, then
+  text will be formatted based only on explicit line breaks, and
+  all pixels that would lie outside the bounding box specified
+  by Width and Height are ignored. The information in the
+  RowInfoArray only describes characters which are at least
+  partially displayed. For the final row, the LineHeight and
+  BaseLine may describe pixels which are outside the limit
+  specified by Height (unless EFI_HII_OUT_FLAG_CLIP_CLEAN_Y is
+  specified) even though those pixels were not drawn. If
+  EFI_HII_OUT_FLAG_CLIP_CLEAN_X is set, then it modifies the
+  behavior of EFI_HII_OUT_FLAG_CLIP so that if a character's
+  right-most on pixel cannot fit, then it will not be drawn at
+  all. This flag requires that EFI_HII_OUT_FLAG_CLIP be set. If
+  EFI_HII_OUT_FLAG_CLIP_CLEAN_Y is set, then it modifies the
+  behavior of EFI_HII_OUT_FLAG_CLIP so that if a row's bottom
+  most pixel cannot fit, then it will not be drawn at all. This
+  flag requires that EFI_HII_OUT_FLAG_CLIP be set. If
+  EFI_HII_OUT_FLAG_WRAP is set, then text will be wrapped at the
+  right-most line-break opportunity prior to a character whose
+  right-most extent would exceed Width. If no line-break
+  opportunity can be found, then the text will behave as if
+  EFI_HII_OUT_FLAG_CLIP_CLEAN_X is set. This flag cannot be used
+  with EFI_HII_OUT_FLAG_CLIP_CLEAN_X. If
+  EFI_HII_OUT_FLAG_TRANSPARENT is set, then BackgroundColor is
+  ignored and all off" pixels in the character's glyph will
+  use the pixel value from Blt. This flag cannot be used if Blt
+  is NULL upon entry. If EFI_HII_IGNORE_IF_NO_GLYPH is set, then
+  characters which have no glyphs are not drawn. Otherwise, they
+  are replaced with Unicode character code 0xFFFD (REPLACEMENT
+  CHARACTER). If EFI_HII_IGNORE_LINE_BREAK is set, then explicit
+  line break characters will be ignored. If
+  EFI_HII_DIRECT_TO_SCREEN is set, then the string will be
+  written directly to the output device specified by Screen.
+  Otherwise the string will be rendered to the bitmap specified
+  by Bitmap.
+
+
+  @param This       A pointer to the EFI_HII_FONT_PROTOCOL instance.
+
+  @param Flags      Describes how the string is to be drawn.
+
+  @param PackageList  
+                    The package list in the HII database to
+                    search for the specified string.
+
+  @param StringId   The string's id, which is unique within
+                    PackageList.
+
+  @param Language   Points to the language for the retrieved
+                    string. If NULL, then the current system
+                    language is used.
+
+  @param StringInfo Points to the string output information,
+                    including the color and font. If NULL, then
+                    the string will be output in the default
+                    system font and color.
+
+  @param Blt        If this points to a non-NULL on entry, this points
+                    to the image, which is Width pixels wide and
+                    Height pixels high. The string will be drawn onto
+                    this image and EFI_HII_OUT_FLAG_CLIP is implied.
+                    If this points to a NULL on entry, then a buffer
+                    will be allocated to hold the generated image and
+                    the pointer updated on exit. It is the caller's
+                    responsibility to free this buffer.
+
+  @param BltX, BltY Specifies the offset from the left and top
+                    edge of the output image of the first
+                    character cell in the image.
+
+  @param RowInfoArray     If this is non-NULL on entry, then on
+                          exit, this will point to an allocated
+                          buffer containing row information and
+                          RowInfoArraySize will be updated to
+                          contain the number of elements. This array
+                          describes the characters which were at
+                          least partially drawn and the heights of
+                          the rows. It is the caller's
+                          responsibility to free this buffer.
+
+  @param RowInfoArraySize If this is non-NULL on entry, then on
+                          exit it contains the number of
+                          elements in RowInfoArray.
+
+  @param ColumnInfoArray  If non-NULL, on return it is filled
+                          with the horizontal offset for each
+                          character in the string on the row
+                          where it is displayed. Non-printing
+                          characters will have the offset ~0.
+                          The caller is responsible to allocate
+                          a buffer large enough so that there is
+                          one entry for each character in the
+                          string, not including the
+                          null-terminator. It is possible when
+                          character display is normalized that
+                          some character cells overlap.
+
+
+  @retval EFI_SUCCESS           The string was successfully updated.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate an output
+                                buffer for RowInfoArray or Blt.
+
+  @retval EFI_INVALID_PARAMETER The String, or Blt, or Height, or
+                                Width was NULL.
+  @retval EFI_INVALID_PARAMETER The Blt or PackageList was NULL.
+  @retval EFI_INVALID_PARAMETER Flags were invalid combination.
+  @retval EFI_NOT_FOUND         The specified PackageList is not in the Database, 
+                                or the stringid is not in the specified PackageList. 
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_STRING_ID_TO_IMAGE)(
+  IN CONST  EFI_HII_FONT_PROTOCOL *This,
+  IN        EFI_HII_OUT_FLAGS     Flags,
+  IN        EFI_HII_HANDLE        PackageList,
+  IN        EFI_STRING_ID         StringId,
+  IN CONST  CHAR8                 *Language,
+  IN CONST  EFI_FONT_DISPLAY_INFO *StringInfo       OPTIONAL,
+  IN OUT    EFI_IMAGE_OUTPUT      **Blt,
+  IN        UINTN                 BltX,
+  IN        UINTN                 BltY,
+  OUT       EFI_HII_ROW_INFO      **RowInfoArray    OPTIONAL,
+  OUT       UINTN                 *RowInfoArraySize OPTIONAL,
+  OUT       UINTN                 *ColumnInfoArray  OPTIONAL
+);
+
+
+/**
+
+  Convert the glyph for a single character into a bitmap.
+
+  @param This       A pointer to the EFI_HII_FONT_PROTOCOL instance.
+
+  @param Char       The character to retrieve.
+
+  @param StringInfo Points to the string font and color
+                    information or NULL if the string should use
+                    the default system font and color.
+
+  @param Blt        This must point to a NULL on entry. A buffer will
+                    be allocated to hold the output and the pointer
+                    updated on exit. It is the caller's responsibility
+                    to free this buffer.
+
+  @param Baseline   The number of pixels from the bottom of the bitmap
+                    to the baseline.
+
+
+  @retval EFI_SUCCESS             The glyph bitmap created.
+
+  @retval EFI_OUT_OF_RESOURCES    Unable to allocate the output buffer Blt.
+
+  @retval EFI_WARN_UNKNOWN_GLYPH  The glyph was unknown and was
+                                  replaced with the glyph for
+                                  Unicode character code 0xFFFD.
+
+  @retval EFI_INVALID_PARAMETER   Blt is NULL, or Width is NULL, or
+                                  Height is NULL
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_GLYPH)(
+  IN CONST  EFI_HII_FONT_PROTOCOL *This,
+  IN CONST  CHAR16                Char,
+  IN CONST  EFI_FONT_DISPLAY_INFO *StringInfo,
+  OUT       EFI_IMAGE_OUTPUT      **Blt,
+  OUT       UINTN                 *Baseline OPTIONAL
+);
+
+/**
+
+  This function iterates through fonts which match the specified
+  font, using the specified criteria. If String is non-NULL, then
+  all of the characters in the string must exist in order for a
+  candidate font to be returned.
+
+  @param This           A pointer to the EFI_HII_FONT_PROTOCOL instance.
+
+  @param FontHandle     On entry, points to the font handle returned
+                        by a previous call to GetFontInfo() or NULL
+                        to start with the first font. On return,
+                        points to the returned font handle or points
+                        to NULL if there are no more matching fonts.
+
+  @param StringInfoIn   Upon entry, points to the font to return
+                        information about. If NULL, then the information 
+                        about the system default font will be returned.
+
+  @param  StringInfoOut Upon return, contains the matching font's information.
+                        If NULL, then no information is returned. This buffer
+                        is allocated with a call to the Boot Service AllocatePool().
+                        It is the caller's responsibility to call the Boot 
+                        Service FreePool() when the caller no longer requires
+                        the contents of StringInfoOut.
+
+  @param String         Points to the string which will be tested to
+                        determine if all characters are available. If
+                        NULL, then any font is acceptable.
+  
+  @retval EFI_SUCCESS            Matching font returned successfully.
+  
+  @retval EFI_NOT_FOUND          No matching font was found.
+
+  @retval EFI_OUT_OF_RESOURCES   There were insufficient resources to complete the request.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_FONT_INFO)(
+  IN CONST  EFI_HII_FONT_PROTOCOL *This,
+  IN OUT    EFI_FONT_HANDLE       *FontHandle,
+  IN CONST  EFI_FONT_DISPLAY_INFO *StringInfoIn, OPTIONAL
+  OUT       EFI_FONT_DISPLAY_INFO **StringInfoOut,
+  IN CONST  EFI_STRING            String OPTIONAL
+);
+
+///
+/// The protocol provides the service to retrieve the font informations.
+///
+struct _EFI_HII_FONT_PROTOCOL {
+  EFI_HII_STRING_TO_IMAGE     StringToImage;
+  EFI_HII_STRING_ID_TO_IMAGE  StringIdToImage;
+  EFI_HII_GET_GLYPH           GetGlyph;
+  EFI_HII_GET_FONT_INFO       GetFontInfo;
+};
+
+extern EFI_GUID gEfiHiiFontProtocolGuid;
+
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/HiiImage.h b/MdePkg/Include/Protocol/HiiImage.h
new file mode 100644
index 000000000000..3407532ea2c1
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiImage.h
@@ -0,0 +1,356 @@
+/** @file
+  The file provides services to access to images in the images database.
+  
+  Copyright (c) 2006 - 2016, 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 __HII_IMAGE_H__
+#define __HII_IMAGE_H__
+
+#include <Protocol/GraphicsOutput.h>
+
+#define EFI_HII_IMAGE_PROTOCOL_GUID \
+  { 0x31a6406a, 0x6bdf, 0x4e46, { 0xb2, 0xa2, 0xeb, 0xaa, 0x89, 0xc4, 0x9, 0x20 } }
+
+typedef struct _EFI_HII_IMAGE_PROTOCOL EFI_HII_IMAGE_PROTOCOL;
+
+
+///
+/// Flags in EFI_IMAGE_INPUT
+/// 
+#define EFI_IMAGE_TRANSPARENT 0x00000001
+
+/**
+   
+  Definition of EFI_IMAGE_INPUT.
+   
+  @param Flags  Describe image characteristics. If
+                EFI_IMAGE_TRANSPARENT is set, then the image was
+                designed for transparent display.
+
+  @param Width  Image width, in pixels. 
+
+  @param Height Image height, in pixels.
+
+  @param Bitmap A pointer to the actual bitmap, organized left-to-right,
+                top-to-bottom. The size of the bitmap is
+                Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL).
+
+   
+**/
+typedef struct _EFI_IMAGE_INPUT {
+  UINT32                          Flags;
+  UINT16                          Width;
+  UINT16                          Height;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL   *Bitmap;
+} EFI_IMAGE_INPUT;
+
+
+/**
+
+  This function adds the image Image to the group of images
+  owned by PackageList, and returns a new image identifier
+  (ImageId).
+
+  @param This        A pointer to the EFI_HII_IMAGE_PROTOCOL instance. 
+  
+  @param PackageList Handle of the package list where this image will be added.
+
+  @param ImageId     On return, contains the new image id, which is
+                     unique within PackageList.
+
+  @param Image       Points to the image.
+
+  @retval EFI_SUCCESS             The new image was added
+                                  successfully
+  
+  @retval EFI_OUT_OF_RESOURCES    Could not add the image.
+  
+  @retval EFI_INVALID_PARAMETER   Image is NULL or ImageId is
+                                  NULL.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_NEW_IMAGE)(
+  IN CONST  EFI_HII_IMAGE_PROTOCOL  *This,
+  IN        EFI_HII_HANDLE          PackageList,
+  OUT       EFI_IMAGE_ID            *ImageId,
+  IN CONST  EFI_IMAGE_INPUT         *Image
+);
+
+/**
+
+  This function retrieves the image specified by ImageId which
+  is associated with the specified PackageList and copies it
+  into the buffer specified by Image. If the image specified by
+  ImageId is not present in the specified PackageList, then
+  EFI_NOT_FOUND is returned. If the buffer specified by
+  ImageSize is too small to hold the image, then
+  EFI_BUFFER_TOO_SMALL will be returned. ImageSize will be
+  updated to the size of buffer actually required to hold the
+  image.
+
+  @param This         A pointer to the EFI_HII_IMAGE_PROTOCOL instance. 
+  
+  @param PackageList  The package list in the HII database to
+                      search for the specified image.
+  
+  @param ImageId      The image's id, which is unique within
+                      PackageList.
+  
+  @param Image        Points to the new image.
+  
+  @retval EFI_SUCCESS            The image was returned successfully.
+
+  @retval EFI_NOT_FOUND          The image specified by ImageId is not
+                                 available. Or The specified PackageList is not in the database.
+  
+  @retval EFI_INVALID_PARAMETER  The Image or Langugae was NULL.
+  @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there was not
+                                 enough memory.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_IMAGE)(
+  IN CONST  EFI_HII_IMAGE_PROTOCOL  *This,
+  IN        EFI_HII_HANDLE          PackageList,
+  IN        EFI_IMAGE_ID            ImageId,
+  OUT       EFI_IMAGE_INPUT         *Image
+);
+
+/**
+   
+  This function updates the image specified by ImageId in the
+  specified PackageListHandle to the image specified by Image.
+
+
+  @param This         A pointer to the EFI_HII_IMAGE_PROTOCOL instance. 
+
+  @param PackageList  The package list containing the images.
+
+  @param ImageId      The image id, which is unique within PackageList.
+
+  @param Image        Points to the image.
+
+  @retval EFI_SUCCESS           The image was successfully updated.
+  
+  @retval EFI_NOT_FOUND         The image specified by ImageId is not in the database.
+                                The specified PackageList is not in the database. 
+  
+  @retval EFI_INVALID_PARAMETER The Image or Language was NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_SET_IMAGE)(
+  IN CONST  EFI_HII_IMAGE_PROTOCOL  *This,
+  IN        EFI_HII_HANDLE          PackageList,
+  IN        EFI_IMAGE_ID            ImageId,
+  IN CONST  EFI_IMAGE_INPUT         *Image
+);
+
+
+///
+/// EFI_HII_DRAW_FLAGS describes how the image is to be drawn.
+/// These flags are defined as EFI_HII_DRAW_FLAG_***
+///
+typedef UINT32  EFI_HII_DRAW_FLAGS;
+
+#define EFI_HII_DRAW_FLAG_CLIP          0x00000001
+#define EFI_HII_DRAW_FLAG_TRANSPARENT   0x00000030
+#define EFI_HII_DRAW_FLAG_DEFAULT       0x00000000
+#define EFI_HII_DRAW_FLAG_FORCE_TRANS   0x00000010
+#define EFI_HII_DRAW_FLAG_FORCE_OPAQUE  0x00000020
+#define EFI_HII_DIRECT_TO_SCREEN        0x00000080
+
+/**
+   
+  Definition of EFI_IMAGE_OUTPUT.
+   
+  @param Width  Width of the output image.
+
+  @param Height Height of the output image.
+
+  @param Bitmap Points to the output bitmap.
+
+  @param Screen Points to the EFI_GRAPHICS_OUTPUT_PROTOCOL which
+                describes the screen on which to draw the
+                specified image.
+
+**/
+typedef struct _EFI_IMAGE_OUTPUT {
+  UINT16  Width;
+  UINT16  Height;
+  union {
+    EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Bitmap;
+    EFI_GRAPHICS_OUTPUT_PROTOCOL  *Screen;
+  } Image;
+} EFI_IMAGE_OUTPUT;
+
+
+/**
+   
+  This function renders an image to a bitmap or the screen using
+  the specified color and options. It draws the image on an
+  existing bitmap, allocates a new bitmap or uses the screen. The
+  images can be clipped. If EFI_HII_DRAW_FLAG_CLIP is set, then
+  all pixels drawn outside the bounding box specified by Width and
+  Height are ignored. If EFI_HII_DRAW_FLAG_TRANSPARENT is set,
+  then all 'off' pixels in the images drawn will use the
+  pixel value from Blt. This flag cannot be used if Blt is NULL
+  upon entry. If EFI_HII_DIRECT_TO_SCREEN is set, then the image
+  will be written directly to the output device specified by
+  Screen. Otherwise the image will be rendered to the bitmap
+  specified by Bitmap.
+
+
+  @param This       A pointer to the EFI_HII_IMAGE_PROTOCOL instance. 
+ 
+  @param Flags      Describes how the image is to be drawn.
+                    EFI_HII_DRAW_FLAGS is defined in Related
+                    Definitions, below.
+  
+  @param Image      Points to the image to be displayed. 
+  
+  @param Blt        If this points to a non-NULL on entry, this points
+                    to the image, which is Width pixels wide and
+                    Height pixels high. The image will be drawn onto
+                    this image and EFI_HII_DRAW_FLAG_CLIP is implied.
+                    If this points to a NULL on entry, then a buffer
+                    will be allocated to hold the generated image and
+                    the pointer updated on exit. It is the caller's
+                    responsibility to free this buffer.
+
+  @param BltX, BltY Specifies the offset from the left and top
+                    edge of the image of the first pixel in
+                    the image.
+
+  @retval EFI_SUCCESS           The image was successfully updated.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate an output
+                                buffer for RowInfoArray or Blt.
+
+  @retval EFI_INVALID_PARAMETER The Image or Blt or Height or
+                                Width was NULL.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DRAW_IMAGE)(
+  IN CONST  EFI_HII_IMAGE_PROTOCOL  *This,
+  IN        EFI_HII_DRAW_FLAGS      Flags,
+  IN CONST  EFI_IMAGE_INPUT         *Image,
+  IN OUT    EFI_IMAGE_OUTPUT        **Blt,
+  IN        UINTN                   BltX,
+  IN        UINTN                   BltY
+);
+
+/**
+   
+  This function renders an image as a bitmap or to the screen and
+  can clip the image. The bitmap is either supplied by the caller
+  or else is allocated by the function. The images can be drawn
+  transparently or opaquely. If EFI_HII_DRAW_FLAG_CLIP is set,
+  then all pixels drawn outside the bounding box specified by
+  Width and Height are ignored. If EFI_HII_DRAW_FLAG_TRANSPARENT
+  is set, then all "off" pixels in the character's glyph will
+  use the pixel value from Blt. This flag cannot be used if Blt
+  is NULL upon entry. If EFI_HII_DIRECT_TO_SCREEN is set, then
+  the image will be written directly to the output device
+  specified by Screen. Otherwise the image will be rendered to
+  the bitmap specified by Bitmap.
+  This function renders an image to a bitmap or the screen using
+  the specified color and options. It draws the image on an
+  existing bitmap, allocates a new bitmap or uses the screen. The
+  images can be clipped. If EFI_HII_DRAW_FLAG_CLIP is set, then
+  all pixels drawn outside the bounding box specified by Width and
+  Height are ignored. The EFI_HII_DRAW_FLAG_TRANSPARENT flag
+  determines whether the image will be drawn transparent or
+  opaque. If EFI_HII_DRAW_FLAG_FORCE_TRANS is set, then the image
+  will be drawn so that all 'off' pixels in the image will
+  be drawn using the pixel value from Blt and all other pixels
+  will be copied. If EFI_HII_DRAW_FLAG_FORCE_OPAQUE is set, then
+  the image's pixels will be copied directly to the
+  destination. If EFI_HII_DRAW_FLAG_DEFAULT is set, then the image
+  will be drawn transparently or opaque, depending on the
+  image's transparency setting (see EFI_IMAGE_TRANSPARENT).
+  Images cannot be drawn transparently if Blt is NULL. If
+  EFI_HII_DIRECT_TO_SCREEN is set, then the image will be written
+  directly to the output device specified by Screen. Otherwise the
+  image will be rendered to the bitmap specified by Bitmap.
+
+  @param This         A pointer to the EFI_HII_IMAGE_PROTOCOL instance. 
+
+  @param Flags        Describes how the image is to be drawn.
+
+  @param PackageList  The package list in the HII database to
+                      search for the specified image.
+
+  @param ImageId      The image's id, which is unique within PackageList.
+
+  @param Blt          If this points to a non-NULL on entry, this points
+                      to the image, which is Width pixels wide and
+                      Height pixels high. The image will be drawn onto
+                      this image and EFI_HII_DRAW_FLAG_CLIP is implied.
+                      If this points to a NULL on entry, then a buffer
+                      will be allocated to hold the generated image and
+                      the pointer updated on exit. It is the caller's
+                      responsibility to free this buffer.
+
+  @param BltX, BltY   Specifies the offset from the left and top
+                      edge of the output image of the first
+                      pixel in the image.
+
+  @retval EFI_SUCCESS           The image was successfully updated.
+  
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate an output
+                                buffer for RowInfoArray or Blt.
+  
+  @retval EFI_NOT_FOUND         The image specified by ImageId is not in the database. 
+                                Or The specified PackageList is not in the database.                            
+  
+  @retval EFI_INVALID_PARAMETER The Blt was NULL.    
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DRAW_IMAGE_ID)(
+IN CONST  EFI_HII_IMAGE_PROTOCOL  *This,
+IN        EFI_HII_DRAW_FLAGS      Flags,
+IN        EFI_HII_HANDLE          PackageList,
+IN        EFI_IMAGE_ID            ImageId,
+IN OUT    EFI_IMAGE_OUTPUT        **Blt,
+IN        UINTN                   BltX,
+IN        UINTN                   BltY
+);
+
+
+///
+/// Services to access to images in the images database.
+///
+struct _EFI_HII_IMAGE_PROTOCOL {
+  EFI_HII_NEW_IMAGE     NewImage;
+  EFI_HII_GET_IMAGE     GetImage;
+  EFI_HII_SET_IMAGE     SetImage;
+  EFI_HII_DRAW_IMAGE    DrawImage;
+  EFI_HII_DRAW_IMAGE_ID DrawImageId;
+};
+
+extern EFI_GUID gEfiHiiImageProtocolGuid;
+
+#endif
+
+
diff --git a/MdePkg/Include/Protocol/HiiImageDecoder.h b/MdePkg/Include/Protocol/HiiImageDecoder.h
new file mode 100644
index 000000000000..6ee16c922243
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiImageDecoder.h
@@ -0,0 +1,212 @@
+/** @file
+  This protocol provides generic image decoder interfaces to various image formats.
+
+(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
+  Copyright (c) 2016, 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 __HII_IMAGE_DECODER_H__
+#define __HII_IMAGE_DECODER_H__
+
+#include <Protocol/HiiImage.h>
+
+
+//
+// In UEFI 2.6 spec,this guid value is duplicate with
+// EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID. Now update this guid value to
+// avoid the duplicate guid issue. So its value is not consistent with
+// UEFI spec definition now. We have proposed to update UEFI spec to
+// use this new guid. After new spec released, we will remove this
+// comments.
+//
+#define EFI_HII_IMAGE_DECODER_PROTOCOL_GUID \
+  {0x9e66f251, 0x727c, 0x418c, { 0xbf, 0xd6, 0xc2, 0xb4, 0x25, 0x28, 0x18, 0xea }}
+
+
+#define EFI_HII_IMAGE_DECODER_NAME_JPEG_GUID \
+  {0xefefd093, 0xd9b, 0x46eb,  { 0xa8, 0x56, 0x48, 0x35, 0x7, 0x0, 0xc9, 0x8 }}
+
+#define EFI_HII_IMAGE_DECODER_NAME_PNG_GUID \
+  {0xaf060190, 0x5e3a, 0x4025, { 0xaf, 0xbd, 0xe1, 0xf9, 0x5, 0xbf, 0xaa, 0x4c }}
+
+typedef struct _EFI_HII_IMAGE_DECODER_PROTOCOL EFI_HII_IMAGE_DECODER_PROTOCOL;
+
+typedef enum {
+  EFI_HII_IMAGE_DECODER_COLOR_TYPE_RGB     = 0x0,
+  EFI_HII_IMAGE_DECODER_COLOR_TYPE_RGBA    = 0x1,
+  EFI_HII_IMAGE_DECODER_COLOR_TYPE_CMYK    = 0x2,
+  EFI_HII_IMAGE_DECODER_COLOR_TYPE_UNKNOWN = 0xFF
+} EFI_HII_IMAGE_DECODER_COLOR_TYPE;
+
+//
+// EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER
+//
+// DecoderName        Name of the decoder
+// ImageInfoSize      The size of entire image information structure in bytes
+// ImageWidth         The image width
+// ImageHeight        The image height
+// ColorType          The color type, see EFI_HII_IMAGE_DECODER_COLOR_TYPE.
+// ColorDepthInBits   The color depth in bits
+//
+typedef struct _EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER {
+  EFI_GUID                            DecoderName;
+  UINT16                              ImageInfoSize;
+  UINT16                              ImageWidth;
+  UINT16                              ImageHeight;
+  EFI_HII_IMAGE_DECODER_COLOR_TYPE    ColorType;
+  UINT8                               ColorDepthInBits;
+} EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER;
+
+#define EFI_IMAGE_JPEG_SCANTYPE_PROGREESSIVE 0x01
+#define EFI_IMAGE_JPEG_SCANTYPE_INTERLACED   0x02
+
+//
+// EFI_HII_IMAGE_DECODER_JPEG_INFO
+// Header         The common header
+// ScanType       The scan type of JPEG image
+// Reserved       Reserved
+//
+typedef struct _EFI_HII_IMAGE_DECODER_JPEG_INFO {
+  EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER  Header;
+  UINT16                                    ScanType;
+  UINT64                                    Reserved;
+} EFI_HII_IMAGE_DECODER_JPEG_INFO;
+
+//
+// EFI_HII_IMAGE_DECODER_PNG_INFO
+// Header         The common header
+// Channels       Number of channels in the PNG image
+// Reserved       Reserved
+//
+typedef struct _EFI_HII_IMAGE_DECODER_PNG_INFO {
+  EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER  Header;
+  UINT16                                    Channels;
+  UINT64                                    Reserved;
+} EFI_HII_IMAGE_DECODER_PNG_INFO;
+
+//
+// EFI_HII_IMAGE_DECODER_OTHER_INFO
+//
+typedef struct _EFI_HII_IMAGE_DECODER_OTHER_INFO {
+  EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER Header;
+  CHAR16                                  ImageExtenion[1];
+  //
+  // Variable length of image file extension name.
+  //
+} EFI_HII_IMAGE_DECODER_OTHER_INFO;
+
+/**
+  There could be more than one EFI_HII_IMAGE_DECODER_PROTOCOL instances installed
+  in the system for different image formats. This function returns the decoder
+  name which callers can use to find the proper image decoder for the image. It
+  is possible to support multiple image formats in one EFI_HII_IMAGE_DECODER_PROTOCOL.
+  The capability of the supported image formats is returned in DecoderName and
+  NumberOfDecoderName.
+
+  @param This                    EFI_HII_IMAGE_DECODER_PROTOCOL instance.
+  @param DecoderName             Pointer to a dimension to retrieve the decoder
+                                 names in EFI_GUID format. The number of the
+                                 decoder names is returned in NumberOfDecoderName.
+  @param NumberofDecoderName     Pointer to retrieve the number of decoders which
+                                 supported by this decoder driver.
+
+  @retval EFI_SUCCESS            Get decoder name success.
+  @retval EFI_UNSUPPORTED        Get decoder name fail.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_IMAGE_DECODER_GET_NAME)(
+  IN      EFI_HII_IMAGE_DECODER_PROTOCOL   *This,
+  IN OUT  EFI_GUID                         **DecoderName,
+  IN OUT  UINT16                           *NumberOfDecoderName
+  );
+
+/**
+  This function returns the image information of the given image raw data. This
+  function first checks whether the image raw data is supported by this decoder
+  or not. This function may go through the first few bytes in the image raw data
+  for the specific data structure or the image signature. If the image is not supported
+  by this image decoder, this function returns EFI_UNSUPPORTED to the caller.
+  Otherwise, this function returns the proper image information to the caller.
+  It is the caller?s responsibility to free the ImageInfo.
+
+  @param This                    EFI_HII_IMAGE_DECODER_PROTOCOL instance.
+  @param Image                   Pointer to the image raw data.
+  @param SizeOfImage             Size of the entire image raw data.
+  @param ImageInfo               Pointer to receive EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER.
+
+  @retval EFI_SUCCESS            Get image info success.
+  @retval EFI_UNSUPPORTED        Unsupported format of image.
+  @retval EFI_INVALID_PARAMETER  Incorrect parameter.
+  @retval EFI_BAD_BUFFER_SIZE    Not enough memory.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_IMAGE_DECODER_GET_IMAGE_INFO)(
+  IN      EFI_HII_IMAGE_DECODER_PROTOCOL           *This,
+  IN      VOID                                     *Image,
+  IN      UINTN                                    SizeOfImage,
+  IN OUT  EFI_HII_IMAGE_DECODER_IMAGE_INFO_HEADER  **ImageInfo
+  );
+
+/**
+  This function decodes the image which the image type of this image is supported
+  by this EFI_HII_IMAGE_DECODER_PROTOCOL. If **Bitmap is not NULL, the caller intends
+  to put the image in the given image buffer. That allows the caller to put an
+  image overlap on the original image. The transparency is handled by the image
+  decoder because the transparency capability depends on the image format. Callers
+  can set Transparent to FALSE to force disabling the transparency process on the
+  image. Forcing Transparent to FALSE may also improve the performance of the image
+  decoding because the image decoder can skip the transparency processing.  If **Bitmap
+  is NULL, the image decoder allocates the memory buffer for the EFI_IMAGE_OUTPUT
+  and decodes the image to the image buffer. It is the caller?s responsibility to
+  free the memory for EFI_IMAGE_OUTPUT. Image decoder doesn?t have to handle the
+  transparency in this case because there is no background image given by the caller.
+  The background color in this case is all black (#00000000).
+
+  @param This                    EFI_HII_IMAGE_DECODER_PROTOCOL instance.
+  @param Image                   Pointer to the image raw data.
+  @param ImageRawDataSize        Size of the entire image raw data.
+  @param Blt                     EFI_IMAGE_OUTPUT to receive the image or overlap
+                                 the image on the original buffer.
+  @param Transparent             BOOLEAN value indicates whether the image decoder
+                                 has to handle the transparent image or not.
+
+
+  @retval EFI_SUCCESS            Image decode success.
+  @retval EFI_UNSUPPORTED        Unsupported format of image.
+  @retval EFI_INVALID_PARAMETER  Incorrect parameter.
+  @retval EFI_BAD_BUFFER_SIZE    Not enough memory.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_IMAGE_DECODER_DECODE)(
+  IN      EFI_HII_IMAGE_DECODER_PROTOCOL   *This,
+  IN      VOID                              *Image,
+  IN      UINTN                             ImageRawDataSize,
+  IN OUT  EFI_IMAGE_OUTPUT                  **Bitmap,
+  IN      BOOLEAN                           Transparent
+  );
+
+struct _EFI_HII_IMAGE_DECODER_PROTOCOL {
+  EFI_HII_IMAGE_DECODER_GET_NAME          GetImageDecoderName;
+  EFI_HII_IMAGE_DECODER_GET_IMAGE_INFO    GetImageInfo;
+  EFI_HII_IMAGE_DECODER_DECODE            DecodeImage;
+};
+
+extern EFI_GUID gEfiHiiImageDecoderProtocolGuid;
+extern EFI_GUID gEfiHiiImageDecoderNameJpegGuid;
+extern EFI_GUID gEfiHiiImageDecoderNamePngGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/HiiImageEx.h b/MdePkg/Include/Protocol/HiiImageEx.h
new file mode 100644
index 000000000000..5c4fd647e198
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiImageEx.h
@@ -0,0 +1,245 @@
+/** @file
+  Protocol which allows access to the images in the images database.
+
+(C) Copyright 2016 Hewlett Packard Enterprise Development LP<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_HII_IMAGE_EX_H__
+#define __EFI_HII_IMAGE_EX_H__
+
+#include <Protocol/HiiImage.h>
+
+//
+// Global ID for the Hii Image Ex Protocol.
+//
+#define EFI_HII_IMAGE_EX_PROTOCOL_GUID \
+  {0x1a1241e6, 0x8f19, 0x41a9,  { 0xbc, 0xe, 0xe8, 0xef, 0x39, 0xe0, 0x65, 0x46 }}
+
+typedef struct _EFI_HII_IMAGE_EX_PROTOCOL EFI_HII_IMAGE_EX_PROTOCOL;
+
+/**
+  The prototype of this extension function is the same with EFI_HII_IMAGE_PROTOCOL.NewImage().
+  Same with EFI_HII_IMAGE_PROTOCOL.NewImage().This protocol invokes
+EFI_HII_IMAGE_PROTOCOL.NewImage() implicitly.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  PackageList            Handle of the package list where this image will
+                                 be added.
+  @param  ImageId                On return, contains the new image id, which is
+                                 unique within PackageList.
+  @param  Image                  Points to the image.
+
+  @retval EFI_SUCCESS            The new image was added successfully.
+  @retval EFI_NOT_FOUND          The specified PackageList could not be found in
+                                 database.
+  @retval EFI_OUT_OF_RESOURCES   Could not add the image due to lack of resources.
+  @retval EFI_INVALID_PARAMETER  Image is NULL or ImageId is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_NEW_IMAGE_EX)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL  *This,
+  IN        EFI_HII_HANDLE              PackageList,
+  OUT       EFI_IMAGE_ID                *ImageId,
+  IN CONST  EFI_IMAGE_INPUT             *Image
+  );
+
+/**
+  Return the information about the image, associated with the package list.
+  The prototype of this extension function is the same with EFI_HII_IMAGE_PROTOCOL.GetImage().
+  Same with EFI_HII_IMAGE_PROTOCOL.SetImage(),this protocol invokes EFI_HII_IMAGE_PROTOCOL.SetImage() implicitly.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  PackageList            Handle of the package list where this image will
+                                 be searched.
+  @param  ImageId                The image's id,, which is unique within
+                                 PackageList.
+  @param  Image                  Points to the image.
+
+  @retval EFI_SUCCESS            The new image was returned successfully.
+  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the
+                                 database. The specified PackageList is not in
+                                 the database.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to
+                                 hold the image.
+  @retval EFI_INVALID_PARAMETER  The Image or ImageSize was NULL.
+  @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there
+                                 was not enough memory.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_IMAGE_EX)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL       *This,
+  IN        EFI_HII_HANDLE                  PackageList,
+  IN        EFI_IMAGE_ID                    ImageId,
+  OUT       EFI_IMAGE_INPUT                 *Image
+  );
+
+/**
+  Change the information about the image. The prototype of this extension
+  function is the same with EFI_HII_IMAGE_PROTOCOL.SetImage().  Same with
+  EFI_HII_IMAGE_PROTOCOL.DrawImageId(),this protocol invokes EFI_HII_IMAGE_PROTOCOL.DrawImageId() implicitly.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  PackageList            The package list containing the images.
+  @param  ImageId                The image's id,, which is unique within
+                                 PackageList.
+  @param  Image                  Points to the image.
+
+  @retval EFI_SUCCESS            The new image was updated successfully.
+  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the
+                                 database. The specified PackageList is not in
+                                 the database.
+  @retval EFI_INVALID_PARAMETER  The Image was NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_SET_IMAGE_EX)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL   *This,
+  IN        EFI_HII_HANDLE              PackageList,
+  IN        EFI_IMAGE_ID                ImageId,
+  IN CONST  EFI_IMAGE_INPUT             *Image
+  );
+
+/**
+  Renders an image to a bitmap or to the display. The prototype of this extension
+  function is the same with EFI_HII_IMAGE_PROTOCOL.DrawImage().
+  Same with EFI_HII_IMAGE_PROTOCOL.SetImage(),this protocol invokes EFI_HII_IMAGE_PROTOCOL.SetImage() implicitly.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  Flags                  Describes how the image is to be drawn.
+  @param  Image                  Points to the image to be displayed.
+  @param  Blt                    If this points to a non-NULL on entry, this points
+                                 to the image, which is Width pixels wide and
+                                 Height pixels high.  The image will be drawn onto
+                                 this image and  EFI_HII_DRAW_FLAG_CLIP is implied.
+                                 If this points to a  NULL on entry, then a buffer
+                                 will be allocated to hold  the generated image and
+                                 the pointer updated on exit. It is the caller's
+                                 responsibility to free this buffer.
+  @param  BltX                   Specifies the offset from the left and top edge of
+                                 the  output image of the first pixel in the image.
+  @param  BltY                   Specifies the offset from the left and top edge of
+                                 the  output image of the first pixel in the image.
+
+  @retval EFI_SUCCESS            The image was successfully drawn.
+  @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.
+  @retval EFI_INVALID_PARAMETER  The Image or Blt was NULL.
+                                 Any combination of Flags is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DRAW_IMAGE_EX)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL   *This,
+  IN        EFI_HII_DRAW_FLAGS          Flags,
+  IN CONST  EFI_IMAGE_INPUT             *Image,
+  IN OUT    EFI_IMAGE_OUTPUT            **Blt,
+  IN        UINTN                       BltX,
+  IN        UINTN                       BltY
+  );
+
+/**
+  Renders an image to a bitmap or the screen containing the contents of the specified
+  image. The prototype of this extension function is the same with E
+  FI_HII_IMAGE_PROTOCOL.DrawImageId().
+  Same with EFI_HII_IMAGE_PROTOCOL.DrawImageId(),this protocol invokes
+EFI_HII_IMAGE_PROTOCOL.DrawImageId() implicitly.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  Flags                  Describes how the image is to be drawn.
+  @param  PackageList            The package list in the HII database to search for
+                                 the  specified image.
+  @param  ImageId                The image's id, which is unique within
+                                 PackageList.
+  @param  Blt                    If this points to a non-NULL on entry, this points
+                                 to the image, which is Width pixels wide and
+                                 Height pixels high. The image will be drawn onto
+                                 this image and EFI_HII_DRAW_FLAG_CLIP is implied.
+                                 If this points to a NULL on entry, then a buffer
+                                 will be allocated to hold  the generated image
+                                 and the pointer updated on exit. It is the caller's
+                                 responsibility to free this buffer.
+  @param  BltX                   Specifies the offset from the left and top edge of
+                                 the output image of the first pixel in the image.
+  @param  BltY                   Specifies the offset from the left and top edge of
+                                 the output image of the first pixel in the image.
+
+  @retval EFI_SUCCESS            The image was successfully drawn.
+  @retval EFI_OUT_OF_RESOURCES   Unable to allocate an output buffer for Blt.
+  @retval EFI_INVALID_PARAMETER  The Blt was NULL.
+  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the database.
+                                 The specified PackageList is not in the database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_DRAW_IMAGE_ID_EX)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL   *This,
+  IN        EFI_HII_DRAW_FLAGS          Flags,
+  IN        EFI_HII_HANDLE              PackageList,
+  IN        EFI_IMAGE_ID                ImageId,
+  IN OUT    EFI_IMAGE_OUTPUT            **Blt,
+  IN        UINTN                       BltX,
+  IN        UINTN                       BltY
+  );
+
+/**
+  This function returns the image information to EFI_IMAGE_OUTPUT. Only the width
+  and height are returned to the EFI_IMAGE_OUTPUT instead of decoding the image
+  to the buffer. This function is used to get the geometry of the image. This function
+  will try to locate all of the EFI_HII_IMAGE_DECODER_PROTOCOL installed on the
+  system if the decoder of image type is not supported by the EFI_HII_IMAGE_EX_PROTOCOL.
+
+  @param  This                   A pointer to the EFI_HII_IMAGE_EX_PROTOCOL instance.
+  @param  PackageList            Handle of the package list where this image will
+                                 be searched.
+  @param  ImageId                The image's id,, which is unique within PackageList.
+  @param  Image                  Points to the image.
+
+  @retval EFI_SUCCESS            The new image was returned successfully.
+  @retval EFI_NOT_FOUND          The image specified by ImageId is not in the
+                                 database. The specified PackageList is not in the database.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by ImageSize is too small to
+                                 hold the image.
+  @retval EFI_INVALID_PARAMETER  The Image or ImageSize was NULL.
+  @retval EFI_OUT_OF_RESOURCES   The bitmap could not be retrieved because there
+                                 was not enough memory.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_IMAGE_INFO)(
+  IN CONST  EFI_HII_IMAGE_EX_PROTOCOL       *This,
+  IN        EFI_HII_HANDLE                  PackageList,
+  IN        EFI_IMAGE_ID                    ImageId,
+  OUT       EFI_IMAGE_OUTPUT                *Image
+  );
+
+///
+/// Protocol which allows access to the images in the images database.
+///
+struct _EFI_HII_IMAGE_EX_PROTOCOL {
+  EFI_HII_NEW_IMAGE_EX      NewImageEx;
+  EFI_HII_GET_IMAGE_EX      GetImageEx;
+  EFI_HII_SET_IMAGE_EX      SetImageEx;
+  EFI_HII_DRAW_IMAGE_EX     DrawImageEx;
+  EFI_HII_DRAW_IMAGE_ID_EX  DrawImageIdEx;
+  EFI_HII_GET_IMAGE_INFO    GetImageInfo;
+};
+
+extern EFI_GUID gEfiHiiImageExProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/HiiPackageList.h b/MdePkg/Include/Protocol/HiiPackageList.h
new file mode 100644
index 000000000000..3842973281ec
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiPackageList.h
@@ -0,0 +1,33 @@
+/** @file
+  EFI_HII_PACKAGE_LIST_PROTOCOL as defined in UEFI 2.1.
+  Boot service LoadImage() installs EFI_HII_PACKAGE_LIST_PROTOCOL on the handle
+  if the image contains a custom PE/COFF resource with the type 'HII'.
+  The protocol's interface pointer points to the HII package list, which is
+  contained in the resource's data.
+  
+  Copyright (c) 2009, 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 __HII_PACKAGE_LIST_H__
+#define __HII_PACKAGE_LIST_H__
+
+#define EFI_HII_PACKAGE_LIST_PROTOCOL_GUID \
+  { 0x6a1ee763, 0xd47a, 0x43b4, {0xaa, 0xbe, 0xef, 0x1d, 0xe2, 0xab, 0x56, 0xfc}}
+
+typedef EFI_HII_PACKAGE_LIST_HEADER *    EFI_HII_PACKAGE_LIST_PROTOCOL;
+
+extern EFI_GUID gEfiHiiPackageListProtocolGuid;
+
+
+
+#endif
+
+
diff --git a/MdePkg/Include/Protocol/HiiString.h b/MdePkg/Include/Protocol/HiiString.h
new file mode 100644
index 000000000000..9e9f7ff50753
--- /dev/null
+++ b/MdePkg/Include/Protocol/HiiString.h
@@ -0,0 +1,241 @@
+/** @file
+  The file provides services to manipulate string data.
+  
+Copyright (c) 2006 - 2011, 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 __HII_STRING_H__
+#define __HII_STRING_H__
+
+#include <Protocol/HiiFont.h>
+
+#define EFI_HII_STRING_PROTOCOL_GUID \
+  { 0xfd96974, 0x23aa, 0x4cdc, { 0xb9, 0xcb, 0x98, 0xd1, 0x77, 0x50, 0x32, 0x2a } }
+
+typedef struct _EFI_HII_STRING_PROTOCOL EFI_HII_STRING_PROTOCOL;
+
+/**
+  This function adds the string String to the group of strings owned by PackageList, with the
+  specified font information StringFontInfo, and returns a new string id.
+  The new string identifier is guaranteed to be unique within the package list. 
+  That new string identifier is reserved for all languages in the package list. 
+
+  @param  This                   A pointer to the EFI_HII_STRING_PROTOCOL instance.
+  @param  PackageList            The handle of the package list where this string will
+                                 be added.
+  @param  StringId               On return, contains the new strings id, which is
+                                 unique within PackageList.
+  @param  Language               Points to the language for the new string.
+  @param  LanguageName           Points to the printable language name to associate
+                                 with the passed in  Language field.If LanguageName
+                                 is not NULL and the string package header's
+                                 LanguageName  associated with a given Language is
+                                 not zero, the LanguageName being passed in will
+                                 be ignored.
+  @param  String                 Points to the new null-terminated string.
+  @param  StringFontInfo         Points to the new string's font information or
+                                 NULL if the string should have the default system
+                                 font, size and style.
+
+  @retval EFI_SUCCESS            The new string was added successfully.
+  @retval EFI_NOT_FOUND          The specified PackageList could not be found in
+                                 database.
+  @retval EFI_OUT_OF_RESOURCES   Could not add the string due to lack of resources.
+  @retval EFI_INVALID_PARAMETER  String is NULL, or StringId is NULL, or Language is NULL.
+  @retval EFI_INVALID_PARAMETER  The specified StringFontInfo does not exist in
+                                 current database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_NEW_STRING)(
+  IN CONST  EFI_HII_STRING_PROTOCOL   *This,
+  IN        EFI_HII_HANDLE            PackageList,
+  OUT       EFI_STRING_ID             *StringId,
+  IN CONST  CHAR8                     *Language,
+  IN  CONST CHAR16                    *LanguageName, OPTIONAL  
+  IN CONST  EFI_STRING                String,
+  IN CONST  EFI_FONT_INFO             *StringFontInfo OPTIONAL
+);
+
+
+/**
+  This function retrieves the string specified by StringId which is associated
+  with the specified PackageList in the language Language and copies it into
+  the buffer specified by String.
+
+  @param  This                   A pointer to the EFI_HII_STRING_PROTOCOL instance.
+  @param  Language               Points to the language for the retrieved string.
+  @param  PackageList            The package list in the HII database to search for
+                                 the  specified string.
+  @param  StringId               The string's id, which is unique within
+                                 PackageList.
+  @param  String                 Points to the new null-terminated string.
+  @param  StringSize             On entry, points to the size of the buffer pointed
+                                 to by  String, in bytes. On return, points to the
+                                 length of the string, in bytes.
+  @param  StringFontInfo         If not NULL, points to the string's font
+                                 information.  It's caller's responsibility to free
+                                 this buffer.
+
+  @retval EFI_SUCCESS            The string was returned successfully.
+  @retval EFI_NOT_FOUND          The string specified by StringId is not available.
+                                 The specified PackageList is not in the database.
+  @retval EFI_INVALID_LANGUAGE    The string specified by StringId is available but 
+                                  not in the specified language.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by StringSize is too small to
+                                 hold the string.
+  @retval EFI_INVALID_PARAMETER   The Language or StringSize was NULL.
+  @retval EFI_INVALID_PARAMETER   The value referenced by StringSize was not zero and
+                                  String was NULL.
+  @retval EFI_OUT_OF_RESOURCES    There were insufficient resources to complete the
+                                  request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_STRING)(
+  IN CONST  EFI_HII_STRING_PROTOCOL *This,
+  IN CONST  CHAR8                   *Language,
+  IN        EFI_HII_HANDLE          PackageList,
+  IN        EFI_STRING_ID           StringId,
+  OUT       EFI_STRING              String,
+  IN OUT    UINTN                   *StringSize,
+  OUT       EFI_FONT_INFO           **StringFontInfo OPTIONAL
+);
+
+/**
+  This function updates the string specified by StringId in the specified PackageList to the text
+  specified by String and, optionally, the font information specified by StringFontInfo.
+
+  @param  This                   A pointer to the EFI_HII_STRING_PROTOCOL instance.
+  @param  PackageList            The package list containing the strings.
+  @param  StringId               The string's id, which is unique within
+                                 PackageList.
+  @param  Language               Points to the language for the updated string.
+  @param  String                 Points to the new null-terminated string.
+  @param  StringFontInfo         Points to the string's font information or NULL if
+                                 the  string font information is not changed.
+
+  @retval EFI_SUCCESS            The string was updated successfully.
+  @retval EFI_NOT_FOUND          The string specified by StringId is not in the
+                                 database.
+  @retval EFI_INVALID_PARAMETER  The String or Language was NULL.
+  @retval EFI_INVALID_PARAMETER  The specified StringFontInfo does not exist in
+                                 current database.
+  @retval EFI_OUT_OF_RESOURCES   The system is out of resources to accomplish the
+                                 task.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_SET_STRING)(
+  IN CONST  EFI_HII_STRING_PROTOCOL *This,
+  IN        EFI_HII_HANDLE          PackageList,
+  IN        EFI_STRING_ID           StringId,
+  IN CONST  CHAR8                   *Language,
+  IN        EFI_STRING              String,
+  IN CONST  EFI_FONT_INFO           *StringFontInfo OPTIONAL
+);
+
+
+/**
+  This function returns the list of supported languages.
+
+  @param  This                   A pointer to the EFI_HII_STRING_PROTOCOL instance.
+  @param  PackageList            The package list to examine.
+  @param  Languages              Points to the buffer to hold the returned
+                                 null-terminated ASCII string.
+  @param  LanguagesSize          On entry, points to the size of the buffer pointed
+                                 to by Languages, in bytes. On return, points to
+                                 the length of Languages, in bytes.
+
+  @retval EFI_SUCCESS            The languages were returned successfully.
+  @retval EFI_INVALID_PARAMETER  The LanguagesSize was NULL.
+  @retval EFI_INVALID_PARAMETER  The value referenced by LanguagesSize is not zero
+                                 and Languages is NULL.
+  @retval EFI_BUFFER_TOO_SMALL   The LanguagesSize is too small to hold the list of
+                                 supported languages. LanguageSize is updated to
+                                 contain the required size.
+  @retval EFI_NOT_FOUND          Could not find string package in specified
+                                 packagelist.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_LANGUAGES)(
+  IN CONST  EFI_HII_STRING_PROTOCOL   *This,
+  IN        EFI_HII_HANDLE            PackageList,
+  IN OUT    CHAR8                     *Languages,
+  IN OUT    UINTN                     *LanguagesSize
+);
+
+
+/**
+  Each string package has associated with it a single primary language and zero
+  or more secondary languages. This routine returns the secondary languages
+  associated with a package list.
+
+  @param  This                   A pointer to the EFI_HII_STRING_PROTOCOL instance.
+  @param  PackageList            The package list to examine.
+  @param  PrimaryLanguage        Points to the null-terminated ASCII string that specifies
+                                 the primary language. Languages are specified in the
+                                 format specified in Appendix M of the UEFI 2.0 specification.
+  @param  SecondaryLanguages     Points to the buffer to hold the returned null-terminated
+                                 ASCII string that describes the list of
+                                 secondary languages for the specified
+                                 PrimaryLanguage. If there are no secondary
+                                 languages, the function returns successfully, but
+                                 this is set to NULL.
+  @param  SecondaryLanguagesSize On entry, points to the size of the buffer pointed
+                                 to by SecondaryLanguages, in bytes. On return,
+                                 points to the length of SecondaryLanguages in bytes.
+
+  @retval EFI_SUCCESS            Secondary languages were correctly returned.
+  @retval EFI_INVALID_PARAMETER  PrimaryLanguage or SecondaryLanguagesSize was NULL.
+  @retval EFI_INVALID_PARAMETER  The value referenced by SecondaryLanguagesSize is not
+                                 zero and SecondaryLanguages is NULL.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer specified by SecondaryLanguagesSize is
+                                 too small to hold the returned information.
+                                 SecondaryLanguageSize is updated to hold the size of
+                                 the buffer required.
+  @retval EFI_INVALID_LANGUAGE   The language specified by PrimaryLanguage is not
+                                 present in the specified package list.
+  @retval EFI_NOT_FOUND          The specified PackageList is not in the Database.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HII_GET_2ND_LANGUAGES)(
+  IN CONST  EFI_HII_STRING_PROTOCOL   *This,
+  IN        EFI_HII_HANDLE            PackageList,
+  IN CONST  CHAR8                     *PrimaryLanguage,
+  IN OUT    CHAR8                     *SecondaryLanguages,
+  IN OUT    UINTN                     *SecondaryLanguagesSize
+);
+
+
+///
+/// Services to manipulate the string.
+///
+struct _EFI_HII_STRING_PROTOCOL {
+  EFI_HII_NEW_STRING        NewString;
+  EFI_HII_GET_STRING        GetString;
+  EFI_HII_SET_STRING        SetString;
+  EFI_HII_GET_LANGUAGES     GetLanguages;
+  EFI_HII_GET_2ND_LANGUAGES GetSecondaryLanguages;
+};
+
+
+extern EFI_GUID gEfiHiiStringProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Http.h b/MdePkg/Include/Protocol/Http.h
new file mode 100644
index 000000000000..bdfe76db80d4
--- /dev/null
+++ b/MdePkg/Include/Protocol/Http.h
@@ -0,0 +1,519 @@
+/** @file
+  This file defines the EFI HTTP Protocol interface. It is split into
+  the following two main sections:
+  HTTP Service Binding Protocol (HTTPSB)
+  HTTP Protocol (HTTP)
+
+  Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2015 Hewlett Packard Enterprise Development LP<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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_HTTP_PROTOCOL_H__
+#define __EFI_HTTP_PROTOCOL_H__
+
+#define EFI_HTTP_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xbdc8e6af, 0xd9bc, 0x4379, {0xa7, 0x2a, 0xe0, 0xc4, 0xe7, 0x5d, 0xae, 0x1c } \
+  }
+
+#define EFI_HTTP_PROTOCOL_GUID \
+  { \
+    0x7a59b29b, 0x910b, 0x4171, {0x82, 0x42, 0xa8, 0x5a, 0x0d, 0xf2, 0x5b, 0x5b } \
+  }
+
+typedef struct _EFI_HTTP_PROTOCOL EFI_HTTP_PROTOCOL;
+
+///
+/// EFI_HTTP_VERSION
+///
+typedef enum {
+  HttpVersion10,
+  HttpVersion11,
+  HttpVersionUnsupported
+} EFI_HTTP_VERSION;
+
+///
+/// EFI_HTTP_METHOD
+///
+typedef enum {
+  HttpMethodGet,
+  HttpMethodPost,
+  HttpMethodPatch,
+  HttpMethodOptions,
+  HttpMethodConnect,
+  HttpMethodHead,
+  HttpMethodPut,
+  HttpMethodDelete,
+  HttpMethodTrace,
+  HttpMethodMax
+} EFI_HTTP_METHOD;
+
+///
+/// EFI_HTTP_STATUS_CODE
+///
+typedef enum {
+  HTTP_STATUS_UNSUPPORTED_STATUS = 0,
+  HTTP_STATUS_100_CONTINUE,
+  HTTP_STATUS_101_SWITCHING_PROTOCOLS,
+  HTTP_STATUS_200_OK,
+  HTTP_STATUS_201_CREATED,
+  HTTP_STATUS_202_ACCEPTED,
+  HTTP_STATUS_203_NON_AUTHORITATIVE_INFORMATION,
+  HTTP_STATUS_204_NO_CONTENT,
+  HTTP_STATUS_205_RESET_CONTENT,
+  HTTP_STATUS_206_PARTIAL_CONTENT,
+  HTTP_STATUS_300_MULTIPLE_CHIOCES,
+  HTTP_STATUS_301_MOVED_PERMANENTLY,
+  HTTP_STATUS_302_FOUND,
+  HTTP_STATUS_303_SEE_OTHER,
+  HTTP_STATUS_304_NOT_MODIFIED,
+  HTTP_STATUS_305_USE_PROXY,
+  HTTP_STATUS_307_TEMPORARY_REDIRECT,
+  HTTP_STATUS_400_BAD_REQUEST,
+  HTTP_STATUS_401_UNAUTHORIZED,
+  HTTP_STATUS_402_PAYMENT_REQUIRED,
+  HTTP_STATUS_403_FORBIDDEN,
+  HTTP_STATUS_404_NOT_FOUND,
+  HTTP_STATUS_405_METHOD_NOT_ALLOWED,
+  HTTP_STATUS_406_NOT_ACCEPTABLE,
+  HTTP_STATUS_407_PROXY_AUTHENTICATION_REQUIRED,
+  HTTP_STATUS_408_REQUEST_TIME_OUT,
+  HTTP_STATUS_409_CONFLICT,
+  HTTP_STATUS_410_GONE,
+  HTTP_STATUS_411_LENGTH_REQUIRED,
+  HTTP_STATUS_412_PRECONDITION_FAILED,
+  HTTP_STATUS_413_REQUEST_ENTITY_TOO_LARGE,
+  HTTP_STATUS_414_REQUEST_URI_TOO_LARGE,
+  HTTP_STATUS_415_UNSUPPORTED_MEDIA_TYPE,
+  HTTP_STATUS_416_REQUESTED_RANGE_NOT_SATISFIED,
+  HTTP_STATUS_417_EXPECTATION_FAILED,
+  HTTP_STATUS_500_INTERNAL_SERVER_ERROR,
+  HTTP_STATUS_501_NOT_IMPLEMENTED,
+  HTTP_STATUS_502_BAD_GATEWAY,
+  HTTP_STATUS_503_SERVICE_UNAVAILABLE,
+  HTTP_STATUS_504_GATEWAY_TIME_OUT,
+  HTTP_STATUS_505_HTTP_VERSION_NOT_SUPPORTED
+} EFI_HTTP_STATUS_CODE;
+
+///
+/// EFI_HTTPv4_ACCESS_POINT
+///
+typedef struct {
+  ///
+  /// Set to TRUE to instruct the EFI HTTP instance to use the default address
+  /// information in every TCP connection made by this instance. In addition, when set
+  /// to TRUE, LocalAddress and LocalSubnet are ignored.
+  ///
+  BOOLEAN                       UseDefaultAddress;
+  ///
+  /// If UseDefaultAddress is set to FALSE, this defines the local IP address to be
+  /// used in every TCP connection opened by this instance.
+  ///
+  EFI_IPv4_ADDRESS              LocalAddress;
+  ///
+  /// If UseDefaultAddress is set to FALSE, this defines the local subnet to be used
+  /// in every TCP connection opened by this instance.
+  ///
+  EFI_IPv4_ADDRESS              LocalSubnet;
+  ///
+  /// This defines the local port to be used in
+  /// every TCP connection opened by this instance.
+  ///
+  UINT16                        LocalPort;
+} EFI_HTTPv4_ACCESS_POINT;
+
+///
+/// EFI_HTTPv6_ACCESS_POINT
+///
+typedef struct {
+  ///
+  /// Local IP address to be used in every TCP connection opened by this instance.
+  ///
+  EFI_IPv6_ADDRESS              LocalAddress;
+  ///
+  /// Local port to be used in every TCP connection opened by this instance.
+  ///
+  UINT16                        LocalPort;
+} EFI_HTTPv6_ACCESS_POINT;
+
+///
+/// EFI_HTTP_CONFIG_DATA_ACCESS_POINT
+///
+
+
+typedef struct {
+  ///
+  /// HTTP version that this instance will support.
+  ///
+  EFI_HTTP_VERSION                   HttpVersion;
+  ///
+  /// Time out (in milliseconds) when blocking for requests.
+  ///
+  UINT32                             TimeOutMillisec;
+  ///
+  /// Defines behavior of EFI DNS and TCP protocols consumed by this instance. If
+  /// FALSE, this instance will use EFI_DNS4_PROTOCOL and EFI_TCP4_PROTOCOL. If TRUE,
+  /// this instance will use EFI_DNS6_PROTOCOL and EFI_TCP6_PROTOCOL.
+  ///
+  BOOLEAN                            LocalAddressIsIPv6;
+
+  union {
+    ///
+    /// When LocalAddressIsIPv6 is FALSE, this points to the local address, subnet, and
+    /// port used by the underlying TCP protocol.
+    ///
+    EFI_HTTPv4_ACCESS_POINT          *IPv4Node;
+    ///
+    /// When LocalAddressIsIPv6 is TRUE, this points to the local IPv6 address and port
+    /// used by the underlying TCP protocol.
+    ///
+    EFI_HTTPv6_ACCESS_POINT          *IPv6Node;
+  } AccessPoint;
+} EFI_HTTP_CONFIG_DATA;
+
+///
+/// EFI_HTTP_REQUEST_DATA
+///
+typedef struct {
+  ///
+  /// The HTTP method (e.g. GET, POST) for this HTTP Request.
+  ///
+  EFI_HTTP_METHOD               Method;
+  ///
+  /// The URI of a remote host. From the information in this field, the HTTP instance
+  /// will be able to determine whether to use HTTP or HTTPS and will also be able to
+  /// determine the port number to use. If no port number is specified, port 80 (HTTP)
+  /// is assumed. See RFC 3986 for more details on URI syntax.
+  ///
+  CHAR16                        *Url;
+} EFI_HTTP_REQUEST_DATA;
+
+///
+/// EFI_HTTP_RESPONSE_DATA
+///
+typedef struct {
+  ///
+  /// Response status code returned by the remote host.
+  ///
+  EFI_HTTP_STATUS_CODE          StatusCode;
+} EFI_HTTP_RESPONSE_DATA;
+
+///
+/// EFI_HTTP_HEADER
+///
+typedef struct {
+  ///
+  /// Null terminated string which describes a field name. See RFC 2616 Section 14 for
+  /// detailed information about field names.
+  ///
+  CHAR8                         *FieldName;
+  ///
+  /// Null terminated string which describes the corresponding field value. See RFC 2616
+  /// Section 14 for detailed information about field values.
+  ///
+  CHAR8                         *FieldValue;
+} EFI_HTTP_HEADER;
+
+///
+/// EFI_HTTP_MESSAGE
+///
+typedef struct {
+  ///
+  /// HTTP message data.
+  ///
+  union {
+    ///
+    /// When the token is used to send a HTTP request, Request is a pointer to storage that
+    /// contains such data as URL and HTTP method.
+    ///
+    EFI_HTTP_REQUEST_DATA       *Request;
+    ///
+    /// When used to await a response, Response points to storage containing HTTP response
+    /// status code.
+    ///
+    EFI_HTTP_RESPONSE_DATA      *Response;
+  } Data;
+  ///
+  /// Number of HTTP header structures in Headers list. On request, this count is
+  /// provided by the caller. On response, this count is provided by the HTTP driver.
+  ///
+  UINTN                         HeaderCount;
+  ///
+  /// Array containing list of HTTP headers. On request, this array is populated by the
+  /// caller. On response, this array is allocated and populated by the HTTP driver. It
+  /// is the responsibility of the caller to free this memory on both request and
+  /// response.
+  ///
+  EFI_HTTP_HEADER               *Headers;
+  ///
+  /// Length in bytes of the HTTP body. This can be zero depending on the HttpMethod type.
+  ///
+  UINTN                         BodyLength;
+  ///
+  /// Body associated with the HTTP request or response. This can be NULL depending on
+  /// the HttpMethod type.
+  ///
+  VOID                          *Body;
+} EFI_HTTP_MESSAGE;
+
+
+///
+/// EFI_HTTP_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI HTTP
+  /// Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL. The Task Priority
+  /// Level (TPL) of Event must be lower than or equal to TPL_CALLBACK.
+  ///
+  EFI_EVENT                     Event;
+  ///
+  /// Status will be set to one of the following value if the HTTP request is
+  /// successfully sent or if an unexpected error occurs:
+  ///   EFI_SUCCESS:      The HTTP request was successfully sent to the remote host.
+  ///   EFI_HTTP_ERROR:   The response message was successfully received but contains a
+  ///                     HTTP error. The response status code is returned in token.
+  ///   EFI_ABORTED:      The HTTP request was cancelled by the caller and removed from
+  ///                     the transmit queue.
+  ///   EFI_TIMEOUT:      The HTTP request timed out before reaching the remote host.
+  ///   EFI_DEVICE_ERROR: An unexpected system or network error occurred.
+  ///
+  EFI_STATUS                    Status;
+  ///
+  /// Pointer to storage containing HTTP message data.
+  ///
+  EFI_HTTP_MESSAGE              *Message;
+} EFI_HTTP_TOKEN;
+
+/**
+  Returns the operational parameters for the current HTTP child instance.
+
+  The GetModeData() function is used to read the current mode data (operational
+  parameters) for this HTTP protocol instance.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+  @param[out] HttpConfigData      Point to buffer for operational parameters of this
+                                  HTTP instance.
+
+  @retval EFI_SUCCESS             Operation succeeded.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+                                  HttpConfigData is NULL.
+                                  HttpInstance->LocalAddressIsIPv6 is FALSE and
+                                  HttpConfigData->IPv4Node is NULL.
+                                  HttpInstance->LocalAddressIsIPv6 is TRUE and
+                                  HttpConfigData->IPv6Node is NULL.
+  @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been started.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HTTP_GET_MODE_DATA)(
+  IN  EFI_HTTP_PROTOCOL         *This,
+  OUT EFI_HTTP_CONFIG_DATA      *HttpConfigData
+  );
+
+/**
+  Initialize or brutally reset the operational parameters for this EFI HTTP instance.
+
+  The Configure() function does the following:
+  When HttpConfigData is not NULL Initialize this EFI HTTP instance by configuring
+  timeout, local address, port, etc.
+  When HttpConfigData is NULL, reset this EFI HTTP instance by closing all active
+  connections with remote hosts, canceling all asynchronous tokens, and flush request
+  and response buffers without informing the appropriate hosts.
+
+  No other EFI HTTP function can be executed by this instance until the Configure()
+  function is executed and returns successfully.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+  @param[in]  HttpConfigData      Pointer to the configure data to configure the instance.
+
+  @retval EFI_SUCCESS             Operation succeeded.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  HttpConfigData->LocalAddressIsIPv6 is FALSE and
+                                  HttpConfigData->IPv4Node is NULL.
+                                  HttpConfigData->LocalAddressIsIPv6 is TRUE and
+                                  HttpConfigData->IPv6Node is NULL.
+  @retval EFI_ALREADY_STARTED     Reinitialize this HTTP instance without calling
+                                  Configure() with NULL to reset it.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+  @retval EFI_OUT_OF_RESOURCES    Could not allocate enough system resources when
+                                  executing Configure().
+  @retval EFI_UNSUPPORTED         One or more options in ConfigData are not supported
+                                  in the implementation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_HTTP_CONFIGURE)(
+  IN  EFI_HTTP_PROTOCOL         *This,
+  IN  EFI_HTTP_CONFIG_DATA      *HttpConfigData
+  );
+
+/**
+  The Request() function queues an HTTP request to this HTTP instance, 
+  similar to Transmit() function in the EFI TCP driver. When the HTTP request is sent
+  successfully, or if there is an error, Status in token will be updated and Event will
+  be signaled.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+  @param[in]  Token               Pointer to storage containing HTTP request token.
+
+  @retval EFI_SUCCESS             Outgoing data was processed.
+  @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been started.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+  @retval EFI_TIMEOUT             Data was dropped out of the transmit or receive queue.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token->Message is NULL.
+                                  Token->Message->Body is not NULL,
+                                  Token->Message->BodyLength is non-zero, and
+                                  Token->Message->Data is NULL, but a previous call to
+                                  Request()has not been completed successfully.
+  @retval EFI_OUT_OF_RESOURCES    Could not allocate enough system resources.
+  @retval EFI_UNSUPPORTED         The HTTP method is not supported in current implementation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_REQUEST) (
+  IN  EFI_HTTP_PROTOCOL         *This,
+  IN  EFI_HTTP_TOKEN            *Token
+  );
+
+/**
+  Abort an asynchronous HTTP request or response token.
+
+  The Cancel() function aborts a pending HTTP request or response transaction. If
+  Token is not NULL and the token is in transmit or receive queues when it is being
+  cancelled, its Token->Status will be set to EFI_ABORTED and then Token->Event will
+  be signaled. If the token is not in one of the queues, which usually means that the
+  asynchronous operation has completed, EFI_NOT_FOUND is returned. If Token is NULL,
+  all asynchronous tokens issued by Request() or Response() will be aborted.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+  @param[in]  Token               Point to storage containing HTTP request or response
+                                  token.
+
+  @retval EFI_SUCCESS             Request and Response queues are successfully flushed.
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_NOT_STARTED         This instance hasn't been configured.
+  @retval EFI_NOT_FOUND           The asynchronous request or response token is not
+                                  found.
+  @retval EFI_UNSUPPORTED         The implementation does not support this function.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_CANCEL)(
+  IN  EFI_HTTP_PROTOCOL         *This,
+  IN  EFI_HTTP_TOKEN            *Token
+  );
+
+/**
+  The Response() function queues an HTTP response to this HTTP instance, similar to
+  Receive() function in the EFI TCP driver. When the HTTP Response is received successfully,
+  or if there is an error, Status in token will be updated and Event will be signaled.
+
+  The HTTP driver will queue a receive token to the underlying TCP instance. When data
+  is received in the underlying TCP instance, the data will be parsed and Token will
+  be populated with the response data. If the data received from the remote host
+  contains an incomplete or invalid HTTP header, the HTTP driver will continue waiting
+  (asynchronously) for more data to be sent from the remote host before signaling
+  Event in Token.
+
+  It is the responsibility of the caller to allocate a buffer for Body and specify the
+  size in BodyLength. If the remote host provides a response that contains a content
+  body, up to BodyLength bytes will be copied from the receive buffer into Body and
+  BodyLength will be updated with the amount of bytes received and copied to Body. This
+  allows the client to download a large file in chunks instead of into one contiguous
+  block of memory. Similar to HTTP request, if Body is not NULL and BodyLength is
+  non-zero and all other fields are NULL or 0, the HTTP driver will queue a receive
+  token to underlying TCP instance. If data arrives in the receive buffer, up to
+  BodyLength bytes of data will be copied to Body. The HTTP driver will then update
+  BodyLength with the amount of bytes received and copied to Body.
+
+  If the HTTP driver does not have an open underlying TCP connection with the host
+  specified in the response URL, Request() will return EFI_ACCESS_DENIED. This is
+  consistent with RFC 2616 recommendation that HTTP clients should attempt to maintain
+  an open TCP connection between client and host.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+  @param[in]  Token               Pointer to storage containing HTTP response token.
+
+  @retval EFI_SUCCESS             Allocation succeeded.
+  @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been
+                                  initialized.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+                                  Token->Message->Headers is NULL.
+                                  Token->Message is NULL.
+                                  Token->Message->Body is not NULL,
+                                  Token->Message->BodyLength is non-zero, and
+                                  Token->Message->Data is NULL, but a previous call to
+                                  Response() has not been completed successfully.
+  @retval EFI_OUT_OF_RESOURCES    Could not allocate enough system resources.
+  @retval EFI_ACCESS_DENIED       An open TCP connection is not present with the host
+                                  specified by response URL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_RESPONSE) (
+  IN  EFI_HTTP_PROTOCOL         *This,
+  IN  EFI_HTTP_TOKEN            *Token
+  );
+
+/**
+  The Poll() function can be used by network drivers and applications to increase the
+  rate that data packets are moved between the communication devices and the transmit
+  and receive queues.
+
+  In some systems, the periodic timer event in the managed network driver may not poll
+  the underlying communications device fast enough to transmit and/or receive all data
+  packets without missing incoming packets or dropping outgoing packets. Drivers and
+  applications that are experiencing packet loss should try calling the Poll() function
+  more often.
+
+  @param[in]  This                Pointer to EFI_HTTP_PROTOCOL instance.
+
+  @retval EFI_SUCCESS             Incoming or outgoing data was processed..
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred
+  @retval EFI_INVALID_PARAMETER   This is NULL.
+  @retval EFI_NOT_READY           No incoming or outgoing data is processed.
+  @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been started.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_POLL) (
+  IN  EFI_HTTP_PROTOCOL         *This
+  );
+
+///
+/// The EFI HTTP protocol is designed to be used by EFI drivers and applications to
+/// create and transmit HTTP Requests, as well as handle HTTP responses that are
+/// returned by a remote host. This EFI protocol uses and relies on an underlying EFI
+/// TCP protocol.
+///
+struct _EFI_HTTP_PROTOCOL {
+  EFI_HTTP_GET_MODE_DATA        GetModeData;
+  EFI_HTTP_CONFIGURE            Configure;
+  EFI_HTTP_REQUEST              Request;
+  EFI_HTTP_CANCEL               Cancel;
+  EFI_HTTP_RESPONSE             Response;
+  EFI_HTTP_POLL                 Poll;
+};
+
+extern EFI_GUID gEfiHttpServiceBindingProtocolGuid;
+extern EFI_GUID gEfiHttpProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/HttpUtilities.h b/MdePkg/Include/Protocol/HttpUtilities.h
new file mode 100644
index 000000000000..59c1ea2f7853
--- /dev/null
+++ b/MdePkg/Include/Protocol/HttpUtilities.h
@@ -0,0 +1,124 @@
+/** @file
+  EFI HTTP Utilities protocol provides a platform independent abstraction for HTTP
+  message comprehension.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_HTTP_UTILITIES_PROTOCOL_H__
+#define __EFI_HTTP_UTILITIES_PROTOCOL_H__
+
+#include <Protocol/Http.h>
+
+#define EFI_HTTP_UTILITIES_PROTOCOL_GUID  \
+  { \
+    0x3e35c163, 0x4074, 0x45dd, {0x43, 0x1e, 0x23, 0x98, 0x9d, 0xd8, 0x6b, 0x32 } \
+  }
+
+typedef struct _EFI_HTTP_UTILITIES_PROTOCOL EFI_HTTP_UTILITIES_PROTOCOL;
+
+
+/**
+  Create HTTP header based on a combination of seed header, fields
+  to delete, and fields to append.
+
+  The Build() function is used to manage the headers portion of an
+  HTTP message by providing the ability to add, remove, or replace
+  HTTP headers.
+
+  @param[in]  This                Pointer to EFI_HTTP_UTILITIES_PROTOCOL instance.
+  @param[in]  SeedMessageSize     Size of the initial HTTP header. This can be zero.
+  @param[in]  SeedMessage         Initial HTTP header to be used as a base for
+                                  building a new HTTP header. If NULL,
+                                  SeedMessageSize is ignored.
+  @param[in]  DeleteCount         Number of null-terminated HTTP header field names
+                                  in DeleteList.
+  @param[in]  DeleteList          List of null-terminated HTTP header field names to
+                                  remove from SeedMessage. Only the field names are
+                                  in this list because the field values are irrelevant
+                                  to this operation.
+  @param[in]  AppendCount         Number of header fields in AppendList.
+  @param[in]  AppendList          List of HTTP headers to populate NewMessage with.
+                                  If SeedMessage is not NULL, AppendList will be
+                                  appended to the existing list from SeedMessage in
+                                  NewMessage.
+  @param[out] NewMessageSize      Pointer to number of header fields in NewMessage.
+  @param[out] NewMessage          Pointer to a new list of HTTP headers based on.
+
+  @retval EFI_SUCCESS             Add, remove, and replace operations succeeded.
+  @retval EFI_OUT_OF_RESOURCES    Could not allocate memory for NewMessage.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_UTILS_BUILD) (
+  IN  EFI_HTTP_UTILITIES_PROTOCOL  *This,
+  IN  UINTN                        SeedMessageSize,
+  IN  VOID                         *SeedMessage,   OPTIONAL
+  IN  UINTN                        DeleteCount,
+  IN  CHAR8                        *DeleteList[],  OPTIONAL
+  IN  UINTN                        AppendCount,
+  IN  EFI_HTTP_HEADER              *AppendList[],  OPTIONAL
+  OUT UINTN                        *NewMessageSize,
+  OUT VOID                         **NewMessage
+  );
+
+/**
+  Parses HTTP header and produces an array of key/value pairs.
+
+  The Parse() function is used to transform data stored in HttpHeader
+  into a list of fields paired with their corresponding values.
+
+  @param[in]  This                Pointer to EFI_HTTP_UTILITIES_PROTOCOL instance.
+  @param[in]  HttpMessage         Contains raw unformatted HTTP header string.
+  @param[in]  HttpMessageSize     Size of HTTP header.
+  @param[out] HeaderFields        Array of key/value header pairs.
+  @param[out] FieldCount          Number of headers in HeaderFields.
+
+  @retval EFI_SUCCESS             Allocation succeeded.
+  @retval EFI_NOT_STARTED         This EFI HTTP Protocol instance has not been
+                                  initialized.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  HttpMessage is NULL.
+                                  HeaderFields is NULL.
+                                  FieldCount is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HTTP_UTILS_PARSE) (
+  IN  EFI_HTTP_UTILITIES_PROTOCOL  *This,
+  IN  CHAR8                        *HttpMessage,
+  IN  UINTN                        HttpMessageSize,
+  OUT EFI_HTTP_HEADER              **HeaderFields,
+  OUT UINTN                        *FieldCount
+  );
+
+
+///
+/// EFI_HTTP_UTILITIES_PROTOCOL
+/// designed to be used by EFI drivers and applications to parse HTTP
+/// headers from a byte stream. This driver is neither dependent on
+/// network connectivity, nor the existence of an underlying network
+/// infrastructure.
+///
+struct _EFI_HTTP_UTILITIES_PROTOCOL {
+  EFI_HTTP_UTILS_BUILD          Build;
+  EFI_HTTP_UTILS_PARSE          Parse;
+};
+
+extern EFI_GUID gEfiHttpUtilitiesProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/I2cBusConfigurationManagement.h b/MdePkg/Include/Protocol/I2cBusConfigurationManagement.h
new file mode 100644
index 000000000000..b29333e0009e
--- /dev/null
+++ b/MdePkg/Include/Protocol/I2cBusConfigurationManagement.h
@@ -0,0 +1,171 @@
+/** @file
+  I2C Bus Configuration Management Protocol as defined in the PI 1.3 specification.
+
+  The EFI I2C bus configuration management protocol provides platform specific 
+  services that allow the I2C host protocol to reconfigure the switches and multiplexers 
+  and set the clock frequency for the I2C bus. This protocol also enables the I2C host protocol 
+  to reset an I2C device which may be locking up the I2C bus by holding the clock or data line low.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.3.
+
+**/
+
+#ifndef __I2C_BUS_CONFIGURATION_MANAGEMENT_H__
+#define __I2C_BUS_CONFIGURATION_MANAGEMENT_H__
+
+#define EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL_GUID \
+  { 0x55b71fb5, 0x17c6, 0x410e, { 0xb5, 0xbd, 0x5f, 0xa2, 0xe3, 0xd4, 0x46, 0x6b }}
+
+///
+/// I2C bus configuration management protocol
+///
+/// The EFI I2C bus configuration management protocol provides platform
+/// specific services that allow the I2C host protocol to reconfigure the
+/// switches and multiplexers and set the clock frequency for the I2C bus.
+/// This protocol also enables the I2C host protocol to reset an I2C device
+/// which may be locking up the I2C bus by holding the clock or data line
+/// low.
+///
+/// The I2C protocol stack uses the concept of an I2C bus configuration as
+/// a way to describe a particular state of the switches and multiplexers
+/// in the I2C bus.
+///
+/// A simple I2C bus does not have any multiplexers or switches is described
+/// to the I2C protocol stack with a single I2C bus configuration which
+/// specifies the I2C bus frequency.
+///
+/// An I2C bus with switches and multiplexers use an I2C bus configuration
+/// to describe each of the unique settings for the switches and multiplexers
+/// and the I2C bus frequency.  However the I2C bus configuration management
+/// protocol only needs to define the I2C bus configurations that the software
+/// uses, which may be a subset of the total.
+///
+/// The I2C bus configuration description includes a list of I2C devices
+/// which may be accessed when this I2C bus configuration is enabled.  I2C
+/// devices before a switch or multiplexer must be included in one I2C bus
+/// configuration while I2C devices after a switch or multiplexer are on
+/// another I2C bus configuration.
+///
+/// The I2C bus configuration management protocol is an optional protocol.
+/// When the I2C bus configuration protocol is not defined the I2C host
+/// protocol does not start and the I2C master protocol may be used for
+/// other purposes such as SMBus traffic.  When the I2C bus configuration
+/// protocol is available, the I2C host protocol uses the I2C bus
+/// configuration protocol to call into the platform specific code to set
+/// the switches and multiplexers and set the maximum I2C bus frequency.
+///
+/// The platform designers determine the maximum I2C bus frequency by
+/// selecting a frequency which supports all of the I2C devices on the
+/// I2C bus for the setting of switches and multiplexers.  The platform
+/// designers must validate this against the I2C device data sheets and
+/// any limits of the I2C controller or bus length.
+///
+/// During I2C device enumeration, the I2C bus driver retrieves the I2C
+/// bus configuration that must be used to perform I2C transactions to
+/// each I2C device.  This I2C bus configuration value is passed into
+/// the I2C host protocol to identify the I2C bus configuration required
+/// to access a specific I2C device.  The I2C host protocol calls
+/// EnableBusConfiguration() to set the switches and multiplexers in the
+/// I2C bus and the I2C clock frequency.  The I2C host protocol may
+/// optimize calls to EnableBusConfiguration() by only making the call
+/// when the I2C bus configuration value changes between I2C requests.
+///
+/// When I2C transactions are required on the same I2C bus to change the
+/// state of multiplexers or switches, the I2C master protocol must be
+/// used to perform the necessary I2C transactions.
+///
+/// It is up to the platform specific code to choose the proper I2C bus
+/// configuration when ExitBootServices() is called. Some operating systems
+/// are not able to manage the I2C bus configurations and must use the I2C
+/// bus configuration that is established by the platform firmware before
+/// ExitBootServices() returns.
+///
+typedef struct _EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL;
+
+
+/**
+  Enable access to an I2C bus configuration.
+
+  This routine must be called at or below TPL_NOTIFY.  For synchronous
+  requests this routine must be called at or below TPL_CALLBACK.
+
+  Reconfigure the switches and multiplexers in the I2C bus to enable
+  access to a specific I2C bus configuration.  Also select the maximum
+  clock frequency for this I2C bus configuration.
+
+  This routine uses the I2C Master protocol to perform I2C transactions
+  on the local bus.  This eliminates any recursion in the I2C stack for
+  configuration transactions on the same I2C bus.  This works because the
+  local I2C bus is idle while the I2C bus configuration is being enabled.
+
+  If I2C transactions must be performed on other I2C busses, then the
+  EFI_I2C_HOST_PROTOCOL, the EFI_I2C_IO_PROTCOL, or a third party I2C
+  driver interface for a specific device must be used.  This requirement
+  is because the I2C host protocol controls the flow of requests to the
+  I2C controller.  Use the EFI_I2C_HOST_PROTOCOL when the I2C device is
+  not enumerated by the EFI_I2C_ENUMERATE_PROTOCOL.  Use a protocol
+  produced by a third party driver when it is available or the
+  EFI_I2C_IO_PROTOCOL when the third party driver is not available but
+  the device is enumerated with the EFI_I2C_ENUMERATE_PROTOCOL.
+
+  When Event is NULL, EnableI2cBusConfiguration operates synchronously
+  and returns the I2C completion status as its return value.
+
+  @param[in]  This            Pointer to an EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL
+                              structure.
+  @param[in]  I2cBusConfiguration Index of an I2C bus configuration.  All
+                                  values in the range of zero to N-1 are
+                                  valid where N is the total number of I2C
+                                  bus configurations for an I2C bus.
+  @param[in]  Event           Event to signal when the transaction is complete
+  @param[out] I2cStatus       Buffer to receive the transaction status.
+
+  @return  When Event is NULL, EnableI2cBusConfiguration operates synchrouously
+  and returns the I2C completion status as its return value.  In this case it is
+  recommended to use NULL for I2cStatus.  The values returned from
+  EnableI2cBusConfiguration are:
+
+  @retval EFI_SUCCESS           The asynchronous bus configuration request
+                                was successfully started when Event is not
+                                NULL.
+  @retval EFI_SUCCESS           The bus configuration request completed
+                                successfully when Event is NULL.
+  @retval EFI_DEVICE_ERROR      The bus configuration failed.
+  @retval EFI_NO_MAPPING        Invalid I2cBusConfiguration value
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL_ENABLE_I2C_BUS_CONFIGURATION) (
+  IN CONST EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL *This,
+  IN UINTN                                               I2cBusConfiguration,
+  IN EFI_EVENT                                           Event      OPTIONAL,
+  IN EFI_STATUS                                          *I2cStatus OPTIONAL
+  );
+
+///
+/// I2C bus configuration management protocol
+///
+struct _EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL {
+  ///
+  /// Enable an I2C bus configuration for use.
+  ///
+  EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL_ENABLE_I2C_BUS_CONFIGURATION EnableI2cBusConfiguration;
+};
+
+///
+/// Reference to variable defined in the .DEC file
+///
+extern EFI_GUID gEfiI2cBusConfigurationManagementProtocolGuid;
+
+#endif  //  __I2C_BUS_CONFIGURATION_MANAGEMENT_H__
diff --git a/MdePkg/Include/Protocol/I2cEnumerate.h b/MdePkg/Include/Protocol/I2cEnumerate.h
new file mode 100644
index 000000000000..00f80d0b68e4
--- /dev/null
+++ b/MdePkg/Include/Protocol/I2cEnumerate.h
@@ -0,0 +1,110 @@
+/** @file
+  I2C Device Enumerate Protocol as defined in the PI 1.3 specification.
+
+  This protocol supports the enumerations of device on the I2C bus.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.3.
+
+**/
+
+#ifndef __I2C_ENUMERATE_H__
+#define __I2C_ENUMERATE_H__
+
+#include <Pi/PiI2c.h>
+
+#define EFI_I2C_ENUMERATE_PROTOCOL_GUID   { 0xda8cd7c4, 0x1c00, 0x49e2, { 0x80, 0x3e, 0x52, 0x14, 0xe7, 0x01, 0x89, 0x4c }}
+
+typedef struct _EFI_I2C_ENUMERATE_PROTOCOL  EFI_I2C_ENUMERATE_PROTOCOL;
+
+/**
+  Enumerate the I2C devices
+
+  This function enables the caller to traverse the set of I2C devices
+  on an I2C bus.
+
+  @param[in]  This              The platform data for the next device on
+                                the I2C bus was returned successfully.
+  @param[in, out] Device        Pointer to a buffer containing an
+                                EFI_I2C_DEVICE structure.  Enumeration is
+                                started by setting the initial EFI_I2C_DEVICE
+                                structure pointer to NULL.  The buffer
+                                receives an EFI_I2C_DEVICE structure pointer
+                                to the next I2C device.
+
+  @retval EFI_SUCCESS           The platform data for the next device on
+                                the I2C bus was returned successfully.
+  @retval EFI_INVALID_PARAMETER Device is NULL
+  @retval EFI_NO_MAPPING        *Device does not point to a valid
+                                EFI_I2C_DEVICE structure returned in a
+                                previous call Enumerate().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_ENUMERATE_PROTOCOL_ENUMERATE) (
+  IN CONST EFI_I2C_ENUMERATE_PROTOCOL *This,
+  IN OUT CONST EFI_I2C_DEVICE         **Device
+  );
+
+/**
+  Get the requested I2C bus frequency for a specified bus configuration.
+
+  This function returns the requested I2C bus clock frequency for the
+  I2cBusConfiguration.  This routine is provided for diagnostic purposes
+  and is meant to be called after calling Enumerate to get the
+  I2cBusConfiguration value.
+
+  @param[in] This                 Pointer to an EFI_I2C_ENUMERATE_PROTOCOL
+                                  structure.
+  @param[in] I2cBusConfiguration  I2C bus configuration to access the I2C
+                                  device
+  @param[out] *BusClockHertz      Pointer to a buffer to receive the I2C
+                                  bus clock frequency in Hertz
+
+  @retval EFI_SUCCESS           The I2C bus frequency was returned
+                                successfully.
+  @retval EFI_INVALID_PARAMETER BusClockHertz was NULL
+  @retval EFI_NO_MAPPING        Invalid I2cBusConfiguration value
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_ENUMERATE_PROTOCOL_GET_BUS_FREQUENCY) (
+  IN CONST EFI_I2C_ENUMERATE_PROTOCOL *This,
+  IN UINTN                            I2cBusConfiguration,
+  OUT UINTN                           *BusClockHertz
+  );
+
+///
+/// I2C Enumerate protocol
+///
+struct _EFI_I2C_ENUMERATE_PROTOCOL {
+  ///
+  /// Traverse the set of I2C devices on an I2C bus.  This routine
+  /// returns the next I2C device on an I2C bus.
+  ///
+  EFI_I2C_ENUMERATE_PROTOCOL_ENUMERATE         Enumerate;
+
+  ///
+  /// Get the requested I2C bus frequency for a specified bus
+  /// configuration.
+  ///
+  EFI_I2C_ENUMERATE_PROTOCOL_GET_BUS_FREQUENCY GetBusFrequency;
+};
+
+///
+/// Reference to variable defined in the .DEC file
+///
+extern EFI_GUID gEfiI2cEnumerateProtocolGuid;
+
+#endif  //  __I2C_ENUMERATE_H__
diff --git a/MdePkg/Include/Protocol/I2cHost.h b/MdePkg/Include/Protocol/I2cHost.h
new file mode 100644
index 000000000000..fcd82de6b96e
--- /dev/null
+++ b/MdePkg/Include/Protocol/I2cHost.h
@@ -0,0 +1,152 @@
+/** @file
+  I2C Host Protocol as defined in the PI 1.3 specification.
+
+  This protocol provides callers with the ability to do I/O transactions 
+  to all of the devices on the I2C bus.
+
+  Copyright (c) 2013 - 2015, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.3.
+
+**/
+
+#ifndef __I2C_HOST_H__
+#define __I2C_HOST_H__
+
+#include <Pi/PiI2c.h>
+
+#define EFI_I2C_HOST_PROTOCOL_GUID  { 0xa5aab9e3, 0xc727, 0x48cd, { 0x8b, 0xbf, 0x42, 0x72, 0x33, 0x85, 0x49, 0x48 }}
+
+///
+/// I2C Host Protocol
+///
+/// The I2C bus driver uses the services of the EFI_I2C_HOST_PROTOCOL
+/// to produce an instance of the EFI_I2C_IO_PROTOCOL for each I2C
+/// device on an I2C bus.
+///
+/// The EFI_I2C_HOST_PROTOCOL exposes an asynchronous interface to
+/// callers to perform transactions to any device on the I2C bus.
+/// Internally, the I2C host protocol manages the flow of the I2C
+/// transactions to the host controller, keeping them in FIFO order.
+/// Prior to each transaction, the I2C host protocol ensures that the
+/// switches and multiplexers are properly configured.  The I2C host
+/// protocol then starts the transaction on the host controller using
+/// the EFI_I2C_MASTER_PROTOCOL.
+///
+typedef struct _EFI_I2C_HOST_PROTOCOL EFI_I2C_HOST_PROTOCOL;
+
+
+/**
+  Queue an I2C transaction for execution on the I2C controller.
+
+  This routine must be called at or below TPL_NOTIFY.  For
+  synchronous requests this routine must be called at or below
+  TPL_CALLBACK.
+  
+  The I2C host protocol uses the concept of I2C bus configurations
+  to describe the I2C bus.  An I2C bus configuration is defined as
+  a unique setting of the multiplexers and switches in the I2C bus
+  which enable access to one or more I2C devices.  When using a
+  switch to divide a bus, due to bus frequency differences, the
+  I2C bus configuration management protocol defines an I2C bus
+  configuration for the I2C devices on each side of the switch.
+  When using a multiplexer, the I2C bus configuration management
+  defines an I2C bus configuration for each of the selector values
+  required to control the multiplexer.  See Figure 1 in the I2C -bus
+  specification and user manual for a complex I2C bus configuration.
+
+  The I2C host protocol processes all transactions in FIFO order.
+  Prior to performing the transaction, the I2C host protocol calls
+  EnableI2cBusConfiguration to reconfigure the switches and
+  multiplexers in the I2C bus enabling access to the specified I2C
+  device.  The EnableI2cBusConfiguration also selects the I2C bus
+  frequency for the I2C device.  After the I2C bus is configured,
+  the I2C host protocol calls the I2C master protocol to start the
+  I2C transaction.
+
+  When Event is NULL, QueueRequest() operates synchronously and
+  returns the I2C completion status as its return value.
+
+  When Event is not NULL, QueueRequest() synchronously returns
+  EFI_SUCCESS indicating that the asynchronously I2C transaction was
+  queued.  The values above are returned in the buffer pointed to by
+  I2cStatus upon the completion of the I2C transaction when I2cStatus
+  is not NULL.
+
+  @param[in] This             Pointer to an EFI_I2C_HOST_PROTOCOL structure.
+  @param[in] I2cBusConfiguration  I2C bus configuration to access the I2C
+                                  device
+  @param[in] SlaveAddress     Address of the device on the I2C bus.  Set
+                              the I2C_ADDRESSING_10_BIT when using 10-bit
+                              addresses, clear this bit for 7-bit addressing.
+                              Bits 0-6 are used for 7-bit I2C slave addresses
+                              and bits 0-9 are used for 10-bit I2C slave
+                              addresses.
+  @param[in] Event            Event to signal for asynchronous transactions,
+                              NULL for synchronous transactions
+  @param[in] RequestPacket    Pointer to an EFI_I2C_REQUEST_PACKET structure
+                              describing the I2C transaction
+  @param[out] I2cStatus       Optional buffer to receive the I2C transaction
+                              completion status
+
+  @retval EFI_SUCCESS           The asynchronous transaction was successfully
+                                queued when Event is not NULL.
+  @retval EFI_SUCCESS           The transaction completed successfully when
+                                Event is NULL.
+  @retval EFI_BAD_BUFFER_SIZE   The RequestPacket->LengthInBytes value is
+                                too large.
+  @retval EFI_DEVICE_ERROR      There was an I2C error (NACK) during the
+                                transaction.
+  @retval EFI_INVALID_PARAMETER RequestPacket is NULL
+  @retval EFI_NOT_FOUND         Reserved bit set in the SlaveAddress parameter
+  @retval EFI_NO_MAPPING        Invalid I2cBusConfiguration value
+  @retval EFI_NO_RESPONSE       The I2C device is not responding to the slave
+                                address.  EFI_DEVICE_ERROR will be returned
+                                if the controller cannot distinguish when the
+                                NACK occurred.
+  @retval EFI_OUT_OF_RESOURCES  Insufficient memory for I2C transaction
+  @retval EFI_UNSUPPORTED       The controller does not support the requested
+                                transaction.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_HOST_PROTOCOL_QUEUE_REQUEST) (
+  IN CONST EFI_I2C_HOST_PROTOCOL *This,
+  IN UINTN                       I2cBusConfiguration,
+  IN UINTN                       SlaveAddress,
+  IN EFI_EVENT                   Event      OPTIONAL,
+  IN EFI_I2C_REQUEST_PACKET      *RequestPacket,
+  OUT EFI_STATUS                 *I2cStatus OPTIONAL
+  );
+
+///
+/// I2C Host Protocol
+///
+struct _EFI_I2C_HOST_PROTOCOL {
+  ///
+  /// Queue an I2C transaction for execution on the I2C bus
+  ///
+  EFI_I2C_HOST_PROTOCOL_QUEUE_REQUEST     QueueRequest;
+
+  ///
+  /// Pointer to an EFI_I2C_CONTROLLER_CAPABILITIES data structure
+  /// containing the capabilities of the I2C host controller.
+  ///
+  CONST EFI_I2C_CONTROLLER_CAPABILITIES   *I2cControllerCapabilities;
+};
+
+///
+/// Reference to variable defined in the .DEC file
+///
+extern EFI_GUID gEfiI2cHostProtocolGuid;
+
+#endif  //  __I2C_HOST_H__
diff --git a/MdePkg/Include/Protocol/I2cIo.h b/MdePkg/Include/Protocol/I2cIo.h
new file mode 100644
index 000000000000..4e4267d83855
--- /dev/null
+++ b/MdePkg/Include/Protocol/I2cIo.h
@@ -0,0 +1,172 @@
+/** @file
+  I2C I/O Protocol as defined in the PI 1.3 specification.
+
+  The EFI I2C I/O protocol enables the user to manipulate a single 
+  I2C device independent of the host controller and I2C design.
+
+  Copyright (c) 2013 - 2015, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.3.
+
+**/
+
+#ifndef __I2C_IO_H__
+#define __I2C_IO_H__
+
+#include <Pi/PiI2c.h>
+
+#define EFI_I2C_IO_PROTOCOL_GUID { 0xb60a3e6b, 0x18c4, 0x46e5, { 0xa2, 0x9a, 0xc9, 0xa1, 0x06, 0x65, 0xa2, 0x8e }}
+
+///
+/// I2C I/O protocol
+///
+/// The I2C IO protocol enables access to a specific device on the I2C
+/// bus.
+///
+/// Each I2C device is identified uniquely in the system by the tuple
+/// DeviceGuid:DeviceIndex.  The DeviceGuid represents the manufacture
+/// and part number and is provided by the silicon vendor or the third
+/// party I2C device driver writer.  The DeviceIndex identifies the part
+/// within the system by using a unique number and is created by the
+/// board designer or the writer of the EFI_I2C_ENUMERATE_PROTOCOL.
+///
+/// I2C slave addressing is abstracted to validate addresses and limit
+/// operation to the specified I2C device.  The third party providing
+/// the I2C device support provides an ordered list of slave addresses
+/// for the I2C device required to implement the EFI_I2C_ENUMERATE_PROTOCOL.
+/// The order of the list must be preserved.
+///
+typedef struct _EFI_I2C_IO_PROTOCOL  EFI_I2C_IO_PROTOCOL;
+
+
+/**
+  Queue an I2C transaction for execution on the I2C device.
+
+  This routine must be called at or below TPL_NOTIFY.  For synchronous
+  requests this routine must be called at or below TPL_CALLBACK.
+
+  This routine queues an I2C transaction to the I2C controller for
+  execution on the I2C bus.
+
+  When Event is NULL, QueueRequest() operates synchronously and returns
+  the I2C completion status as its return value.
+
+  When Event is not NULL, QueueRequest() synchronously returns EFI_SUCCESS
+  indicating that the asynchronous I2C transaction was queued.  The values
+  above are returned in the buffer pointed to by I2cStatus upon the
+  completion of the I2C transaction when I2cStatus is not NULL.
+
+  The upper layer driver writer provides the following to the platform
+  vendor:
+  
+  1.  Vendor specific GUID for the I2C part
+  2.  Guidance on proper construction of the slave address array when the
+      I2C device uses more than one slave address.  The I2C bus protocol
+      uses the SlaveAddressIndex to perform relative to physical address
+      translation to access the blocks of hardware within the I2C device.
+
+  @param[in] This               Pointer to an EFI_I2C_IO_PROTOCOL structure.
+  @param[in] SlaveAddressIndex  Index value into an array of slave addresses
+                                for the I2C device.  The values in the array
+                                are specified by the board designer, with the
+                                third party I2C device driver writer providing
+                                the slave address order.
+
+                                For devices that have a single slave address,
+                                this value must be zero.  If the I2C device
+                                uses more than one slave address then the
+                                third party (upper level) I2C driver writer
+                                needs to specify the order of entries in the
+                                slave address array.
+
+                                \ref ThirdPartyI2cDrivers "Third Party I2C
+                                Drivers" section in I2cMaster.h.
+  @param[in] Event              Event to signal for asynchronous transactions,
+                                NULL for synchronous transactions
+  @param[in] RequestPacket      Pointer to an EFI_I2C_REQUEST_PACKET structure
+                                describing the I2C transaction
+  @param[out] I2cStatus         Optional buffer to receive the I2C transaction
+                                completion status
+
+  @retval EFI_SUCCESS           The asynchronous transaction was successfully
+                                queued when Event is not NULL.
+  @retval EFI_SUCCESS           The transaction completed successfully when
+                                Event is NULL.
+  @retval EFI_BAD_BUFFER_SIZE   The RequestPacket->LengthInBytes value is too
+                                large.
+  @retval EFI_DEVICE_ERROR      There was an I2C error (NACK) during the
+                                transaction.
+  @retval EFI_INVALID_PARAMETER RequestPacket is NULL.
+  @retval EFI_NO_MAPPING        The EFI_I2C_HOST_PROTOCOL could not set the
+                                bus configuration required to access this I2C
+                                device.
+  @retval EFI_NO_RESPONSE       The I2C device is not responding to the slave
+                                address selected by SlaveAddressIndex.
+                                EFI_DEVICE_ERROR will be returned if the
+                                controller cannot distinguish when the NACK
+                                occurred.
+  @retval EFI_OUT_OF_RESOURCES  Insufficient memory for I2C transaction
+  @retval EFI_UNSUPPORTED       The controller does not support the requested
+                                transaction.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_IO_PROTOCOL_QUEUE_REQUEST) (
+  IN CONST EFI_I2C_IO_PROTOCOL  *This,
+  IN UINTN                      SlaveAddressIndex,
+  IN EFI_EVENT                  Event      OPTIONAL,
+  IN EFI_I2C_REQUEST_PACKET     *RequestPacket,
+  OUT EFI_STATUS                *I2cStatus OPTIONAL
+  );
+
+///
+/// I2C I/O protocol
+///
+struct _EFI_I2C_IO_PROTOCOL {
+  ///
+  /// Queue an I2C transaction for execution on the I2C device.
+  ///
+  EFI_I2C_IO_PROTOCOL_QUEUE_REQUEST         QueueRequest;
+
+  ///
+  /// Unique value assigned by the silicon manufacture or the third
+  /// party I2C driver writer for the I2C part.  This value logically
+  /// combines both the manufacture name and the I2C part number into
+  /// a single value specified as a GUID.
+  ///
+  CONST EFI_GUID                            *DeviceGuid;
+
+  ///
+  /// Unique ID of the I2C part within the system
+  ///
+  UINT32                                    DeviceIndex;
+
+  ///
+  /// Hardware revision - ACPI _HRV value.  See the Advanced Configuration
+  /// and Power Interface Specification, Revision 5.0  for the field format
+  /// and the Plug and play support for I2C web-page for restriction on values.
+  ///
+  UINT32                                    HardwareRevision;
+
+  ///
+  /// Pointer to an EFI_I2C_CONTROLLER_CAPABILITIES data structure containing
+  /// the capabilities of the I2C host controller.
+  ///
+  CONST EFI_I2C_CONTROLLER_CAPABILITIES     *I2cControllerCapabilities;
+};
+
+///
+/// Reference to variable defined in the .DEC file
+///
+extern EFI_GUID gEfiI2cIoProtocolGuid;
+
+#endif  //  __I2C_IO_H__
diff --git a/MdePkg/Include/Protocol/I2cMaster.h b/MdePkg/Include/Protocol/I2cMaster.h
new file mode 100644
index 000000000000..26f689788c36
--- /dev/null
+++ b/MdePkg/Include/Protocol/I2cMaster.h
@@ -0,0 +1,192 @@
+/** @file
+  I2C Master Protocol as defined in the PI 1.3 specification.
+
+  This protocol manipulates the I2C host controller to perform transactions as a master 
+  on the I2C bus using the current state of any switches or multiplexers in the I2C bus.
+
+  Copyright (c) 2013, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.3.
+
+**/
+
+#ifndef __I2C_MASTER_H__
+#define __I2C_MASTER_H__
+
+#include <Pi/PiI2c.h>
+
+#define EFI_I2C_MASTER_PROTOCOL_GUID { 0xcd72881f, 0x45b5, 0x4feb, { 0x98, 0xc8, 0x31, 0x3d, 0xa8, 0x11, 0x74, 0x62 }}
+
+typedef struct _EFI_I2C_MASTER_PROTOCOL EFI_I2C_MASTER_PROTOCOL;
+
+/**
+  Set the frequency for the I2C clock line.
+
+  This routine must be called at or below TPL_NOTIFY.
+
+  The software and controller do a best case effort of using the specified
+  frequency for the I2C bus.  If the frequency does not match exactly then
+  the I2C master protocol selects the next lower frequency to avoid
+  exceeding the operating conditions for any of the I2C devices on the bus.
+  For example if 400 KHz was specified and the controller's divide network
+  only supports 402 KHz or 398 KHz then the I2C master protocol selects 398
+  KHz.  If there are not lower frequencies available, then return
+  EFI_UNSUPPORTED.
+
+  @param[in] This           Pointer to an EFI_I2C_MASTER_PROTOCOL structure
+  @param[in] BusClockHertz  Pointer to the requested I2C bus clock frequency
+                            in Hertz.  Upon return this value contains the
+                            actual frequency in use by the I2C controller.
+
+  @retval EFI_SUCCESS           The bus frequency was set successfully.
+  @retval EFI_ALREADY_STARTED   The controller is busy with another transaction.
+  @retval EFI_INVALID_PARAMETER BusClockHertz is NULL
+  @retval EFI_UNSUPPORTED       The controller does not support this frequency.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_MASTER_PROTOCOL_SET_BUS_FREQUENCY) (
+  IN CONST EFI_I2C_MASTER_PROTOCOL   *This,
+  IN OUT UINTN                       *BusClockHertz
+  );
+
+/**
+  Reset the I2C controller and configure it for use
+
+  This routine must be called at or below TPL_NOTIFY.
+
+  The I2C controller is reset.  The caller must call SetBusFrequench() after
+  calling Reset().
+
+  @param[in]     This       Pointer to an EFI_I2C_MASTER_PROTOCOL structure.
+
+  @retval EFI_SUCCESS         The reset completed successfully.
+  @retval EFI_ALREADY_STARTED The controller is busy with another transaction.
+  @retval EFI_DEVICE_ERROR    The reset operation failed.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_MASTER_PROTOCOL_RESET) (
+  IN CONST EFI_I2C_MASTER_PROTOCOL *This
+  );
+
+/**
+  Start an I2C transaction on the host controller.
+
+  This routine must be called at or below TPL_NOTIFY.  For synchronous
+  requests this routine must be called at or below TPL_CALLBACK.
+
+  This function initiates an I2C transaction on the controller.  To
+  enable proper error handling by the I2C protocol stack, the I2C
+  master protocol does not support queuing but instead only manages
+  one I2C transaction at a time.  This API requires that the I2C bus
+  is in the correct configuration for the I2C transaction.
+
+  The transaction is performed by sending a start-bit and selecting the
+  I2C device with the specified I2C slave address and then performing
+  the specified I2C operations.  When multiple operations are requested
+  they are separated with a repeated start bit and the slave address.
+  The transaction is terminated with a stop bit.
+
+  When Event is NULL, StartRequest operates synchronously and returns
+  the I2C completion status as its return value.
+
+  When Event is not NULL, StartRequest synchronously returns EFI_SUCCESS
+  indicating that the I2C transaction was started asynchronously.  The
+  transaction status value is returned in the buffer pointed to by
+  I2cStatus upon the completion of the I2C transaction when I2cStatus
+  is not NULL.  After the transaction status is returned the Event is
+  signaled.
+
+  Note: The typical consumer of this API is the I2C host protocol.
+  Extreme care must be taken by other consumers of this API to prevent
+  confusing the third party I2C drivers due to a state change at the
+  I2C device which the third party I2C drivers did not initiate.  I2C
+  platform specific code may use this API within these guidelines.
+
+  @param[in] This           Pointer to an EFI_I2C_MASTER_PROTOCOL structure.
+  @param[in] SlaveAddress   Address of the device on the I2C bus.  Set the
+                            I2C_ADDRESSING_10_BIT when using 10-bit addresses,
+                            clear this bit for 7-bit addressing.  Bits 0-6
+                            are used for 7-bit I2C slave addresses and bits
+                            0-9 are used for 10-bit I2C slave addresses.
+  @param[in] RequestPacket  Pointer to an EFI_I2C_REQUEST_PACKET
+                            structure describing the I2C transaction.
+  @param[in] Event          Event to signal for asynchronous transactions,
+                            NULL for asynchronous transactions
+  @param[out] I2cStatus     Optional buffer to receive the I2C transaction
+                            completion status
+
+  @retval EFI_SUCCESS           The asynchronous transaction was successfully
+                                started when Event is not NULL.
+  @retval EFI_SUCCESS           The transaction completed successfully when
+                                Event is NULL.
+  @retval EFI_ALREADY_STARTED   The controller is busy with another transaction.
+  @retval EFI_BAD_BUFFER_SIZE   The RequestPacket->LengthInBytes value is too
+                                large.
+  @retval EFI_DEVICE_ERROR      There was an I2C error (NACK) during the
+                                transaction.
+  @retval EFI_INVALID_PARAMETER RequestPacket is NULL
+  @retval EFI_NOT_FOUND         Reserved bit set in the SlaveAddress parameter
+  @retval EFI_NO_RESPONSE       The I2C device is not responding to the slave
+                                address.  EFI_DEVICE_ERROR will be returned if
+                                the controller cannot distinguish when the NACK
+                                occurred.
+  @retval EFI_OUT_OF_RESOURCES  Insufficient memory for I2C transaction
+  @retval EFI_UNSUPPORTED       The controller does not support the requested
+                                transaction.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_I2C_MASTER_PROTOCOL_START_REQUEST) (
+  IN CONST EFI_I2C_MASTER_PROTOCOL *This,
+  IN UINTN                         SlaveAddress,
+  IN EFI_I2C_REQUEST_PACKET        *RequestPacket,
+  IN EFI_EVENT                     Event      OPTIONAL,
+  OUT EFI_STATUS                   *I2cStatus OPTIONAL
+  );
+
+///
+/// I2C master mode protocol
+///
+/// This protocol manipulates the I2C host controller to perform transactions as a
+/// master on the I2C bus using the current state of any switches or multiplexers
+/// in the I2C bus.
+///
+struct _EFI_I2C_MASTER_PROTOCOL {
+  ///
+  /// Set the clock frequency for the I2C bus.
+  ///
+  EFI_I2C_MASTER_PROTOCOL_SET_BUS_FREQUENCY SetBusFrequency;
+
+  ///
+  /// Reset the I2C host controller.
+  ///
+  EFI_I2C_MASTER_PROTOCOL_RESET             Reset;
+
+  ///
+  /// Start an I2C transaction in master mode on the host controller.
+  ///
+  EFI_I2C_MASTER_PROTOCOL_START_REQUEST     StartRequest;
+
+  ///
+  /// Pointer to an EFI_I2C_CONTROLLER_CAPABILITIES data structure containing
+  /// the capabilities of the I2C host controller.
+  ///
+  CONST EFI_I2C_CONTROLLER_CAPABILITIES     *I2cControllerCapabilities;
+};
+
+extern EFI_GUID gEfiI2cMasterProtocolGuid;
+
+#endif  //  __I2C_MASTER_H__
diff --git a/MdePkg/Include/Protocol/IScsiInitiatorName.h b/MdePkg/Include/Protocol/IScsiInitiatorName.h
new file mode 100644
index 000000000000..5dffaeedf96c
--- /dev/null
+++ b/MdePkg/Include/Protocol/IScsiInitiatorName.h
@@ -0,0 +1,87 @@
+/** @file
+  EFI_ISCSI_INITIATOR_NAME_PROTOCOL as defined in UEFI 2.0.
+  It provides the ability to get and set the iSCSI Initiator Name.                                                  
+
+  Copyright (c) 2006 - 2011, 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 __ISCSI_INITIATOR_NAME_H__
+#define __ISCSI_INITIATOR_NAME_H__
+
+#define EFI_ISCSI_INITIATOR_NAME_PROTOCOL_GUID \
+{ \
+  0x59324945, 0xec44, 0x4c0d, {0xb1, 0xcd, 0x9d, 0xb1, 0x39, 0xdf, 0x7, 0xc } \
+}
+
+typedef struct _EFI_ISCSI_INITIATOR_NAME_PROTOCOL EFI_ISCSI_INITIATOR_NAME_PROTOCOL;
+
+/**
+  Retrieves the current set value of iSCSI Initiator Name.
+
+  @param  This       Pointer to the EFI_ISCSI_INITIATOR_NAME_PROTOCOL instance.
+  @param  BufferSize Size of the buffer in bytes pointed to by Buffer / Actual size of the
+                     variable data buffer.
+  @param  Buffer     Pointer to the buffer for data to be read. The data is a null-terminated UTF-8 encoded string.
+                     The maximum length is 223 characters, including the null-terminator.
+
+  @retval EFI_SUCCESS           Data was successfully retrieved into the provided buffer and the
+                                BufferSize was sufficient to handle the iSCSI initiator name
+  @retval EFI_BUFFER_TOO_SMALL  BufferSize is too small for the result.
+  @retval EFI_INVALID_PARAMETER BufferSize or Buffer is NULL.
+  @retval EFI_DEVICE_ERROR      The iSCSI initiator name could not be retrieved due to a hardware error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_ISCSI_INITIATOR_NAME_GET)(
+  IN EFI_ISCSI_INITIATOR_NAME_PROTOCOL *This,
+  IN OUT UINTN                         *BufferSize,
+  OUT VOID                             *Buffer
+  );
+
+  
+
+/**
+  Sets the iSCSI Initiator Name.
+
+  @param  This       Pointer to the EFI_ISCSI_INITIATOR_NAME_PROTOCOL instance.
+  @param  BufferSize Size of the buffer in bytes pointed to by Buffer.
+  @param  Buffer     Pointer to the buffer for data to be written. The data is a null-terminated UTF-8 encoded string.
+                     The maximum length is 223 characters, including the null-terminator.
+
+  @retval EFI_SUCCESS           Data was successfully stored by the protocol.
+  @retval EFI_UNSUPPORTED       Platform policies do not allow for data to be written.
+  @retval EFI_INVALID_PARAMETER BufferSize or Buffer is NULL, or BufferSize exceeds the maximum allowed limit.
+  @retval EFI_DEVICE_ERROR      The data could not be stored due to a hardware error.
+  @retval EFI_OUT_OF_RESOURCES  Not enough storage is available to hold the data.
+  @retval EFI_PROTOCOL_ERROR    Input iSCSI initiator name does not adhere to RFC 3720
+                                (and other related protocols)
+
+**/
+typedef EFI_STATUS
+(EFIAPI *EFI_ISCSI_INITIATOR_NAME_SET)(
+  IN EFI_ISCSI_INITIATOR_NAME_PROTOCOL *This,
+  IN OUT UINTN                         *BufferSize,
+  IN VOID                              *Buffer
+  );  
+
+///
+/// iSCSI Initiator Name Protocol for setting and obtaining the iSCSI Initiator Name. 
+///
+struct _EFI_ISCSI_INITIATOR_NAME_PROTOCOL {
+  EFI_ISCSI_INITIATOR_NAME_GET         Get;
+  EFI_ISCSI_INITIATOR_NAME_SET         Set;
+};
+
+extern EFI_GUID gEfiIScsiInitiatorNameProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/IdeControllerInit.h b/MdePkg/Include/Protocol/IdeControllerInit.h
new file mode 100644
index 000000000000..c099af308435
--- /dev/null
+++ b/MdePkg/Include/Protocol/IdeControllerInit.h
@@ -0,0 +1,565 @@
+/** @file
+  This file declares EFI IDE Controller Init Protocol
+  
+  The EFI_IDE_CONTROLLER_INIT_PROTOCOL provides the chipset-specific information
+  to the driver entity. This protocol is mandatory for IDE controllers if the
+  IDE devices behind the controller are to be enumerated by a driver entity.
+  
+  There can only be one instance of EFI_IDE_CONTROLLER_INIT_PROTOCOL for each IDE
+  controller in a system. It is installed on the handle that corresponds to the
+  IDE controller. A driver entity that wishes to manage an IDE bus and possibly
+  IDE devices in a system will have to retrieve the EFI_IDE_CONTROLLER_INIT_PROTOCOL
+  instance that is associated with the controller to be managed.
+  
+  A device handle for an IDE controller must contain an EFI_DEVICE_PATH_PROTOCOL.
+
+Copyright (c) 2007 - 2011, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards.
+  
+**/
+
+#ifndef _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
+#define _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
+
+#include <IndustryStandard/Atapi.h>
+
+///
+/// Global ID for the EFI_IDE_CONTROLLER_INIT_PROTOCOL.
+///
+#define EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID \
+  { \
+    0xa1e37052, 0x80d9, 0x4e65, {0xa3, 0x17, 0x3e, 0x9a, 0x55, 0xc4, 0x3e, 0xc9 } \
+  }
+
+///
+/// Forward declaration for EFI_IDE_CONTROLLER_INIT_PROTOCOL.
+///
+typedef struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL  EFI_IDE_CONTROLLER_INIT_PROTOCOL;
+
+///
+/// The phase of the IDE Controller enumeration.
+///
+typedef enum {
+  ///
+  /// The driver entity is about to begin enumerating the devices
+  /// behind the specified channel. This notification can be used to
+  /// perform any chipset-specific programming.
+  ///
+  EfiIdeBeforeChannelEnumeration,
+  ///
+  /// The driver entity has completed enumerating the devices
+  /// behind the specified channel. This notification can be used to
+  /// perform any chipset-specific programming.
+  ///
+  EfiIdeAfterChannelEnumeration,
+  ///
+  /// The driver entity is about to reset the devices behind the
+  /// specified channel. This notification can be used to perform any
+  /// chipset-specific programming.
+  ///
+  EfiIdeBeforeChannelReset,
+  ///
+  /// The driver entity has completed resetting the devices behind
+  /// the specified channel. This notification can be used to perform
+  /// any chipset-specific programming.  
+  ///
+  EfiIdeAfterChannelReset,
+  ///
+  /// The driver entity is about to detect the presence of devices
+  /// behind the specified channel. This notification can be used to
+  /// set up the bus signals to default levels or for implementing
+  /// predelays.
+  ///
+  EfiIdeBusBeforeDevicePresenceDetection,
+  ///
+  /// The driver entity is done with detecting the presence of
+  /// devices behind the specified channel. This notification can be
+  /// used to perform any chipset-specific programming.  
+  ///
+  EfiIdeBusAfterDevicePresenceDetection,
+  ///
+  /// The IDE bus is requesting the IDE controller driver to
+  /// reprogram the IDE controller hardware and thereby reset all
+  /// the mode and timing settings to default settings.  
+  ///
+  EfiIdeResetMode,
+  EfiIdeBusPhaseMaximum
+} EFI_IDE_CONTROLLER_ENUM_PHASE;
+
+///
+/// This extended mode describes the SATA physical protocol.
+/// SATA physical layers can operate at different speeds.
+/// These speeds are defined below. Various PATA protocols
+/// and associated modes are not applicable to SATA devices.
+///
+typedef enum {
+  EfiAtaSataTransferProtocol
+} EFI_ATA_EXT_TRANSFER_PROTOCOL;
+
+///
+/// Automatically detects the optimum SATA speed.
+///
+#define  EFI_SATA_AUTO_SPEED  0
+
+///
+/// Indicates a first-generation (Gen1) SATA speed.
+///
+#define  EFI_SATA_GEN1_SPEED  1
+
+///
+/// Indicates a second-generation (Gen2) SATA speed.
+///
+#define  EFI_SATA_GEN2_SPEED  2
+
+///
+/// EFI_ATA_MODE structure.
+///
+typedef struct {
+  BOOLEAN      Valid;   ///< TRUE if Mode is valid.
+  UINT32       Mode;    ///< The actual ATA mode. This field is not a bit map.
+} EFI_ATA_MODE;
+
+///
+/// EFI_ATA_EXTENDED_MODE structure
+///
+typedef struct {
+  ///
+  /// An enumeration defining various transfer protocols other than the protocols
+  /// that exist at the time this specification was developed (i.e., PIO, single 
+  /// word DMA, multiword DMA, and UDMA). Each transfer protocol is associated 
+  /// with a mode. The various transfer protocols are defined by the ATA/ATAPI 
+  /// specification. This enumeration makes the interface extensible because we 
+  /// can support new transport protocols beyond UDMA. Type EFI_ATA_EXT_TRANSFER_PROTOCOL 
+  /// is defined below.
+  ///
+  EFI_ATA_EXT_TRANSFER_PROTOCOL  TransferProtocol;
+  ///
+  /// The mode for operating the transfer protocol that is identified by TransferProtocol.
+  ///
+  UINT32                         Mode;
+} EFI_ATA_EXTENDED_MODE;
+
+///
+/// EFI_ATA_COLLECTIVE_MODE structure.
+///
+typedef struct {
+  ///
+  /// This field specifies the PIO mode. PIO modes are defined in the ATA/ATAPI
+  /// specification. The ATA/ATAPI specification defines the enumeration.  In 
+  /// other words, a value of 1 in this field means PIO mode 1. The actual meaning
+  /// of PIO mode 1 is governed by the ATA/ATAPI specification. Type EFI_ATA_MODE
+  /// is defined below.
+  ///
+  EFI_ATA_MODE           PioMode;
+  ///
+  /// This field specifies the single word DMA mode. Single word DMA modes are defined
+  /// in the ATA/ATAPI specification, versions 1 and 2. Single word DMA support was
+  /// obsoleted in the ATA/ATAPI specification, version 3. Therefore, most devices and
+  /// controllers will not support this transfer mode. The ATA/ATAPI specification defines
+  /// the enumeration. In other words, a value of 1 in this field means single word DMA
+  /// mode 1. The actual meaning of single word DMA mode 1 is governed by the ATA/
+  /// ATAPI specification.  
+  ///
+  EFI_ATA_MODE           SingleWordDmaMode;
+  ///
+  /// This field specifies the multiword DMA mode. Various multiword DMA modes are
+  /// defined in the ATA/ATAPI specification. A value of 1 in this field means multiword
+  /// DMA mode 1. The actual meaning of multiword DMA mode 1 is governed by the
+  /// ATA/ATAPI specification.  
+  ///
+  EFI_ATA_MODE           MultiWordDmaMode;
+  ///
+  /// This field specifies the ultra DMA (UDMA) mode. UDMA modes are defined in the
+  /// ATA/ATAPI specification. A value of 1 in this field means UDMA mode 1. The
+  /// actual meaning of UDMA mode 1 is governed by the ATA/ATAPI specification.  
+  ///
+  EFI_ATA_MODE           UdmaMode;
+  ///
+  /// The number of extended-mode bitmap entries. Extended modes describe transfer
+  /// protocols beyond PIO, single word DMA, multiword DMA, and UDMA. This field
+  /// can be zero and provides extensibility.  
+  ///
+  UINT32                 ExtModeCount;
+  ///
+  /// ExtModeCount number of entries. Each entry represents a transfer protocol other
+  /// than the ones defined above (i.e., PIO, single word DMA, multiword DMA, and
+  /// UDMA). This field is defined for extensibility. At this time, only one extended
+  /// transfer protocol is defined to cover SATA transfers. Type
+  /// EFI_ATA_EXTENDED_MODE is defined below.  
+  ///
+  EFI_ATA_EXTENDED_MODE  ExtMode[1];
+} EFI_ATA_COLLECTIVE_MODE;
+
+///
+/// EFI_ATA_IDENTIFY_DATA & EFI_ATAPI_IDENTIFY_DATA structure
+///
+/// The definition of these two structures is not part of the protocol
+/// definition because the ATA/ATAPI Specification controls the definition
+/// of all the fields. The ATA/ATAPI Specification can obsolete old fields
+/// or redefine existing fields. 
+typedef ATA_IDENTIFY_DATA   EFI_ATA_IDENTIFY_DATA;
+typedef ATAPI_IDENTIFY_DATA EFI_ATAPI_IDENTIFY_DATA;
+
+///
+/// This flag indicates whether the IDENTIFY data is a response from an ATA device
+/// (EFI_ATA_IDENTIFY_DATA) or response from an ATAPI device 
+/// (EFI_ATAPI_IDENTIFY_DATA).  According to the ATA/ATAPI specification,
+/// EFI_IDENTIFY_DATA is for an ATA device if bit 15 of the Config field is zero. 
+/// The Config field is common to both EFI_ATA_IDENTIFY_DATA and 
+/// EFI_ATAPI_IDENTIFY_DATA.
+///
+#define   EFI_ATAPI_DEVICE_IDENTIFY_DATA  0x8000
+
+///
+/// EFI_IDENTIFY_DATA structure.
+///
+typedef union {
+  ///
+  /// The data that is returned by an ATA device upon successful completion 
+  /// of the ATA IDENTIFY_DEVICE command. 
+  ///
+  EFI_ATA_IDENTIFY_DATA       AtaData;
+  ///
+  /// The data that is returned by an ATAPI device upon successful completion
+  /// of the ATA IDENTIFY_PACKET_DEVICE command.
+  ///
+  EFI_ATAPI_IDENTIFY_DATA     AtapiData;
+} EFI_IDENTIFY_DATA;
+
+/**
+  Returns the information about the specified IDE channel.
+  
+  This function can be used to obtain information about a particular IDE channel.
+  The driver entity uses this information during the enumeration process. 
+  
+  If Enabled is set to FALSE, the driver entity will not scan the channel. Note 
+  that it will not prevent an operating system driver from scanning the channel.
+  
+  For most of today's controllers, MaxDevices will either be 1 or 2. For SATA 
+  controllers, this value will always be 1. SATA configurations can contain SATA 
+  port multipliers. SATA port multipliers behave like SATA bridges and can support
+  up to 16 devices on the other side. If a SATA port out of the IDE controller 
+  is connected to a port multiplier, MaxDevices will be set to the number of SATA 
+  devices that the port multiplier supports. Because today's port multipliers 
+  support up to fifteen SATA devices, this number can be as large as fifteen. The IDE  
+  bus driver is required to scan for the presence of port multipliers behind an SATA 
+  controller and enumerate up to MaxDevices number of devices behind the port 
+  multiplier.    
+  
+  In this context, the devices behind a port multiplier constitute a channel.  
+  
+  @param[in]  This         The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in]  Channel      Zero-based channel number.
+  @param[out] Enabled      TRUE if this channel is enabled.  Disabled channels 
+                           are not scanned to see if any devices are present.
+  @param[out] MaxDevices   The maximum number of IDE devices that the bus driver
+                           can expect on this channel.  For the ATA/ATAPI 
+                           specification, version 6, this number will either be 
+                           one or two. For Serial ATA (SATA) configurations with a 
+                           port multiplier, this number can be as large as fifteen.
+
+  @retval EFI_SUCCESS             Information was returned without any errors.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_GET_CHANNEL_INFO)(
+  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN  UINT8                             Channel,
+  OUT BOOLEAN                           *Enabled,
+  OUT UINT8                             *MaxDevices
+  );
+
+/**
+  The notifications from the driver entity that it is about to enter a certain
+  phase of the IDE channel enumeration process.
+  
+  This function can be used to notify the IDE controller driver to perform 
+  specific actions, including any chipset-specific initialization, so that the 
+  chipset is ready to enter the next phase. Seven notification points are defined 
+  at this time. 
+  
+  More synchronization points may be added as required in the future.  
+
+  @param[in] This      The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in] Phase     The phase during enumeration.
+  @param[in] Channel   Zero-based channel number.
+
+  @retval EFI_SUCCESS             The notification was accepted without any errors.
+  @retval EFI_UNSUPPORTED         Phase is not supported.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+  @retval EFI_NOT_READY           This phase cannot be entered at this time; for 
+                                  example, an attempt was made to enter a Phase 
+                                  without having entered one or more previous 
+                                  Phase.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_NOTIFY_PHASE)(
+  IN EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN EFI_IDE_CONTROLLER_ENUM_PHASE     Phase,
+  IN UINT8                             Channel
+  );
+
+/**
+  Submits the device information to the IDE controller driver.
+
+  This function is used by the driver entity to pass detailed information about 
+  a particular device to the IDE controller driver. The driver entity obtains 
+  this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
+  is the pointer to the response data buffer. The IdentifyData buffer is owned 
+  by the driver entity, and the IDE controller driver must make a local copy 
+  of the entire buffer or parts of the buffer as needed. The original IdentifyData 
+  buffer pointer may not be valid when
+  
+    - EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
+    - EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
+    
+  The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to 
+  compute the optimum mode for the device. These fields are not limited to the 
+  timing information. For example, an implementation of the IDE controller driver 
+  may examine the vendor and type/mode field to match known bad drives.  
+  
+  The driver entity may submit drive information in any order, as long as it 
+  submits information for all the devices belonging to the enumeration group 
+  before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
+  in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+  should be called with IdentifyData set to NULL.  The IDE controller driver may 
+  not have any other mechanism to know whether a device is present or not. Therefore, 
+  setting IdentifyData to NULL does not constitute an error condition. 
+  EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a 
+  given (Channel, Device) pair.  
+    
+  @param[in] This           A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in] Channel        Zero-based channel number.
+  @param[in] Device         Zero-based device number on the Channel.
+  @param[in] IdentifyData   The device's response to the ATA IDENTIFY_DEVICE command.
+
+  @retval EFI_SUCCESS             The information was accepted without any errors.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+  @retval EFI_INVALID_PARAMETER   Device is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_SUBMIT_DATA)(
+  IN EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN UINT8                             Channel,
+  IN UINT8                             Device,
+  IN EFI_IDENTIFY_DATA                 *IdentifyData
+  );
+
+/**
+  Disqualifies specific modes for an IDE device.
+
+  This function allows the driver entity or other drivers (such as platform 
+  drivers) to reject certain timing modes and request the IDE controller driver
+  to recalculate modes. This function allows the driver entity and the IDE 
+  controller driver to negotiate the timings on a per-device basis. This function 
+  is useful in the case of drives that lie about their capabilities. An example 
+  is when the IDE device fails to accept the timing modes that are calculated 
+  by the IDE controller driver based on the response to the Identify Drive command.
+
+  If the driver entity does not want to limit the ATA timing modes and leave that 
+  decision to the IDE controller driver, it can either not call this function for 
+  the given device or call this function and set the Valid flag to FALSE for all 
+  modes that are listed in EFI_ATA_COLLECTIVE_MODE.
+  
+  The driver entity may disqualify modes for a device in any order and any number 
+  of times.
+  
+  This function can be called multiple times to invalidate multiple modes of the 
+  same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI 
+  specification for more information on PIO modes.  
+  
+  For Serial ATA (SATA) controllers, this member function can be used to disqualify
+  a higher transfer rate mode on a given channel. For example, a platform driver
+  may inform the IDE controller driver to not use second-generation (Gen2) speeds 
+  for a certain SATA drive.
+  
+  @param[in] This       The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in] Channel    The zero-based channel number.
+  @param[in] Device     The zero-based device number on the Channel.
+  @param[in] BadModes   The modes that the device does not support and that
+                        should be disqualified.
+
+  @retval EFI_SUCCESS             The modes were accepted without any errors.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+  @retval EFI_INVALID_PARAMETER   Device is invalid.
+  @retval EFI_INVALID_PARAMETER   IdentifyData is NULL.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_DISQUALIFY_MODE)(
+  IN EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN UINT8                             Channel,
+  IN UINT8                             Device,
+  IN EFI_ATA_COLLECTIVE_MODE           *BadModes
+  );
+
+/**
+  Returns the information about the optimum modes for the specified IDE device.
+
+  This function is used by the driver entity to obtain the optimum ATA modes for
+  a specific device.  The IDE controller driver takes into account the following 
+  while calculating the mode:
+    - The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+    - The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()
+
+  The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() 
+  for all the devices that belong to an enumeration group before calling 
+  EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.  
+  
+  The IDE controller driver will use controller- and possibly platform-specific 
+  algorithms to arrive at SupportedModes.  The IDE controller may base its 
+  decision on user preferences and other considerations as well. This function 
+  may be called multiple times because the driver entity may renegotiate the mode 
+  with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
+    
+  The driver entity may collect timing information for various devices in any 
+  order. The driver entity is responsible for making sure that all the dependencies
+  are satisfied. For example, the SupportedModes information for device A that 
+  was previously returned may become stale after a call to 
+  EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
+  
+  The buffer SupportedModes is allocated by the callee because the caller does 
+  not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE 
+  is defined in a way that allows for future extensibility and can be of variable 
+  length. This memory pool should be deallocated by the caller when it is no 
+  longer necessary.  
+  
+  The IDE controller driver for a Serial ATA (SATA) controller can use this 
+  member function to force a lower speed (first-generation [Gen1] speeds on a 
+  second-generation [Gen2]-capable hardware).  The IDE controller driver can 
+  also allow the driver entity to stay with the speed that has been negotiated 
+  by the physical layer.
+  
+  @param[in]  This             The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in]  Channel          A zero-based channel number.
+  @param[in]  Device           A zero-based device number on the Channel.
+  @param[out] SupportedModes   The optimum modes for the device.
+
+  @retval EFI_SUCCESS             SupportedModes was returned.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+  @retval EFI_INVALID_PARAMETER   Device is invalid. 
+  @retval EFI_INVALID_PARAMETER   SupportedModes is NULL.
+  @retval EFI_NOT_READY           Modes cannot be calculated due to a lack of 
+                                  data.  This error may happen if 
+                                  EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() 
+                                  and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData() 
+                                  were not called for at least one drive in the 
+                                  same enumeration group.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_CALCULATE_MODE)(
+  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN  UINT8                             Channel,
+  IN  UINT8                             Device,
+  OUT EFI_ATA_COLLECTIVE_MODE           **SupportedModes
+  );
+
+/**
+  Commands the IDE controller driver to program the IDE controller hardware
+  so that the specified device can operate at the specified mode.
+
+  This function is used by the driver entity to instruct the IDE controller 
+  driver to program the IDE controller hardware to the specified modes. This 
+  function can be called only once for a particular device. For a Serial ATA 
+  (SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
+  specific programming may be required.
+
+  @param[in] This      Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
+  @param[in] Channel   Zero-based channel number.
+  @param[in] Device    Zero-based device number on the Channel.
+  @param[in] Modes     The modes to set.
+
+  @retval EFI_SUCCESS             The command was accepted without any errors.
+  @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
+  @retval EFI_INVALID_PARAMETER   Device is invalid.
+  @retval EFI_NOT_READY           Modes cannot be set at this time due to lack of data.
+  @retval EFI_DEVICE_ERROR        Modes cannot be set due to hardware failure.
+                                  The driver entity should not use this device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IDE_CONTROLLER_SET_TIMING)(
+  IN EFI_IDE_CONTROLLER_INIT_PROTOCOL  *This,
+  IN UINT8                             Channel,
+  IN UINT8                             Device,
+  IN EFI_ATA_COLLECTIVE_MODE           *Modes
+  );
+
+///
+/// Provides the basic interfaces to abstract an IDE controller.
+///
+struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL {
+  ///
+  /// Returns the information about a specific channel.
+  ///
+  EFI_IDE_CONTROLLER_GET_CHANNEL_INFO    GetChannelInfo;
+  
+  ///
+  /// The notification that the driver entity is about to enter the
+  /// specified phase during the enumeration process.  
+  ///
+  EFI_IDE_CONTROLLER_NOTIFY_PHASE        NotifyPhase;
+  
+  ///
+  /// Submits the Drive Identify data that was returned by the device.
+  ///
+  EFI_IDE_CONTROLLER_SUBMIT_DATA         SubmitData;
+  
+  ///
+  /// Submits information about modes that should be disqualified.  The specified 
+  /// IDE device does not support these modes and these modes should not be 
+  /// returned by EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode()
+  ///
+  EFI_IDE_CONTROLLER_DISQUALIFY_MODE     DisqualifyMode;
+  
+  ///
+  /// Calculates and returns the optimum mode for a particular IDE device.
+  ///
+  EFI_IDE_CONTROLLER_CALCULATE_MODE      CalculateMode;
+  
+  ///
+  /// Programs the IDE controller hardware to the default timing or per the modes
+  /// that were returned by the last call to EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode().  
+  ///
+  EFI_IDE_CONTROLLER_SET_TIMING          SetTiming;
+  
+  ///
+  /// Set to TRUE if the enumeration group includes all the channels that are
+  /// produced by this controller. Set to FALSE if an enumeration group consists of
+  /// only one channel.  
+  ///
+  BOOLEAN                                EnumAll;
+  
+  ///
+  /// The number of channels that are produced by this controller. Parallel ATA
+  /// (PATA) controllers can support up to two channels. Advanced Host Controller 
+  /// Interface (AHCI) Serial ATA (SATA) controllers can support up to 32 channels,
+  /// each of which can have up to one device. In the presence of a multiplier, 
+  /// each channel can have fifteen devices.
+  ///
+  UINT8                                  ChannelCount;
+};
+
+extern EFI_GUID gEfiIdeControllerInitProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/IncompatiblePciDeviceSupport.h b/MdePkg/Include/Protocol/IncompatiblePciDeviceSupport.h
new file mode 100644
index 000000000000..9a924d4a6725
--- /dev/null
+++ b/MdePkg/Include/Protocol/IncompatiblePciDeviceSupport.h
@@ -0,0 +1,173 @@
+/** @file
+  This file declares Incompatible PCI Device Support Protocol
+  
+  Allows the PCI bus driver to support resource allocation for some PCI devices 
+  that do not comply with the PCI Specification.
+  
+  @par Note: 
+    This protocol is optional. Only those platforms that implement this protocol 
+    will have the capability to support incompatible PCI devices. The absence of 
+    this protocol can cause the PCI bus driver to configure these incompatible 
+    PCI devices incorrectly. As a result, these devices may not work properly.  
+  
+  The EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL is used by the PCI bus driver
+  to support resource allocation for some PCI devices that do not comply with the 
+  PCI Specification.  This protocol can find some incompatible PCI devices and 
+  report their special resource requirements to the PCI bus driver. The generic 
+  PCI bus driver does not have prior knowledge of any incompatible PCI devices. 
+  It interfaces with the EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL to find out 
+  if a device is incompatible and to obtain the special configuration requirements 
+  for a specific incompatible PCI device.
+
+  This protocol is optional, and only one instance of this protocol can be present
+  in the system. If a platform supports this protocol, this protocol is produced 
+  by a Driver Execution Environment (DXE) driver and must be made available before 
+  the Boot Device Selection (BDS) phase. The PCI bus driver will look for the 
+  presence of this protocol before it begins PCI enumeration.  If this protocol 
+  exists in a platform, it indicates that the platform has the capability to support
+  those incompatible PCI devices. However, final support for incompatible PCI 
+  devices still depends on the implementation of the PCI bus driver. The PCI bus 
+  driver may fully, partially, or not even support these incompatible devices.  
+
+  During PCI bus enumeration, the PCI bus driver will probe the PCI Base Address 
+  Registers (BARs) for each PCI device regardless of whether the PCI device is 
+  incompatible or not to determine the resource requirements so that the PCI bus 
+  driver can invoke the proper PCI resources for them.  Generally, this resource 
+  information includes the following:
+    - Resource type
+    - Resource length
+    - Alignment
+    
+  However, some incompatible PCI devices may have special requirements. As a result,
+  the length or the alignment that is derived through BAR probing may not be exactly 
+  the same as the actual resource requirement of the device. For example, there 
+  are some devices that request I/O resources at a length of 0x100 from their I/O
+  BAR, but these incompatible devices will never work correctly if an odd I/O base 
+  address, such as 0x100, 0x300, or 0x500, is assigned to the BAR. Instead, these 
+  devices request an even base address, such as 0x200 or 0x400. The Incompatible 
+  PCI Device Support Protocol can then be used to obtain these special resource 
+  requirements for these incompatible PCI devices. In this way, the PCI bus driver 
+  will take special consideration for these devices during PCI resource allocation 
+  to ensure that they can work correctly.
+  
+  This protocol may support the following incompatible PCI BAR types:
+    - I/O or memory length that is different from what the BAR reports
+    - I/O or memory alignment that is different from what the BAR reports
+    - Fixed I/O or memory base address
+    
+  See the Conventional PCI Specification 3.0 for the details of how a PCI BAR 
+  reports the resource length and the alignment that it requires.
+
+  Copyright (c) 2007 - 2009, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+
+**/
+
+#ifndef _INCOMPATIBLE_PCI_DEVICE_SUPPORT_H_
+#define _INCOMPATIBLE_PCI_DEVICE_SUPPORT_H_
+
+///
+/// Global ID for EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL
+///
+#define EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL_GUID \
+  { \
+    0xeb23f55a, 0x7863, 0x4ac2, {0x8d, 0x3d, 0x95, 0x65, 0x35, 0xde, 0x03, 0x75} \
+  }
+
+///
+/// Forward declaration for EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL
+///
+typedef struct _EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL;
+
+/**
+  Returns a list of ACPI resource descriptors that detail the special resource
+  configuration requirements for an incompatible PCI device.
+  
+  This function returns a list of ACPI resource descriptors that detail the 
+  special resource configuration requirements for an incompatible PCI device.  
+  
+  Prior to bus enumeration, the PCI bus driver will look for the presence
+  of the EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL. Only one instance of this
+  protocol can be present in the system. For each PCI device that the PCI bus 
+  driver discovers, the PCI bus driver calls this function with the device's vendor
+  ID, device ID, revision ID, subsystem vendor ID, and subsystem device ID. If the
+  VendorId, DeviceId, RevisionId, SubsystemVendorId, or SubsystemDeviceId value is
+  set to (UINTN)-1, that field will be ignored. The ID values that are not (UINTN)-1
+  will be used to identify the current device.  
+  
+  This function will only return EFI_SUCCESS. However, if the device is an 
+  incompatible PCI device, a list of ACPI resource descriptors will be returned 
+  in Configuration. Otherwise, NULL will be returned in Configuration instead. 
+  The PCI bus driver does not need to allocate memory for Configuration. However, 
+  it is the PCI bus driver's responsibility to free it. The PCI bus driver then 
+  can configure this device with the information that is derived from this list 
+  of resource nodes, rather than the result of BAR probing.
+
+  Only the following two resource descriptor types from the ACPI Specification 
+  may be used to describe the incompatible PCI device resource requirements:
+    - QWORD Address Space Descriptor (ACPI 2.0, section 6.4.3.5.1; also ACPI 3.0)
+    - End Tag (ACPI 2.0, section 6.4.2.8; also ACPI 3.0)
+
+  The QWORD Address Space Descriptor can describe memory, I/O, and bus number 
+  ranges for dynamic or fixed resources.  The configuration of a PCI root bridge 
+  is described with one or more QWORD Address Space Descriptors, followed by an 
+  End Tag. See the ACPI Specification for details on the field values.
+  
+  @param[in]  This                Pointer to the EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL 
+                                  instance.
+  @param[in]  VendorId            A unique ID to identify the manufacturer of 
+                                  the PCI device.  See the Conventional PCI
+                                  Specification 3.0 for details.
+  @param[in]  DeviceId            A unique ID to identify the particular PCI 
+                                  device. See the Conventional PCI Specification 
+                                  3.0 for details.
+  @param[in]  RevisionId          A PCI device-specific revision identifier. 
+                                  See the Conventional PCI Specification 3.0
+                                  for details.
+  @param[in]  SubsystemVendorId   Specifies the subsystem vendor ID. See the 
+                                  Conventional PCI Specification 3.0 for details.
+  @param[in]  SubsystemDeviceId   Specifies the subsystem device ID. See the 
+                                  Conventional PCI Specification 3.0 for details.
+  @param[out] Configuration       A list of ACPI resource descriptors that detail
+                                  the configuration requirement.
+
+  @retval EFI_SUCCESS   The function always returns EFI_SUCCESS.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE)(
+  IN  EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL  *This,
+  IN  UINTN                                         VendorId,
+  IN  UINTN                                         DeviceId,
+  IN  UINTN                                         RevisionId,
+  IN  UINTN                                         SubsystemVendorId,
+  IN  UINTN                                         SubsystemDeviceId,
+  OUT VOID                                          **Configuration
+  );
+
+///
+/// Interface structure for the Incompatible PCI Device Support Protocol
+///
+struct _EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL {
+  ///
+  ///  Returns a list of ACPI resource descriptors that detail any special
+  ///  resource configuration requirements if the specified device is a recognized
+  ///  incompatible PCI device.
+  ///
+  EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_CHECK_DEVICE  CheckDevice;
+};
+
+extern EFI_GUID gEfiIncompatiblePciDeviceSupportProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Ip4.h b/MdePkg/Include/Protocol/Ip4.h
new file mode 100644
index 000000000000..e36f38d8f5d2
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ip4.h
@@ -0,0 +1,612 @@
+/** @file
+  This file defines the EFI IPv4 (Internet Protocol version 4)
+  Protocol interface. It is split into the following three main
+  sections:
+  - EFI IPv4 Service Binding Protocol
+  - EFI IPv4 Variable (deprecated in UEFI 2.4B)
+  - EFI IPv4 Protocol.
+  The EFI IPv4 Protocol provides basic network IPv4 packet I/O services,
+  which includes support foR a subset of the Internet Control Message 
+  Protocol (ICMP) and may include support for the Internet Group Management
+  Protocol (IGMP).
+  
+Copyright (c) 2006 - 2014, 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.   
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.0.        
+
+**/
+
+#ifndef __EFI_IP4_PROTOCOL_H__
+#define __EFI_IP4_PROTOCOL_H__
+
+#include <Protocol/ManagedNetwork.h>
+
+#define EFI_IP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xc51711e7, 0xb4bf, 0x404a, {0xbf, 0xb8, 0x0a, 0x04, 0x8e, 0xf1, 0xff, 0xe4 } \
+  }
+
+#define EFI_IP4_PROTOCOL_GUID \
+  { \
+    0x41d94cd2, 0x35b6, 0x455a, {0x82, 0x58, 0xd4, 0xe5, 0x13, 0x34, 0xaa, 0xdd } \
+  }
+
+typedef struct _EFI_IP4_PROTOCOL EFI_IP4_PROTOCOL;
+
+///
+/// EFI_IP4_ADDRESS_PAIR is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              InstanceHandle;
+  EFI_IPv4_ADDRESS        Ip4Address;
+  EFI_IPv4_ADDRESS        SubnetMask;
+} EFI_IP4_ADDRESS_PAIR; 
+
+///
+/// EFI_IP4_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              DriverHandle;
+  UINT32                  AddressCount;
+  EFI_IP4_ADDRESS_PAIR    AddressPairs[1];
+} EFI_IP4_VARIABLE_DATA;
+
+typedef struct {
+  ///
+  /// The default IPv4 protocol packets to send and receive. Ignored
+  /// when AcceptPromiscuous is TRUE.
+  ///
+  UINT8                   DefaultProtocol;
+  ///
+  /// Set to TRUE to receive all IPv4 packets that get through the receive filters.
+  /// Set to FALSE to receive only the DefaultProtocol IPv4
+  /// packets that get through the receive filters.
+  ///
+  BOOLEAN                 AcceptAnyProtocol;
+  ///
+  /// Set to TRUE to receive ICMP error report packets. Ignored when
+  /// AcceptPromiscuous or AcceptAnyProtocol is TRUE.
+  ///
+  BOOLEAN                 AcceptIcmpErrors;
+  ///
+  /// Set to TRUE to receive broadcast IPv4 packets. Ignored when
+  /// AcceptPromiscuous is TRUE.
+  /// Set to FALSE to stop receiving broadcast IPv4 packets.
+  ///
+  BOOLEAN                 AcceptBroadcast;
+  ///
+  /// Set to TRUE to receive all IPv4 packets that are sent to any
+  /// hardware address or any protocol address.
+  /// Set to FALSE to stop receiving all promiscuous IPv4 packets
+  ///
+  BOOLEAN                 AcceptPromiscuous;
+  ///
+  /// Set to TRUE to use the default IPv4 address and default routing table.
+  ///
+  BOOLEAN                 UseDefaultAddress;
+  ///
+  /// The station IPv4 address that will be assigned to this EFI IPv4Protocol instance.
+  ///
+  EFI_IPv4_ADDRESS        StationAddress;
+  ///
+  /// The subnet address mask that is associated with the station address.
+  ///
+  EFI_IPv4_ADDRESS        SubnetMask;
+  ///
+  /// TypeOfService field in transmitted IPv4 packets.
+  ///
+  UINT8                   TypeOfService;
+  ///
+  /// TimeToLive field in transmitted IPv4 packets.
+  ///
+  UINT8                   TimeToLive;
+  ///
+  /// State of the DoNotFragment bit in transmitted IPv4 packets.
+  ///
+  BOOLEAN                 DoNotFragment;
+  ///
+  /// Set to TRUE to send and receive unformatted packets. The other
+  /// IPv4 receive filters are still applied. Fragmentation is disabled for RawData mode.
+  ///
+  BOOLEAN                 RawData;
+  ///
+  /// The timer timeout value (number of microseconds) for the
+  /// receive timeout event to be associated with each assembled
+  /// packet. Zero means do not drop assembled packets.
+  ///
+  UINT32                  ReceiveTimeout;
+  ///
+  /// The timer timeout value (number of microseconds) for the
+  /// transmit timeout event to be associated with each outgoing
+  /// packet. Zero means do not drop outgoing packets.
+  ///
+  UINT32                  TransmitTimeout;
+} EFI_IP4_CONFIG_DATA;
+
+
+typedef struct {
+  EFI_IPv4_ADDRESS        SubnetAddress;
+  EFI_IPv4_ADDRESS        SubnetMask;
+  EFI_IPv4_ADDRESS        GatewayAddress;
+} EFI_IP4_ROUTE_TABLE;
+
+typedef struct {
+  UINT8                   Type;
+  UINT8                   Code;
+} EFI_IP4_ICMP_TYPE;
+
+typedef struct {
+  ///
+  /// Set to TRUE after this EFI IPv4 Protocol instance has been successfully configured.
+  ///
+  BOOLEAN                 IsStarted;
+  ///
+  /// The maximum packet size, in bytes, of the packet which the upper layer driver could feed.
+  ///
+  UINT32                  MaxPacketSize;
+  ///
+  /// Current configuration settings.
+  ///
+  EFI_IP4_CONFIG_DATA     ConfigData;
+  ///
+  /// Set to TRUE when the EFI IPv4 Protocol instance has a station address and subnet mask.
+  ///
+  BOOLEAN                 IsConfigured;
+  ///
+  /// Number of joined multicast groups.
+  ///
+  UINT32                  GroupCount;
+  ///
+  /// List of joined multicast group addresses.
+  ///
+  EFI_IPv4_ADDRESS        *GroupTable;
+  ///
+  /// Number of entries in the routing table.
+  ///
+  UINT32                  RouteCount;
+  ///
+  /// Routing table entries.
+  ///
+  EFI_IP4_ROUTE_TABLE     *RouteTable;
+  ///
+  /// Number of entries in the supported ICMP types list.
+  ///
+  UINT32                  IcmpTypeCount;
+  ///
+  /// Array of ICMP types and codes that are supported by this EFI IPv4 Protocol driver
+  ///
+  EFI_IP4_ICMP_TYPE       *IcmpTypeList;
+} EFI_IP4_MODE_DATA;
+
+#pragma pack(1)
+
+typedef struct {
+  UINT8                   HeaderLength:4;
+  UINT8                   Version:4;
+  UINT8                   TypeOfService;
+  UINT16                  TotalLength;
+  UINT16                  Identification;
+  UINT16                  Fragmentation;
+  UINT8                   TimeToLive;
+  UINT8                   Protocol;
+  UINT16                  Checksum;
+  EFI_IPv4_ADDRESS        SourceAddress;
+  EFI_IPv4_ADDRESS        DestinationAddress;
+} EFI_IP4_HEADER;
+#pragma pack()
+
+
+typedef struct {
+  UINT32                  FragmentLength;
+  VOID                    *FragmentBuffer;
+} EFI_IP4_FRAGMENT_DATA;
+
+
+typedef struct {
+  EFI_TIME               TimeStamp;
+  EFI_EVENT              RecycleSignal;
+  UINT32                 HeaderLength;
+  EFI_IP4_HEADER         *Header;
+  UINT32                 OptionsLength;
+  VOID                   *Options;
+  UINT32                 DataLength;
+  UINT32                 FragmentCount;
+  EFI_IP4_FRAGMENT_DATA  FragmentTable[1];
+} EFI_IP4_RECEIVE_DATA;
+
+
+typedef struct {
+  EFI_IPv4_ADDRESS       SourceAddress;
+  EFI_IPv4_ADDRESS       GatewayAddress;
+  UINT8                  Protocol;
+  UINT8                  TypeOfService;
+  UINT8                  TimeToLive;
+  BOOLEAN                DoNotFragment;
+} EFI_IP4_OVERRIDE_DATA;
+
+typedef struct {
+  EFI_IPv4_ADDRESS       DestinationAddress;
+  EFI_IP4_OVERRIDE_DATA  *OverrideData;      //OPTIONAL
+  UINT32                 OptionsLength;      //OPTIONAL
+  VOID                   *OptionsBuffer;     //OPTIONAL
+  UINT32                 TotalDataLength;
+  UINT32                 FragmentCount;
+  EFI_IP4_FRAGMENT_DATA  FragmentTable[1];
+} EFI_IP4_TRANSMIT_DATA;
+
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated
+  /// by the EFI IPv4 Protocol driver. The type of Event must be
+  /// EFI_NOTIFY_SIGNAL. The Task Priority Level (TPL) of
+  /// Event must be lower than or equal to TPL_CALLBACK.
+  ///
+  EFI_EVENT                Event;
+  ///
+  /// The status that is returned to the caller at the end of the operation
+  /// to indicate whether this operation completed successfully.
+  ///
+  EFI_STATUS               Status;
+  union {
+    ///
+    /// When this token is used for receiving, RxData is a pointer to the EFI_IP4_RECEIVE_DATA.
+    ///
+    EFI_IP4_RECEIVE_DATA   *RxData;
+    ///
+    /// When this token is used for transmitting, TxData is a pointer to the EFI_IP4_TRANSMIT_DATA.
+    ///
+    EFI_IP4_TRANSMIT_DATA  *TxData;
+  } Packet;
+} EFI_IP4_COMPLETION_TOKEN;
+
+/**
+  Gets the current operational settings for this instance of the EFI IPv4 Protocol driver.
+  
+  The GetModeData() function returns the current operational mode data for this
+  driver instance. The data fields in EFI_IP4_MODE_DATA are read only. This
+  function is used optionally to retrieve the operational mode data of underlying
+  networks or drivers.
+
+  @param  This          The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  Ip4ModeData   The pointer to the EFI IPv4 Protocol mode data structure.
+  @param  MnpConfigData The pointer to the managed network configuration data structure.
+  @param  SnpModeData   The pointer to the simple network mode data structure.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The required mode data could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_GET_MODE_DATA)(
+  IN CONST  EFI_IP4_PROTOCOL                *This,
+  OUT       EFI_IP4_MODE_DATA               *Ip4ModeData     OPTIONAL,
+  OUT       EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData   OPTIONAL,
+  OUT       EFI_SIMPLE_NETWORK_MODE         *SnpModeData     OPTIONAL
+  );  
+
+/**
+  Assigns an IPv4 address and subnet mask to this EFI IPv4 Protocol driver instance.
+  
+  The Configure() function is used to set, change, or reset the operational
+  parameters and filter settings for this EFI IPv4 Protocol instance. Until these
+  parameters have been set, no network traffic can be sent or received by this
+  instance. Once the parameters have been reset (by calling this function with
+  IpConfigData set to NULL), no more traffic can be sent or received until these
+  parameters have been set again. Each EFI IPv4 Protocol instance can be started
+  and stopped independently of each other by enabling or disabling their receive
+  filter settings with the Configure() function.
+  
+  When IpConfigData.UseDefaultAddress is set to FALSE, the new station address will
+  be appended as an alias address into the addresses list in the EFI IPv4 Protocol
+  driver. While set to TRUE, Configure() will trigger the EFI_IP4_CONFIG_PROTOCOL
+  to retrieve the default IPv4 address if it is not available yet. Clients could
+  frequently call GetModeData() to check the status to ensure that the default IPv4
+  address is ready.
+  
+  If operational parameters are reset or changed, any pending transmit and receive
+  requests will be cancelled. Their completion token status will be set to EFI_ABORTED
+  and their events will be signaled.
+
+  @param  This         The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  IpConfigData The pointer to the EFI IPv4 Protocol configuration data structure.
+
+  @retval EFI_SUCCESS           The driver instance was successfully opened.
+  @retval EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                This is NULL.
+                                IpConfigData.StationAddress is not a unicast IPv4 address.
+                                IpConfigData.SubnetMask is not a valid IPv4 subnet 
+  @retval EFI_UNSUPPORTED       One or more of the following conditions is TRUE:
+                                A configuration protocol (DHCP, BOOTP, RARP, etc.) could
+                                not be located when clients choose to use the default IPv4
+                                address. This EFI IPv4 Protocol implementation does not
+                                support this requested filter or timeout setting.
+  @retval EFI_OUT_OF_RESOURCES  The EFI IPv4 Protocol driver instance data could not be allocated.
+  @retval EFI_ALREADY_STARTED   The interface is already open and must be stopped before the
+                                IPv4 address or subnet mask can be changed. The interface must
+                                also be stopped when switching to/from raw packet mode.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred. The EFI IPv4
+                                Protocol driver instance is not opened.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIGURE)(
+  IN EFI_IP4_PROTOCOL    *This,
+  IN EFI_IP4_CONFIG_DATA *IpConfigData     OPTIONAL
+  );  
+
+/**
+  Joins and leaves multicast groups.
+  
+  The Groups() function is used to join and leave multicast group sessions. Joining
+  a group will enable reception of matching multicast packets. Leaving a group will
+  disable the multicast packet reception.
+  
+  If JoinFlag is FALSE and GroupAddress is NULL, all joined groups will be left.
+
+  @param  This                  The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  JoinFlag              Set to TRUE to join the multicast group session and FALSE to leave.
+  @param  GroupAddress          The pointer to the IPv4 multicast address.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following is TRUE:
+                                - This is NULL.
+                                - JoinFlag is TRUE and GroupAddress is NULL.
+                                - GroupAddress is not NULL and *GroupAddress is
+                                  not a multicast IPv4 address.
+  @retval EFI_NOT_STARTED       This instance has not been started.
+  @retval EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES  System resources could not be allocated.
+  @retval EFI_UNSUPPORTED       This EFI IPv4 Protocol implementation does not support multicast groups.
+  @retval EFI_ALREADY_STARTED   The group address is already in the group table (when
+                                JoinFlag is TRUE).
+  @retval EFI_NOT_FOUND         The group address is not in the group table (when JoinFlag is FALSE).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_GROUPS)(
+  IN EFI_IP4_PROTOCOL    *This,
+  IN BOOLEAN             JoinFlag,
+  IN EFI_IPv4_ADDRESS    *GroupAddress  OPTIONAL
+  );    
+
+/**
+  Adds and deletes routing table entries.
+
+  The Routes() function adds a route to or deletes a route from the routing table.
+  
+  Routes are determined by comparing the SubnetAddress with the destination IPv4
+  address arithmetically AND-ed with the SubnetMask. The gateway address must be
+  on the same subnet as the configured station address.
+  
+  The default route is added with SubnetAddress and SubnetMask both set to 0.0.0.0.
+  The default route matches all destination IPv4 addresses that do not match any
+  other routes.
+  
+  A GatewayAddress that is zero is a nonroute. Packets are sent to the destination
+  IP address if it can be found in the ARP cache or on the local subnet. One automatic
+  nonroute entry will be inserted into the routing table for outgoing packets that
+  are addressed to a local subnet (gateway address of 0.0.0.0).
+  
+  Each EFI IPv4 Protocol instance has its own independent routing table. Those EFI
+  IPv4 Protocol instances that use the default IPv4 address will also have copies
+  of the routing table that was provided by the EFI_IP4_CONFIG_PROTOCOL, and these
+  copies will be updated whenever the EIF IPv4 Protocol driver reconfigures its
+  instances. As a result, client modification to the routing table will be lost.
+
+  @param  This                   The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  DeleteRoute            Set to TRUE to delete this route from the routing table. Set to
+                                 FALSE to add this route to the routing table. SubnetAddress
+                                 and SubnetMask are used as the key to each route entry.
+  @param  SubnetAddress          The address of the subnet that needs to be routed.
+  @param  SubnetMask             The subnet mask of SubnetAddress.
+  @param  GatewayAddress         The unicast gateway IPv4 address for this route.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_NOT_STARTED        The driver instance has not been started.
+  @retval EFI_NO_MAPPING         When using the default address, configuration (DHCP, BOOTP,
+                                 RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - SubnetAddress is NULL.
+                                 - SubnetMask is NULL.
+                                 - GatewayAddress is NULL.
+                                 - *SubnetAddress is not a valid subnet address.
+                                 - *SubnetMask is not a valid subnet mask.
+                                 - *GatewayAddress is not a valid unicast IPv4 address.
+  @retval EFI_OUT_OF_RESOURCES   Could not add the entry to the routing table.
+  @retval EFI_NOT_FOUND          This route is not in the routing table (when DeleteRoute is TRUE).
+  @retval EFI_ACCESS_DENIED      The route is already defined in the routing table (when
+                                 DeleteRoute is FALSE).
+                                 
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_ROUTES)(
+  IN EFI_IP4_PROTOCOL    *This,
+  IN BOOLEAN             DeleteRoute,
+  IN EFI_IPv4_ADDRESS    *SubnetAddress,
+  IN EFI_IPv4_ADDRESS    *SubnetMask,
+  IN EFI_IPv4_ADDRESS    *GatewayAddress  
+  );  
+
+/**
+  Places outgoing data packets into the transmit queue.
+
+  The Transmit() function places a sending request in the transmit queue of this
+  EFI IPv4 Protocol instance. Whenever the packet in the token is sent out or some
+  errors occur, the event in the token will be signaled and the status is updated.
+
+  @param  This  The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  Token The pointer to the transmit token.
+
+  @retval  EFI_SUCCESS           The data has been queued for transmission.
+  @retval  EFI_NOT_STARTED       This instance has not been started.
+  @retval  EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                 RARP, etc.) is not finished yet.
+  @retval  EFI_INVALID_PARAMETER One or more pameters are invalid.
+  @retval  EFI_ACCESS_DENIED     The transmit completion token with the same Token.Event
+                                 was already in the transmit queue.
+  @retval  EFI_NOT_READY         The completion token could not be queued because the transmit
+                                 queue is full. 
+  @retval  EFI_NOT_FOUND         Not route is found to destination address.
+  @retval  EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
+  @retval  EFI_BUFFER_TOO_SMALL  Token.Packet.TxData.TotalDataLength is too
+                                 short to transmit.
+  @retval  EFI_BAD_BUFFER_SIZE   The length of the IPv4 header + option length + total data length is
+                                 greater than MTU (or greater than the maximum packet size if
+                                 Token.Packet.TxData.OverrideData.
+                                 DoNotFragment is TRUE.)
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_TRANSMIT)(
+  IN EFI_IP4_PROTOCOL          *This,
+  IN EFI_IP4_COMPLETION_TOKEN  *Token
+  );    
+
+/**
+  Places a receiving request into the receiving queue.
+  
+  The Receive() function places a completion token into the receive packet queue.
+  This function is always asynchronous.
+  
+  The Token.Event field in the completion token must be filled in by the caller
+  and cannot be NULL. When the receive operation completes, the EFI IPv4 Protocol
+  driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
+  is signaled.
+
+  @param  This  The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  Token The pointer to a token that is associated with the receive data descriptor.
+
+  @retval EFI_SUCCESS           The receive completion token was cached.
+  @retval EFI_NOT_STARTED       This EFI IPv4 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP, RARP, etc.)
+                                is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - Token is NULL.
+                                - Token.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The receive completion token could not be queued due to a lack of system
+                                resources (usually memory).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+                                The EFI IPv4 Protocol instance has been reset to startup defaults.
+  @retval EFI_ACCESS_DENIED     The receive completion token with the same Token.Event was already
+                                in the receive queue.
+  @retval EFI_NOT_READY         The receive request could not be queued because the receive queue is full.
+  @retval EFI_ICMP_ERROR        An ICMP error packet was received.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_RECEIVE)(
+  IN EFI_IP4_PROTOCOL          *This,
+  IN EFI_IP4_COMPLETION_TOKEN  *Token
+  );      
+
+/**
+  Abort an asynchronous transmit or receive request.
+  
+  The Cancel() function is used to abort a pending transmit or receive request.
+  If the token is in the transmit or receive request queues, after calling this
+  function, Token->Status will be set to EFI_ABORTED and then Token->Event will
+  be signaled. If the token is not in one of the queues, which usually means the
+  asynchronous operation has completed, this function will not signal the token
+  and EFI_NOT_FOUND is returned.
+
+  @param  This  The pointer to the EFI_IP4_PROTOCOL instance.
+  @param  Token The pointer to a token that has been issued by
+                EFI_IP4_PROTOCOL.Transmit() or
+                EFI_IP4_PROTOCOL.Receive(). If NULL, all pending
+                tokens are aborted. Type EFI_IP4_COMPLETION_TOKEN is
+                defined in EFI_IP4_PROTOCOL.Transmit().
+
+  @retval EFI_SUCCESS           The asynchronous I/O request was aborted and
+                                Token->Event was signaled. When Token is NULL, all
+                                pending requests were aborted and their events were signaled.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_NOT_STARTED       This instance has not been started.
+  @retval EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_NOT_FOUND         When Token is not NULL, the asynchronous I/O request was
+                                not found in the transmit or receive queue. It has either completed
+                                or was not issued by Transmit() and Receive().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CANCEL)(
+  IN EFI_IP4_PROTOCOL          *This,
+  IN EFI_IP4_COMPLETION_TOKEN  *Token OPTIONAL
+  );      
+  
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+  
+  The Poll() function polls for incoming data packets and processes outgoing data
+  packets. Network drivers and applications can call the EFI_IP4_PROTOCOL.Poll()
+  function to increase the rate that data packets are moved between the communications
+  device and the transmit and receive queues.
+  
+  In some systems the periodic timer event may not poll the underlying communications
+  device fast enough to transmit and/or receive all data packets without missing
+  incoming packets or dropping outgoing packets. Drivers and applications that are
+  experiencing packet loss should try calling the EFI_IP4_PROTOCOL.Poll() function
+  more often.
+
+  @param  This The pointer to the EFI_IP4_PROTOCOL instance.
+
+  @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval  EFI_NOT_STARTED       This EFI IPv4 Protocol instance has not been started.
+  @retval  EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                 RARP, etc.) is not finished yet.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval  EFI_NOT_READY         No incoming or outgoing data is processed.
+  @retval  EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_POLL)(
+  IN EFI_IP4_PROTOCOL          *This
+  );  
+
+///
+/// The EFI IPv4 Protocol implements a simple packet-oriented interface that can be 
+/// used by drivers, daemons, and applications to transmit and receive network packets.
+///
+struct _EFI_IP4_PROTOCOL {
+  EFI_IP4_GET_MODE_DATA        GetModeData;
+  EFI_IP4_CONFIGURE            Configure;
+  EFI_IP4_GROUPS               Groups;
+  EFI_IP4_ROUTES               Routes;
+  EFI_IP4_TRANSMIT             Transmit;
+  EFI_IP4_RECEIVE              Receive;
+  EFI_IP4_CANCEL               Cancel;
+  EFI_IP4_POLL                 Poll;
+};
+
+extern EFI_GUID gEfiIp4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiIp4ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Ip4Config.h b/MdePkg/Include/Protocol/Ip4Config.h
new file mode 100644
index 000000000000..ece7efb6688c
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ip4Config.h
@@ -0,0 +1,182 @@
+/** @file
+  This file provides a definition of the EFI IPv4 Configuration
+  Protocol.
+
+Copyright (c) 2006 - 2014, 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.
+  
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.0.
+
+**/
+#ifndef __EFI_IP4CONFIG_PROTOCOL_H__
+#define __EFI_IP4CONFIG_PROTOCOL_H__
+
+#include <Protocol/Ip4.h>
+
+#define EFI_IP4_CONFIG_PROTOCOL_GUID \
+  { \
+    0x3b95aa31, 0x3793, 0x434b, {0x86, 0x67, 0xc8, 0x07, 0x08, 0x92, 0xe0, 0x5e } \
+  }
+
+typedef struct _EFI_IP4_CONFIG_PROTOCOL EFI_IP4_CONFIG_PROTOCOL;
+
+#define IP4_CONFIG_VARIABLE_ATTRIBUTES \
+        (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS)
+
+///
+/// EFI_IP4_IPCONFIG_DATA contains the minimum IPv4 configuration data 
+/// that is needed to start basic network communication. The StationAddress 
+/// and SubnetMask must be a valid unicast IP address and subnet mask.
+/// If RouteTableSize is not zero, then RouteTable contains a properly 
+/// formatted routing table for the StationAddress/SubnetMask, with the 
+/// last entry in the table being the default route.
+///
+typedef struct {
+  ///
+  /// Default station IP address, stored in network byte order.
+  ///
+  EFI_IPv4_ADDRESS             StationAddress;
+  ///
+  /// Default subnet mask, stored in network byte order.
+  ///
+  EFI_IPv4_ADDRESS             SubnetMask;
+  ///
+  /// Number of entries in the following RouteTable. May be zero.
+  ///
+  UINT32                       RouteTableSize;
+  ///
+  /// Default routing table data (stored in network byte order).
+  /// Ignored if RouteTableSize is zero.
+  ///
+  EFI_IP4_ROUTE_TABLE          *RouteTable;
+} EFI_IP4_IPCONFIG_DATA;
+
+
+/**
+  Starts running the configuration policy for the EFI IPv4 Protocol driver.
+  
+  The Start() function is called to determine and to begin the platform 
+  configuration policy by the EFI IPv4 Protocol driver. This determination may 
+  be as simple as returning EFI_UNSUPPORTED if there is no EFI IPv4 Protocol 
+  driver configuration policy. It may be as involved as loading some defaults 
+  from nonvolatile storage, downloading dynamic data from a DHCP server, and 
+  checking permissions with a site policy server.
+  Starting the configuration policy is just the beginning. It may finish almost 
+  instantly or it may take several minutes before it fails to retrieve configuration 
+  information from one or more servers. Once the policy is started, drivers 
+  should use the DoneEvent parameter to determine when the configuration policy 
+  has completed. EFI_IP4_CONFIG_PROTOCOL.GetData() must then be called to 
+  determine if the configuration succeeded or failed.
+  Until the configuration completes successfully, EFI IPv4 Protocol driver instances 
+  that are attempting to use default configurations must return EFI_NO_MAPPING.
+  Once the configuration is complete, the EFI IPv4 Configuration Protocol driver 
+  signals DoneEvent. The configuration may need to be updated in the future. 
+  Note that in this case the EFI IPv4 Configuration Protocol driver must signal 
+  ReconfigEvent, and all EFI IPv4 Protocol driver instances that are using default 
+  configurations must return EFI_NO_MAPPING until the configuration policy has 
+  been rerun.
+
+  @param  This                   The pointer to the EFI_IP4_CONFIG_PROTOCOL instance.
+  @param  DoneEvent              Event that will be signaled when the EFI IPv4 
+                                 Protocol driver configuration policy completes 
+                                 execution. This event must be of type EVT_NOTIFY_SIGNAL.
+  @param  ReconfigEvent          Event that will be signaled when the EFI IPv4 
+                                 Protocol driver configuration needs to be updated. 
+                                 This event must be of type EVT_NOTIFY_SIGNAL.
+  
+  @retval EFI_SUCCESS            The configuration policy for the EFI IPv4 Protocol 
+                                 driver is now running.
+  @retval EFI_INVALID_PARAMETER  One or more of the following parameters is NULL:
+                                  This
+                                  DoneEvent
+                                  ReconfigEvent
+  @retval EFI_OUT_OF_RESOURCES   Required system resources could not be allocated.
+  @retval EFI_ALREADY_STARTED    The configuration policy for the EFI IPv4 Protocol 
+                                 driver was already started.
+  @retval EFI_DEVICE_ERROR       An unexpected system error or network error occurred.
+  @retval EFI_UNSUPPORTED        This interface does not support the EFI IPv4 Protocol 
+                                 driver configuration.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG_START)(
+  IN EFI_IP4_CONFIG_PROTOCOL   *This,
+  IN EFI_EVENT                 DoneEvent,
+  IN EFI_EVENT                 ReconfigEvent
+  );
+
+/**
+  Stops running the configuration policy for the EFI IPv4 Protocol driver.
+  
+  The Stop() function stops the configuration policy for the EFI IPv4 Protocol driver. 
+  All configuration data will be lost after calling Stop().
+
+  @param  This                   The pointer to the EFI_IP4_CONFIG_PROTOCOL instance.
+
+  @retval EFI_SUCCESS            The configuration policy for the EFI IPv4 Protocol 
+                                 driver has been stopped.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_STARTED        The configuration policy for the EFI IPv4 Protocol 
+                                 driver was not started.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG_STOP)(
+  IN EFI_IP4_CONFIG_PROTOCOL   *This
+  );
+
+/**
+  Returns the default configuration data (if any) for the EFI IPv4 Protocol driver.
+
+  The GetData() function returns the current configuration data for the EFI IPv4 
+  Protocol driver after the configuration policy has completed.
+  
+  @param  This                   The pointer to the EFI_IP4_CONFIG_PROTOCOL instance.
+  @param  IpConfigDataSize       On input, the size of the IpConfigData buffer. 
+                                 On output, the count of bytes that were written 
+                                 into the IpConfigData buffer.
+  @param  IpConfigData           The pointer to the EFI IPv4 Configuration Protocol 
+                                 driver configuration data structure. 
+                                 Type EFI_IP4_IPCONFIG_DATA is defined in 
+                                 "Related Definitions" below.
+
+  @retval EFI_SUCCESS            The EFI IPv4 Protocol driver configuration has been returned.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_STARTED        The configuration policy for the EFI IPv4 Protocol 
+                                 driver is not running.
+  @retval EFI_NOT_READY EFI      IPv4 Protocol driver configuration is still running.
+  @retval EFI_ABORTED EFI        IPv4 Protocol driver configuration could not complete.
+  @retval EFI_BUFFER_TOO_SMALL   *IpConfigDataSize is smaller than the configuration 
+                                 data buffer or IpConfigData is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG_GET_DATA)(
+  IN EFI_IP4_CONFIG_PROTOCOL   *This,
+  IN OUT UINTN                 *IpConfigDataSize,
+  OUT EFI_IP4_IPCONFIG_DATA    *IpConfigData    OPTIONAL
+  );
+
+///
+/// The EFI_IP4_CONFIG_PROTOCOL driver performs platform-dependent and policy-dependent 
+/// configurations for the EFI IPv4 Protocol driver. 
+///
+struct _EFI_IP4_CONFIG_PROTOCOL {
+  EFI_IP4_CONFIG_START         Start;
+  EFI_IP4_CONFIG_STOP          Stop;
+  EFI_IP4_CONFIG_GET_DATA      GetData;
+};
+
+extern EFI_GUID gEfiIp4ConfigProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Ip4Config2.h b/MdePkg/Include/Protocol/Ip4Config2.h
new file mode 100644
index 000000000000..5eed0cbc1342
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ip4Config2.h
@@ -0,0 +1,318 @@
+/** @file
+  This file provides a definition of the EFI IPv4 Configuration II
+  Protocol.
+
+Copyright (c) 2015 - 2016, 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<BR>
+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.
+
+@par Revision Reference:
+This Protocol is introduced in UEFI Specification 2.5
+
+**/
+#ifndef __EFI_IP4CONFIG2_PROTOCOL_H__
+#define __EFI_IP4CONFIG2_PROTOCOL_H__
+
+#include <Protocol/Ip4.h>
+
+#define EFI_IP4_CONFIG2_PROTOCOL_GUID \
+  { \
+    0x5b446ed1, 0xe30b, 0x4faa, {0x87, 0x1a, 0x36, 0x54, 0xec, 0xa3, 0x60, 0x80 } \
+  }
+
+typedef struct _EFI_IP4_CONFIG2_PROTOCOL EFI_IP4_CONFIG2_PROTOCOL;
+
+
+///
+/// EFI_IP4_CONFIG2_DATA_TYPE
+///
+typedef enum {
+  ///
+  /// The interface information of the communication device this EFI 
+  /// IPv4 Configuration II Protocol instance manages. This type of 
+  /// data is read only. The corresponding Data is of type 
+  /// EFI_IP4_CONFIG2_INTERFACE_INFO.
+  ///
+  Ip4Config2DataTypeInterfaceInfo,
+  ///
+  /// The general configuration policy for the EFI IPv4 network stack 
+  /// running on the communication device this EFI IPv4 
+  /// Configuration II Protocol instance manages. The policy will 
+  /// affect other configuration settings. The corresponding Data is of 
+  /// type EFI_IP4_CONFIG2_POLICY.
+  ///
+  Ip4Config2DataTypePolicy,
+  ///
+  /// The station addresses set manually for the EFI IPv4 network 
+  /// stack. It is only configurable when the policy is 
+  /// Ip4Config2PolicyStatic. The corresponding Data is of 
+  /// type EFI_IP4_CONFIG2_MANUAL_ADDRESS.
+  ///
+  Ip4Config2DataTypeManualAddress,
+  ///
+  /// The gateway addresses set manually for the EFI IPv4 network 
+  /// stack running on the communication device this EFI IPv4 
+  /// Configuration II Protocol manages. It is not configurable when 
+  /// the policy is Ip4Config2PolicyDhcp. The gateway 
+  /// addresses must be unicast IPv4 addresses. The corresponding 
+  /// Data is a pointer to an array of EFI_IPv4_ADDRESS instances.
+  ///
+  Ip4Config2DataTypeGateway,
+  ///
+  /// The DNS server list for the EFI IPv4 network stack running on 
+  /// the communication device this EFI IPv4 Configuration II 
+  /// Protocol manages. It is not configurable when the policy is 
+  /// Ip4Config2PolicyDhcp. The DNS server addresses must be 
+  /// unicast IPv4 addresses. The corresponding Data is a pointer to 
+  /// an array of EFI_IPv4_ADDRESS instances.
+  ///
+  Ip4Config2DataTypeDnsServer,
+  Ip4Config2DataTypeMaximum
+} EFI_IP4_CONFIG2_DATA_TYPE;
+
+///
+/// EFI_IP4_CONFIG2_INTERFACE_INFO related definitions
+///
+#define EFI_IP4_CONFIG2_INTERFACE_INFO_NAME_SIZE 32
+
+///
+/// EFI_IP4_CONFIG2_INTERFACE_INFO
+///
+typedef struct {
+  ///
+  /// The name of the interface. It is a NULL-terminated Unicode string.
+  ///
+  CHAR16                Name[EFI_IP4_CONFIG2_INTERFACE_INFO_NAME_SIZE];
+  ///
+  /// The interface type of the network interface. See RFC 1700, 
+  /// section "Number Hardware Type".
+  ///
+  UINT8                 IfType;
+  ///
+  /// The size, in bytes, of the network interface's hardware address.
+  ///
+  UINT32                HwAddressSize;
+  ///
+  /// The hardware address for the network interface.
+  ///
+  EFI_MAC_ADDRESS       HwAddress;
+  ///
+  /// The station IPv4 address of this EFI IPv4 network stack.
+  ///
+  EFI_IPv4_ADDRESS      StationAddress;
+  ///
+  /// The subnet address mask that is associated with the station address.
+  ///
+  EFI_IPv4_ADDRESS      SubnetMask;
+  ///
+  /// Size of the following RouteTable, in bytes. May be zero.
+  ///
+  UINT32                RouteTableSize;
+  ///
+  /// The route table of the IPv4 network stack runs on this interface. 
+  /// Set to NULL if RouteTableSize is zero. Type EFI_IP4_ROUTE_TABLE is defined in 
+  /// EFI_IP4_PROTOCOL.GetModeData().
+  ///
+  EFI_IP4_ROUTE_TABLE   *RouteTable     OPTIONAL;
+} EFI_IP4_CONFIG2_INTERFACE_INFO;
+
+///
+/// EFI_IP4_CONFIG2_POLICY
+///
+typedef enum {
+  ///
+  /// Under this policy, the Ip4Config2DataTypeManualAddress, 
+  /// Ip4Config2DataTypeGateway and Ip4Config2DataTypeDnsServer configuration 
+  /// data are required to be set manually. The EFI IPv4 Protocol will get all 
+  /// required configuration such as IPv4 address, subnet mask and 
+  /// gateway settings from the EFI IPv4 Configuration II protocol.
+  ///
+  Ip4Config2PolicyStatic,
+  ///
+  /// Under this policy, the Ip4Config2DataTypeManualAddress, 
+  /// Ip4Config2DataTypeGateway and Ip4Config2DataTypeDnsServer configuration data are 
+  /// not allowed to set via SetData(). All of these configurations are retrieved from DHCP 
+  /// server or other auto-configuration mechanism.
+  ///
+  Ip4Config2PolicyDhcp,
+  Ip4Config2PolicyMax
+} EFI_IP4_CONFIG2_POLICY;
+
+///
+/// EFI_IP4_CONFIG2_MANUAL_ADDRESS
+///
+typedef struct {
+  ///  
+  /// The IPv4 unicast address.
+  ///
+  EFI_IPv4_ADDRESS        Address;
+  ///
+  /// The subnet mask. 
+  ///
+  EFI_IPv4_ADDRESS        SubnetMask;
+} EFI_IP4_CONFIG2_MANUAL_ADDRESS;
+
+/**
+  Set the configuration for the EFI IPv4 network stack running on the communication device this EFI 
+  IPv4 Configuration II Protocol instance manages.
+
+  This function is used to set the configuration data of type DataType for the EFI IPv4 network stack 
+  running on the communication device this EFI IPv4 Configuration II Protocol instance manages.
+  The successfully configured data is valid after system reset or power-off.
+  The DataSize is used to calculate the count of structure instances in the Data for some 
+  DataType that multiple structure instances are allowed.
+  This function is always non-blocking. When setting some typeof configuration data, an 
+  asynchronous process is invoked to check the correctness of the data, such as doing address conflict 
+  detection on the manually set local IPv4 address. EFI_NOT_READY is returned immediately to 
+  indicate that such an asynchronous process is invoked and the process is not finished yet. The caller 
+  willing to get the result of the asynchronous process is required to call RegisterDataNotify()
+  to register an event on the specified configuration data. Once the event is signaled, the caller can call 
+  GetData()to get back the configuration data in order to know the result. For other types of 
+  configuration data that do not require an asynchronous configuration process, the result of the 
+  operation is immediately returned. 
+
+  @param[in]   This               Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.       
+  @param[in]   DataType           The type of data to set.
+  @param[in]   DataSize           Size of the buffer pointed to by Data in bytes.
+  @param[in]   Data               The data buffer to set. The type ofthe data buffer is associated 
+                                  with the DataType. 
+
+  @retval EFI_SUCCESS             The specified configuration data for the EFI IPv4 network stack is set 
+                                  successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following are TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  One or more fields in Data do not match the requirement of the data type 
+                                  indicated by DataType.
+  @retval EFI_WRITE_PROTECTED     The specified configuration data is read-only or the specified configuration 
+                                  data can not be set under the current policy.
+  @retval EFI_ACCESS_DENIED       Another set operation on the specified configuration data is already in process.
+  @retval EFI_NOT_READY           An asynchronous process is invoked to set the specified configuration data and 
+                                  the process is not finished yet.
+  @retval EFI_BAD_BUFFER_SIZE     The DataSize does not match the size of the type indicated by DataType.                                 
+  @retval EFI_UNSUPPORTED         This DataType is not supported.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR        An unexpected system error or network error occurred.
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG2_SET_DATA) (
+  IN EFI_IP4_CONFIG2_PROTOCOL   *This,
+  IN EFI_IP4_CONFIG2_DATA_TYPE  DataType,
+  IN UINTN                      DataSize,
+  IN VOID                       *Data
+  );
+
+/**
+  Get the configuration data for the EFI IPv4 network stack running on the communication device this 
+  EFI IPv4 Configuration II Protocol instance manages.
+
+  This function returns the configuration data of type DataType for the EFI IPv4 network stack 
+  running on the communication device this EFI IPv4 Configuration II Protocol instance manages.
+  The caller is responsible for allocating the buffer usedto return the specified configuration data and 
+  the required size will be returned to the caller if the size of the buffer is too small.
+  EFI_NOT_READY is returned if the specified configuration data is not ready due to an already in 
+  progress asynchronous configuration process. The caller can call RegisterDataNotify() to 
+  register an event on the specified configuration data. Once the asynchronous configuration process is 
+  finished, the event will be signaled and a subsequent GetData() call will return the specified 
+  configuration data.
+
+  @param[in]   This               Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.       
+  @param[in]   DataType           The type of data to get.
+  @param[out]  DataSize           On input, in bytes, the size of Data. On output, in bytes, the size 
+                                  of buffer required to store the specified configuration data. 
+  @param[in]   Data               The data buffer in which the configuration data is returned. The 
+                                  type of the data buffer is associated with the DataType. Ignored 
+                                  if DataSize is 0.  
+
+  @retval EFI_SUCCESS             The specified configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the followings are TRUE:
+                                  This is NULL.
+                                  DataSize is NULL.
+                                  Data is NULL if *DataSizeis not zero.
+  @retval EFI_BUFFER_TOO_SMALL    The size of Data is too small for the specified configuration data 
+                                  and the required size is returned in DataSize.
+  @retval EFI_NOT_READY           The specified configuration data is not ready due to an already in 
+                                  progress asynchronous configuration process.
+  @retval EFI_NOT_FOUND           The specified configuration data is not found.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG2_GET_DATA) (
+  IN EFI_IP4_CONFIG2_PROTOCOL     *This,
+  IN EFI_IP4_CONFIG2_DATA_TYPE    DataType,
+  IN OUT UINTN                    *DataSize,
+  IN VOID                         *Data        OPTIONAL
+  );
+
+/**
+  Register an event that is to be signaled whenever a configuration process on the specified 
+  configuration data is done.
+
+  This function registers an event that is to be signaled whenever a configuration process on the 
+  specified configuration data is done. An event can be registered for different DataType
+  simultaneously and the caller is responsible for determining which type of configuration data causes 
+  the signaling of the event in such case.
+
+  @param[in]   This               Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.       
+  @param[in]   DataType           The type of data to unregister the event for.
+  @param[in]   Event              The event to register.
+
+  @retval EFI_SUCCESS             The notification event for the specified configuration data is 
+                                  registered.
+  @retval EFI_INVALID_PARAMETER   This is NULL or Event is NULL.
+  @retval EFI_UNSUPPORTED         The configuration data type specified by DataType is not supported.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+  @retval EFI_ACCESS_DENIED       The Event is already registered for the DataType.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG2_REGISTER_NOTIFY) (
+  IN EFI_IP4_CONFIG2_PROTOCOL     *This,
+  IN EFI_IP4_CONFIG2_DATA_TYPE    DataType,
+  IN EFI_EVENT                    Event
+  );
+
+/**
+  Remove a previously registered event for the specified configuration data.
+
+  This function removes a previously registeredevent for the specified configuration data.
+
+  @param[in]   This               Pointer to the EFI_IP4_CONFIG2_PROTOCOL instance.       
+  @param[in]   DataType           The type of data to remove the previously registered event for.
+  @param[in]   Event              The event to unregister.
+
+  @retval EFI_SUCCESS             The event registered for the specified configuration data is removed.
+  @retval EFI_INVALID_PARAMETER   This is NULL or Event is NULL.
+  @retval EFI_NOT_FOUND           The Eventhas not been registered for the specified DataType.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIG2_UNREGISTER_NOTIFY) (
+  IN EFI_IP4_CONFIG2_PROTOCOL     *This,
+  IN EFI_IP4_CONFIG2_DATA_TYPE    DataType,
+  IN EFI_EVENT                    Event
+  );
+
+///
+/// The EFI_IP4_CONFIG2_PROTOCOL is designed to be the central repository for the common 
+/// configurations and the administrator configurable settings for the EFI IPv4 network stack.
+/// An EFI IPv4 Configuration II Protocol instance will be installed on each communication device that 
+/// the EFI IPv4 network stack runs on.
+///
+struct _EFI_IP4_CONFIG2_PROTOCOL {
+  EFI_IP4_CONFIG2_SET_DATA           SetData;
+  EFI_IP4_CONFIG2_GET_DATA           GetData;
+  EFI_IP4_CONFIG2_REGISTER_NOTIFY    RegisterDataNotify;
+  EFI_IP4_CONFIG2_UNREGISTER_NOTIFY  UnregisterDataNotify;
+};
+
+extern EFI_GUID gEfiIp4Config2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Ip6.h b/MdePkg/Include/Protocol/Ip6.h
new file mode 100644
index 000000000000..1598f8250a87
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ip6.h
@@ -0,0 +1,953 @@
+/** @file
+  This file defines the EFI IPv6 (Internet Protocol version 6)
+  Protocol interface. It is split into the following three main
+  sections:
+  - EFI IPv6 Service Binding Protocol
+  - EFI IPv6 Variable (deprecated in UEFI 2.4B)
+  - EFI IPv6 Protocol
+  The EFI IPv6 Protocol provides basic network IPv6 packet I/O services,
+  which includes support for Neighbor Discovery Protocol (ND), Multicast
+  Listener Discovery Protocol (MLD), and a subset of the Internet Control
+  Message Protocol (ICMPv6).
+
+  Copyright (c) 2008 - 2014, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_IP6_PROTOCOL_H__
+#define __EFI_IP6_PROTOCOL_H__
+
+#include <Protocol/ManagedNetwork.h>
+
+
+#define EFI_IP6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xec835dd3, 0xfe0f, 0x617b, {0xa6, 0x21, 0xb3, 0x50, 0xc3, 0xe1, 0x33, 0x88 } \
+  }
+
+#define EFI_IP6_PROTOCOL_GUID \
+  { \
+    0x2c8759d5, 0x5c2d, 0x66ef, {0x92, 0x5f, 0xb6, 0x6c, 0x10, 0x19, 0x57, 0xe2 } \
+  }
+
+typedef struct _EFI_IP6_PROTOCOL EFI_IP6_PROTOCOL;
+
+///
+/// EFI_IP6_ADDRESS_PAIR is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct{
+  ///
+  /// The EFI IPv6 Protocol instance handle that is using this address/prefix pair.
+  ///
+  EFI_HANDLE          InstanceHandle;
+  ///
+  /// IPv6 address in network byte order.
+  ///
+  EFI_IPv6_ADDRESS    Ip6Address;
+  ///
+  /// The length of the prefix associated with the Ip6Address.
+  ///
+  UINT8               PrefixLength;
+} EFI_IP6_ADDRESS_PAIR;
+
+///
+/// EFI_IP6_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  ///
+  /// The handle of the driver that creates this entry.
+  ///
+  EFI_HANDLE              DriverHandle;
+  ///
+  /// The number of IPv6 address pairs that follow this data structure.
+  ///
+  UINT32                  AddressCount;
+  ///
+  /// List of IPv6 address pairs that are currently in use.
+  ///
+  EFI_IP6_ADDRESS_PAIR    AddressPairs[1];
+} EFI_IP6_VARIABLE_DATA;
+
+///
+/// ICMPv6 type definitions for error messages
+///
+///@{
+#define ICMP_V6_DEST_UNREACHABLE                 0x1
+#define ICMP_V6_PACKET_TOO_BIG                   0x2
+#define ICMP_V6_TIME_EXCEEDED                    0x3
+#define ICMP_V6_PARAMETER_PROBLEM                0x4
+///@}
+
+///
+/// ICMPv6 type definition for informational messages
+///
+///@{
+#define ICMP_V6_ECHO_REQUEST                     0x80
+#define ICMP_V6_ECHO_REPLY                       0x81
+#define ICMP_V6_LISTENER_QUERY                   0x82
+#define ICMP_V6_LISTENER_REPORT                  0x83
+#define ICMP_V6_LISTENER_DONE                    0x84
+#define ICMP_V6_ROUTER_SOLICIT                   0x85
+#define ICMP_V6_ROUTER_ADVERTISE                 0x86
+#define ICMP_V6_NEIGHBOR_SOLICIT                 0x87
+#define ICMP_V6_NEIGHBOR_ADVERTISE               0x88
+#define ICMP_V6_REDIRECT                         0x89
+#define ICMP_V6_LISTENER_REPORT_2                0x8F
+///@}
+
+///
+/// ICMPv6 code definitions for ICMP_V6_DEST_UNREACHABLE
+///
+///@{
+#define ICMP_V6_NO_ROUTE_TO_DEST                 0x0
+#define ICMP_V6_COMM_PROHIBITED                  0x1
+#define ICMP_V6_BEYOND_SCOPE                     0x2
+#define ICMP_V6_ADDR_UNREACHABLE                 0x3
+#define ICMP_V6_PORT_UNREACHABLE                 0x4
+#define ICMP_V6_SOURCE_ADDR_FAILED               0x5
+#define ICMP_V6_ROUTE_REJECTED                   0x6
+///@}
+
+///
+/// ICMPv6 code definitions for ICMP_V6_TIME_EXCEEDED
+///
+///@{
+#define ICMP_V6_TIMEOUT_HOP_LIMIT                0x0
+#define ICMP_V6_TIMEOUT_REASSEMBLE               0x1
+///@}
+
+///
+/// ICMPv6 code definitions for ICMP_V6_PARAMETER_PROBLEM
+///
+///@{
+#define ICMP_V6_ERRONEOUS_HEADER                 0x0
+#define ICMP_V6_UNRECOGNIZE_NEXT_HDR             0x1
+#define ICMP_V6_UNRECOGNIZE_OPTION               0x2
+///@}
+
+///
+/// EFI_IP6_CONFIG_DATA
+/// is used to report and change IPv6 session parameters.
+///
+typedef struct {
+  ///
+  /// For the IPv6 packet to send and receive, this is the default value
+  /// of the 'Next Header' field in the last IPv6 extension header or in
+  /// the IPv6 header if there are no extension headers. Ignored when
+  /// AcceptPromiscuous is TRUE.
+  ///
+  UINT8                   DefaultProtocol;
+  ///
+  /// Set to TRUE to receive all IPv6 packets that get through the
+  /// receive filters.
+  /// Set to FALSE to receive only the DefaultProtocol IPv6
+  /// packets that get through the receive filters. Ignored when
+  /// AcceptPromiscuous is TRUE.
+  ///
+  BOOLEAN                 AcceptAnyProtocol;
+  ///
+  /// Set to TRUE to receive ICMP error report packets. Ignored when
+  /// AcceptPromiscuous or AcceptAnyProtocol is TRUE.
+  ///
+  BOOLEAN                 AcceptIcmpErrors;
+  ///
+  /// Set to TRUE to receive all IPv6 packets that are sent to any
+  /// hardware address or any protocol address. Set to FALSE to stop
+  /// receiving all promiscuous IPv6 packets.
+  ///
+  BOOLEAN                 AcceptPromiscuous;
+  ///
+  /// The destination address of the packets that will be transmitted.
+  /// Ignored if it is unspecified.
+  ///
+  EFI_IPv6_ADDRESS        DestinationAddress;
+  ///
+  /// The station IPv6 address that will be assigned to this EFI IPv6
+  /// Protocol instance. This field can be set and changed only when
+  /// the EFI IPv6 driver is transitioning from the stopped to the started
+  /// states. If the StationAddress is specified, the EFI IPv6 Protocol
+  /// driver will deliver only incoming IPv6 packets whose destination
+  /// matches this IPv6 address exactly. The StationAddress is required
+  /// to be one of currently configured IPv6 addresses. An address
+  /// containing all zeroes is also accepted as a special case. Under this
+  /// situation, the IPv6 driver is responsible for binding a source
+  /// address to this EFI IPv6 protocol instance according to the source
+  /// address selection algorithm. Only incoming packets destined to
+  /// the selected address will be delivered to the user.  And the
+  /// selected station address can be retrieved through later
+  /// GetModeData() call. If no address is available for selecting,
+  /// EFI_NO_MAPPING will be returned, and the station address will
+  /// only be successfully bound to this EFI IPv6 protocol instance
+  /// after IP6ModeData.IsConfigured changed to TRUE.
+  ///
+  EFI_IPv6_ADDRESS        StationAddress;
+  ///
+  /// TrafficClass field in transmitted IPv6 packets. Default value
+  /// is zero.
+  ///
+  UINT8                   TrafficClass;
+  ///
+  /// HopLimit field in transmitted IPv6 packets.
+  ///
+  UINT8                   HopLimit;
+  ///
+  /// FlowLabel field in transmitted IPv6 packets. Default value is
+  /// zero.
+  ///
+  UINT32                  FlowLabel;
+  ///
+  /// The timer timeout value (number of microseconds) for the
+  /// receive timeout event to be associated with each assembled
+  /// packet. Zero means do not drop assembled packets.
+  ///
+  UINT32                  ReceiveTimeout;
+  ///
+  /// The timer timeout value (number of microseconds) for the
+  /// transmit timeout event to be associated with each outgoing
+  /// packet. Zero means do not drop outgoing packets.
+  ///
+  UINT32                  TransmitTimeout;
+} EFI_IP6_CONFIG_DATA;
+
+///
+/// EFI_IP6_ADDRESS_INFO
+///
+typedef struct {
+  EFI_IPv6_ADDRESS        Address;       ///< The IPv6 address.
+  UINT8                   PrefixLength;  ///< The length of the prefix associated with the Address.
+} EFI_IP6_ADDRESS_INFO;
+
+///
+/// EFI_IP6_ROUTE_TABLE
+/// is the entry structure that is used in routing tables
+///
+typedef struct {
+  ///
+  /// The IPv6 address of the gateway to be used as the next hop for
+  /// packets to this prefix. If the IPv6 address is all zeros, then the
+  /// prefix is on-link.
+  ///
+  EFI_IPv6_ADDRESS        Gateway;
+  ///
+  /// The destination prefix to be routed.
+  ///
+  EFI_IPv6_ADDRESS        Destination;
+  ///
+  /// The length of the prefix associated with the Destination.
+  ///
+  UINT8                   PrefixLength;
+} EFI_IP6_ROUTE_TABLE;
+
+///
+/// EFI_IP6_NEIGHBOR_STATE
+///
+typedef enum {
+  ///
+  /// Address resolution is being performed on this entry. Specially,
+  /// Neighbor Solicitation has been sent to the solicited-node
+  /// multicast address of the target, but corresponding Neighbor
+  /// Advertisement has not been received.
+  ///
+  EfiNeighborInComplete,
+  ///
+  /// Positive confirmation was received that the forward path to the
+  /// neighbor was functioning properly.
+  ///
+  EfiNeighborReachable,
+  ///
+  ///Reachable Time has elapsed since the last positive confirmation
+  ///was received. In this state, the forward path to the neighbor was
+  ///functioning properly.
+  ///
+  EfiNeighborStale,
+  ///
+  /// This state is an optimization that gives upper-layer protocols
+  /// additional time to provide reachability confirmation.
+  ///
+  EfiNeighborDelay,
+  ///
+  /// A reachability confirmation is actively sought by retransmitting
+  /// Neighbor Solicitations every RetransTimer milliseconds until a
+  /// reachability confirmation is received.
+  ///
+  EfiNeighborProbe
+} EFI_IP6_NEIGHBOR_STATE;
+
+///
+/// EFI_IP6_NEIGHBOR_CACHE
+/// is the entry structure that is used in neighbor cache. It records a set
+/// of entries about individual neighbors to which traffic has been sent recently.
+///
+typedef struct {
+  EFI_IPv6_ADDRESS        Neighbor;    ///< The on-link unicast/anycast IP address of the neighbor.
+  EFI_MAC_ADDRESS         LinkAddress; ///< Link-layer address of the neighbor.
+  EFI_IP6_NEIGHBOR_STATE  State;       ///< State of this neighbor cache entry.
+} EFI_IP6_NEIGHBOR_CACHE;
+
+///
+/// EFI_IP6_ICMP_TYPE
+/// is used to describe those ICMP messages that are supported by this EFI
+/// IPv6 Protocol driver.
+///
+typedef struct {
+  UINT8                   Type;   ///< The type of ICMP message.
+  UINT8                   Code;   ///< The code of the ICMP message.
+} EFI_IP6_ICMP_TYPE;
+
+///
+/// EFI_IP6_MODE_DATA
+///
+typedef struct {
+  ///
+  /// Set to TRUE after this EFI IPv6 Protocol instance is started.
+  /// All other fields in this structure are undefined until this field is TRUE.
+  /// Set to FALSE when the EFI IPv6 Protocol instance is stopped.
+  ///
+  BOOLEAN                 IsStarted;
+  ///
+  /// The maximum packet size, in bytes, of the packet which the upper layer driver could feed.
+  ///
+  UINT32                  MaxPacketSize;
+  ///
+  /// Current configuration settings. Undefined until IsStarted is TRUE.
+  ///
+  EFI_IP6_CONFIG_DATA     ConfigData;
+  ///
+  /// Set to TRUE when the EFI IPv6 Protocol instance is configured.
+  /// The instance is configured when it has a station address and
+  /// corresponding prefix length.
+  /// Set to FALSE when the EFI IPv6 Protocol instance is not configured.
+  ///
+  BOOLEAN                 IsConfigured;
+  ///
+  /// Number of configured IPv6 addresses on this interface.
+  ///
+  UINT32                  AddressCount;
+  ///
+  /// List of currently configured IPv6 addresses and corresponding
+  /// prefix lengths assigned to this interface. It is caller's
+  /// responsibility to free this buffer.
+  ///
+  EFI_IP6_ADDRESS_INFO    *AddressList;
+  ///
+  /// Number of joined multicast groups. Undefined until
+  /// IsConfigured is TRUE.
+  ///
+  UINT32                  GroupCount;
+  ///
+  /// List of joined multicast group addresses. It is caller's
+  /// responsibility to free this buffer. Undefined until
+  /// IsConfigured is TRUE.
+  ///
+  EFI_IPv6_ADDRESS        *GroupTable;
+  ///
+  /// Number of entries in the routing table. Undefined until
+  /// IsConfigured is TRUE.
+  ///
+  UINT32                  RouteCount;
+  ///
+  /// Routing table entries. It is caller's responsibility to free this buffer.
+  ///
+  EFI_IP6_ROUTE_TABLE     *RouteTable;
+  ///
+  /// Number of entries in the neighbor cache. Undefined until
+  /// IsConfigured is TRUE.
+  ///
+  UINT32                  NeighborCount;
+  ///
+  /// Neighbor cache entries. It is caller's responsibility to free this
+  /// buffer. Undefined until IsConfigured is TRUE.
+  ///
+  EFI_IP6_NEIGHBOR_CACHE  *NeighborCache;
+  ///
+  /// Number of entries in the prefix table. Undefined until
+  /// IsConfigured is TRUE.
+  ///
+  UINT32                  PrefixCount;
+  ///
+  /// On-link Prefix table entries. It is caller's responsibility to free this
+  /// buffer. Undefined until IsConfigured is TRUE.
+  ///
+  EFI_IP6_ADDRESS_INFO    *PrefixTable;
+  ///
+  /// Number of entries in the supported ICMP types list.
+  ///
+  UINT32                  IcmpTypeCount;
+  ///
+  /// Array of ICMP types and codes that are supported by this EFI
+  /// IPv6 Protocol driver. It is caller's responsibility to free this
+  /// buffer.
+  ///
+  EFI_IP6_ICMP_TYPE       *IcmpTypeList;
+} EFI_IP6_MODE_DATA;
+
+///
+/// EFI_IP6_HEADER
+/// The fields in the IPv6 header structure are defined in the Internet
+/// Protocol version6 specification.
+///
+#pragma pack(1)
+typedef struct _EFI_IP6_HEADER {
+  UINT8                   TrafficClassH:4;
+  UINT8                   Version:4;
+  UINT8                   FlowLabelH:4;
+  UINT8                   TrafficClassL:4;
+  UINT16                  FlowLabelL;
+  UINT16                  PayloadLength;
+  UINT8                   NextHeader;
+  UINT8                   HopLimit;
+  EFI_IPv6_ADDRESS        SourceAddress;
+  EFI_IPv6_ADDRESS        DestinationAddress;
+} EFI_IP6_HEADER;
+#pragma pack()
+
+///
+/// EFI_IP6_FRAGMENT_DATA
+/// describes the location and length of the IPv6 packet
+/// fragment to transmit or that has been received.
+///
+typedef struct _EFI_IP6_FRAGMENT_DATA {
+  UINT32                  FragmentLength;  ///< Length of fragment data. This field may not be set to zero.
+  VOID                    *FragmentBuffer; ///< Pointer to fragment data. This field may not be set to NULL.
+} EFI_IP6_FRAGMENT_DATA;
+
+///
+/// EFI_IP6_RECEIVE_DATA
+///
+typedef struct _EFI_IP6_RECEIVE_DATA {
+  ///
+  /// Time when the EFI IPv6 Protocol driver accepted the packet.
+  /// Ignored if it is zero.
+  ///
+  EFI_TIME                TimeStamp;
+  ///
+  /// After this event is signaled, the receive data structure is released
+  /// and must not be referenced.
+  ///
+  EFI_EVENT               RecycleSignal;
+  ///
+  ///Length of the IPv6 packet headers, including both the IPv6
+  ///header and any extension headers.
+  ///
+  UINT32                  HeaderLength;
+  ///
+  /// Pointer to the IPv6 packet header. If the IPv6 packet was
+  /// fragmented, this argument is a pointer to the header in the first
+  /// fragment.
+  ///
+  EFI_IP6_HEADER          *Header;
+  ///
+  /// Sum of the lengths of IPv6 packet buffers in FragmentTable. May
+  /// be zero.
+  ///
+  UINT32                  DataLength;
+  ///
+  /// Number of IPv6 payload fragments. May be zero.
+  ///
+  UINT32                  FragmentCount;
+  ///
+  /// Array of payload fragment lengths and buffer pointers.
+  ///
+  EFI_IP6_FRAGMENT_DATA   FragmentTable[1];
+} EFI_IP6_RECEIVE_DATA;
+
+///
+/// EFI_IP6_OVERRIDE_DATA
+/// The information and flags in the override data structure will override
+/// default parameters or settings for one Transmit() function call.
+///
+typedef struct _EFI_IP6_OVERRIDE_DATA {
+  UINT8                   Protocol;   ///< Protocol type override.
+  UINT8                   HopLimit;   ///< Hop-Limit override.
+  UINT32                  FlowLabel;  ///< Flow-Label override.
+} EFI_IP6_OVERRIDE_DATA;
+
+///
+/// EFI_IP6_TRANSMIT_DATA
+///
+typedef struct _EFI_IP6_TRANSMIT_DATA {
+  ///
+  /// The destination IPv6 address.  If it is unspecified,
+  /// ConfigData.DestinationAddress will be used instead.
+  ///
+  EFI_IPv6_ADDRESS        DestinationAddress;
+  ///
+  /// If not NULL, the IPv6 transmission control override data.
+  ///
+  EFI_IP6_OVERRIDE_DATA   *OverrideData;
+  ///
+  /// Total length in byte of the IPv6 extension headers specified in
+  /// ExtHdrs.
+  ///
+  UINT32                  ExtHdrsLength;
+  ///
+  /// Pointer to the IPv6 extension headers. The IP layer will append
+  /// the required extension headers if they are not specified by
+  /// ExtHdrs. Ignored if ExtHdrsLength is zero.
+  ///
+  VOID                    *ExtHdrs;
+  ///
+  /// The protocol of first extension header in ExtHdrs. Ignored if
+  /// ExtHdrsLength is zero.
+  ///
+  UINT8                   NextHeader;
+  ///
+  /// Total length in bytes of the FragmentTable data to transmit.
+  ///
+  UINT32                  DataLength;
+  ///
+  /// Number of entries in the fragment data table.
+  ///
+  UINT32                  FragmentCount;
+  ///
+  /// Start of the fragment data table.
+  ///
+  EFI_IP6_FRAGMENT_DATA   FragmentTable[1];
+} EFI_IP6_TRANSMIT_DATA;
+
+///
+/// EFI_IP6_COMPLETION_TOKEN
+/// structures are used for both transmit and receive operations.
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by
+  /// the EFI IPv6 Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT               Event;
+  ///
+  /// Will be set to one of the following values:
+  /// - EFI_SUCCESS:  The receive or transmit completed
+  ///   successfully.
+  /// - EFI_ABORTED:  The receive or transmit was aborted
+  /// - EFI_TIMEOUT:  The transmit timeout expired.
+  /// - EFI_ICMP_ERROR:  An ICMP error packet was received.
+  /// - EFI_DEVICE_ERROR:  An unexpected system or network
+  ///   error occurred.
+  /// - EFI_SECURITY_VIOLATION: The transmit or receive was
+  ///   failed because of an IPsec policy check.
+  /// - EFI_NO_MEDIA: There was a media error.
+  ///
+  EFI_STATUS              Status;
+  union {
+    ///
+    /// When the Token is used for receiving, RxData is a pointer to the EFI_IP6_RECEIVE_DATA.
+    ///
+    EFI_IP6_RECEIVE_DATA  *RxData;
+    ///
+    /// When the Token is used for transmitting, TxData is a pointer to the EFI_IP6_TRANSMIT_DATA.
+    ///
+    EFI_IP6_TRANSMIT_DATA *TxData;
+  } Packet;
+} EFI_IP6_COMPLETION_TOKEN;
+
+/**
+  Gets the current operational settings for this instance of the EFI IPv6 Protocol driver.
+
+  The GetModeData() function returns the current operational mode data for this driver instance.
+  The data fields in EFI_IP6_MODE_DATA are read only. This function is used optionally to
+  retrieve the operational mode data of underlying networks or drivers..
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[out] Ip6ModeData        Pointer to the EFI IPv6 Protocol mode data structure.
+  @param[out] MnpConfigData      Pointer to the managed network configuration data structure.
+  @param[out] SnpModeData        Pointer to the simple network mode data structure.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_OUT_OF_RESOURCES   The required mode data could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_GET_MODE_DATA)(
+  IN EFI_IP6_PROTOCOL                 *This,
+  OUT EFI_IP6_MODE_DATA               *Ip6ModeData     OPTIONAL,
+  OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData   OPTIONAL,
+  OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData     OPTIONAL
+  );
+
+/**
+  Assigns an IPv6 address and subnet mask to this EFI IPv6 Protocol driver instance.
+
+  The Configure() function is used to set, change, or reset the operational parameters and filter
+  settings for this EFI IPv6 Protocol instance. Until these parameters have been set, no network traffic
+  can be sent or received by this instance. Once the parameters have been reset (by calling this
+  function with Ip6ConfigData set to NULL), no more traffic can be sent or received until these
+  parameters have been set again. Each EFI IPv6 Protocol instance can be started and stopped
+  independently of each other by enabling or disabling their receive filter settings with the
+  Configure() function.
+
+  If Ip6ConfigData.StationAddress is a valid non-zero IPv6 unicast address, it is required
+  to be one of the currently configured IPv6 addresses list in the EFI IPv6 drivers, or else
+  EFI_INVALID_PARAMETER will be returned. If Ip6ConfigData.StationAddress is
+  unspecified, the IPv6 driver will bind a source address according to the source address selection
+  algorithm. Clients could frequently call GetModeData() to check get currently configured IPv6
+  address list in the EFI IPv6 driver. If both Ip6ConfigData.StationAddress and
+  Ip6ConfigData.Destination are unspecified, when transmitting the packet afterwards, the
+  source address filled in each outgoing IPv6 packet is decided based on the destination of this packet. .
+
+  If operational parameters are reset or changed, any pending transmit and receive requests will be
+  cancelled. Their completion token status will be set to EFI_ABORTED and their events will be
+  signaled.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  Ip6ConfigData      Pointer to the EFI IPv6 Protocol configuration data structure.
+
+  @retval EFI_SUCCESS            The driver instance was successfully opened.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - Ip6ConfigData.StationAddress is neither zero nor
+                                   a unicast IPv6 address.
+                                 - Ip6ConfigData.StationAddress is neither zero nor
+                                   one of the configured IP addresses in the EFI IPv6 driver.
+                                 - Ip6ConfigData.DefaultProtocol is illegal.
+  @retval EFI_OUT_OF_RESOURCES   The EFI IPv6 Protocol driver instance data could not be allocated.
+  @retval EFI_NO_MAPPING         The IPv6 driver was responsible for choosing a source address for
+                                 this instance, but no source address was available for use.
+  @retval EFI_ALREADY_STARTED    The interface is already open and must be stopped before the IPv6
+                                 address or prefix length can be changed.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred. The EFI IPv6
+                                 Protocol driver instance is not opened.
+  @retval EFI_UNSUPPORTED        Default protocol specified through
+                                 Ip6ConfigData.DefaulProtocol isn't supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIGURE)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN EFI_IP6_CONFIG_DATA         *Ip6ConfigData OPTIONAL
+  );
+
+/**
+  Joins and leaves multicast groups.
+
+  The Groups() function is used to join and leave multicast group sessions. Joining a group will
+  enable reception of matching multicast packets. Leaving a group will disable reception of matching
+  multicast packets. Source-Specific Multicast isn't required to be supported.
+
+  If JoinFlag is FALSE and GroupAddress is NULL, all joined groups will be left.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  JoinFlag           Set to TRUE to join the multicast group session and FALSE to leave.
+  @param[in]  GroupAddress       Pointer to the IPv6 multicast address.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  One or more of the following is TRUE:
+                                 - This is NULL.
+                                 - JoinFlag is TRUE and GroupAddress is NULL.
+                                 - GroupAddress is not NULL and *GroupAddress is
+                                   not a multicast IPv6 address.
+                                 - GroupAddress is not NULL and *GroupAddress is in the
+                                   range of SSM destination address.
+  @retval EFI_NOT_STARTED        This instance has not been started.
+  @retval EFI_OUT_OF_RESOURCES   System resources could not be allocated.
+  @retval EFI_UNSUPPORTED        This EFI IPv6 Protocol implementation does not support multicast groups.
+  @retval EFI_ALREADY_STARTED    The group address is already in the group table (when
+                                 JoinFlag is TRUE).
+  @retval EFI_NOT_FOUND          The group address is not in the group table (when JoinFlag is FALSE).
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_GROUPS)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN BOOLEAN                     JoinFlag,
+  IN EFI_IPv6_ADDRESS            *GroupAddress  OPTIONAL
+  );
+
+/**
+  Adds and deletes routing table entries.
+
+  The Routes() function adds a route to or deletes a route from the routing table.
+
+  Routes are determined by comparing the leftmost PrefixLength bits of Destination with
+  the destination IPv6 address arithmetically. The gateway address must be on the same subnet as the
+  configured station address.
+
+  The default route is added with Destination and PrefixLegth both set to all zeros. The
+  default route matches all destination IPv6 addresses that do not match any other routes.
+
+  All EFI IPv6 Protocol instances share a routing table.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  DeleteRoute        Set to TRUE to delete this route from the routing table. Set to
+                                 FALSE to add this route to the routing table. Destination,
+                                 PrefixLength and Gateway are used as the key to each
+                                 route entry.
+  @param[in]  Destination        The address prefix of the subnet that needs to be routed.
+  @param[in]  PrefixLength       The prefix length of Destination. Ignored if Destination
+                                 is NULL.
+  @param[in]  GatewayAddress     The unicast gateway IPv6 address for this route.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_NOT_STARTED        The driver instance has not been started.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - When DeleteRoute is TRUE, both Destination and
+                                   GatewayAddress are NULL.
+                                 - When DeleteRoute is FALSE, either Destination or
+                                   GatewayAddress is NULL.
+                                 - *GatewayAddress is not a valid unicast IPv6 address.
+                                 - *GatewayAddress is one of the local configured IPv6
+                                   addresses.
+  @retval EFI_OUT_OF_RESOURCES   Could not add the entry to the routing table.
+  @retval EFI_NOT_FOUND          This route is not in the routing table (when DeleteRoute is TRUE).
+  @retval EFI_ACCESS_DENIED      The route is already defined in the routing table (when
+                                 DeleteRoute is FALSE).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_ROUTES)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN BOOLEAN                     DeleteRoute,
+  IN EFI_IPv6_ADDRESS            *Destination OPTIONAL,
+  IN UINT8                       PrefixLength,
+  IN EFI_IPv6_ADDRESS            *GatewayAddress OPTIONAL
+  );
+
+/**
+  Add or delete Neighbor cache entries.
+
+  The Neighbors() function is used to add, update, or delete an entry from neighbor cache.
+  IPv6 neighbor cache entries are typically inserted and updated by the network protocol driver as
+  network traffic is processed. Most neighbor cache entries will time out and be deleted if the network
+  traffic stops. Neighbor cache entries that were inserted by Neighbors() may be static (will not
+  timeout) or dynamic (will time out).
+
+  The implementation should follow the neighbor cache timeout mechanism which is defined in
+  RFC4861. The default neighbor cache timeout value should be tuned for the expected network
+  environment
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  DeleteFlag         Set to TRUE to delete the specified cache entry, set to FALSE to
+                                 add (or update, if it already exists and Override is TRUE) the
+                                 specified cache entry. TargetIp6Address is used as the key
+                                 to find the requested cache entry.
+  @param[in]  TargetIp6Address   Pointer to Target IPv6 address.
+  @param[in]  TargetLinkAddress  Pointer to link-layer address of the target. Ignored if NULL.
+  @param[in]  Timeout            Time in 100-ns units that this entry will remain in the neighbor
+                                 cache, it will be deleted after Timeout. A value of zero means that
+                                 the entry is permanent. A non-zero value means that the entry is
+                                 dynamic.
+  @param[in]  Override           If TRUE, the cached link-layer address of the matching entry will
+                                 be overridden and updated; if FALSE, EFI_ACCESS_DENIED
+                                 will be returned if a corresponding cache entry already existed.
+
+  @retval  EFI_SUCCESS           The data has been queued for transmission.
+  @retval  EFI_NOT_STARTED       This instance has not been started.
+  @retval  EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - TargetIpAddress is NULL.
+                                 - *TargetLinkAddress is invalid when not NULL.
+                                 - *TargetIpAddress is not a valid unicast IPv6 address.
+                                 - *TargetIpAddress is one of the local configured IPv6
+                                   addresses.
+  @retval  EFI_OUT_OF_RESOURCES  Could not add the entry to the neighbor cache.
+  @retval  EFI_NOT_FOUND         This entry is not in the neighbor cache (when DeleteFlag  is
+                                 TRUE or when DeleteFlag  is FALSE while
+                                 TargetLinkAddress is NULL.).
+  @retval  EFI_ACCESS_DENIED     The to-be-added entry is already defined in the neighbor cache,
+                                 and that entry is tagged as un-overridden (when DeleteFlag
+                                 is FALSE).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_NEIGHBORS)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN BOOLEAN                     DeleteFlag,
+  IN EFI_IPv6_ADDRESS            *TargetIp6Address,
+  IN EFI_MAC_ADDRESS             *TargetLinkAddress,
+  IN UINT32                      Timeout,
+  IN BOOLEAN                     Override
+  );
+
+/**
+  Places outgoing data packets into the transmit queue.
+
+  The Transmit() function places a sending request in the transmit queue of this
+  EFI IPv6 Protocol instance. Whenever the packet in the token is sent out or some
+  errors occur, the event in the token will be signaled and the status is updated.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to the transmit token.
+
+  @retval  EFI_SUCCESS           The data has been queued for transmission.
+  @retval  EFI_NOT_STARTED       This instance has not been started.
+  @retval  EFI_NO_MAPPING        The IPv6 driver was responsible for choosing a source address for
+                                 this transmission, but no source address was available for use.
+  @retval  EFI_INVALID_PARAMETER One or more of the following is TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Event is NULL.
+                                 - Token.Packet.TxData is NULL.
+                                 - Token.Packet.ExtHdrsLength is not zero and Token.Packet.ExtHdrs is NULL.
+                                 - Token.Packet.FragmentCount is zero.
+                                 - One or more of the Token.Packet.TxData.FragmentTable[].FragmentLength fields is zero.
+                                 - One or more of the Token.Packet.TxData.FragmentTable[].FragmentBuffer fields is NULL.
+                                 - Token.Packet.TxData.DataLength is zero or not equal to the sum of fragment lengths.
+                                 - Token.Packet.TxData.DestinationAddress is non-zero when DestinationAddress is configured as
+                                   non-zero when doing Configure() for this EFI IPv6 protocol instance.
+                                 - Token.Packet.TxData.DestinationAddress is unspecified when DestinationAddress is unspecified
+                                   when doing Configure() for this EFI IPv6 protocol instance.
+  @retval  EFI_ACCESS_DENIED     The transmit completion token with the same Token.Event
+                                 was already in the transmit queue.
+  @retval  EFI_NOT_READY         The completion token could not be queued because the transmit
+                                 queue is full.
+  @retval  EFI_NOT_FOUND         Not route is found to destination address.
+  @retval  EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
+  @retval  EFI_BUFFER_TOO_SMALL  Token.Packet.TxData.TotalDataLength is too
+                                 short to transmit.
+  @retval  EFI_BAD_BUFFER_SIZE   If Token.Packet.TxData.DataLength is beyond the
+                                 maximum that which can be described through the Fragment Offset
+                                 field in Fragment header when performing fragmentation.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_TRANSMIT)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN EFI_IP6_COMPLETION_TOKEN    *Token
+  );
+
+/**
+  Places a receiving request into the receiving queue.
+
+  The Receive() function places a completion token into the receive packet queue.
+  This function is always asynchronous.
+
+  The Token.Event field in the completion token must be filled in by the caller
+  and cannot be NULL. When the receive operation completes, the EFI IPv6 Protocol
+  driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
+  is signaled.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to a token that is associated with the receive data descriptor.
+
+  @retval EFI_SUCCESS            The receive completion token was cached.
+  @retval EFI_NOT_STARTED        This EFI IPv6 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING         When IP6 driver responsible for binding source address to this instance,
+                                 while no source address is available for use.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES   The receive completion token could not be queued due to a lack of system
+                                 resources (usually memory).
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+                                 The EFI IPv6 Protocol instance has been reset to startup defaults.
+  @retval EFI_ACCESS_DENIED      The receive completion token with the same Token.Event was already
+                                 in the receive queue.
+  @retval EFI_NOT_READY          The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_RECEIVE)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN EFI_IP6_COMPLETION_TOKEN    *Token
+  );
+
+/**
+  Abort an asynchronous transmit or receive request.
+
+  The Cancel() function is used to abort a pending transmit or receive request.
+  If the token is in the transmit or receive request queues, after calling this
+  function, Token->Status will be set to EFI_ABORTED and then Token->Event will
+  be signaled. If the token is not in one of the queues, which usually means the
+  asynchronous operation has completed, this function will not signal the token
+  and EFI_NOT_FOUND is returned.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to a token that has been issued by
+                                 EFI_IP6_PROTOCOL.Transmit() or
+                                 EFI_IP6_PROTOCOL.Receive(). If NULL, all pending
+                                 tokens are aborted. Type EFI_IP6_COMPLETION_TOKEN is
+                                 defined in EFI_IP6_PROTOCOL.Transmit().
+
+  @retval EFI_SUCCESS            The asynchronous I/O request was aborted and
+                                 Token->Event was signaled. When Token is NULL, all
+                                 pending requests were aborted and their events were signaled.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_STARTED        This instance has not been started.
+  @retval EFI_NOT_FOUND          When Token is not NULL, the asynchronous I/O request was
+                                 not found in the transmit or receive queue. It has either completed
+                                 or was not issued by Transmit() and Receive().
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CANCEL)(
+  IN EFI_IP6_PROTOCOL            *This,
+  IN EFI_IP6_COMPLETION_TOKEN    *Token    OPTIONAL
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  The Poll() function polls for incoming data packets and processes outgoing data
+  packets. Network drivers and applications can call the EFI_IP6_PROTOCOL.Poll()
+  function to increase the rate that data packets are moved between the communications
+  device and the transmit and receive queues.
+
+  In some systems the periodic timer event may not poll the underlying communications
+  device fast enough to transmit and/or receive all data packets without missing
+  incoming packets or dropping outgoing packets. Drivers and applications that are
+  experiencing packet loss should try calling the EFI_IP6_PROTOCOL.Poll() function
+  more often.
+
+  @param[in]  This               Pointer to the EFI_IP6_PROTOCOL instance.
+
+  @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval  EFI_NOT_STARTED       This EFI IPv6 Protocol instance has not been started.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval  EFI_NOT_READY         No incoming or outgoing data is processed.
+  @retval  EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_POLL)(
+  IN EFI_IP6_PROTOCOL            *This
+  );
+
+///
+/// The EFI IPv6 Protocol implements a simple packet-oriented interface that can be
+/// used by drivers, daemons, and applications to transmit and receive network packets.
+///
+struct _EFI_IP6_PROTOCOL {
+  EFI_IP6_GET_MODE_DATA   GetModeData;
+  EFI_IP6_CONFIGURE       Configure;
+  EFI_IP6_GROUPS          Groups;
+  EFI_IP6_ROUTES          Routes;
+  EFI_IP6_NEIGHBORS       Neighbors;
+  EFI_IP6_TRANSMIT        Transmit;
+  EFI_IP6_RECEIVE         Receive;
+  EFI_IP6_CANCEL          Cancel;
+  EFI_IP6_POLL            Poll;
+};
+
+extern EFI_GUID gEfiIp6ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiIp6ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Ip6Config.h b/MdePkg/Include/Protocol/Ip6Config.h
new file mode 100644
index 000000000000..dd4facb897c5
--- /dev/null
+++ b/MdePkg/Include/Protocol/Ip6Config.h
@@ -0,0 +1,369 @@
+/** @file
+  This file provides a definition of the EFI IPv6 Configuration
+  Protocol.
+
+Copyright (c) 2008 - 2011, 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<BR>
+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_IP6CONFIG_PROTOCOL_H__
+#define __EFI_IP6CONFIG_PROTOCOL_H__
+
+#include <Protocol/Ip6.h>
+
+#define EFI_IP6_CONFIG_PROTOCOL_GUID \
+  { \
+    0x937fe521, 0x95ae, 0x4d1a, {0x89, 0x29, 0x48, 0xbc, 0xd9, 0x0a, 0xd3, 0x1a } \
+  }
+
+typedef struct _EFI_IP6_CONFIG_PROTOCOL EFI_IP6_CONFIG_PROTOCOL;
+
+///
+/// EFI_IP6_CONFIG_DATA_TYPE
+///
+typedef enum {         
+  /// 
+  /// The interface information of the communication 
+  /// device this EFI IPv6 Configuration Protocol instance manages. 
+  /// This type of data is read only.The corresponding Data is of type 
+  /// EFI_IP6_CONFIG_INTERFACE_INFO.
+  /// 
+  Ip6ConfigDataTypeInterfaceInfo,
+  /// 
+  /// The alternative interface ID for the 
+  /// communication device this EFI IPv6 Configuration Protocol 
+  /// instance manages if the link local IPv6 address generated from 
+  /// the interfaced ID based on the default source the EFI IPv6 
+  /// Protocol uses is a duplicate address. The length of the interface 
+  /// ID is 64 bit. The corresponding Data is of type 
+  /// EFI_IP6_CONFIG_INTERFACE_ID.
+  /// 
+  Ip6ConfigDataTypeAltInterfaceId,
+  /// 
+  /// The general configuration policy for the EFI IPv6 network 
+  /// stack running on the communication device this EFI IPv6 
+  /// Configuration Protocol instance manages. The policy will affect 
+  /// other configuration settings. The corresponding Data is of type 
+  /// EFI_IP6_CONFIG_POLICY.
+  ///
+  Ip6ConfigDataTypePolicy,
+  /// 
+  /// The number of consecutive 
+  /// Neighbor Solicitation messages sent while performing Duplicate 
+  /// Address Detection on a tentative address. A value of zero 
+  /// indicates that Duplicate Address Detection will not be performed 
+  /// on tentative addresses. The corresponding Data is of type 
+  /// EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS.
+  /// 
+  Ip6ConfigDataTypeDupAddrDetectTransmits,
+  /// 
+  /// The station addresses set manually for the EFI 
+  /// IPv6 network stack. It is only configurable when the policy is 
+  /// Ip6ConfigPolicyManual. The corresponding Data is a 
+  /// pointer to an array of EFI_IPv6_ADDRESS instances.
+  /// 
+  Ip6ConfigDataTypeManualAddress,
+  /// 
+  /// The gateway addresses set manually for the EFI IPv6 
+  /// network stack running on the communication device this EFI 
+  /// IPv6 Configuration Protocol manages. It is not configurable when 
+  /// the policy is Ip6ConfigPolicyAutomatic. The gateway 
+  /// addresses must be unicast IPv6 addresses. The corresponding 
+  /// Data is a pointer to an array of EFI_IPv6_ADDRESS instances.
+  /// 
+  Ip6ConfigDataTypeGateway,
+  /// 
+  /// The DNS server list for the EFI IPv6 network stack 
+  /// running on the communication device this EFI IPv6 
+  /// Configuration Protocol manages. It is not configurable when the 
+  /// policy is Ip6ConfigPolicyAutomatic.The DNS server 
+  /// addresses must be unicast IPv6 addresses. The corresponding 
+  /// Data is a pointer to an array of EFI_IPv6_ADDRESS instances.
+  /// 
+  Ip6ConfigDataTypeDnsServer,
+  ///
+  /// The number of this enumeration memebers.
+  ///
+  Ip6ConfigDataTypeMaximum
+} EFI_IP6_CONFIG_DATA_TYPE;
+
+///
+/// EFI_IP6_CONFIG_INTERFACE_INFO
+/// describes the operational state of the interface this 
+/// EFI IPv6 Configuration Protocol instance manages.
+///
+typedef struct {
+  ///
+  /// The name of the interface. It is a NULL-terminated string.
+  ///
+  CHAR16                Name[32];
+  /// 
+  /// The interface type of the network interface.
+  /// 
+  UINT8                 IfType;
+  /// 
+  /// The size, in bytes, of the network interface's hardware address.
+  /// 
+  UINT32                HwAddressSize;
+  /// 
+  /// The hardware address for the network interface.
+  /// 
+  EFI_MAC_ADDRESS       HwAddress;
+  /// 
+  /// Number of EFI_IP6_ADDRESS_INFO structures pointed to by AddressInfo.
+  /// 
+  UINT32                AddressInfoCount;
+  /// 
+  /// Pointer to an array of EFI_IP6_ADDRESS_INFO instances 
+  /// which contain the local IPv6 addresses and the corresponding 
+  /// prefix length information. Set to NULL if AddressInfoCount 
+  /// is zero.
+  /// 
+  EFI_IP6_ADDRESS_INFO  *AddressInfo;
+  /// 
+  /// Number of route table entries in the following RouteTable.
+  /// 
+  UINT32                RouteCount;
+  /// 
+  /// The route table of the IPv6 network stack runs on this interface. 
+  /// Set to NULL if RouteCount is zero. 
+  /// 
+  EFI_IP6_ROUTE_TABLE   *RouteTable;
+} EFI_IP6_CONFIG_INTERFACE_INFO;
+
+///
+/// EFI_IP6_CONFIG_INTERFACE_ID
+/// describes the 64-bit interface ID.
+///
+typedef struct {
+  UINT8                 Id[8];
+} EFI_IP6_CONFIG_INTERFACE_ID;
+
+///
+/// EFI_IP6_CONFIG_POLICY
+/// defines the general configuration policy the EFI IPv6 
+/// Configuration Protocol supports.
+///
+typedef enum {
+  ///
+  /// Under this policy, the IpI6ConfigDataTypeManualAddress, 
+  /// Ip6ConfigDataTypeGateway and Ip6ConfigDataTypeDnsServer
+  /// configuration data are required to be set manually. 
+  /// The EFI IPv6 Protocol will get all required configuration
+  /// such as address, prefix and gateway settings from the EFI
+  /// IPv6 Configuration protocol.
+  ///
+  Ip6ConfigPolicyManual,      
+  /// 
+  /// Under this policy, the IpI6ConfigDataTypeManualAddress, 
+  /// Ip6ConfigDataTypeGateway and Ip6ConfigDataTypeDnsServer
+  /// configuration data are not allowed to set via SetData().
+  /// All of these configurations are retrieved from some auto
+  /// configuration mechanism. 
+  /// The EFI IPv6 Protocol will use the IPv6 stateless address 
+  /// autoconfiguration mechanism and/or the IPv6 stateful address 
+  /// autoconfiguration mechanism described in the related RFCs to 
+  /// get address and other configuration information
+  /// 
+  Ip6ConfigPolicyAutomatic
+} EFI_IP6_CONFIG_POLICY;
+
+///
+/// EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS
+/// describes the number of consecutive Neighbor Solicitation messages sent
+/// while performing Duplicate Address Detection on a tentative address. 
+/// The default value for a newly detected communication device is 1.
+///
+typedef struct {
+  UINT32    DupAddrDetectTransmits;  ///< The number of consecutive Neighbor Solicitation messages sent.
+} EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS;           
+
+///
+/// EFI_IP6_CONFIG_MANUAL_ADDRESS
+/// is used to set the station address information for the EFI IPv6 network
+/// stack manually when the policy is Ip6ConfigPolicyManual.
+///
+typedef struct {
+  EFI_IPv6_ADDRESS      Address;       ///< The IPv6 unicast address.
+  BOOLEAN               IsAnycast;     ///< Set to TRUE if Address is anycast.
+  UINT8                 PrefixLength;  ///< The length, in bits, of the prefix associated with this Address.
+} EFI_IP6_CONFIG_MANUAL_ADDRESS;
+
+
+/**
+  Set the configuration for the EFI IPv6 network stack running on the communication
+  device this EFI IPv6 Configuration Protocol instance manages.
+  
+  This function is used to set the configuration data of type DataType for the EFI 
+  IPv6 network stack running on the communication device this EFI IPv6 Configuration
+  Protocol instance manages.
+
+  The DataSize is used to calculate the count of structure instances in the Data for 
+  some DataType that multiple structure instances are allowed.
+  
+  This function is always non-blocking. When setting some type of configuration data,
+  an asynchronous process is invoked to check the correctness of the data, such as 
+  doing Duplicate Address Detection on the manually set local IPv6 addresses. 
+  EFI_NOT_READY is returned immediately to indicate that such an asynchronous process
+  is invoked and the process is not finished yet. The caller willing to get the result
+  of the asynchronous process is required to call RegisterDataNotify() to register an
+  event on the specified configuration data. Once the event is signaled, the caller 
+  can call GetData() to get back the configuration data in order to know the result.
+  For other types of configuration data that do not require an asynchronous configuration 
+  process, the result of the operation is immediately returned.
+
+  @param[in]     This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
+  @param[in]     DataType       The type of data to set.  
+  @param[in]     DataSize       Size of the buffer pointed to by Data in bytes.
+  @param[in]     Data           The data buffer to set. The type of the data buffer is
+                                associated with the DataType.
+  
+  @retval EFI_SUCCESS           The specified configuration data for the EFI IPv6 
+                                network stack is set successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+                                - Data is NULL.
+                                - One or more fields in Data do not match the requirement of the 
+                                  data type indicated by DataType. 
+  @retval EFI_WRITE_PROTECTED   The specified configuration data is read-only or the specified 
+                                configuration data can not be set under the current policy
+  @retval EFI_ACCESS_DENIED     Another set operation on the specified configuration 
+                                data is already in process.
+  @retval EFI_NOT_READY         An asynchronous process is invoked to set the specified
+                                configuration data and the process is not finished yet.
+  @retval EFI_BAD_BUFFER_SIZE   The DataSize does not match the size of the type 
+                                indicated by DataType.
+  @retval EFI_UNSUPPORTED       This DataType is not supported.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_DEVICE_ERROR      An unexpected system error or network error occurred.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIG_SET_DATA)(
+  IN EFI_IP6_CONFIG_PROTOCOL    *This,
+  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
+  IN UINTN                      DataSize,
+  IN VOID                       *Data
+  );
+
+/**
+  Get the configuration data for the EFI IPv6 network stack running on the communication
+  device this EFI IPv6 Configuration Protocol instance manages.
+  
+  This function returns the configuration data of type DataType for the EFI IPv6 network
+  stack running on the communication device this EFI IPv6 Configuration Protocol instance
+  manages.
+
+  The caller is responsible for allocating the buffer used to return the specified
+  configuration data and the required size will be returned to the caller if the size of
+  the buffer is too small. 
+  
+  EFI_NOT_READY is returned if the specified configuration data is not ready due to an 
+  already in progress asynchronous configuration process. The caller can call RegisterDataNotify()
+  to register an event on the specified configuration data. Once the asynchronous configuration
+  process is finished, the event will be signaled and a subsequent GetData() call will return 
+  the specified configuration data.
+
+  @param[in]     This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
+  @param[in]     DataType       The type of data to get.  
+  @param[in,out] DataSize       On input, in bytes, the size of Data. On output, in bytes, the 
+                                size of buffer required to store the specified configuration data.
+  @param[in]     Data           The data buffer in which the configuration data is returned. The 
+                                type of the data buffer is associated with the DataType.
+  
+  @retval EFI_SUCCESS           The specified configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
+                                - This is NULL.
+                                - DataSize is NULL.
+                                - Data is NULL if *DataSize is not zero.
+  @retval EFI_BUFFER_TOO_SMALL  The size of Data is too small for the specified configuration data 
+                                and the required size is returned in DataSize.
+  @retval EFI_NOT_READY         The specified configuration data is not ready due to an already in 
+                                progress asynchronous configuration process.
+  @retval EFI_NOT_FOUND         The specified configuration data is not found.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIG_GET_DATA)(
+  IN EFI_IP6_CONFIG_PROTOCOL    *This,
+  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
+  IN OUT UINTN                  *DataSize,
+  IN VOID                       *Data   OPTIONAL
+  );
+
+/**
+  Register an event that is to be signaled whenever a configuration process on the specified
+  configuration data is done.
+  
+  This function registers an event that is to be signaled whenever a configuration process
+  on the specified configuration data is done. An event can be registered for different DataType
+  simultaneously and the caller is responsible for determining which type of configuration data
+  causes the signaling of the event in such case.
+
+  @param[in]     This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
+  @param[in]     DataType       The type of data to unregister the event for.  
+  @param[in]     Event          The event to register. 
+  
+  @retval EFI_SUCCESS           The notification event for the specified configuration data is 
+                                registered.
+  @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
+  @retval EFI_UNSUPPORTED       The configuration data type specified by DataType is not 
+                                supported.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_ACCESS_DENIED     The Event is already registered for the DataType.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIG_REGISTER_NOTIFY)(
+  IN EFI_IP6_CONFIG_PROTOCOL    *This,
+  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
+  IN EFI_EVENT                  Event
+  );
+
+/**
+  Remove a previously registered event for the specified configuration data.
+  
+  This function removes a previously registered event for the specified configuration data.
+
+  @param[in]     This           Pointer to the EFI_IP6_CONFIG_PROTOCOL instance.
+  @param[in]     DataType       The type of data to remove the previously registered event for.  
+  @param[in]     Event          The event to unregister.
+  
+  @retval EFI_SUCCESS           The event registered for the specified configuration data is removed.
+  @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
+  @retval EFI_NOT_FOUND         The Event has not been registered for the specified 
+                                DataType.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIG_UNREGISTER_NOTIFY)(
+  IN EFI_IP6_CONFIG_PROTOCOL    *This,
+  IN EFI_IP6_CONFIG_DATA_TYPE   DataType,
+  IN EFI_EVENT                  Event
+  );
+
+///
+/// The EFI_IP6_CONFIG_PROTOCOL provides the mechanism to set and get various
+/// types of configurations for the EFI IPv6 network stack.
+///
+struct _EFI_IP6_CONFIG_PROTOCOL {
+  EFI_IP6_CONFIG_SET_DATA           SetData;
+  EFI_IP6_CONFIG_GET_DATA           GetData;
+  EFI_IP6_CONFIG_REGISTER_NOTIFY    RegisterDataNotify;
+  EFI_IP6_CONFIG_UNREGISTER_NOTIFY  UnregisterDataNotify;
+};
+
+extern EFI_GUID gEfiIp6ConfigProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/IpSec.h b/MdePkg/Include/Protocol/IpSec.h
new file mode 100644
index 000000000000..a22326309ca0
--- /dev/null
+++ b/MdePkg/Include/Protocol/IpSec.h
@@ -0,0 +1,224 @@
+/** @file
+  EFI IPSEC Protocol Definition
+  The EFI_IPSEC_PROTOCOL is used to abstract the ability to deal with the individual
+  packets sent and received by the host and provide packet-level security for IP 
+  datagram.
+  The EFI_IPSEC2_PROTOCOL is used to abstract the ability to deal with the individual
+  packets sent and received by the host and provide packet-level security for IP 
+  datagram. In addition, it supports the Option (extension header) processing in 
+  IPsec which doesn't support in EFI_IPSEC_PROTOCOL. It is also recommended to 
+  use EFI_IPSEC2_PROTOCOL instead of EFI_IPSEC_PROTOCOL especially for IPsec Tunnel 
+  Mode.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:          
+  The EFI_IPSEC2_PROTOCOL is introduced in UEFI Specification 2.3D.
+
+**/
+
+#ifndef __EFI_IPSEC_PROTOCOL_H__
+#define __EFI_IPSEC_PROTOCOL_H__
+
+#include <Protocol/IpSecConfig.h>
+
+#define EFI_IPSEC_PROTOCOL_GUID \
+  { \
+    0xdfb386f7, 0xe100, 0x43ad, {0x9c, 0x9a, 0xed, 0x90, 0xd0, 0x8a, 0x5e, 0x12 } \
+  }
+
+#define EFI_IPSEC2_PROTOCOL_GUID \
+  { \
+    0xa3979e64, 0xace8, 0x4ddc, {0xbc, 0x7, 0x4d, 0x66, 0xb8, 0xfd, 0x9, 0x77 } \
+  }
+
+typedef struct _EFI_IPSEC_PROTOCOL  EFI_IPSEC_PROTOCOL;
+typedef struct _EFI_IPSEC2_PROTOCOL EFI_IPSEC2_PROTOCOL;
+
+///
+/// EFI_IPSEC_FRAGMENT_DATA 
+/// defines the instances of packet fragments.
+///
+typedef struct _EFI_IPSEC_FRAGMENT_DATA { 
+  UINT32  FragmentLength;
+  VOID    *FragmentBuffer;
+} EFI_IPSEC_FRAGMENT_DATA; 
+
+
+/**
+  Handles IPsec packet processing for inbound and outbound IP packets. 
+
+  The EFI_IPSEC_PROCESS process routine handles each inbound or outbound packet.
+  The behavior is that it can perform one of the following actions: 
+  bypass the packet, discard the packet, or protect the packet.       
+
+  @param[in]      This             Pointer to the EFI_IPSEC_PROTOCOL instance.
+  @param[in]      NicHandle        Instance of the network interface.
+  @param[in]      IpVer            IPV4 or IPV6.
+  @param[in, out] IpHead           Pointer to the IP Header.
+  @param[in]      LastHead         The protocol of the next layer to be processed by IPsec.
+  @param[in]      OptionsBuffer    Pointer to the options buffer. 
+  @param[in]      OptionsLength    Length of the options buffer.
+  @param[in, out] FragmentTable    Pointer to a list of fragments. 
+  @param[in]      FragmentCount    Number of fragments.
+  @param[in]      TrafficDirection Traffic direction.
+  @param[out]     RecycleSignal    Event for recycling of resources.
+ 
+  @retval EFI_SUCCESS              The packet was bypassed and all buffers remain the same.
+  @retval EFI_SUCCESS              The packet was protected.
+  @retval EFI_ACCESS_DENIED        The packet was discarded.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI  *EFI_IPSEC_PROCESS)(
+  IN     EFI_IPSEC_PROTOCOL      *This,
+  IN     EFI_HANDLE              NicHandle,
+  IN     UINT8                   IpVer,
+  IN OUT VOID                    *IpHead,
+  IN     UINT8                   *LastHead,
+  IN     VOID                    *OptionsBuffer,
+  IN     UINT32                  OptionsLength,
+  IN OUT EFI_IPSEC_FRAGMENT_DATA **FragmentTable,
+  IN     UINT32                  *FragmentCount,
+  IN     EFI_IPSEC_TRAFFIC_DIR   TrafficDirection,
+     OUT EFI_EVENT               *RecycleSignal
+  );
+
+///
+/// EFI_IPSEC_PROTOCOL 
+/// provides the ability for  securing IP communications by authenticating
+/// and/or encrypting each IP packet in a data stream. 
+//  EFI_IPSEC_PROTOCOL can be consumed by both the IPv4 and IPv6 stack.
+//  A user can employ this protocol for IPsec package handling in both IPv4
+//  and IPv6 environment.
+///
+struct _EFI_IPSEC_PROTOCOL {
+  EFI_IPSEC_PROCESS      Process;           ///< Handle the IPsec message.
+  EFI_EVENT              DisabledEvent;     ///< Event signaled when the interface is disabled.
+  BOOLEAN                DisabledFlag;      ///< State of the interface.
+};
+
+/**
+  Handles IPsec processing for both inbound and outbound IP packets. Compare with 
+  Process() in EFI_IPSEC_PROTOCOL, this interface has the capability to process 
+  Option(Extension Header). 
+
+  The EFI_IPSEC2_PROCESS process routine handles each inbound or outbound packet.
+  The behavior is that it can perform one of the following actions: 
+  bypass the packet, discard the packet, or protect the packet.  
+
+  @param[in]       This               Pointer to the EFI_IPSEC2_PROTOCOL instance.
+  @param[in]       NicHandle          Instance of the network interface. 
+  @param[in]       IpVer              IP version.IPv4 or IPv6.
+  @param[in, out]  IpHead             Pointer to the IP Header it is either 
+                                      the EFI_IP4_HEADER or EFI_IP6_HEADER.
+                                      On input, it contains the IP header. 
+                                      On output, 1) in tunnel mode and the 
+                                      traffic direction is inbound, the buffer 
+                                      will be reset to zero by IPsec; 2) in 
+                                      tunnel mode and the traffic direction 
+                                      is outbound, the buffer will reset to 
+                                      be the tunnel IP header.3) in transport 
+                                      mode, the related fielders (like payload 
+                                      length, Next header) in IP header will 
+                                      be modified according to the condition.
+  @param[in, out]  LastHead           For IP4, it is the next protocol in IP
+                                      header. For IP6 it is the Next Header 
+                                      of the last extension header.
+  @param[in, out]  OptionsBuffer      On input, it contains the options 
+                                      (extensions header) to be processed by 
+                                      IPsec. On output, 1) in tunnel mode and
+                                      the traffic direction is outbound, it 
+                                      will be set to NULL, and that means this 
+                                      contents was wrapped after inner header 
+                                      and should not be concatenated after 
+                                      tunnel header again; 2) in transport 
+                                      mode and the traffic direction is inbound, 
+                                      if there are IP options (extension headers) 
+                                      protected by IPsec, IPsec will concatenate 
+                                      the those options after the input options 
+                                      (extension headers); 3) on other situations, 
+                                      the output of contents of OptionsBuffer 
+                                      might be same with input's. The caller 
+                                      should take the responsibility to free 
+                                      the buffer both on input and on output.
+  @param[in, out]  OptionsLength      On input, the input length of the options 
+                                      buffer. On output, the output length of 
+                                      the options buffer.
+  @param[in, out]  FragmentTable      Pointer to a list of fragments. On input, 
+                                      these fragments contain the IP payload. 
+                                      On output, 1) in tunnel mode and the traffic 
+                                      direction is inbound, the fragments contain 
+                                      the whole IP payload which is from the 
+                                      IP inner header to the last byte of the 
+                                      packet; 2) in tunnel mode and the traffic 
+                                      direction is the outbound, the fragments 
+                                      contains the whole encapsulated payload 
+                                      which encapsulates the whole IP payload 
+                                      between the encapsulated header and 
+                                      encapsulated trailer fields. 3) in transport 
+                                      mode and the traffic direction is inbound, 
+                                      the fragments contains the IP payload 
+                                      which is from the next layer protocol to 
+                                      the last byte of the packet; 4) in transport 
+                                      mode and the traffic direction is outbound, 
+                                      the fragments contains the whole encapsulated 
+                                      payload which encapsulates the next layer 
+                                      protocol information between the encapsulated 
+                                      header and encapsulated trailer fields.
+  @param[in, out]  FragmentCount      Number of fragments.
+  @param[in]       TrafficDirection   Traffic direction.
+  @param[out]      RecycleSignal      Event for recycling of resources.
+
+  @retval      EFI_SUCCESS           The packet was processed by IPsec successfully.
+  @retval      EFI_ACCESS_DENIED     The packet was discarded.
+  @retval      EFI_NOT_READY         The IKE negotiation is invoked and the packet 
+                                     was discarded.
+  @retval      EFI_INVALID_PARAMETER One or more of following are TRUE:
+                                     If OptionsBuffer is NULL;
+                                     If OptionsLength is NULL;
+                                     If FragmentTable is NULL;
+                                     If FragmentCount is NULL.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_PROCESSEXT) ( 
+  IN EFI_IPSEC2_PROTOCOL         *This, 
+  IN EFI_HANDLE                  NicHandle, 
+  IN UINT8                       IpVer, 
+  IN OUT VOID                    *IpHead, 
+  IN OUT UINT8                   *LastHead, 
+  IN OUT VOID                    **OptionsBuffer, 
+  IN OUT UINT32                  *OptionsLength, 
+  IN OUT EFI_IPSEC_FRAGMENT_DATA **FragmentTable, 
+  IN OUT UINT32                  *FragmentCount, 
+  IN EFI_IPSEC_TRAFFIC_DIR       TrafficDirection, 
+     OUT EFI_EVENT               *RecycleSignal
+  );
+
+/// 
+/// EFI_IPSEC2_PROTOCOL
+/// supports the Option (extension header) processing in IPsec which doesn't support
+/// in EFI_IPSEC_PROTOCOL. It is also recommended to use EFI_IPSEC2_PROTOCOL instead
+/// of EFI_IPSEC_PROTOCOL especially for IPsec Tunnel Mode.
+/// provides the ability for securing IP communications by authenticating and/or
+/// encrypting each IP packet in a data stream.
+///
+struct _EFI_IPSEC2_PROTOCOL { 
+EFI_IPSEC_PROCESSEXT ProcessExt;
+EFI_EVENT            DisabledEvent; 
+BOOLEAN              DisabledFlag; 
+};
+
+extern EFI_GUID gEfiIpSecProtocolGuid;
+extern EFI_GUID gEfiIpSec2ProtocolGuid;
+#endif
diff --git a/MdePkg/Include/Protocol/IpSecConfig.h b/MdePkg/Include/Protocol/IpSecConfig.h
new file mode 100644
index 000000000000..4efc2e3d747a
--- /dev/null
+++ b/MdePkg/Include/Protocol/IpSecConfig.h
@@ -0,0 +1,807 @@
+/** @file
+  EFI IPsec Configuration Protocol Definition
+  The EFI_IPSEC_CONFIG_PROTOCOL provides the mechanism to set and retrieve security and 
+  policy related information for the EFI IPsec protocol driver.
+
+  Copyright (c) 2009 - 2011, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_IPSE_CCONFIG_PROTOCOL_H__
+#define __EFI_IPSE_CCONFIG_PROTOCOL_H__
+
+
+#define EFI_IPSEC_CONFIG_PROTOCOL_GUID \
+  { \
+    0xce5e5929, 0xc7a3, 0x4602, {0xad, 0x9e, 0xc9, 0xda, 0xf9, 0x4e, 0xbf, 0xcf } \
+  }
+
+typedef struct _EFI_IPSEC_CONFIG_PROTOCOL EFI_IPSEC_CONFIG_PROTOCOL;
+
+///
+/// EFI_IPSEC_CONFIG_DATA_TYPE
+///
+typedef enum {
+  /// 
+  /// The IPsec Security Policy Database (aka SPD) setting.  In IPsec, 
+  /// an essential element of Security Association (SA) processing is 
+  /// underlying SPD that specifies what services are to be offered to 
+  /// IP datagram and in what fashion. The SPD must be consulted 
+  /// during the processing of all traffic (inbound and outbound), 
+  /// including traffic not protected by IPsec, that traverses the IPsec 
+  /// boundary. With this DataType, SetData() function is to set 
+  /// the SPD entry information, which may add one new entry, delete 
+  /// one existed entry or flush the whole database according to the 
+  /// parameter values. The corresponding Data is of type 
+  /// EFI_IPSEC_SPD_DATA
+  /// 
+  IPsecConfigDataTypeSpd,
+  /// 
+  /// The IPsec Security Association Database (aka SAD) setting. A 
+  /// SA is a simplex connection that affords security services to the 
+  /// traffic carried by it. Security services are afforded to an SA by the 
+  /// use of AH, or ESP, but not both. The corresponding Data is of 
+  /// type EFI_IPSEC_SAD_DATA.
+  /// 
+  IPsecConfigDataTypeSad,
+  /// 
+  /// The IPsec Peer Authorization Database (aka PAD) setting, which 
+  /// provides the link between the SPD and a security association 
+  /// management protocol. The PAD entry specifies the 
+  /// authentication protocol (e.g. IKEv1, IKEv2) method used and the 
+  /// authentication data. The corresponding Data is of type 
+  /// EFI_IPSEC_PAD_DATA.
+  ///
+  IPsecConfigDataTypePad,
+  IPsecConfigDataTypeMaximum
+} EFI_IPSEC_CONFIG_DATA_TYPE;
+
+///
+/// EFI_IP_ADDRESS_INFO
+///
+typedef struct _EFI_IP_ADDRESS_INFO {
+  EFI_IP_ADDRESS  Address;      ///< The IPv4 or IPv6 address
+  UINT8           PrefixLength; ///< The length of the prefix associated with the Address.
+} EFI_IP_ADDRESS_INFO;
+
+
+///
+/// EFI_IPSEC_SPD_SELECTOR
+///
+typedef struct _EFI_IPSEC_SPD_SELECTOR {
+  /// 
+  /// Specifies the actual number of entries in LocalAddress.
+  /// 
+  UINT32                          LocalAddressCount;
+  /// 
+  /// A list of ranges of IPv4 or IPv6 addresses, which refers to the 
+  /// addresses being protected by IPsec policy.
+  /// 
+  EFI_IP_ADDRESS_INFO             *LocalAddress;
+  /// 
+  /// Specifies the actual number of entries in RemoteAddress.
+  /// 
+  UINT32                          RemoteAddressCount;
+  /// 
+  /// A list of ranges of IPv4 or IPv6 addresses, which are peer entities 
+  /// to LocalAddress. 
+  /// 
+  EFI_IP_ADDRESS_INFO             *RemoteAddress;
+  /// 
+  /// Next layer protocol. Obtained from the IPv4 Protocol or the IPv6 
+  /// Next Header fields. The next layer protocol is whatever comes 
+  /// after any IP extension headers that are present. A zero value is a 
+  /// wildcard that matches any value in NextLayerProtocol field.
+  /// 
+  UINT16                          NextLayerProtocol; 
+  /// 
+  /// Local Port if the Next Layer Protocol uses two ports (as do TCP, 
+  /// UDP, and others). A zero value is a wildcard that matches any 
+  /// value in LocalPort field.
+  /// 
+  UINT16                          LocalPort;
+  /// 
+  /// A designed port range size. The start port is LocalPort, and 
+  /// the total number of ports is described by LocalPortRange. 
+  /// This field is ignored if NextLayerProtocol does not use 
+  /// ports. 
+  /// 
+  UINT16                          LocalPortRange;
+  /// 
+  /// Remote Port if the Next Layer Protocol uses two ports. A zero 
+  /// value is a wildcard that matches any value in RemotePort field.
+  /// 
+  UINT16                          RemotePort;
+  /// 
+  /// A designed port range size. The start port is RemotePort, and 
+  /// the total number of ports is described by RemotePortRange. 
+  /// This field is ignored if NextLayerProtocol does not use ports.
+  /// 
+  UINT16                          RemotePortRange;
+} EFI_IPSEC_SPD_SELECTOR;
+ 
+///
+/// EFI_IPSEC_TRAFFIC_DIR
+/// represents the directionality in an SPD entry.
+///
+typedef enum {
+  ///
+  /// The EfiIPsecInBound refers to traffic entering an IPsec implementation via 
+  /// the unprotected interface or emitted by the implementation on the unprotected
+  /// side of the boundary and directed towards the protected interface. 
+  ///
+  EfiIPsecInBound,
+  ///
+  /// The EfiIPsecOutBound refers to traffic entering the implementation via 
+  /// the protected interface, or emitted by the implementation on the protected side
+  /// of the boundary and directed toward the unprotected interface.
+  ///
+  EfiIPsecOutBound
+} EFI_IPSEC_TRAFFIC_DIR;
+
+///
+/// EFI_IPSEC_ACTION
+/// represents three possible processing choices.
+///
+typedef enum {
+  /// 
+  /// Refers to traffic that is not allowed to traverse the IPsec boundary.
+  /// 
+  EfiIPsecActionDiscard,
+  /// 
+  /// Refers to traffic that is allowed to cross the IPsec boundary 
+  /// without protection.
+  /// 
+  EfiIPsecActionBypass,
+  /// 
+  /// Refers to traffic that is afforded IPsec protection, and for such 
+  /// traffic the SPD must specify the security protocols to be 
+  /// employed, their mode, security service options, and the 
+  /// cryptographic algorithms to be used. 
+  ///
+  EfiIPsecActionProtect
+} EFI_IPSEC_ACTION;
+
+///
+/// EFI_IPSEC_SA_LIFETIME
+/// defines the lifetime of an SA, which represents when a SA must be 
+/// replaced or terminated. A value of all 0 for each field removes 
+/// the limitation of a SA lifetime.
+///
+typedef struct _EFI_IPSEC_SA_LIFETIME {
+  /// 
+  /// The number of bytes to which the IPsec cryptographic algorithm
+  /// can be applied. For ESP, this is the encryption algorithm and for
+  /// AH, this is the authentication algorithm. The ByteCount 
+  /// includes pad bytes for cryptographic operations.
+  /// 
+  UINT64        ByteCount;
+  /// 
+  /// A time interval in second that warns the implementation to 
+  /// initiate action such as setting up a replacement SA.
+  /// 
+  UINT64        SoftLifetime;
+  /// 
+  /// A time interval in second when the current SA ends and is 
+  /// destroyed.
+  /// 
+  UINT64        HardLifetime;
+} EFI_IPSEC_SA_LIFETIME;
+
+///
+/// EFI_IPSEC_MODE
+/// There are two modes of IPsec operation: transport mode and tunnel mode. In 
+/// EfiIPsecTransport mode, AH and ESP provide protection primarily for next layer protocols; 
+/// In EfiIPsecTunnel mode, AH and ESP are applied to tunneled IP packets.
+///
+typedef enum {
+  EfiIPsecTransport,
+  EfiIPsecTunnel
+} EFI_IPSEC_MODE;
+
+///
+/// EFI_IPSEC_TUNNEL_DF_OPTION
+/// The option of copying the DF bit from an outbound package to
+/// the tunnel mode header that it emits, when traffic is carried
+/// via a tunnel mode SA. This applies to SAs where both inner and
+/// outer headers are IPv4.
+///
+typedef enum {
+  EfiIPsecTunnelClearDf,  ///< Clear DF bit from inner header.
+  EfiIPsecTunnelSetDf,    ///< Set DF bit from inner header.
+  EfiIPsecTunnelCopyDf    ///< Copy DF bit from inner header.
+} EFI_IPSEC_TUNNEL_DF_OPTION;
+
+///
+/// EFI_IPSEC_TUNNEL_OPTION
+///
+typedef struct _EFI_IPSEC_TUNNEL_OPTION {
+  /// 
+  /// Local tunnel address when IPsec mode is EfiIPsecTunnel.
+  /// 
+  EFI_IP_ADDRESS              LocalTunnelAddress;
+  /// 
+  /// Remote tunnel address when IPsec mode is EfiIPsecTunnel.
+  /// 
+  EFI_IP_ADDRESS              RemoteTunnelAddress;
+  /// 
+  /// The option of copying the DF bit from an outbound package
+  /// to the tunnel mode header that it emits, when traffic is 
+  /// carried via a tunnel mode SA. 
+  /// 
+  EFI_IPSEC_TUNNEL_DF_OPTION  DF;
+} EFI_IPSEC_TUNNEL_OPTION;
+
+///
+/// EFI_IPSEC_PROTOCOL_TYPE
+///
+typedef enum {
+  EfiIPsecAH,  ///< IP Authentication Header protocol which is specified in RFC 4302.
+  EfiIPsecESP  ///< IP Encapsulating Security Payload which is specified in RFC 4303. 
+} EFI_IPSEC_PROTOCOL_TYPE;
+
+///
+/// EFI_IPSEC_PROCESS_POLICY
+/// describes a policy list for traffic processing.
+///
+typedef struct _EFI_IPSEC_PROCESS_POLICY {
+  /// 
+  /// Extended Sequence Number. Is this SA using extended sequence 
+  /// numbers. 64 bit counter is used if TRUE.
+  /// 
+  BOOLEAN                 ExtSeqNum;
+  /// 
+  /// A flag indicating whether overflow of the sequence number 
+  /// counter should generate an auditable event and prevent 
+  /// transmission of additional packets on the SA, or whether rollover 
+  /// is permitted.
+  /// 
+  BOOLEAN                 SeqOverflow;
+  /// 
+  /// Is this SA using stateful fragment checking. TRUE represents 
+  /// stateful fragment checking.
+  /// 
+  BOOLEAN                 FragCheck;
+  /// 
+  /// A time interval after which a SA must be replaced with a new SA 
+  /// (and new SPI) or terminated. 
+  /// 
+  EFI_IPSEC_SA_LIFETIME   SaLifetime;
+  /// 
+  /// IPsec mode: tunnel or transport.
+  /// 
+  EFI_IPSEC_MODE          Mode;
+  /// 
+  /// Tunnel Option. TunnelOption is ignored if Mode is EfiIPsecTransport.
+  /// 
+  EFI_IPSEC_TUNNEL_OPTION *TunnelOption;
+  /// 
+  /// IPsec protocol: AH or ESP
+  /// 
+  EFI_IPSEC_PROTOCOL_TYPE Proto;
+  ///  
+  /// Cryptographic algorithm type used for authentication.
+  /// 
+  UINT8                   AuthAlgoId;
+  /// 
+  /// Cryptographic algorithm type used for encryption. EncAlgo is 
+  /// NULL when IPsec protocol is AH. For ESP protocol, EncAlgo 
+  /// can also be used to describe the algorithm if a combined mode 
+  /// algorithm is used.
+  ///
+  UINT8                   EncAlgoId;
+} EFI_IPSEC_PROCESS_POLICY;
+
+///
+/// EFI_IPSEC_SA_ID
+/// A triplet to identify an SA, consisting of the following members.
+///
+typedef struct _EFI_IPSEC_SA_ID {
+  /// 
+  /// Security Parameter Index (aka SPI).  An arbitrary 32-bit value 
+  /// that is used by a receiver to identity the SA to which an incoming 
+  /// package should be bound.
+  /// 
+  UINT32                          Spi;
+  /// 
+  /// IPsec protocol: AH or ESP
+  /// 
+  EFI_IPSEC_PROTOCOL_TYPE         Proto;
+  /// 
+  /// Destination IP address. 
+  /// 
+  EFI_IP_ADDRESS                  DestAddress;
+} EFI_IPSEC_SA_ID;
+
+
+#define MAX_PEERID_LEN     128
+
+///
+/// EFI_IPSEC_SPD_DATA
+///
+typedef struct _EFI_IPSEC_SPD_DATA {
+  /// 
+  /// A null-terminated ASCII name string which is used as a symbolic 
+  /// identifier for an IPsec Local or Remote address.
+  /// 
+  UINT8                           Name[MAX_PEERID_LEN];
+  /// 
+  /// Bit-mapped list describing Populate from Packet flags. When 
+  /// creating a SA, if PackageFlag bit is set to TRUE, instantiate 
+  /// the selector from the corresponding field in the package that 
+  /// triggered the creation of the SA, else from the value(s) in the 
+  /// corresponding SPD entry. The PackageFlag bit setting for 
+  /// corresponding selector field of EFI_IPSEC_SPD_SELECTOR:
+  ///     Bit 0: EFI_IPSEC_SPD_SELECTOR.LocalAddress 
+  ///     Bit 1: EFI_IPSEC_SPD_SELECTOR.RemoteAddress 
+  ///     Bit 2: 
+  /// EFI_IPSEC_SPD_SELECTOR.NextLayerProtocol 
+  ///     Bit 3: EFI_IPSEC_SPD_SELECTOR.LocalPort 
+  ///     Bit 4: EFI_IPSEC_SPD_SELECTOR.RemotePort 
+  ///     Others: Reserved.
+  ///
+  UINT32                          PackageFlag;
+  /// 
+  /// The traffic direction of data gram.
+  /// 
+  EFI_IPSEC_TRAFFIC_DIR           TrafficDirection;
+  /// 
+  /// Processing choices to indicate which action is required by this 
+  /// policy. 
+  /// 
+  EFI_IPSEC_ACTION                Action;
+  /// 
+  /// The policy and rule information for a SPD entry.
+  /// 
+  EFI_IPSEC_PROCESS_POLICY        *ProcessingPolicy;
+  /// 
+  /// Specifies the actual number of entries in SaId list.
+  /// 
+  UINTN                           SaIdCount;
+  /// 
+  /// The SAD entry used for the traffic processing. The 
+  /// existed SAD entry links indicate this is the manual key case.
+  /// 
+  EFI_IPSEC_SA_ID                 SaId[1];
+} EFI_IPSEC_SPD_DATA;
+
+///
+/// EFI_IPSEC_AH_ALGO_INFO
+/// The security algorithm selection for IPsec AH authentication.
+/// The required authentication algorithm is specified in RFC 4305.
+///
+typedef struct _EFI_IPSEC_AH_ALGO_INFO {
+  UINT8                           AuthAlgoId;
+  UINTN                           AuthKeyLength;
+  VOID                            *AuthKey;
+} EFI_IPSEC_AH_ALGO_INFO;
+
+///
+/// EFI_IPSEC_ESP_ALGO_INFO
+/// The security algorithm selection for IPsec ESP encryption and authentication.
+/// The required authentication algorithm is specified in RFC 4305. 
+/// EncAlgoId fields can also specify an ESP combined mode algorithm 
+/// (e.g. AES with CCM mode, specified in RFC 4309), which provides both 
+/// confidentiality and authentication services.
+///
+typedef struct _EFI_IPSEC_ESP_ALGO_INFO {
+  UINT8                     EncAlgoId;
+  UINTN                     EncKeyLength;
+  VOID                      *EncKey;
+  UINT8                     AuthAlgoId;
+  UINTN                     AuthKeyLength;
+  VOID                      *AuthKey;
+} EFI_IPSEC_ESP_ALGO_INFO;
+
+///
+/// EFI_IPSEC_ALGO_INFO
+///
+typedef union {
+  EFI_IPSEC_AH_ALGO_INFO          AhAlgoInfo;
+  EFI_IPSEC_ESP_ALGO_INFO         EspAlgoInfo;
+} EFI_IPSEC_ALGO_INFO;
+
+///
+/// EFI_IPSEC_SA_DATA
+///
+typedef struct _EFI_IPSEC_SA_DATA {
+  /// 
+  /// IPsec mode: tunnel or transport.
+  /// 
+  EFI_IPSEC_MODE                  Mode;
+  /// 
+  /// Sequence Number Counter. A 64-bit counter used to generate the 
+  /// sequence number field in AH or ESP headers.
+  /// 
+  UINT64                          SNCount;
+  /// 
+  /// Anti-Replay Window. A 64-bit counter and a bit-map used to 
+  /// determine whether an inbound AH or ESP packet is a replay.
+  /// 
+  UINT8                           AntiReplayWindows;
+  /// 
+  /// AH/ESP cryptographic algorithm, key and parameters. 
+  /// 
+  EFI_IPSEC_ALGO_INFO             AlgoInfo;
+  /// 
+  /// Lifetime of this SA. 
+  /// 
+  EFI_IPSEC_SA_LIFETIME           SaLifetime;
+  /// 
+  /// Any observed path MTU and aging variables. The Path MTU 
+  /// processing is defined in section 8 of RFC 4301.
+  /// 
+  UINT32                          PathMTU;
+  /// 
+  /// Link to one SPD entry.
+  /// 
+  EFI_IPSEC_SPD_SELECTOR          *SpdSelector;
+  /// 
+  /// Indication of whether it's manually set or negotiated automatically. 
+  /// If ManualSet is FALSE, the corresponding SA entry is inserted through 
+  /// IKE protocol negotiation.
+  ///
+  BOOLEAN                         ManualSet;
+} EFI_IPSEC_SA_DATA;
+
+///
+/// EFI_IPSEC_SA_DATA2
+///
+typedef struct _EFI_IPSEC_SA_DATA2 { 
+  ///
+  /// IPsec mode: tunnel or transport
+  ///
+  EFI_IPSEC_MODE             Mode; 
+  ///
+  /// Sequence Number Counter. A 64-bit counter used to generate the sequence 
+  /// number field in AH or ESP headers. 
+  ///
+  UINT64                     SNCount; 
+  ///
+  /// Anti-Replay Window. A 64-bit counter and a bit-map used to determine 
+  /// whether an inbound AH or ESP packet is a replay.
+  ///
+  UINT8                      AntiReplayWindows; 
+  ///
+  /// AH/ESP cryptographic algorithm, key and parameters.
+  ///
+  EFI_IPSEC_ALGO_INFO        AlgoInfo; 
+  ///
+  /// Lifetime of this SA.
+  ///
+  EFI_IPSEC_SA_LIFETIME      SaLifetime; 
+  ///
+  /// Any observed path MTU and aging variables. The Path MTU processing is 
+  /// defined in section 8 of RFC 4301.
+  ///
+  UINT32                     PathMTU; 
+  ///
+  /// Link to one SPD entry
+  ///
+  EFI_IPSEC_SPD_SELECTOR     *SpdSelector; 
+  ///
+  /// Indication of whether it's manually set or negotiated automatically. 
+  /// If ManualSet is FALSE, the corresponding SA entry is inserted through IKE 
+  /// protocol negotiation
+  ///
+  BOOLEAN                    ManualSet;
+  ///
+  /// The tunnel header IP source address.
+  ///
+  EFI_IP_ADDRESS             TunnelSourceAddress;
+  ///
+  /// The tunnel header IP destination address.
+  ///
+  EFI_IP_ADDRESS             TunnelDestinationAddress;
+} EFI_IPSEC_SA_DATA2; 
+
+
+///
+/// EFI_IPSEC_PAD_ID
+/// specifies the identifier for PAD entry, which is also used for SPD lookup.
+/// IpAddress Pointer to the IPv4 or IPv6 address range.
+///
+typedef struct _EFI_IPSEC_PAD_ID {
+  ///
+  /// Flag to identify which type of PAD Id is used.
+  /// 
+  BOOLEAN               PeerIdValid;    
+  union {
+    ///
+    /// Pointer to the IPv4 or IPv6 address range.
+    ///
+    EFI_IP_ADDRESS_INFO   IpAddress;
+    ///
+    /// Pointer to a null terminated ASCII string
+    /// representing the symbolic names. A PeerId can be a DNS 
+    /// name, Distinguished Name, RFC 822 email address or Key ID 
+    /// (specified in section 4.4.3.1 of RFC 4301)
+    ///
+    UINT8                 PeerId[MAX_PEERID_LEN];
+  } Id;
+} EFI_IPSEC_PAD_ID;
+
+///
+/// EFI_IPSEC_CONFIG_SELECTOR
+/// describes the expected IPsec configuration data selector 
+/// of type EFI_IPSEC_CONFIG_DATA_TYPE.
+///
+typedef union {
+  EFI_IPSEC_SPD_SELECTOR              SpdSelector;
+  EFI_IPSEC_SA_ID                     SaId;
+  EFI_IPSEC_PAD_ID                    PadId;
+} EFI_IPSEC_CONFIG_SELECTOR;
+
+///
+/// EFI_IPSEC_AUTH_PROTOCOL_TYPE
+/// defines the possible authentication protocol for IPsec 
+/// security association management.
+///
+typedef enum {
+  EfiIPsecAuthProtocolIKEv1,
+  EfiIPsecAuthProtocolIKEv2,
+  EfiIPsecAuthProtocolMaximum
+} EFI_IPSEC_AUTH_PROTOCOL_TYPE;
+
+///
+/// EFI_IPSEC_AUTH_METHOD
+///
+typedef enum {
+  ///
+  /// Using Pre-shared Keys for manual security associations.
+  ///
+  EfiIPsecAuthMethodPreSharedSecret,
+  ///
+  /// IKE employs X.509 certificates for SA establishment.
+  ///
+  EfiIPsecAuthMethodCertificates,
+  EfiIPsecAuthMethodMaximum
+} EFI_IPSEC_AUTH_METHOD;
+
+///
+/// EFI_IPSEC_PAD_DATA
+///
+typedef struct _EFI_IPSEC_PAD_DATA {
+  /// 
+  /// Authentication Protocol for IPsec security association  management.
+  /// 
+  EFI_IPSEC_AUTH_PROTOCOL_TYPE  AuthProtocol;
+  /// 
+  /// Authentication method used.
+  /// 
+  EFI_IPSEC_AUTH_METHOD         AuthMethod;
+  /// 
+  /// The IKE ID payload will be used as a symbolic name for SPD 
+  /// lookup if IkeIdFlag is TRUE. Otherwise, the remote IP 
+  /// address provided in traffic selector playloads will be used.
+  /// 
+  BOOLEAN                       IkeIdFlag;
+  /// 
+  /// The size of Authentication data buffer, in bytes.
+  /// 
+  UINTN                         AuthDataSize;
+  /// 
+  /// Buffer for Authentication data, (e.g., the pre-shared secret or the 
+  /// trust anchor relative to which the peer's certificate will be 
+  /// validated).
+  /// 
+  VOID                          *AuthData;
+  /// 
+  /// The size of RevocationData, in bytes
+  /// 
+  UINTN                         RevocationDataSize;
+  /// 
+  /// Pointer to CRL or OCSP data, if certificates are used for 
+  /// authentication method.
+  /// 
+  VOID                          *RevocationData;
+} EFI_IPSEC_PAD_DATA;
+
+
+/**
+  Set the security association, security policy and peer authorization configuration
+  information for the EFI IPsec driver. 
+
+  This function is used to set the IPsec configuration information of type DataType for
+  the EFI IPsec driver.
+  The IPsec configuration data has a unique selector/identifier separately to identify
+  a data entry. The selector structure depends on DataType's definition.
+  Using SetData() with a Data of NULL causes the IPsec configuration data entry identified
+  by DataType and Selector to be deleted.        
+
+  @param[in] This               Pointer to the EFI_IPSEC_CONFIG_PROTOCOL instance.
+  @param[in] DataType           The type of data to be set.
+  @param[in] Selector           Pointer to an entry selector on operated configuration data 
+                                specified by DataType. A NULL Selector causes the entire 
+                                specified-type configuration information to be flushed.
+  @param[in] Data               The data buffer to be set. The structure of the data buffer is 
+                                associated with the DataType.
+  @param[in] InsertBefore       Pointer to one entry selector which describes the expected
+                                position the new data entry will be added. If InsertBefore is NULL,
+                                the new entry will be appended the end of database.
+ 
+  @retval EFI_SUCCESS           The specified configuration entry data is set successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+  @retval EFI_UNSUPPORTED       The specified DataType is not supported.
+  @retval EFI_OUT_OF_RESOURCED  The required system resource could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_CONFIG_SET_DATA)(
+  IN EFI_IPSEC_CONFIG_PROTOCOL        *This,
+  IN EFI_IPSEC_CONFIG_DATA_TYPE       DataType,
+  IN EFI_IPSEC_CONFIG_SELECTOR        *Selector,
+  IN VOID                             *Data,
+  IN EFI_IPSEC_CONFIG_SELECTOR        *InsertBefore   OPTIONAL
+  );
+
+/**
+  Return the configuration value for the EFI IPsec driver. 
+
+  This function lookup the data entry from IPsec database or IKEv2 configuration
+  information. The expected data type and unique identification are described in
+  DataType and Selector parameters.        
+
+  @param[in]      This          Pointer to the EFI_IPSEC_CONFIG_PROTOCOL instance.
+  @param[in]      DataType      The type of data to retrieve.
+  @param[in]      Selector      Pointer to an entry selector which is an identifier of the IPsec 
+                                configuration data entry.
+  @param[in, out] DataSize      On output the size of data returned in Data.
+  @param[out]     Data          The buffer to return the contents of the IPsec configuration data. 
+                                The type of the data buffer is associated with the DataType. 
+ 
+  @retval EFI_SUCCESS           The specified configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
+                                - This is NULL.
+                                - Selector is NULL.
+                                - DataSize is NULL.
+                                - Data is NULL and *DataSize is not zero
+  @retval EFI_NOT_FOUND         The configuration data specified by Selector is not found.
+  @retval EFI_UNSUPPORTED       The specified DataType is not supported.
+  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the result. DataSize has been
+                                updated with the size needed to complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_CONFIG_GET_DATA)(
+  IN EFI_IPSEC_CONFIG_PROTOCOL        *This,
+  IN EFI_IPSEC_CONFIG_DATA_TYPE       DataType,
+  IN EFI_IPSEC_CONFIG_SELECTOR        *Selector,
+  IN OUT UINTN                        *DataSize,
+  OUT VOID                            *Data
+  );
+
+/**
+  Enumerates the current selector for IPsec configuration data entry. 
+
+  This function is called multiple times to retrieve the entry Selector in IPsec
+  configuration database. On each call to GetNextSelector(), the next entry 
+  Selector are retrieved into the output interface.
+ 
+  If the entire IPsec configuration database has been iterated, the error 
+  EFI_NOT_FOUND is returned.
+  If the Selector buffer is too small for the next Selector copy, an 
+  EFI_BUFFER_TOO_SMALL error is returned, and SelectorSize is updated to reflect 
+  the size of buffer needed.
+
+  On the initial call to GetNextSelector() to start the IPsec configuration database
+  search, a pointer to the buffer with all zero value is passed in Selector. Calls 
+  to SetData() between calls to GetNextSelector may produce unpredictable results.         
+
+  @param[in]      This          Pointer to the EFI_IPSEC_CONFIG_PROTOCOL instance.
+  @param[in]      DataType      The type of IPsec configuration data to retrieve.
+  @param[in, out] SelectorSize  The size of the Selector buffer.
+  @param[in, out] Selector      On input, supplies the pointer to last Selector that was 
+                                returned by GetNextSelector().
+                                On output, returns one copy of the current entry Selector
+                                of a given DataType. 
+ 
+  @retval EFI_SUCCESS           The specified configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the followings are TRUE:
+                                - This is NULL.
+                                - SelectorSize is NULL.
+                                - Selector is NULL.
+  @retval EFI_NOT_FOUND         The next configuration data entry was not found.
+  @retval EFI_UNSUPPORTED       The specified DataType is not supported.
+  @retval EFI_BUFFER_TOO_SMALL  The SelectorSize is too small for the result. This parameter
+                                has been updated with the size needed to complete the search 
+                                request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_CONFIG_GET_NEXT_SELECTOR)(
+  IN EFI_IPSEC_CONFIG_PROTOCOL        *This,
+  IN EFI_IPSEC_CONFIG_DATA_TYPE       DataType,
+  IN OUT UINTN                        *SelectorSize,
+  IN OUT EFI_IPSEC_CONFIG_SELECTOR    *Selector
+  );
+
+/**
+  Register an event that is to be signaled whenever a configuration process on the
+  specified IPsec configuration information is done. 
+
+  This function registers an event that is to be signaled whenever a configuration
+  process on the specified IPsec configuration data is done (e.g. IPsec security 
+  policy database configuration is ready). An event can be registered for different
+  DataType simultaneously and the caller is responsible for determining which type 
+  of configuration data causes the signaling of the event in such case.        
+
+  @param[in] This               Pointer to the EFI_IPSEC_CONFIG_PROTOCOL instance.
+  @param[in] DataType           The type of data to be registered the event for.
+  @param[in] Event              The event to be registered.
+ 
+  @retval EFI_SUCCESS           The event is registered successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
+  @retval EFI_ACCESS_DENIED     The Event is already registered for the DataType.
+  @retval EFI_UNSUPPORTED       The notify registration unsupported or the specified
+                                DataType is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_CONFIG_REGISTER_NOTIFY)(
+  IN EFI_IPSEC_CONFIG_PROTOCOL        *This,
+  IN EFI_IPSEC_CONFIG_DATA_TYPE       DataType,
+  IN EFI_EVENT                        Event
+  );
+
+/**
+  Remove the specified event that is previously registered on the specified IPsec
+  configuration data. 
+
+  This function removes a previously registered event for the specified configuration data.        
+
+  @param[in] This               Pointer to the EFI_IPSEC_CONFIG_PROTOCOL instance.
+  @param[in] DataType           The configuration data type to remove the registered event for.
+  @param[in] Event              The event to be unregistered.
+ 
+  @retval EFI_SUCCESS           The event is removed successfully.
+  @retval EFI_NOT_FOUND         The Event specified by DataType could not be found in the 
+                                database.
+  @retval EFI_INVALID_PARAMETER This is NULL or Event is NULL.
+  @retval EFI_UNSUPPORTED       The notify registration unsupported or the specified
+                                DataType is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IPSEC_CONFIG_UNREGISTER_NOTIFY)(
+  IN EFI_IPSEC_CONFIG_PROTOCOL        *This,
+  IN EFI_IPSEC_CONFIG_DATA_TYPE       DataType,
+  IN EFI_EVENT                        Event
+  );
+
+///
+/// EFI_IPSEC_CONFIG_PROTOCOL
+/// provides the ability to set and lookup the IPsec SAD (Security Association Database),
+/// SPD (Security Policy Database) data entry and configure the security association 
+/// management protocol such as IKEv2. This protocol is used as the central 
+/// repository of any policy-specific configuration for EFI IPsec driver.
+/// EFI_IPSEC_CONFIG_PROTOCOL can be bound to both IPv4 and IPv6 stack. User can use this 
+/// protocol for IPsec configuration in both IPv4 and IPv6 environment.
+/// 
+struct _EFI_IPSEC_CONFIG_PROTOCOL {
+  EFI_IPSEC_CONFIG_SET_DATA           SetData;
+  EFI_IPSEC_CONFIG_GET_DATA           GetData;
+  EFI_IPSEC_CONFIG_GET_NEXT_SELECTOR  GetNextSelector;
+  EFI_IPSEC_CONFIG_REGISTER_NOTIFY    RegisterDataNotify;
+  EFI_IPSEC_CONFIG_UNREGISTER_NOTIFY  UnregisterDataNotify;
+};
+
+extern EFI_GUID gEfiIpSecConfigProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/IsaHc.h b/MdePkg/Include/Protocol/IsaHc.h
new file mode 100644
index 000000000000..bc92675d12ca
--- /dev/null
+++ b/MdePkg/Include/Protocol/IsaHc.h
@@ -0,0 +1,116 @@
+/** @file
+  ISA HC Protocol as defined in the PI 1.2.1 specification.
+
+  This protocol provides registration for ISA devices on a positive- or
+  subtractive-decode ISA bus. It allows devices to be registered and also
+  handles opening and closing the apertures which are positively-decoded.
+
+  Copyright (c) 2015, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.2.1.
+
+**/
+
+#ifndef __ISA_HC_PROTOCOL_H__
+#define __ISA_HC_PROTOCOL_H__
+
+#define EFI_ISA_HC_PROTOCOL_GUID \
+  { \
+    0xbcdaf080, 0x1bde, 0x4e22, {0xae, 0x6a, 0x43, 0x54, 0x1e, 0x12, 0x8e, 0xc4} \
+  }
+
+#define EFI_ISA_HC_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xfad7933a, 0x6c21, 0x4234, {0xa4, 0x34, 0x0a, 0x8a, 0x0d, 0x2b, 0x07, 0x81} \
+  }
+
+typedef struct _EFI_ISA_HC_PROTOCOL EFI_ISA_HC_PROTOCOL;
+typedef struct _EFI_ISA_HC_PROTOCOL *PEFI_ISA_HC_PROTOCOL;
+
+/**
+  Open I/O aperture.
+
+  This function opens an I/O aperture in a ISA Host Controller for the I/O addresses
+  specified by IoAddress to IoAddress + IoLength - 1. It may be possible that a
+  single hardware aperture may be used for more than one device. This function
+  tracks the number of times that each aperture is referenced, and does not close
+  the hardware aperture (via CloseIoAperture()) until there are no more references to it.
+
+  @param This             A pointer to this instance of the EFI_ISA_HC_PROTOCOL.
+  @param IoAddress        An unsigned integer that specifies the first byte of the
+                          I/O space required.
+  @param IoLength         An unsigned integer that specifies the number of bytes
+                          of the I/O space required.
+  @param IoApertureHandle A pointer to the returned I/O aperture handle. This
+                          value can be used on subsequent calls to CloseIoAperture().
+
+  @retval EFI_SUCCESS          The I/O aperture was opened successfully.
+  @retval EFI_UNSUPPORTED      The ISA Host Controller is a subtractive-decode controller.
+  @retval EFI_OUT_OF_RESOURCES There is no available I/O aperture.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ISA_HC_OPEN_IO) (
+  IN CONST EFI_ISA_HC_PROTOCOL  *This,
+  IN UINT16                     IoAddress,
+  IN UINT16                     IoLength,
+  OUT UINT64                    *IoApertureHandle
+  );
+
+/**
+  Close I/O aperture.
+
+  This function closes a previously opened I/O aperture handle. If there are no
+  more I/O aperture handles that refer to the hardware I/O aperture resource,
+  then the hardware I/O aperture is closed. It may be possible that a single
+  hardware aperture may be used for more than one device. This function tracks
+  the number of times that each aperture is referenced, and does not close the
+  hardware aperture (via CloseIoAperture()) until there are no more references to it.
+
+  @param This             A pointer to this instance of the EFI_ISA_HC_PROTOCOL.
+  @param IoApertureHandle The I/O aperture handle previously returned from a 
+                          call to OpenIoAperture().
+
+  @retval EFI_SUCCESS     The IO aperture was closed successfully.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ISA_HC_CLOSE_IO) (
+  IN CONST EFI_ISA_HC_PROTOCOL      *This,
+  IN UINT64                         IoApertureHandle
+  );
+
+///
+/// ISA HC Protocol
+///
+struct _EFI_ISA_HC_PROTOCOL {
+  ///
+  /// The version of this protocol. Higher version numbers are backward
+  /// compatible with lower version numbers.
+  ///
+  UINT32               Version;
+  ///
+  /// Open an I/O aperture.
+  ///
+  EFI_ISA_HC_OPEN_IO   OpenIoAperture;
+  ///
+  /// Close an I/O aperture.
+  ///
+  EFI_ISA_HC_CLOSE_IO  CloseIoAperture;
+};
+
+///
+/// Reference to variable defined in the .DEC file
+///
+extern EFI_GUID gEfiIsaHcProtocolGuid;
+extern EFI_GUID gEfiIsaHcServiceBindingProtocolGuid;
+
+#endif  //  __ISA_HC_H__
diff --git a/MdePkg/Include/Protocol/Kms.h b/MdePkg/Include/Protocol/Kms.h
new file mode 100644
index 000000000000..a8e58bc89b49
--- /dev/null
+++ b/MdePkg/Include/Protocol/Kms.h
@@ -0,0 +1,1328 @@
+/** @file
+  The Key Management Service (KMS) protocol as defined in the UEFI 2.3.1 specification is to
+  provides services to generate, store, retrieve, and manage cryptographic keys.
+  The intention is to specify a simple generic protocol that could be used for many implementations.
+
+  A driver implementing the protocol may need to provide basic key service that consists of a
+  key store and cryptographic key generation capability. It may connect to an external key
+  server over the network, or to a Hardware Security Module (HSM) attached to the system it
+  runs on, or anything else that is capable of providing the key management service.
+
+  Copyright (c) 2011, 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 __KMS_H__
+#define __KMS_H__
+
+#define EFI_KMS_PROTOCOL_GUID \
+  { \
+    0xEC3A978D, 0x7C4E, 0x48FA, {0x9A, 0xBE, 0x6A, 0xD9, 0x1C, 0xC8, 0xF8, 0x11 } \
+  }
+
+typedef struct _EFI_KMS_PROTOCOL EFI_KMS_PROTOCOL;
+
+//
+// Where appropriate, EFI_KMS_DATA_TYPE values may be combined using a bitwise 'OR'
+// operation to indicate support for multiple data types.
+//
+#define EFI_KMS_DATA_TYPE_NONE      0
+#define EFI_KMS_DATA_TYPE_BINARY    1
+#define EFI_KMS_DATA_TYPE_ASCII     2
+#define EFI_KMS_DATA_TYPE_UNICODE   4
+#define EFI_KMS_DATA_TYPE_UTF8      8
+
+
+//
+// The key formats recognized by the KMS protocol are defined by an EFI_GUID which specifies
+// a (key-algorithm, key-size) pair. The names of these GUIDs are in the format
+// EFI_KMS_KEY_(key-algorithm)_(key-size)_GUID, where the key-size is expressed in bits.
+// The key formats recognized fall into three categories, generic (no algorithm), hash algorithms,
+// and encrypted algorithms.
+//
+
+///
+/// The following GUIDs define formats that contain generic key data of a specific size in bits,
+/// but which is not associated with any specific key algorithm(s).
+///@{
+#define EFI_KMS_FORMAT_GENERIC_128_GUID \
+  { \
+    0xec8a3d69, 0x6ddf, 0x4108, {0x94, 0x76, 0x73, 0x37, 0xfc, 0x52, 0x21, 0x36 } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_160_GUID \
+  { \
+    0xa3b3e6f8, 0xefca, 0x4bc1, {0x88, 0xfb, 0xcb, 0x87, 0x33, 0x9b, 0x25, 0x79 } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_256_GUID \
+  { \
+    0x70f64793, 0xc323, 0x4261, {0xac, 0x2c, 0xd8, 0x76, 0xf2, 0x7c, 0x53, 0x45 } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_512_GUID \
+  { \
+    0x978fe043, 0xd7af, 0x422e, {0x8a, 0x92, 0x2b, 0x48, 0xe4, 0x63, 0xbd, 0xe6 } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_1024_GUID \
+  { \
+    0x43be0b44, 0x874b, 0x4ead, {0xb0, 0x9c, 0x24, 0x1a, 0x4f, 0xbd, 0x7e, 0xb3 } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_2048_GUID \
+  { \
+    0x40093f23, 0x630c, 0x4626, {0x9c, 0x48, 0x40, 0x37, 0x3b, 0x19, 0xcb, 0xbe } \
+  }
+#define EFI_KMS_FORMAT_GENERIC_3072_GUID \
+  { \
+    0xb9237513, 0x6c44, 0x4411, {0xa9, 0x90, 0x21, 0xe5, 0x56, 0xe0, 0x5a, 0xde } \
+  }
+///@}
+
+///
+/// These GUIDS define key data formats that contain data generated by basic hash algorithms
+/// with no cryptographic properties.
+///@{
+#define EFI_KMS_FORMAT_MD2_128_GUID \
+  { \
+    0x78be11c4, 0xee44, 0x4a22, {0x9f, 0x05, 0x03, 0x85, 0x2e, 0xc5, 0xc9, 0x78 } \
+  }
+#define EFI_KMS_FORMAT_MDC2_128_GUID \
+  { \
+    0xf7ad60f8, 0xefa8, 0x44a3, {0x91, 0x13, 0x23, 0x1f, 0x39, 0x9e, 0xb4, 0xc7 } \
+  }
+#define EFI_KMS_FORMAT_MD4_128_GUID \
+  { \
+    0xd1c17aa1, 0xcac5, 0x400f, {0xbe, 0x17, 0xe2, 0xa2, 0xae, 0x06, 0x67, 0x7c } \
+  }
+#define EFI_KMS_FORMAT_MDC4_128_GUID \
+  { \
+    0x3fa4f847, 0xd8eb, 0x4df4, {0xbd, 0x49, 0x10, 0x3a, 0x0a, 0x84, 0x7b, 0xbc } \
+  }
+#define EFI_KMS_FORMAT_MD5_128_GUID \
+  { \
+    0xdcbc3662, 0x9cda, 0x4b52, {0xa0, 0x4c, 0x82, 0xeb, 0x1d, 0x23, 0x48, 0xc7 } \
+  }
+#define EFI_KMS_FORMAT_MD5SHA_128_GUID \
+  { \
+    0x1c178237, 0x6897, 0x459e, {0x9d, 0x36, 0x67, 0xce, 0x8e, 0xf9, 0x4f, 0x76 } \
+  }
+#define EFI_KMS_FORMAT_SHA1_160_GUID \
+  { \
+    0x453c5e5a, 0x482d, 0x43f0, {0x87, 0xc9, 0x59, 0x41, 0xf3, 0xa3, 0x8a, 0xc2 } \
+  }
+#define EFI_KMS_FORMAT_SHA256_256_GUID \
+  { \
+    0x6bb4f5cd, 0x8022, 0x448d, {0xbc, 0x6d, 0x77, 0x1b, 0xae, 0x93, 0x5f, 0xc6 } \
+  }
+#define EFI_KMS_FORMAT_SHA512_512_GUID \
+  { \
+    0x2f240e12, 0xe14d, 0x475c, {0x83, 0xb0, 0xef, 0xff, 0x22, 0xd7, 0x7b, 0xe7 } \
+  }
+///@}
+
+///
+/// These GUIDs define key data formats that contain data generated by cryptographic key algorithms.
+/// There may or may not be a separate data hashing algorithm associated with the key algorithm.
+///@{
+#define EFI_KMS_FORMAT_AESXTS_128_GUID \
+  { \
+    0x4776e33f, 0xdb47, 0x479a, {0xa2, 0x5f, 0xa1, 0xcd, 0x0a, 0xfa, 0xb3, 0x8b } \
+  }
+#define EFI_KMS_FORMAT_AESXTS_256_GUID \
+  { \
+    0xdc7e8613, 0xc4bb, 0x4db0, {0x84, 0x62, 0x13, 0x51, 0x13, 0x57, 0xab, 0xe2 } \
+  }
+#define EFI_KMS_FORMAT_AESCBC_128_GUID \
+  { \
+    0xa0e8ee6a, 0x0e92, 0x44d4, {0x86, 0x1b, 0x0e, 0xaa, 0x4a, 0xca, 0x44, 0xa2 } \
+  }
+#define EFI_KMS_FORMAT_AESCBC_256_GUID \
+  { \
+    0xd7e69789, 0x1f68, 0x45e8, {0x96, 0xef, 0x3b, 0x64, 0x07, 0xa5, 0xb2, 0xdc } \
+  }
+#define EFI_KMS_FORMAT_RSASHA1_1024_GUID \
+  { \
+    0x56417bed, 0x6bbe, 0x4882, {0x86, 0xa0, 0x3a, 0xe8, 0xbb, 0x17, 0xf8, 0xf9 } \
+  }
+#define EFI_KMS_FORMAT_RSASHA1_2048_GUID \
+  { \
+    0xf66447d4, 0x75a6, 0x463e, {0xa8, 0x19, 0x07, 0x7f, 0x2d, 0xda, 0x05, 0xe9 } \
+  }
+#define EFI_KMS_FORMAT_RSASHA256_2048_GUID \
+  { \
+    0xa477af13, 0x877d, 0x4060, {0xba, 0xa1, 0x25, 0xd1, 0xbe, 0xa0, 0x8a, 0xd3 } \
+  }
+#define EFI_KMS_FORMAT_RSASHA256_3072_GUID \
+  { \
+    0x4e1356c2,  0xeed, 0x463f, {0x81, 0x47, 0x99, 0x33, 0xab, 0xdb, 0xc7, 0xd5 } \
+  }
+///@}
+
+#define EFI_KMS_ATTRIBUTE_TYPE_NONE             0x00
+#define EFI_KMS_ATTRIBUTE_TYPE_INTEGER          0x01
+#define EFI_KMS_ATTRIBUTE_TYPE_LONG_INTEGER     0x02
+#define EFI_KMS_ATTRIBUTE_TYPE_BIG_INTEGER      0x03
+#define EFI_KMS_ATTRIBUTE_TYPE_ENUMERATION      0x04
+#define EFI_KMS_ATTRIBUTE_TYPE_BOOLEAN          0x05
+#define EFI_KMS_ATTRIBUTE_TYPE_BYTE_STRING      0x06
+#define EFI_KMS_ATTRIBUTE_TYPE_TEXT_STRING      0x07
+#define EFI_KMS_ATTRIBUTE_TYPE_DATE_TIME        0x08
+#define EFI_KMS_ATTRIBUTE_TYPE_INTERVAL         0x09
+#define EFI_KMS_ATTRIBUTE_TYPE_STRUCTURE        0x0A
+#define EFI_KMS_ATTRIBUTE_TYPE_DYNAMIC          0x0B
+
+typedef struct {
+  ///
+  /// The size in bytes for the client identifier.
+  ///
+  UINT16        ClientIdSize;
+  ///
+  /// Pointer to a valid client identifier.
+  ///
+  VOID          *ClientId;
+  ///
+  /// The client name string type used by this client. The string type set here must be one of
+  /// the string types reported in the ClientNameStringTypes field of the KMS protocol. If the
+  /// KMS does not support client names, this field should be set to EFI_KMS_DATA_TYPE_NONE.
+  ///
+  UINT8         ClientNameType;
+  ///
+  /// The size in characters for the client name. This field will be ignored if
+  /// ClientNameStringType is set to EFI_KMS_DATA_TYPE_NONE. Otherwise, it must contain
+  /// number of characters contained in the ClientName field.
+  ///
+  UINT8         ClientNameCount;
+  ///
+  /// Pointer to a client name. This field will be ignored if ClientNameStringType is set to
+  /// EFI_KMS_DATA_TYPE_NONE. Otherwise, it must point to a valid string of the specified type.
+  ///
+  VOID          *ClientName;
+} EFI_KMS_CLIENT_INFO;
+
+typedef struct {
+  ///
+  /// The size of the KeyIdentifier field in bytes. This field is limited to the range 0 to 255.
+  ///
+  UINT8         KeyIdentifierSize;
+  ///
+  /// Pointer to an array of KeyIdentifierType elements.
+  ///
+  VOID          *KeyIdentifier;
+  ///
+  /// An EFI_GUID which specifies the algorithm and key value size for this key.
+  ///
+  EFI_GUID      KeyFormat;
+  ///
+  /// Pointer to a key value for a key specified by the KeyFormat field. A NULL value for this
+  /// field indicates that no key is available.
+  ///
+  VOID          *KeyValue;
+  ///
+  /// Specifies the results of KMS operations performed with this descriptor. This field is used
+  /// to indicate the status of individual operations when a KMS function is called with multiple
+  /// EFI_KMS_KEY_DESCRIPTOR structures.
+  /// KeyStatus codes returned for the individual key requests are:
+  ///   EFI_SUCCESS             Successfully processed this key.
+  ///   EFI_WARN_STALE_DATA     Successfully processed this key, however, the key's parameters
+  ///                           exceed internal policies/limits and should be replaced.
+  ///   EFI_COMPROMISED_DATA    Successfully processed this key, but the key may have been
+  ///                           compromised and must be replaced.
+  ///   EFI_UNSUPPORTED         Key format is not supported by the service.
+  ///   EFI_OUT_OF_RESOURCES    Could not allocate resources for the key processing.
+  ///   EFI_TIMEOUT             Timed out waiting for device or key server.
+  ///   EFI_DEVICE_ERROR        Device or key server error.
+  ///   EFI_INVALID_PARAMETER   KeyFormat is invalid.
+  ///   EFI_NOT_FOUND           The key does not exist on the KMS.
+  ///
+  EFI_STATUS    KeyStatus;
+} EFI_KMS_KEY_DESCRIPTOR;
+
+typedef struct {
+  ///
+  /// Part of a tag-type-length triplet that identifies the KeyAttributeData formatting. The
+  /// definition of the value is outside the scope of this standard and may be defined by the KMS.
+  ///
+  UINT16        Tag;
+  ///
+  /// Part of a tag-type-length triplet that identifies the KeyAttributeData formatting. The
+  /// definition of the value is outside the scope of this standard and may be defined by the KMS.
+  ///
+  UINT16        Type;
+  ///
+  /// Length in bytes of the KeyAttributeData.
+  ///
+  UINT32        Length;
+  ///
+  /// An array of bytes to hold the attribute data associated with the KeyAttributeIdentifier.
+  ///
+  UINT8         KeyAttributeData[1];
+} EFI_KMS_DYNAMIC_FIELD;
+
+typedef struct {
+  ///
+  /// The number of members in the EFI_KMS_DYNAMIC_ATTRIBUTE structure.
+  ///
+  UINT32                    FieldCount;
+  ///
+  /// An array of EFI_KMS_DYNAMIC_FIELD structures.
+  ///
+  EFI_KMS_DYNAMIC_FIELD     Field[1];
+} EFI_KMS_DYNAMIC_ATTRIBUTE;
+
+typedef struct {
+  ///
+  /// The data type used for the KeyAttributeIdentifier field. Values for this field are defined
+  /// by the EFI_KMS_DATA_TYPE constants, except that EFI_KMS_DATA_TYPE_BINARY is not
+  /// valid for this field.
+  ///
+  UINT8         KeyAttributeIdentifierType;
+  ///
+  /// The length of the KeyAttributeIdentifier field in units defined by KeyAttributeIdentifierType
+  /// field. This field is limited to the range 0 to 255.
+  ///
+  UINT8         KeyAttributeIdentifierCount;
+  ///
+  /// Pointer to an array of KeyAttributeIdentifierType elements. For string types, there must
+  /// not be a null-termination element at the end of the array.
+  ///
+  VOID          *KeyAttributeIdentifier;
+  ///
+  /// The instance number of this attribute. If there is only one instance, the value is set to
+  /// one. If this value is set to 0xFFFF (all binary 1's) then this field should be ignored if an
+  /// output or treated as a wild card matching any value if it is an input. If the attribute is
+  /// stored with this field, it will match any attribute request regardless of the setting of the
+  /// field in the request. If set to 0xFFFF in the request, it will match any attribute with the
+  /// same KeyAttributeIdentifier.
+  ///
+  UINT16        KeyAttributeInstance;
+  ///
+  /// The data type of the KeyAttributeValue (e.g. struct, bool, etc.). See the list of
+  /// KeyAttributeType definitions.
+  ///
+  UINT16        KeyAttributeType;
+  ///
+  /// The size in bytes of the KeyAttribute field. A value of zero for this field indicates that no
+  /// key attribute value is available.
+  ///
+  UINT16        KeyAttributeValueSize;
+  ///
+  /// Pointer to a key attribute value for the attribute specified by the KeyAttributeIdentifier
+  /// field. If the KeyAttributeValueSize field is zero, then this field must be NULL.
+  ///
+  VOID          *KeyAttributeValue;
+  ///
+  /// KeyAttributeStatusSpecifies the results of KMS operations performed with this attribute.
+  /// This field is used to indicate the status of individual operations when a KMS function is
+  /// called with multiple EFI_KMS_KEY_ATTRIBUTE structures.
+  /// KeyAttributeStatus codes returned for the individual key attribute requests are:
+  ///   EFI_SUCCESS             Successfully processed this request.
+  ///   EFI_WARN_STALE_DATA     Successfully processed this request, however, the key's
+  ///                           parameters exceed internal policies/limits and should be replaced.
+  ///   EFI_COMPROMISED_DATA    Successfully processed this request, but the key may have been
+  ///                           compromised and must be replaced.
+  ///   EFI_UNSUPPORTED         Key attribute format is not supported by the service.
+  ///   EFI_OUT_OF_RESOURCES    Could not allocate resources for the request processing.
+  ///   EFI_TIMEOUT             Timed out waiting for device or key server.
+  ///   EFI_DEVICE_ERROR        Device or key server error.
+  ///   EFI_INVALID_PARAMETER   A field in the EFI_KMS_KEY_ATTRIBUTE structure is invalid.
+  ///   EFI_NOT_FOUND           The key attribute does not exist on the KMS.
+  ///
+  EFI_STATUS    KeyAttributeStatus;
+} EFI_KMS_KEY_ATTRIBUTE;
+
+/**
+  Get the current status of the key management service.
+
+  @param[in]      This              Pointer to the EFI_KMS_PROTOCOL instance.
+
+  @retval EFI_SUCCESS               The KMS is ready for use.
+  @retval EFI_NOT_READY             No connection to the KMS is available.
+  @retval EFI_NO_MAPPING            No valid connection configuration exists for the KMS.
+  @retval EFI_NO_RESPONSE           No response was received from the KMS.
+  @retval EFI_DEVICE_ERROR          An error occurred when attempting to access the KMS.
+  @retval EFI_INVALID_PARAMETER     This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_GET_SERVICE_STATUS) (
+  IN EFI_KMS_PROTOCOL           *This
+  );
+
+/**
+  Register client information with the supported KMS.
+
+  @param[in]      This              Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client            Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] ClientDataSize    Pointer to the size, in bytes, of an arbitrary block of 
+                                    data specified by the ClientData parameter. This
+                                    parameter may be NULL, in which case the ClientData
+                                    parameter will be ignored and no data will be
+                                    transferred to or from the KMS. If the parameter is
+                                    not NULL, then ClientData must be a valid pointer.
+                                    If the value pointed to is 0, no data will be transferred
+                                    to the KMS, but data may be returned by the KMS.
+                                    For all non-zero values *ClientData will be transferred
+                                    to the KMS, which may also return data to the caller.
+                                    In all cases, the value upon return to the caller will
+                                    be the size of the data block returned to the caller,
+                                    which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData        Pointer to a pointer to an arbitrary block of data of
+                                    *ClientDataSize that is to be passed directly to the
+                                    KMS if it supports the use of client data. This 
+                                    parameter may be NULL if and only if the 
+                                    ClientDataSize parameter is also NULL. Upon return to
+                                    the caller, *ClientData points to a block of data of 
+                                    *ClientDataSize that was returned from the KMS. 
+                                    If the returned value for *ClientDataSize is zero,
+                                    then the returned value for *ClientData must be NULL
+                                    and should be ignored by the caller. The KMS protocol
+                                    consumer is responsible for freeing all valid buffers
+                                    used for client data regardless of whether they are
+                                    allocated by the caller for input to the function or by
+                                    the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS               The client information has been accepted by the KMS.
+  @retval EFI_NOT_READY             No connection to the KMS is available.
+  @retval EFI_NO_RESPONSE           There was no response from the device or the key server.
+  @retval EFI_ACCESS_DENIED         Access was denied by the device or the key server.
+  @retval EFI_DEVICE_ERROR          An error occurred when attempting to access the KMS.
+  @retval EFI_OUT_OF_RESOURCES      Required resources were not available to perform the function.
+  @retval EFI_INVALID_PARAMETER     This is NULL.
+  @retval EFI_UNSUPPORTED           The KMS does not support the use of client identifiers.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_REGISTER_CLIENT) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  ); 
+
+/**
+  Request that the KMS generate one or more new keys and associate them with key identifiers.
+  The key value(s) is returned to the caller.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] KeyDescriptorCount Pointer to a count of the number of key descriptors to be
+                                     processed by this operation. On return, this number
+                                     will be updated with the number of key descriptors
+                                     successfully processed.
+  @param[in, out] KeyDescriptors     Pointer to an array of EFI_KMS_KEY_DESCRIPTOR
+                                     structures which describe the keys to be generated.
+                                     On input, the KeyIdentifierSize and the KeyIdentifier
+                                     may specify an identifier to be used for the key,
+                                     but this is not required. The KeyFormat field must
+                                     specify a key format GUID reported as supported by
+                                     the KeyFormats field of the EFI_KMS_PROTOCOL.
+                                     The value for this field in the first key descriptor will
+                                     be considered the default value for subsequent key
+                                     descriptors requested in this operation if those key
+                                     descriptors have a NULL GUID in the key format field.
+                                     On output, the KeyIdentifierSize and KeyIdentifier fields
+                                     will specify an identifier for the key which will be either
+                                     the original identifier if one was provided, or an identifier
+                                     generated either by the KMS or the KMS protocol
+                                     implementation. The KeyFormat field will be updated
+                                     with the GUID used to generate the key if it was a
+                                     NULL GUID, and the KeyValue field will contain a pointer
+                                     to memory containing the key value for the generated
+                                     key. Memory for both the KeyIdentifier and the KeyValue
+                                     fields will be allocated with the BOOT_SERVICES_DATA
+                                     type and must be freed by the caller when it is no longer
+                                     needed. Also, the KeyStatus field must reflect the result
+                                     of the request relative to that key.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully generated and retrieved all requested keys.
+  @retval EFI_UNSUPPORTED            This function is not supported by the KMS. --OR--
+                                     One (or more) of the key requests submitted is not supported by
+                                     the KMS. Check individual key request(s) to see which ones
+                                     may have been processed.
+  @retval EFI_OUT_OF_RESOURCES       Required resources were not available to perform the function.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     request(s) to see which ones may have been processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either no id was
+                                     provided or an invalid id was provided.
+  @retval EFI_DEVICE_ERROR           An error occurred when attempting to access the KMS. Check
+                                     individual key request(s) to see which ones may have been
+                                     processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyDescriptorCount is NULL, or Keys is NULL.
+  @retval EFI_NOT_FOUND              One or more EFI_KMS_KEY_DESCRIPTOR structures
+                                     could not be processed properly. KeyDescriptorCount
+                                     contains the number of structures which were successfully
+                                     processed. Individual structures will reflect the status of the
+                                     processing for that structure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_CREATE_KEY) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINT16                 *KeyDescriptorCount,
+  IN OUT EFI_KMS_KEY_DESCRIPTOR *KeyDescriptors,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Retrieve an existing key.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] KeyDescriptorCount Pointer to a count of the number of key descriptors to be
+                                     processed by this operation. On return, this number
+                                     will be updated with the number of key descriptors
+                                     successfully processed.
+  @param[in, out] KeyDescriptors     Pointer to an array of EFI_KMS_KEY_DESCRIPTOR
+                                     structures which describe the keys to be retrieved
+                                     from the KMS.
+                                     On input, the KeyIdentifierSize and the KeyIdentifier
+                                     must specify an identifier to be used to retrieve a
+                                     specific key. All other fields in the descriptor should
+                                     be NULL.
+                                     On output, the KeyIdentifierSize and KeyIdentifier fields
+                                     will be unchanged, while the KeyFormat and KeyValue
+                                     fields will be updated values associated with this key
+                                     identifier. Memory for the KeyValue field will be 
+                                     allocated with the BOOT_SERVICES_DATA type and
+                                     must be freed by the caller when it is no longer needed.
+                                     Also, the KeyStatus field will reflect the result of the
+                                     request relative to the individual key descriptor.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully retrieved all requested keys.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate resources for the method processing.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     request(s) to see which ones may have been processed.
+  @retval EFI_BUFFER_TOO_SMALL       If multiple keys are associated with a single identifier, and the
+                                     KeyValue buffer does not contain enough structures
+                                     (KeyDescriptorCount) to contain all the key data, then
+                                     the available structures will be filled and
+                                     KeyDescriptorCount will be updated to indicate the
+                                     number of keys which could not be processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key request(s) to
+                                     see which ones may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyDescriptorCount is NULL, or Keys is NULL.
+  @retval EFI_NOT_FOUND              One or more EFI_KMS_KEY_DESCRIPTOR structures
+                                     could not be processed properly. KeyDescriptorCount
+                                     contains the number of structures which were successfully
+                                     processed. Individual structures will reflect the status of the
+                                     processing for that structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_GET_KEY) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINT16                 *KeyDescriptorCount,
+  IN OUT EFI_KMS_KEY_DESCRIPTOR *KeyDescriptors,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Add a new key.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] KeyDescriptorCount Pointer to a count of the number of key descriptors to be
+                                     processed by this operation. On normal return, this
+                                     number will be updated with the number of key
+                                     descriptors successfully processed.
+  @param[in, out] KeyDescriptors     Pointer to an array of EFI_KMS_KEY_DESCRIPTOR
+                                     structures which describe the keys to be added.
+                                     On input, the KeyId field for first key must contain
+                                     valid identifier data to be used for adding a key to
+                                     the KMS. The values for these fields in this key
+                                     definition will be considered default values for
+                                     subsequent keys requested in this operation. A value
+                                     of 0 in any subsequent KeyId field will be replaced
+                                     with the current default value. The KeyFormat and
+                                     KeyValue fields for each key to be added must contain
+                                     consistent values to be associated with the given KeyId.
+                                     On return, the KeyStatus field will reflect the result
+                                     of the operation for each key request.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully added all requested keys.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate required resources.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     request(s) to see which ones may have been processed.
+  @retval EFI_BUFFER_TOO_SMALL       If multiple keys are associated with a single identifier, and the
+                                     KeyValue buffer does not contain enough structures
+                                     (KeyDescriptorCount) to contain all the key data, then
+                                     the available structures will be filled and
+                                     KeyDescriptorCount will be updated to indicate the
+                                     number of keys which could not be processed
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key request(s) to
+                                     see which ones may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyDescriptorCount is NULL, or Keys is NULL.
+  @retval EFI_NOT_FOUND              One or more EFI_KMS_KEY_DESCRIPTOR structures
+                                     could not be processed properly. KeyDescriptorCount
+                                     contains the number of structures which were successfully
+                                     processed. Individual structures will reflect the status of the
+                                     processing for that structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_ADD_KEY) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINT16                 *KeyDescriptorCount,
+  IN OUT EFI_KMS_KEY_DESCRIPTOR *KeyDescriptors,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Delete an existing key from the KMS database.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] KeyDescriptorCount Pointer to a count of the number of key descriptors to be
+                                     processed by this operation. On normal return, this
+                                     number will be updated with the number of key
+                                     descriptors successfully processed.
+  @param[in, out] KeyDescriptors     Pointer to an array of EFI_KMS_KEY_DESCRIPTOR
+                                     structures which describe the keys to be deleted.
+                                     On input, the KeyId field for first key must contain
+                                     valid identifier data to be used for adding a key to
+                                     the KMS. The values for these fields in this key
+                                     definition will be considered default values for
+                                     subsequent keys requested in this operation. A value
+                                     of 0 in any subsequent KeyId field will be replaced
+                                     with the current default value. The KeyFormat and
+                                     KeyValue fields are ignored, but should be 0.
+                                     On return, the KeyStatus field will reflect the result
+                                     of the operation for each key request.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully deleted all requested keys.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate required resources.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     request(s) to see which ones may have been processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key request(s) to
+                                     see which ones may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyDescriptorCount is NULL, or Keys is NULL.
+  @retval EFI_NOT_FOUND              One or more EFI_KMS_KEY_DESCRIPTOR structures
+                                     could not be processed properly. KeyDescriptorCount
+                                     contains the number of structures which were successfully
+                                     processed. Individual structures will reflect the status of the
+                                     processing for that structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_DELETE_KEY) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINT16                 *KeyDescriptorCount,
+  IN OUT EFI_KMS_KEY_DESCRIPTOR *KeyDescriptors,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Get one or more attributes associated with a specified key identifier.
+  If none are found, the returned attributes count contains a value of zero.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in]      KeyIdentifierSize  Pointer to the size in bytes of the KeyIdentifier variable.
+  @param[in]      KeyIdentifier      Pointer to the key identifier associated with this key.
+  @param[in, out] KeyAttributesCount Pointer to the number of EFI_KMS_KEY_ATTRIBUTE
+                                     structures associated with the Key identifier. If none
+                                     are found, the count value is zero on return.
+                                     On input this value reflects the number of KeyAttributes
+                                     that may be returned.
+                                     On output, the value reflects the number of completed
+                                     KeyAttributes structures found.
+  @param[in, out] KeyAttributes      Pointer to an array of EFI_KMS_KEY_ATTRIBUTE
+                                     structures associated with the Key Identifier.
+                                     On input, the fields in the structure should be NULL.
+                                     On output, the attribute fields will have updated values
+                                     for attributes associated with this key identifier.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully retrieved all key attributes.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate resources for the method processing.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     attribute request(s) to see which ones may have been
+                                     processed.
+  @retval EFI_BUFFER_TOO_SMALL       If multiple key attributes are associated with a single identifier,
+                                     and the KeyAttributes buffer does not contain enough
+                                     structures (KeyAttributesCount) to contain all the key
+                                     attributes data, then the available structures will be filled and
+                                     KeyAttributesCount will be updated to indicate the
+                                     number of key attributes which could not be processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key attribute
+                                     request(s) (i.e. key attribute status for each) to see which ones
+                                     may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyIdentifierSize is NULL , or KeyIdentifier
+                                     is NULL, or KeyAttributes is NULL, or
+                                     KeyAttributesSize is NULL.
+  @retval EFI_NOT_FOUND              The KeyIdentifier could not be found.
+                                     KeyAttributesCount contains zero. Individual
+                                     structures will reflect the status of the processing for that
+                                     structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_GET_KEY_ATTRIBUTES) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN UINT8                      *KeyIdentifierSize,
+  IN CONST VOID                 *KeyIdentifier,
+  IN OUT UINT16                 *KeyAttributesCount,
+  IN OUT EFI_KMS_KEY_ATTRIBUTE  *KeyAttributes,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Add one or more attributes to a key specified by a key identifier.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in]      KeyIdentifierSize  Pointer to the size in bytes of the KeyIdentifier variable.
+  @param[in]      KeyIdentifier      Pointer to the key identifier associated with this key.
+  @param[in, out] KeyAttributesCount Pointer to the number of EFI_KMS_KEY_ATTRIBUTE
+                                     structures to associate with the Key. On normal returns,
+                                     this number will be updated with the number of key
+                                     attributes successfully processed.
+  @param[in, out] KeyAttributes      Pointer to an array of EFI_KMS_KEY_ATTRIBUTE
+                                     structures providing the attribute information to
+                                     associate with the key.
+                                     On input, the values for the fields in the structure
+                                     are completely filled in.
+                                     On return the KeyAttributeStatus field will reflect the
+                                     result of the operation for each key attribute request.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully added all requested key attributes.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate required resources.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     attribute request(s) to see which ones may have been
+                                     processed.
+  @retval EFI_BUFFER_TOO_SMALL       If multiple keys attributes are associated with a single key
+                                     identifier, and the attributes buffer does not contain
+                                     enough structures (KeyAttributesCount) to contain all
+                                     the data, then the available structures will be filled and
+                                     KeyAttributesCount will be updated to indicate the
+                                     number of key attributes which could not be processed. The
+                                     status of each key attribute is also updated indicating success or
+                                     failure for that attribute in case there are other errors for those
+                                     attributes that could be processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key attribute
+                                     request(s) (i.e. key attribute status for each) to see which ones
+                                     may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyAttributesCount is NULL, or KeyAttributes
+                                     is NULL, or KeyIdentifierSize is NULL, or
+                                     KeyIdentifer is NULL.
+  @retval EFI_NOT_FOUND              The KeyIdentifier could not be found. On return the
+                                     KeyAttributesCount contains the number of attributes
+                                     processed. Individual structures will reflect the status of the
+                                     processing for that structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_ADD_KEY_ATTRIBUTES) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN UINT8                      *KeyIdentifierSize,
+  IN CONST VOID                 *KeyIdentifier,
+  IN OUT UINT16                 *KeyAttributesCount,
+  IN OUT EFI_KMS_KEY_ATTRIBUTE  *KeyAttributes,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Delete attributes to a key specified by a key identifier.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in]      KeyIdentifierSize  Pointer to the size in bytes of the KeyIdentifier variable.
+  @param[in]      KeyIdentifier      Pointer to the key identifier associated with this key.
+  @param[in, out] KeyAttributesCount Pointer to the number of EFI_KMS_KEY_ATTRIBUTE
+                                     structures to associate with the Key.
+                                     On input, the count value is one or more.
+                                     On normal returns, this number will be updated with
+                                     the number of key attributes successfully processed.
+  @param[in, out] KeyAttributes      Pointer to an array of EFI_KMS_KEY_ATTRIBUTE
+                                     structures providing the attribute information to
+                                     associate with the key.
+                                     On input, the values for the fields in the structure
+                                     are completely filled in.
+                                     On return the KeyAttributeStatus field will reflect the
+                                     result of the operation for each key attribute request.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully deleted all requested key attributes.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate required resources.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     attribute request(s) to see which ones may have been
+                                     processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key attribute
+                                     request(s) (i.e. key attribute status for each) to see which ones
+                                     may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyAttributesCount is NULL, or
+                                     KeyAttributes is NULL, or KeyIdentifierSize
+                                     is NULL, or KeyIdentifer is NULL.
+  @retval EFI_NOT_FOUND              The KeyIdentifier could not be found or the attribute
+                                     could not be found. On return the KeyAttributesCount
+                                     contains the number of attributes processed. Individual
+                                     structures will reflect the status of the processing for that
+                                     structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_DELETE_KEY_ATTRIBUTES) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN UINT8                      *KeyIdentifierSize,
+  IN CONST VOID                 *KeyIdentifier,
+  IN OUT UINT16                 *KeyAttributesCount,
+  IN OUT EFI_KMS_KEY_ATTRIBUTE  *KeyAttributes,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+/**
+  Retrieve one or more key that has matched all of the specified key attributes.
+
+  @param[in]      This               Pointer to the EFI_KMS_PROTOCOL instance.
+  @param[in]      Client             Pointer to a valid EFI_KMS_CLIENT_INFO structure.
+  @param[in, out] KeyAttributesCount Pointer to a count of the number of key attribute structures
+                                     that must be matched for each returned key descriptor.
+                                     On input the count value is one or more.
+                                     On normal returns, this number will be updated with
+                                     the number of key attributes successfully processed.
+  @param[in, out] KeyAttributes      Pointer to an array of EFI_KMS_KEY_ATTRIBUTE
+                                     structure to search for.
+                                     On input, the values for the fields in the structure are
+                                     completely filled in.
+                                     On return the KeyAttributeStatus field will reflect the
+                                     result of the operation for each key attribute request.
+  @param[in, out] KeyDescriptorCount Pointer to a count of the number of key descriptors matched
+                                     by this operation.
+                                     On entry, this number will be zero.
+                                     On return, this number will be updated to the number
+                                     of key descriptors successfully found.
+  @param[in, out] KeyDescriptors     Pointer to an array of EFI_KMS_KEY_DESCRIPTOR
+                                     structures which describe the keys from the KMS
+                                     having the KeyAttribute(s) specified.
+                                     On input, this pointer will be NULL.
+                                     On output, the array will contain an
+                                     EFI_KMS_KEY_DESCRIPTOR structure for each key
+                                     meeting the search criteria. Memory for the array
+                                     and all KeyValue fields will be allocated with the
+                                     EfiBootServicesData type and must be freed by the
+                                     caller when it is no longer needed. Also, the KeyStatus
+                                     field of each descriptor will reflect the result of the
+                                     request relative to that key descriptor.
+  @param[in, out] ClientDataSize     Pointer to the size, in bytes, of an arbitrary block of 
+                                     data specified by the ClientData parameter. This
+                                     parameter may be NULL, in which case the ClientData
+                                     parameter will be ignored and no data will be
+                                     transferred to or from the KMS. If the parameter is
+                                     not NULL, then ClientData must be a valid pointer.
+                                     If the value pointed to is 0, no data will be transferred
+                                     to the KMS, but data may be returned by the KMS.
+                                     For all non-zero values *ClientData will be transferred
+                                     to the KMS, which may also return data to the caller.
+                                     In all cases, the value upon return to the caller will
+                                     be the size of the data block returned to the caller,
+                                     which will be zero if no data is returned from the KMS.
+  @param[in, out] ClientData         Pointer to a pointer to an arbitrary block of data of
+                                     *ClientDataSize that is to be passed directly to the
+                                     KMS if it supports the use of client data. This 
+                                     parameter may be NULL if and only if the 
+                                     ClientDataSize parameter is also NULL. Upon return to
+                                     the caller, *ClientData points to a block of data of 
+                                     *ClientDataSize that was returned from the KMS. 
+                                     If the returned value for *ClientDataSize is zero,
+                                     then the returned value for *ClientData must be NULL
+                                     and should be ignored by the caller. The KMS protocol
+                                     consumer is responsible for freeing all valid buffers
+                                     used for client data regardless of whether they are
+                                     allocated by the caller for input to the function or by
+                                     the implementation for output back to the caller.
+
+  @retval EFI_SUCCESS                Successfully retrieved all requested keys.
+  @retval EFI_OUT_OF_RESOURCES       Could not allocate required resources.
+  @retval EFI_TIMEOUT                Timed out waiting for device or key server. Check individual key
+                                     attribute request(s) to see which ones may have been
+                                     processed.
+  @retval EFI_BUFFER_TOO_SMALL       If multiple keys are associated with the attribute(s), and the
+                                     KeyValue buffer does not contain enough structures
+                                     (KeyDescriptorCount) to contain all the key data, then
+                                     the available structures will be filled and
+                                     KeyDescriptorCount will be updated to indicate the
+                                     number of keys which could not be processed.
+  @retval EFI_ACCESS_DENIED          Access was denied by the device or the key server; OR a
+                                     ClientId is required by the server and either none or an
+                                     invalid id was provided.
+  @retval EFI_DEVICE_ERROR           Device or key server error. Check individual key attribute
+                                     request(s) (i.e. key attribute status for each) to see which ones
+                                     may have been processed.
+  @retval EFI_INVALID_PARAMETER      This is NULL, ClientId is required but it is NULL,
+                                     KeyDescriptorCount is NULL, or
+                                     KeyDescriptors is NULL or KeyAttributes is
+                                     NULL, or KeyAttributesCount is NULL.
+  @retval EFI_NOT_FOUND              One or more EFI_KMS_KEY_ATTRIBUTE structures could
+                                     not be processed properly. KeyAttributeCount contains
+                                     the number of structures which were successfully processed.
+                                     Individual structures will reflect the status of the processing for
+                                     that structure.
+  @retval EFI_UNSUPPORTED            The implementation/KMS does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KMS_GET_KEY_BY_ATTRIBUTES) (
+  IN EFI_KMS_PROTOCOL           *This,
+  IN EFI_KMS_CLIENT_INFO        *Client,
+  IN OUT UINTN                  *KeyAttributeCount,
+  IN OUT EFI_KMS_KEY_ATTRIBUTE  *KeyAttributes,
+  IN OUT UINTN                  *KeyDescriptorCount,
+  IN OUT EFI_KMS_KEY_DESCRIPTOR *KeyDescriptors,
+  IN OUT UINTN                  *ClientDataSize OPTIONAL,
+  IN OUT VOID                   **ClientData OPTIONAL
+  );
+
+///
+/// The Key Management Service (KMS) protocol provides services to generate, store, retrieve,
+/// and manage cryptographic keys.
+///
+struct _EFI_KMS_PROTOCOL {
+  ///
+  /// Get the current status of the key management service. If the implementation has not yet
+  /// connected to the KMS, then a call to this function will initiate a connection. This is the
+  /// only function that is valid for use prior to the service being marked available.
+  ///
+  EFI_KMS_GET_SERVICE_STATUS        GetServiceStatus;
+  ///
+  /// Register a specific client with the KMS.
+  ///
+  EFI_KMS_REGISTER_CLIENT           RegisterClient;
+  ///
+  /// Request the generation of a new key and retrieve it.
+  ///
+  EFI_KMS_CREATE_KEY                CreateKey;
+  ///
+  /// Retrieve an existing key.
+  ///
+  EFI_KMS_GET_KEY                   GetKey;
+  ///
+  /// Add a local key to KMS database. If there is an existing key with this key identifier in the
+  /// KMS database, it will be replaced with the new key.
+  ///
+  EFI_KMS_ADD_KEY                   AddKey;
+  ///
+  /// Delete an existing key from the KMS database.
+  ///
+  EFI_KMS_DELETE_KEY                DeleteKey;
+  ///
+  /// Get attributes for an existing key in the KMS database.
+  ///
+  EFI_KMS_GET_KEY_ATTRIBUTES        GetKeyAttributes;
+  ///
+  /// Add attributes to an existing key in the KMS database.
+  ///
+  EFI_KMS_ADD_KEY_ATTRIBUTES        AddKeyAttributes;
+  ///
+  /// Delete attributes for an existing key in the KMS database.
+  ///
+  EFI_KMS_DELETE_KEY_ATTRIBUTES     DeleteKeyAttributes;
+  ///
+  /// Get existing key(s) with the specified attributes.
+  ///
+  EFI_KMS_GET_KEY_BY_ATTRIBUTES     GetKeyByAttributes;
+  ///
+  /// The version of this EFI_KMS_PROTOCOL structure. This must be set to 0x00020040 for
+  /// the initial version of this protocol.
+  ///
+  UINT32                            ProtocolVersion;
+  ///
+  /// Optional GUID used to identify a specific KMS. This GUID may be supplied by the provider,
+  /// by the implementation, or may be null. If is null, then the ServiceName must not be null.
+  ///
+  EFI_GUID                          ServiceId;
+  ///
+  /// Optional pointer to a unicode string which may be used to identify the KMS or provide
+  /// other information about the supplier.
+  ///
+  CHAR16                            *ServiceName;
+  ///
+  /// Optional 32-bit value which may be used to indicate the version of the KMS provided by
+  /// the supplier.
+  ///
+  UINT32                            ServiceVersion;
+  ///
+  /// TRUE if and only if the service is active and available for use. To avoid unnecessary
+  /// delays in POST, this protocol may be installed without connecting to the service. In this
+  /// case, the first call to the GetServiceStatus () function will cause the implementation to
+  /// connect to the supported service and mark it as available. The capabilities of this service
+  /// as defined in the reminder of this protocol are not guaranteed to be valid until the service
+  /// has been marked available.
+  ///
+  BOOLEAN                           ServiceAvailable;
+  ///
+  /// TRUE if and only if the service supports client identifiers. Client identifiers may be used
+  /// for auditing, access control or any other purpose specific to the implementation.
+  ///
+  BOOLEAN                           ClientIdSupported;
+  ///
+  /// TRUE if and only if the service requires a client identifier in order to process key requests.
+  /// FALSE otherwise.
+  ///
+  BOOLEAN                           ClientIdRequired;
+  ///
+  /// The maximum size in bytes for the client identifier.
+  ///
+  UINT16                            ClientIdMaxSize;
+  ///
+  /// The client name string type(s) supported by the KMS service. If client names are not
+  /// supported, this field will be set the EFI_KMS_DATA_TYPE_NONE. Otherwise, it will be set
+  /// to the inclusive 'OR' of all client name formats supported. Client names may be used for
+  /// auditing, access control or any other purpose specific to the implementation.
+  ///
+  UINT8                             ClientNameStringTypes;
+  ///
+  /// TRUE if only if the KMS requires a client name to be supplied to the service.
+  /// FALSE otherwise.
+  ///
+  BOOLEAN                           ClientNameRequired;
+  ///
+  /// The maximum number of characters allowed for the client name.
+  ///
+  UINT16                            ClientNameMaxCount;
+  ///
+  /// TRUE if and only if the service supports arbitrary client data requests. The use of client
+  /// data requires the caller to have specific knowledge of the individual KMS service and
+  /// should be used only if absolutely necessary.
+  /// FALSE otherwise.
+  ///
+  BOOLEAN                           ClientDataSupported;
+  ///
+  /// The maximum size in bytes for the client data. If the maximum data size is not specified
+  /// by the KMS or it is not known, then this field must be filled with all ones.
+  ///
+  UINTN                             ClientDataMaxSize;
+  ///
+  /// TRUE if variable length key identifiers are supported.
+  /// FALSE if a fixed length key identifier is supported.
+  ///
+  BOOLEAN                           KeyIdVariableLenSupported;
+  ///
+  /// If KeyIdVariableLenSupported is TRUE, this is the maximum supported key identifier length
+  /// in bytes. Otherwise this is the fixed length of key identifier supported. Key ids shorter
+  /// than the fixed length will be padded on the right with blanks.
+  ///
+  UINTN                             KeyIdMaxSize;
+  ///
+  /// The number of key format/size GUIDs returned in the KeyFormats field.
+  ///
+  UINTN                             KeyFormatsCount;
+  ///
+  /// A pointer to an array of EFI_GUID values which specify key formats/sizes supported by
+  /// this KMS. Each format/size pair will be specified by a separate EFI_GUID. At least one
+  /// key format/size must be supported. All formats/sizes with the same hashing algorithm
+  /// must be contiguous in the array, and for each hashing algorithm, the key sizes must be in
+  /// ascending order. See "Related Definitions" for GUIDs which identify supported key formats/sizes.
+  /// This list of GUIDs supported by the KMS is not required to be exhaustive, and the KMS
+  /// may provide support for additional key formats/sizes. Users may request key information
+  /// using an arbitrary GUID, but any GUID not recognized by the implementation or not
+  /// supported by the KMS will return an error code of EFI_UNSUPPORTED
+  ///
+  EFI_GUID                          *KeyFormats;
+  ///
+  /// TRUE if key attributes are supported.
+  /// FALSE if key attributes are not supported.
+  ///
+  BOOLEAN                           KeyAttributesSupported;
+  ///
+  /// The key attribute identifier string type(s) supported by the KMS service. If key attributes
+  /// are not supported, this field will be set to EFI_KMS_DATA_TYPE_NONE. Otherwise, it will
+  /// be set to the inclusive 'OR' of all key attribute identifier string types supported.
+  /// EFI_KMS_DATA_TYPE_BINARY is not valid for this field.
+  ///
+  UINT8                             KeyAttributeIdStringTypes;
+  UINT16                            KeyAttributeIdMaxCount;
+  ///
+  /// The number of predefined KeyAttributes structures returned in the KeyAttributes
+  /// parameter. If the KMS does not support predefined key attributes, or if it does not
+  /// provide a method to obtain predefined key attributes data, then this field must be zero.
+  ///
+  UINTN                             KeyAttributesCount;
+  ///
+  /// A pointer to an array of KeyAttributes structures which contains the predefined
+  /// attributes supported by this KMS. Each structure must contain a valid key attribute
+  /// identifier and should provide any other information as appropriate for the attribute,
+  /// including a default value if one exists. This variable must be set to NULL if the
+  /// KeyAttributesCount variable is zero. It must point to a valid buffer if the
+  /// KeyAttributesCount variable is non-zero.
+  /// This list of predefined attributes is not required to be exhaustive, and the KMS may
+  /// provide additional predefined attributes not enumerated in this list. The implementation
+  /// does not distinguish between predefined and used defined attributes, and therefore,
+  /// predefined attributes not enumerated will still be processed to the KMS.
+  ///
+  EFI_KMS_KEY_ATTRIBUTE             *KeyAttributes;
+};
+
+extern EFI_GUID gEfiKmsFormatGeneric128Guid;
+extern EFI_GUID gEfiKmsFormatGeneric160Guid;
+extern EFI_GUID gEfiKmsFormatGeneric256Guid;
+extern EFI_GUID gEfiKmsFormatGeneric512Guid;
+extern EFI_GUID gEfiKmsFormatGeneric1024Guid;
+extern EFI_GUID gEfiKmsFormatGeneric2048Guid;
+extern EFI_GUID gEfiKmsFormatGeneric3072Guid;
+extern EFI_GUID gEfiKmsFormatMd2128Guid;
+extern EFI_GUID gEfiKmsFormatMdc2128Guid;
+extern EFI_GUID gEfiKmsFormatMd4128Guid;
+extern EFI_GUID gEfiKmsFormatMdc4128Guid;
+extern EFI_GUID gEfiKmsFormatMd5128Guid;
+extern EFI_GUID gEfiKmsFormatMd5sha128Guid;
+extern EFI_GUID gEfiKmsFormatSha1160Guid;
+extern EFI_GUID gEfiKmsFormatSha256256Guid;
+extern EFI_GUID gEfiKmsFormatSha512512Guid;
+extern EFI_GUID gEfiKmsFormatAesxts128Guid;
+extern EFI_GUID gEfiKmsFormatAesxts256Guid;
+extern EFI_GUID gEfiKmsFormatAescbc128Guid;
+extern EFI_GUID gEfiKmsFormatAescbc256Guid;
+extern EFI_GUID gEfiKmsFormatRsasha11024Guid;
+extern EFI_GUID gEfiKmsFormatRsasha12048Guid;
+extern EFI_GUID gEfiKmsFormatRsasha2562048Guid;
+extern EFI_GUID gEfiKmsFormatRsasha2563072Guid;
+extern EFI_GUID gEfiKmsProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/LegacyRegion2.h b/MdePkg/Include/Protocol/LegacyRegion2.h
new file mode 100644
index 000000000000..6f553bd7ad25
--- /dev/null
+++ b/MdePkg/Include/Protocol/LegacyRegion2.h
@@ -0,0 +1,239 @@
+/** @file
+  The Legacy Region Protocol controls the read, write and boot-lock attributes for
+  the region 0xC0000 to 0xFFFFF.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+
+**/
+
+#ifndef __LEGACY_REGION2_H__
+#define __LEGACY_REGION2_H__
+
+
+#define EFI_LEGACY_REGION2_PROTOCOL_GUID \
+{ \
+  0x70101eaf, 0x85, 0x440c, {0xb3, 0x56, 0x8e, 0xe3, 0x6f, 0xef, 0x24, 0xf0 } \
+}
+
+typedef struct _EFI_LEGACY_REGION2_PROTOCOL EFI_LEGACY_REGION2_PROTOCOL;
+
+/**
+  Modify the hardware to allow (decode) or disallow (not decode) memory reads in a region.
+
+  If the On parameter evaluates to TRUE, this function enables memory reads in the address range 
+  Start to (Start + Length - 1).
+  If the On parameter evaluates to FALSE, this function disables memory reads in the address range 
+  Start to (Start + Length - 1).
+
+  @param  This[in]              Indicates the EFI_LEGACY_REGION2_PROTOCOL instance.
+  @param  Start[in]             The beginning of the physical address of the region whose attributes
+                                should be modified.
+  @param  Length[in]            The number of bytes of memory whose attributes should be modified.
+                                The actual number of bytes modified may be greater than the number
+                                specified.
+  @param  Granularity[out]      The number of bytes in the last region affected. This may be less
+                                than the total number of bytes affected if the starting address
+                                was not aligned to a region's starting address or if the length
+                                was greater than the number of bytes in the first region.
+  @param  On[in]                Decode / Non-Decode flag.
+
+  @retval EFI_SUCCESS           The region's attributes were successfully modified.
+  @retval EFI_INVALID_PARAMETER If Start or Length describe an address not in the Legacy Region.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LEGACY_REGION2_DECODE)(
+ IN  EFI_LEGACY_REGION2_PROTOCOL  *This,
+ IN  UINT32                       Start,
+ IN  UINT32                       Length,
+ OUT UINT32                       *Granularity,
+ IN  BOOLEAN                      *On
+ );
+
+
+/**
+  Modify the hardware to disallow memory writes in a region.
+
+  This function changes the attributes of a memory range to not allow writes.
+
+  @param  This[in]              Indicates the EFI_LEGACY_REGION2_PROTOCOL instance.
+  @param  Start[in]             The beginning of the physical address of the region whose
+                                attributes should be modified.
+  @param  Length[in]            The number of bytes of memory whose attributes should be modified.
+                                The actual number of bytes modified may be greater than the number
+                                specified.
+  @param  Granularity[out]      The number of bytes in the last region affected. This may be less
+                                than the total number of bytes affected if the starting address was
+                                not aligned to a region's starting address or if the length was
+                                greater than the number of bytes in the first region.
+
+  @retval EFI_SUCCESS           The region's attributes were successfully modified.
+  @retval EFI_INVALID_PARAMETER If Start or Length describe an address not in the Legacy Region.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LEGACY_REGION2_LOCK)(
+ IN  EFI_LEGACY_REGION2_PROTOCOL   *This,
+ IN  UINT32                        Start,
+ IN  UINT32                        Length,
+ OUT UINT32                        *Granularity
+ );
+
+
+/**
+  Modify the hardware to disallow memory attribute changes in a region.
+
+  This function makes the attributes of a region read only. Once a region is boot-locked with this 
+  function, the read and write attributes of that region cannot be changed until a power cycle has
+  reset the boot-lock attribute. Calls to Decode(), Lock() and Unlock() will have no effect.
+
+  @param  This[in]              Indicates the EFI_LEGACY_REGION2_PROTOCOL instance.
+  @param  Start[in]             The beginning of the physical address of the region whose
+                                attributes should be modified.
+  @param  Length[in]            The number of bytes of memory whose attributes should be modified.
+                                The actual number of bytes modified may be greater than the number
+                                specified.
+  @param  Granularity[out]      The number of bytes in the last region affected. This may be less
+                                than the total number of bytes affected if the starting address was
+                                not aligned to a region's starting address or if the length was
+                                greater than the number of bytes in the first region.
+
+  @retval EFI_SUCCESS           The region's attributes were successfully modified.
+  @retval EFI_INVALID_PARAMETER If Start or Length describe an address not in the Legacy Region.
+  @retval EFI_UNSUPPORTED       The chipset does not support locking the configuration registers in
+                                a way that will not affect memory regions outside the legacy memory
+                                region.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LEGACY_REGION2_BOOT_LOCK)(
+  IN  EFI_LEGACY_REGION2_PROTOCOL         *This,
+  IN  UINT32                              Start,
+  IN  UINT32                              Length,
+  OUT UINT32                              *Granularity OPTIONAL
+  );
+
+
+/**
+  Modify the hardware to allow memory writes in a region.
+
+  This function changes the attributes of a memory range to allow writes.  
+
+  @param  This[in]              Indicates the EFI_LEGACY_REGION2_PROTOCOL instance.
+  @param  Start[in]             The beginning of the physical address of the region whose
+                                attributes should be modified.
+  @param  Length[in]            The number of bytes of memory whose attributes should be modified.
+                                The actual number of bytes modified may be greater than the number
+                                specified.
+  @param  Granularity[out]      The number of bytes in the last region affected. This may be less
+                                than the total number of bytes affected if the starting address was
+                                not aligned to a region's starting address or if the length was
+                                greater than the number of bytes in the first region.
+
+  @retval EFI_SUCCESS           The region's attributes were successfully modified.
+  @retval EFI_INVALID_PARAMETER If Start or Length describe an address not in the Legacy Region.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LEGACY_REGION2_UNLOCK)(
+ IN  EFI_LEGACY_REGION2_PROTOCOL  *This,
+ IN  UINT32                       Start,
+ IN  UINT32                       Length,
+ OUT UINT32                       *Granularity
+ );
+
+
+typedef enum {
+  LegacyRegionDecoded,         ///< This region is currently set to allow reads.
+  LegacyRegionNotDecoded,      ///< This region is currently set to not allow reads.
+  LegacyRegionWriteEnabled,    ///< This region is currently set to allow writes.
+  LegacyRegionWriteDisabled,   ///< This region is currently set to write protected.
+  LegacyRegionBootLocked,      ///< This region's attributes are locked, cannot be modified until
+                               ///< after a power cycle.
+  LegacyRegionNotLocked        ///< This region's attributes are not locked.
+} EFI_LEGACY_REGION_ATTRIBUTE;
+
+
+typedef struct {
+  ///
+  /// The beginning of the physical address of this
+  /// region.
+  ///
+  UINT32                      Start;
+  ///
+  /// The number of bytes in this region.
+  ///
+  UINT32                      Length;
+  ///
+  /// Attribute of the Legacy Region Descriptor that
+  /// describes the capabilities for that memory region.
+  ///
+  EFI_LEGACY_REGION_ATTRIBUTE Attribute;
+  ///
+  /// Describes the byte length programmability
+  /// associated with the Start address and the specified
+  /// Attribute setting.
+  UINT32                      Granularity;
+} EFI_LEGACY_REGION_DESCRIPTOR;
+
+
+/**
+  Get region information for the attributes of the Legacy Region.
+
+  This function is used to discover the granularity of the attributes for the memory in the legacy 
+  region. Each attribute may have a different granularity and the granularity may not be the same
+  for all memory ranges in the legacy region.  
+
+  @param  This[in]              Indicates the EFI_LEGACY_REGION2_PROTOCOL instance.
+  @param  DescriptorCount[out]  The number of region descriptor entries returned in the Descriptor
+                                buffer.
+  @param  Descriptor[out]       A pointer to a pointer used to return a buffer where the legacy
+                                region information is deposited. This buffer will contain a list of
+                                DescriptorCount number of region descriptors.  This function will
+                                provide the memory for the buffer.
+
+  @retval EFI_SUCCESS           The information structure was returned.
+  @retval EFI_UNSUPPORTED       This function is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LEGACY_REGION_GET_INFO)(
+  IN  EFI_LEGACY_REGION2_PROTOCOL   *This,
+  OUT UINT32                        *DescriptorCount,
+  OUT EFI_LEGACY_REGION_DESCRIPTOR  **Descriptor
+  );
+
+
+/// 
+/// The EFI_LEGACY_REGION2_PROTOCOL is used to abstract the hardware control of the memory 
+/// attributes of the Option ROM shadowing region, 0xC0000 to 0xFFFFF.
+/// There are three memory attributes that can be modified through this protocol: read, write and
+/// boot-lock. These protocols may be set in any combination.
+///
+struct _EFI_LEGACY_REGION2_PROTOCOL {
+  EFI_LEGACY_REGION2_DECODE     Decode;
+  EFI_LEGACY_REGION2_LOCK       Lock;
+  EFI_LEGACY_REGION2_BOOT_LOCK  BootLock;
+  EFI_LEGACY_REGION2_UNLOCK     UnLock;
+  EFI_LEGACY_REGION_GET_INFO    GetInfo;
+};
+
+extern EFI_GUID gEfiLegacyRegion2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/LoadFile.h b/MdePkg/Include/Protocol/LoadFile.h
new file mode 100644
index 000000000000..430ddb843dc9
--- /dev/null
+++ b/MdePkg/Include/Protocol/LoadFile.h
@@ -0,0 +1,88 @@
+/** @file
+  Load File protocol as defined in the UEFI 2.0 specification.
+
+  The load file protocol exists to supports the addition of new boot devices, 
+  and to support booting from devices that do not map well to file system. 
+  Network boot is done via a LoadFile protocol.
+
+  UEFI 2.0 can boot from any device that produces a LoadFile protocol.
+
+Copyright (c) 2006 - 2016, 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_LOAD_FILE_PROTOCOL_H__
+#define __EFI_LOAD_FILE_PROTOCOL_H__
+
+#define EFI_LOAD_FILE_PROTOCOL_GUID \
+  { \
+    0x56EC3091, 0x954C, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B } \
+  }
+
+///
+/// Protocol Guid defined by EFI1.1.
+///
+#define LOAD_FILE_PROTOCOL EFI_LOAD_FILE_PROTOCOL_GUID
+
+typedef struct _EFI_LOAD_FILE_PROTOCOL EFI_LOAD_FILE_PROTOCOL;
+
+///
+/// Backward-compatible with EFI1.1
+/// 
+typedef EFI_LOAD_FILE_PROTOCOL  EFI_LOAD_FILE_INTERFACE;
+
+/**
+  Causes the driver to load a specified file.
+
+  @param  This       Protocol instance pointer.
+  @param  FilePath   The device specific path of the file to load.
+  @param  BootPolicy If TRUE, indicates that the request originates from the
+                     boot manager is attempting to load FilePath as a boot
+                     selection. If FALSE, then FilePath must match as exact file
+                     to be loaded.
+  @param  BufferSize On input the size of Buffer in bytes. On output with a return
+                     code of EFI_SUCCESS, the amount of data transferred to
+                     Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
+                     the size of Buffer required to retrieve the requested file.
+  @param  Buffer     The memory buffer to transfer the file to. IF Buffer is NULL,
+                     then the size of the requested file is returned in
+                     BufferSize.
+
+  @retval EFI_SUCCESS           The file was loaded.
+  @retval EFI_UNSUPPORTED       The device does not support the provided BootPolicy
+  @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or
+                                BufferSize is NULL.
+  @retval EFI_NO_MEDIA          No medium was present to load the file.
+  @retval EFI_DEVICE_ERROR      The file was not loaded due to a device error.
+  @retval EFI_NO_RESPONSE       The remote system did not respond.
+  @retval EFI_NOT_FOUND         The file was not found.
+  @retval EFI_ABORTED           The file load process was manually cancelled.
+  @retval EFI_WARN_FILE_SYSTEM  The resulting Buffer contains UEFI-compliant file system.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOAD_FILE)(
+  IN EFI_LOAD_FILE_PROTOCOL           *This,
+  IN EFI_DEVICE_PATH_PROTOCOL         *FilePath,
+  IN BOOLEAN                          BootPolicy,
+  IN OUT UINTN                        *BufferSize,
+  IN VOID                             *Buffer OPTIONAL
+  );
+
+///
+/// The EFI_LOAD_FILE_PROTOCOL is a simple protocol used to obtain files from arbitrary devices.
+///
+struct _EFI_LOAD_FILE_PROTOCOL {
+  EFI_LOAD_FILE LoadFile;
+};
+
+extern EFI_GUID gEfiLoadFileProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/LoadFile2.h b/MdePkg/Include/Protocol/LoadFile2.h
new file mode 100644
index 000000000000..cb977fbf3ec6
--- /dev/null
+++ b/MdePkg/Include/Protocol/LoadFile2.h
@@ -0,0 +1,85 @@
+/** @file
+  Load File protocol as defined in the UEFI 2.0 specification.
+
+  Load file protocol exists to supports the addition of new boot devices, 
+  and to support booting from devices that do not map well to file system. 
+  Network boot is done via a LoadFile protocol.
+
+  UEFI 2.0 can boot from any device that produces a LoadFile protocol.
+
+  Copyright (c) 2006 - 2008, 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 __EFI_LOAD_FILE2_PROTOCOL_H__
+#define __EFI_LOAD_FILE2_PROTOCOL_H__
+
+#define EFI_LOAD_FILE2_PROTOCOL_GUID \
+  { \
+    0x4006c0c1, 0xfcb3, 0x403e, {0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d } \
+  }
+
+///
+/// Protocol Guid defined by UEFI2.1.
+///
+#define LOAD_FILE2_PROTOCOL EFI_LOAD_FILE2_PROTOCOL_GUID
+
+typedef struct _EFI_LOAD_FILE2_PROTOCOL EFI_LOAD_FILE2_PROTOCOL;
+
+
+/**
+  Causes the driver to load a specified file.
+
+  @param  This       Protocol instance pointer.
+  @param  FilePath   The device specific path of the file to load.
+  @param  BootPolicy Should always be FALSE.
+  @param  BufferSize On input the size of Buffer in bytes. On output with a return
+                     code of EFI_SUCCESS, the amount of data transferred to
+                     Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
+                     the size of Buffer required to retrieve the requested file.
+  @param  Buffer     The memory buffer to transfer the file to. IF Buffer is NULL,
+                     then no the size of the requested file is returned in
+                     BufferSize.
+
+  @retval EFI_SUCCESS           The file was loaded.
+  @retval EFI_UNSUPPORTED       BootPolicy is TRUE.
+  @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or
+                                BufferSize is NULL.
+  @retval EFI_NO_MEDIA          No medium was present to load the file.
+  @retval EFI_DEVICE_ERROR      The file was not loaded due to a device error.
+  @retval EFI_NO_RESPONSE       The remote system did not respond.
+  @retval EFI_NOT_FOUND         The file was not found
+  @retval EFI_ABORTED           The file load process was manually canceled.
+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current 
+                                directory entry. BufferSize has been updated with
+                                the size needed to complete the request.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOAD_FILE2)(
+  IN EFI_LOAD_FILE2_PROTOCOL           *This,
+  IN EFI_DEVICE_PATH_PROTOCOL         *FilePath,
+  IN BOOLEAN                          BootPolicy,
+  IN OUT UINTN                        *BufferSize,
+  IN VOID                             *Buffer OPTIONAL
+  );
+
+///
+/// The EFI_LOAD_FILE_PROTOCOL is a simple protocol used to obtain files from arbitrary devices.
+///
+struct _EFI_LOAD_FILE2_PROTOCOL {
+  EFI_LOAD_FILE2 LoadFile;
+};
+
+extern EFI_GUID gEfiLoadFile2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/LoadedImage.h b/MdePkg/Include/Protocol/LoadedImage.h
new file mode 100644
index 000000000000..53971bc91868
--- /dev/null
+++ b/MdePkg/Include/Protocol/LoadedImage.h
@@ -0,0 +1,88 @@
+/** @file
+  UEFI 2.0 Loaded image protocol definition.
+
+  Every EFI driver and application is passed an image handle when it is loaded.
+  This image handle will contain a Loaded Image Protocol.
+
+  Copyright (c) 2006 - 2008, 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 __LOADED_IMAGE_PROTOCOL_H__
+#define __LOADED_IMAGE_PROTOCOL_H__
+
+#define EFI_LOADED_IMAGE_PROTOCOL_GUID \
+  { \
+    0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B } \
+  }
+
+#define EFI_LOADED_IMAGE_DEVICE_PATH_PROTOCOL_GUID \
+  { \
+    0xbc62157e, 0x3e33, 0x4fec, {0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf } \
+  }
+
+///
+/// Protocol GUID defined in EFI1.1.
+/// 
+#define LOADED_IMAGE_PROTOCOL   EFI_LOADED_IMAGE_PROTOCOL_GUID
+
+///
+/// EFI_SYSTEM_TABLE & EFI_IMAGE_UNLOAD are defined in EfiApi.h
+///
+#define EFI_LOADED_IMAGE_PROTOCOL_REVISION  0x1000
+
+///
+/// Revision defined in EFI1.1.
+/// 
+#define EFI_LOADED_IMAGE_INFORMATION_REVISION    EFI_LOADED_IMAGE_PROTOCOL_REVISION
+
+///
+/// Can be used on any image handle to obtain information about the loaded image.
+///
+typedef struct {
+  UINT32            Revision;       ///< Defines the revision of the EFI_LOADED_IMAGE_PROTOCOL structure. 
+                                    ///< All future revisions will be backward compatible to the current revision.
+  EFI_HANDLE        ParentHandle;   ///< Parent image's image handle. NULL if the image is loaded directly from 
+                                    ///< the firmware's boot manager. 
+  EFI_SYSTEM_TABLE  *SystemTable;   ///< the image's EFI system table pointer.
+
+  //
+  // Source location of image
+  //
+  EFI_HANDLE        DeviceHandle;   ///< The device handle that the EFI Image was loaded from. 
+  EFI_DEVICE_PATH_PROTOCOL  *FilePath;  ///< A pointer to the file path portion specific to DeviceHandle 
+                                        ///< that the EFI Image was loaded from. 
+  VOID              *Reserved;      ///< Reserved. DO NOT USE.
+
+  //
+  // Images load options
+  //
+  UINT32            LoadOptionsSize;///< The size in bytes of LoadOptions.
+  VOID              *LoadOptions;   ///< A pointer to the image's binary load options.
+
+  //
+  // Location of where image was loaded
+  //
+  VOID              *ImageBase;     ///< The base address at which the image was loaded.
+  UINT64            ImageSize;      ///< The size in bytes of the loaded image.
+  EFI_MEMORY_TYPE   ImageCodeType;  ///< The memory type that the code sections were loaded as.
+  EFI_MEMORY_TYPE   ImageDataType;  ///< The memory type that the data sections were loaded as.
+  EFI_IMAGE_UNLOAD  Unload;
+} EFI_LOADED_IMAGE_PROTOCOL;
+
+//
+// For backward-compatible with EFI1.1.
+// 
+typedef EFI_LOADED_IMAGE_PROTOCOL EFI_LOADED_IMAGE;
+
+extern EFI_GUID gEfiLoadedImageProtocolGuid;
+extern EFI_GUID gEfiLoadedImageDevicePathProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ManagedNetwork.h b/MdePkg/Include/Protocol/ManagedNetwork.h
new file mode 100644
index 000000000000..2ac001c4f95c
--- /dev/null
+++ b/MdePkg/Include/Protocol/ManagedNetwork.h
@@ -0,0 +1,372 @@
+/** @file
+  EFI_MANAGED_NETWORK_SERVICE_BINDING_PROTOCOL as defined in UEFI 2.0.
+  EFI_MANAGED_NETWORK_PROTOCOL as defined in UEFI 2.0.
+
+Copyright (c) 2006 - 2010, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.0
+
+**/
+
+#ifndef __EFI_MANAGED_NETWORK_PROTOCOL_H__
+#define __EFI_MANAGED_NETWORK_PROTOCOL_H__
+
+#include <Protocol/SimpleNetwork.h>
+
+#define EFI_MANAGED_NETWORK_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xf36ff770, 0xa7e1, 0x42cf, {0x9e, 0xd2, 0x56, 0xf0, 0xf2, 0x71, 0xf4, 0x4c } \
+  }
+
+#define EFI_MANAGED_NETWORK_PROTOCOL_GUID \
+  { \
+    0x7ab33a91, 0xace5, 0x4326, { 0xb5, 0x72, 0xe7, 0xee, 0x33, 0xd3, 0x9f, 0x16 } \
+  }
+
+typedef struct _EFI_MANAGED_NETWORK_PROTOCOL EFI_MANAGED_NETWORK_PROTOCOL;
+
+typedef struct {
+  ///
+  /// Timeout value for a UEFI one-shot timer event. A packet that has not been removed
+  /// from the MNP receive queue will be dropped if its receive timeout expires.
+  ///
+  UINT32     ReceivedQueueTimeoutValue;
+  ///
+  /// Timeout value for a UEFI one-shot timer event. A packet that has not been removed
+  /// from the MNP transmit queue will be dropped if its receive timeout expires.
+  ///
+  UINT32     TransmitQueueTimeoutValue;
+  ///
+  /// Ethernet type II 16-bit protocol type in host byte order. Valid
+  /// values are zero and 1,500 to 65,535.
+  ///
+  UINT16     ProtocolTypeFilter;
+  ///
+  /// Set to TRUE to receive packets that are sent to the network
+  /// device MAC address. The startup default value is FALSE.
+  ///
+  BOOLEAN    EnableUnicastReceive;
+  ///
+  /// Set to TRUE to receive packets that are sent to any of the
+  /// active multicast groups. The startup default value is FALSE.
+  ///
+  BOOLEAN    EnableMulticastReceive;
+  ///
+  /// Set to TRUE to receive packets that are sent to the network
+  /// device broadcast address. The startup default value is FALSE.
+  ///
+  BOOLEAN    EnableBroadcastReceive;
+  ///
+  /// Set to TRUE to receive packets that are sent to any MAC address.
+  /// The startup default value is FALSE.
+  ///
+  BOOLEAN    EnablePromiscuousReceive;
+  ///
+  /// Set to TRUE to drop queued packets when the configuration
+  /// is changed. The startup default value is FALSE.
+  ///
+  BOOLEAN    FlushQueuesOnReset;
+  ///
+  /// Set to TRUE to timestamp all packets when they are received
+  /// by the MNP. Note that timestamps may be unsupported in some
+  /// MNP implementations. The startup default value is FALSE.
+  ///
+  BOOLEAN    EnableReceiveTimestamps;
+  ///
+  /// Set to TRUE to disable background polling in this MNP
+  /// instance. Note that background polling may not be supported in
+  /// all MNP implementations. The startup default value is FALSE,
+  /// unless background polling is not supported.
+  ///
+  BOOLEAN    DisableBackgroundPolling;
+} EFI_MANAGED_NETWORK_CONFIG_DATA;
+
+typedef struct {
+  EFI_TIME      Timestamp;
+  EFI_EVENT     RecycleEvent;
+  UINT32        PacketLength;
+  UINT32        HeaderLength;
+  UINT32        AddressLength;
+  UINT32        DataLength;
+  BOOLEAN       BroadcastFlag;
+  BOOLEAN       MulticastFlag;
+  BOOLEAN       PromiscuousFlag;
+  UINT16        ProtocolType;
+  VOID          *DestinationAddress;
+  VOID          *SourceAddress;
+  VOID          *MediaHeader;
+  VOID          *PacketData;
+} EFI_MANAGED_NETWORK_RECEIVE_DATA;
+
+typedef struct {
+  UINT32        FragmentLength;
+  VOID          *FragmentBuffer;
+} EFI_MANAGED_NETWORK_FRAGMENT_DATA;
+
+typedef struct {
+  EFI_MAC_ADDRESS                   *DestinationAddress; //OPTIONAL
+  EFI_MAC_ADDRESS                   *SourceAddress;      //OPTIONAL
+  UINT16                            ProtocolType;        //OPTIONAL
+  UINT32                            DataLength;
+  UINT16                            HeaderLength;        //OPTIONAL
+  UINT16                            FragmentCount;
+  EFI_MANAGED_NETWORK_FRAGMENT_DATA FragmentTable[1];
+} EFI_MANAGED_NETWORK_TRANSMIT_DATA;
+
+
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated
+  /// by the MNP. The type of Event must be
+  /// EFI_NOTIFY_SIGNAL. The Task Priority Level (TPL) of
+  /// Event must be lower than or equal to TPL_CALLBACK.
+  ///
+  EFI_EVENT                             Event;
+  ///
+  /// The status that is returned to the caller at the end of the operation
+  /// to indicate whether this operation completed successfully.
+  ///
+  EFI_STATUS                            Status;
+  union {
+    ///
+    /// When this token is used for receiving, RxData is a pointer to the EFI_MANAGED_NETWORK_RECEIVE_DATA.
+    ///
+    EFI_MANAGED_NETWORK_RECEIVE_DATA    *RxData;
+    ///
+    /// When this token is used for transmitting, TxData is a pointer to the EFI_MANAGED_NETWORK_TRANSMIT_DATA.
+    ///
+    EFI_MANAGED_NETWORK_TRANSMIT_DATA   *TxData;
+  } Packet;
+} EFI_MANAGED_NETWORK_COMPLETION_TOKEN;
+
+/**
+  Returns the operational parameters for the current MNP child driver.
+
+  @param  This          The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  MnpConfigData The pointer to storage for MNP operational parameters.
+  @param  SnpModeData   The pointer to storage for SNP operational parameters.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_UNSUPPORTED       The requested feature is unsupported in this MNP implementation.
+  @retval EFI_NOT_STARTED       This MNP child driver instance has not been configured. The default
+                                values are returned in MnpConfigData if it is not NULL.
+  @retval Other                 The mode data could not be read.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_GET_MODE_DATA)(
+  IN  EFI_MANAGED_NETWORK_PROTOCOL     *This,
+  OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
+  OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
+  );
+
+/**
+  Sets or clears the operational parameters for the MNP child driver.
+
+  @param  This          The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  MnpConfigData The pointer to configuration data that will be assigned to the MNP
+                        child driver instance. If NULL, the MNP child driver instance is
+                        reset to startup defaults and all pending transmit and receive
+                        requests are flushed.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources (usually memory) could not be
+                                allocated.
+  @retval EFI_UNSUPPORTED       The requested feature is unsupported in this [MNP]
+                                implementation.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval Other                 The MNP child driver instance has been reset to startup defaults.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_CONFIGURE)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL     *This,
+  IN EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL
+  );
+
+/**
+  Translates an IP multicast address to a hardware (MAC) multicast address.
+
+  @param  This       The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  Ipv6Flag   Set to TRUE to if IpAddress is an IPv6 multicast address.
+                     Set to FALSE if IpAddress is an IPv4 multicast address.
+  @param  IpAddress  The pointer to the multicast IP address (in network byte order) to convert.
+  @param  MacAddress The pointer to the resulting multicast MAC address.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER One of the following conditions is TRUE:
+                                - This is NULL.
+                                - IpAddress is NULL.
+                                - *IpAddress is not a valid multicast IP address.
+                                - MacAddress is NULL.
+  @retval EFI_NOT_STARTED       This MNP child driver instance has not been configured.
+  @retval EFI_UNSUPPORTED       The requested feature is unsupported in this MNP implementation.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval Other                 The address could not be converted.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_MCAST_IP_TO_MAC)(
+  IN  EFI_MANAGED_NETWORK_PROTOCOL  *This,
+  IN  BOOLEAN                       Ipv6Flag,
+  IN  EFI_IP_ADDRESS                *IpAddress,
+  OUT EFI_MAC_ADDRESS               *MacAddress
+  );
+
+/**
+  Enables and disables receive filters for multicast address.
+
+  @param  This       The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  JoinFlag   Set to TRUE to join this multicast group.
+                     Set to FALSE to leave this multicast group.
+  @param  MacAddress The pointer to the multicast MAC group (address) to join or leave.
+
+  @retval EFI_SUCCESS           The requested operation completed successfully.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - JoinFlag is TRUE and MacAddress is NULL.
+                                - *MacAddress is not a valid multicast MAC address.
+  @retval EFI_NOT_STARTED       This MNP child driver instance has not been configured.
+  @retval EFI_ALREADY_STARTED   The supplied multicast group is already joined.
+  @retval EFI_NOT_FOUND         The supplied multicast group is not joined.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_UNSUPPORTED       The requested feature is unsupported in this MNP implementation.
+  @retval Other                 The requested operation could not be completed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_GROUPS)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL  *This,
+  IN BOOLEAN                       JoinFlag,
+  IN EFI_MAC_ADDRESS               *MacAddress  OPTIONAL
+  );
+
+/**
+  Places asynchronous outgoing data packets into the transmit queue.
+
+  @param  This  The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  Token The pointer to a token associated with the transmit data descriptor.
+
+  @retval EFI_SUCCESS           The transmit completion token was cached.
+  @retval EFI_NOT_STARTED       This MNP child driver instance has not been configured.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_ACCESS_DENIED     The transmit completion token is already in the transmit queue.
+  @retval EFI_OUT_OF_RESOURCES  The transmit data could not be queued due to a lack of system resources
+                                (usually memory).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval EFI_NOT_READY         The transmit request could not be queued because the transmit queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_TRANSMIT)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
+  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token
+  );
+
+/**
+  Places an asynchronous receiving request into the receiving queue.
+
+  @param  This  The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  Token The pointer to a token associated with the receive data descriptor.
+
+  @retval EFI_SUCCESS           The receive completion token was cached.
+  @retval EFI_NOT_STARTED       This MNP child driver instance has not been configured.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - Token is NULL.
+                                - Token.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The transmit data could not be queued due to a lack of system resources
+                                (usually memory).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval EFI_ACCESS_DENIED     The receive completion token was already in the receive queue.
+  @retval EFI_NOT_READY         The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_RECEIVE)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
+  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token
+  );
+
+
+/**
+  Aborts an asynchronous transmit or receive request.
+
+  @param  This  The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+  @param  Token The pointer to a token that has been issued by
+                EFI_MANAGED_NETWORK_PROTOCOL.Transmit() or
+                EFI_MANAGED_NETWORK_PROTOCOL.Receive(). If
+                NULL, all pending tokens are aborted.
+
+  @retval  EFI_SUCCESS           The asynchronous I/O request was aborted and Token.Event
+                                 was signaled. When Token is NULL, all pending requests were
+                                 aborted and their events were signaled.
+  @retval  EFI_NOT_STARTED       This MNP child driver instance has not been configured.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_NOT_FOUND         When Token is not NULL, the asynchronous I/O request was
+                                 not found in the transmit or receive queue. It has either completed
+                                 or was not issued by Transmit() and Receive().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_CANCEL)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL          *This,
+  IN EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *Token  OPTIONAL
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  @param  This The pointer to the EFI_MANAGED_NETWORK_PROTOCOL instance.
+
+  @retval EFI_SUCCESS      Incoming or outgoing data was processed.
+  @retval EFI_NOT_STARTED  This MNP child driver instance has not been configured.
+  @retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
+  @retval EFI_NOT_READY    No incoming or outgoing data was processed. Consider increasing
+                           the polling rate.
+  @retval EFI_TIMEOUT      Data was dropped out of the transmit and/or receive queue.
+                            Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MANAGED_NETWORK_POLL)(
+  IN EFI_MANAGED_NETWORK_PROTOCOL    *This
+  );
+
+///
+/// The MNP is used by network applications (and drivers) to 
+/// perform raw (unformatted) asynchronous network packet I/O.
+///
+struct _EFI_MANAGED_NETWORK_PROTOCOL {
+  EFI_MANAGED_NETWORK_GET_MODE_DATA       GetModeData;
+  EFI_MANAGED_NETWORK_CONFIGURE           Configure;
+  EFI_MANAGED_NETWORK_MCAST_IP_TO_MAC     McastIpToMac;
+  EFI_MANAGED_NETWORK_GROUPS              Groups;
+  EFI_MANAGED_NETWORK_TRANSMIT            Transmit;
+  EFI_MANAGED_NETWORK_RECEIVE             Receive;
+  EFI_MANAGED_NETWORK_CANCEL              Cancel;
+  EFI_MANAGED_NETWORK_POLL                Poll;
+};
+
+extern EFI_GUID gEfiManagedNetworkServiceBindingProtocolGuid;
+extern EFI_GUID gEfiManagedNetworkProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/McaInitPmi.h b/MdePkg/Include/Protocol/McaInitPmi.h
new file mode 100644
index 000000000000..c0c66147eab8
--- /dev/null
+++ b/MdePkg/Include/Protocol/McaInitPmi.h
@@ -0,0 +1,207 @@
+/** @file
+  MCA/PMI/INIT Protocol as defined in PI Specification VOLUME 4.
+
+  This protocol provides services to handle Machine Checks (MCA),
+  Initialization (INIT) events, and Platform Management Interrupt (PMI) events
+  on an Intel Itanium Processor Family based system.
+
+  Copyright (c) 2009 - 2010, 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 __MCA_INIT_PMI_PROTOCOL_H__
+#define __MCA_INIT_PMI_PROTOCOL_H__
+
+///
+/// Global ID for the MCA/PMI/INIT Protocol.
+///
+#define EFI_SAL_MCA_INIT_PMI_PROTOCOL_GUID \
+  { 0xb60dc6e8, 0x3b6f, 0x11d5, {0xaf, 0x9, 0x0, 0xa0, 0xc9, 0x44, 0xa0, 0x5b} }
+
+
+///
+/// Declare forward reference for the Timer Architectural Protocol
+///
+typedef struct _EFI_SAL_MCA_INIT_PMI_PROTOCOL  EFI_SAL_MCA_INIT_PMI_PROTOCOL;
+
+#pragma pack(1)
+///
+/// MCA Records Structure
+///
+typedef struct {
+  UINT64  First : 1;
+  UINT64  Last : 1;
+  UINT64  EntryCount : 16;
+  UINT64  DispatchedCount : 16;
+  UINT64  Reserved : 30;
+} SAL_MCA_COUNT_STRUCTURE;
+
+#pragma pack()
+
+/**
+  Prototype of MCA handler.
+
+  @param  ModuleGlobal                The context of MCA Handler
+  @param  ProcessorStateParameters    The processor state parameters (PSP)
+  @param  MinstateBase                Base address of the min-state
+  @param  RendezvouseStateInformation Rendezvous state information to be passed to
+                                      the OS on OS MCA entry
+  @param  CpuIndex                    Index of the logical processor
+  @param  McaCountStructure           Pointer to the MCA records structure
+  @param  CorrectedMachineCheck       This flag is set to TRUE is the MCA has been
+                                      corrected by the handler or by a previous handler
+
+  @retval EFI_SUCCESS                 Handler successfully returned
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_MCA_HANDLER)(
+  IN  VOID                    *ModuleGlobal,
+  IN  UINT64                  ProcessorStateParameters,
+  IN  EFI_PHYSICAL_ADDRESS    MinstateBase,
+  IN  UINT64                  RendezvouseStateInformation,
+  IN  UINT64                  CpuIndex,
+  IN  SAL_MCA_COUNT_STRUCTURE *McaCountStructure,
+  OUT BOOLEAN                 *CorrectedMachineCheck
+  );
+
+/**
+  Prototype of INIT handler.
+
+  @param  ModuleGlobal                The context of INIT Handler
+  @param  ProcessorStateParameters    The processor state parameters (PSP)
+  @param  MinstateBase                Base address of the min-state
+  @param  McaInProgress               This flag indicates if an MCA is in progress
+  @param  CpuIndex                    Index of the logical processor
+  @param  McaCountStructure           Pointer to the MCA records structure
+  @param  DumpSwitchPressed           This flag indicates the crash dump switch has been pressed
+
+  @retval EFI_SUCCESS                 Handler successfully returned
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_INIT_HANDLER)(
+  IN  VOID                     *ModuleGlobal,
+  IN  UINT64                   ProcessorStateParameters,
+  IN  EFI_PHYSICAL_ADDRESS     MinstateBase,
+  IN  BOOLEAN                  McaInProgress,
+  IN  UINT64                   CpuIndex,
+  IN  SAL_MCA_COUNT_STRUCTURE  *McaCountStructure,
+  OUT BOOLEAN                  *DumpSwitchPressed
+  );
+
+/**
+  Prototype of PMI handler
+
+  @param  ModuleGlobal                The context of PMI Handler
+  @param  CpuIndex                    Index of the logical processor
+  @param  PmiVector                   The PMI vector number as received from the PALE_PMI exit state (GR24)
+
+  @retval EFI_SUCCESS                 Handler successfully returned
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_PMI_HANDLER)(
+  IN VOID          *ModuleGlobal,
+  IN UINT64        CpuIndex,
+  IN UINT64        PmiVector
+  );
+
+/**
+  Register a MCA handler with the MCA dispatcher.
+
+  @param  This                        The EFI_SAL_MCA_INIT_PMI_PROTOCOL instance
+  @param  McaHandler                  The MCA handler to register
+  @param  ModuleGlobal                The context of MCA Handler
+  @param  MakeFirst                   This flag specifies the handler should be made first in the list
+  @param  MakeLast                    This flag specifies the handler should be made last in the list
+
+  @retval EFI_SUCCESS                 MCA Handle was registered
+  @retval EFI_OUT_OF_RESOURCES        No more resources to register an MCA handler
+  @retval EFI_INVALID_PARAMETER       Invalid parameters were passed
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_REGISTER_MCA_HANDLER)(
+  IN  EFI_SAL_MCA_INIT_PMI_PROTOCOL         *This,
+  IN  EFI_SAL_MCA_HANDLER                   McaHandler,
+  IN  VOID                                  *ModuleGlobal,
+  IN  BOOLEAN                               MakeFirst,
+  IN  BOOLEAN                               MakeLast
+  );
+
+/**
+  Register an INIT handler with the INIT dispatcher.
+
+  @param  This                        The EFI_SAL_MCA_INIT_PMI_PROTOCOL instance
+  @param  InitHandler                 The INIT handler to register
+  @param  ModuleGlobal                The context of INIT Handler
+  @param  MakeFirst                   This flag specifies the handler should be made first in the list
+  @param  MakeLast                    This flag specifies the handler should be made last in the list
+
+  @retval EFI_SUCCESS                 INIT Handle was registered
+  @retval EFI_OUT_OF_RESOURCES        No more resources to register an INIT handler
+  @retval EFI_INVALID_PARAMETER       Invalid parameters were passed
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_REGISTER_INIT_HANDLER)(
+  IN  EFI_SAL_MCA_INIT_PMI_PROTOCOL         *This,
+  IN  EFI_SAL_INIT_HANDLER                  InitHandler,
+  IN  VOID                                  *ModuleGlobal,
+  IN  BOOLEAN                               MakeFirst,
+  IN  BOOLEAN                               MakeLast
+  );
+
+/**
+  Register a PMI handler with the PMI dispatcher.
+
+  @param  This                        The EFI_SAL_MCA_INIT_PMI_PROTOCOL instance
+  @param  PmiHandler                  The PMI handler to register
+  @param  ModuleGlobal                The context of PMI Handler
+  @param  MakeFirst                   This flag specifies the handler should be made first in the list
+  @param  MakeLast                    This flag specifies the handler should be made last in the list
+
+  @retval EFI_SUCCESS                 PMI Handle was registered
+  @retval EFI_OUT_OF_RESOURCES        No more resources to register an PMI handler
+  @retval EFI_INVALID_PARAMETER       Invalid parameters were passed
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SAL_REGISTER_PMI_HANDLER)(
+  IN  EFI_SAL_MCA_INIT_PMI_PROTOCOL         *This,
+  IN  EFI_SAL_PMI_HANDLER                   PmiHandler,
+  IN  VOID                                  *ModuleGlobal,
+  IN  BOOLEAN                               MakeFirst,
+  IN  BOOLEAN                               MakeLast
+  );
+
+///
+/// This protocol is used to register MCA, INIT and PMI handlers with their respective dispatcher
+///
+struct _EFI_SAL_MCA_INIT_PMI_PROTOCOL {
+  EFI_SAL_REGISTER_MCA_HANDLER  RegisterMcaHandler;
+  EFI_SAL_REGISTER_INIT_HANDLER RegisterInitHandler;
+  EFI_SAL_REGISTER_PMI_HANDLER  RegisterPmiHandler;
+  BOOLEAN                       McaInProgress;       ///< Whether MCA handler is in progress
+  BOOLEAN                       InitInProgress;      ///< Whether Init handler is in progress
+  BOOLEAN                       PmiInProgress;       ///< Whether Pmi handler is in progress
+};
+
+extern EFI_GUID gEfiSalMcaInitPmiProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Metronome.h b/MdePkg/Include/Protocol/Metronome.h
new file mode 100644
index 000000000000..358d94b722ce
--- /dev/null
+++ b/MdePkg/Include/Protocol/Metronome.h
@@ -0,0 +1,80 @@
+/** @file
+  Metronome Architectural Protocol as defined in PI SPEC VOLUME 2 DXE
+
+  This code abstracts the DXE core to provide delay services.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_METRONOME_H__
+#define __ARCH_PROTOCOL_METRONOME_H__
+
+///
+/// Global ID for the Metronome Architectural Protocol
+///
+#define EFI_METRONOME_ARCH_PROTOCOL_GUID \
+  { 0x26baccb2, 0x6f42, 0x11d4, {0xbc, 0xe7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+///
+/// Declare forward reference for the Metronome Architectural Protocol
+///
+typedef struct _EFI_METRONOME_ARCH_PROTOCOL   EFI_METRONOME_ARCH_PROTOCOL;
+
+/**
+  The WaitForTick() function waits for the number of ticks specified by 
+  TickNumber from a known time source in the platform.  If TickNumber of 
+  ticks are detected, then EFI_SUCCESS is returned.  The actual time passed 
+  between entry of this function and the first tick is between 0 and 
+  TickPeriod 100 nS units.  If you want to guarantee that at least TickPeriod 
+  time has elapsed, wait for two ticks.  This function waits for a hardware 
+  event to determine when a tick occurs.  It is possible for interrupt 
+  processing, or exception processing to interrupt the execution of the 
+  WaitForTick() function.  Depending on the hardware source for the ticks, it 
+  is possible for a tick to be missed.  This function cannot guarantee that 
+  ticks will not be missed.  If a timeout occurs waiting for the specified 
+  number of ticks, then EFI_TIMEOUT is returned.
+
+  @param  This             The EFI_METRONOME_ARCH_PROTOCOL instance.
+  @param  TickNumber       Number of ticks to wait.
+
+  @retval EFI_SUCCESS           The wait for the number of ticks specified by TickNumber
+                                succeeded.
+  @retval EFI_TIMEOUT           A timeout occurred waiting for the specified number of ticks.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_METRONOME_WAIT_FOR_TICK)(
+   IN EFI_METRONOME_ARCH_PROTOCOL   *This,
+   IN UINT32                        TickNumber
+  );
+
+///
+/// This protocol provides access to a known time source in the platform to the
+/// core.  The core uses this known time source to produce core services that 
+/// require calibrated delays.  
+///
+struct _EFI_METRONOME_ARCH_PROTOCOL {
+  EFI_METRONOME_WAIT_FOR_TICK  WaitForTick;
+  
+  ///
+  /// The period of platform's known time source in 100 nS units.  
+  /// This value on any platform must be at least 10 uS, and must not 
+  /// exceed 200 uS.  The value in this field is a constant that must 
+  /// not be modified after the Metronome architectural protocol is 
+  /// installed.  All consumers must treat this as a read-only field.  
+  ///
+  UINT32                       TickPeriod;
+};
+
+extern EFI_GUID gEfiMetronomeArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MonotonicCounter.h b/MdePkg/Include/Protocol/MonotonicCounter.h
new file mode 100644
index 000000000000..1409be2e5f3d
--- /dev/null
+++ b/MdePkg/Include/Protocol/MonotonicCounter.h
@@ -0,0 +1,28 @@
+/** @file
+  Monotonic Counter Architectural Protocol as defined in PI SPEC VOLUME 2 DXE
+
+  This code provides the services required to access the system's monotonic counter
+
+Copyright (c) 2006 - 2010, 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 __ARCH_PROTOCOL_MONTONIC_COUNTER_H__
+#define __ARCH_PROTOCOL_MONTONIC_COUNTER_H__
+
+///
+/// Global ID for the Monotonic Counter Architectural Protocol.
+///
+#define EFI_MONOTONIC_COUNTER_ARCH_PROTOCOL_GUID \
+  {0x1da97072, 0xbddc, 0x4b30, {0x99, 0xf1, 0x72, 0xa0, 0xb5, 0x6f, 0xff, 0x2a} }
+  
+extern EFI_GUID gEfiMonotonicCounterArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/MpService.h b/MdePkg/Include/Protocol/MpService.h
new file mode 100644
index 000000000000..e61caebc5816
--- /dev/null
+++ b/MdePkg/Include/Protocol/MpService.h
@@ -0,0 +1,632 @@
+/** @file
+  When installed, the MP Services Protocol produces a collection of services
+  that are needed for MP management.
+
+  The MP Services Protocol provides a generalized way of performing following tasks:
+    - Retrieving information of multi-processor environment and MP-related status of
+      specific processors.
+    - Dispatching user-provided function to APs.
+    - Maintain MP-related processor status.
+
+  The MP Services Protocol must be produced on any system with more than one logical
+  processor.
+
+  The Protocol is available only during boot time.
+
+  MP Services Protocol is hardware-independent. Most of the logic of this protocol
+  is architecturally neutral. It abstracts the multi-processor environment and
+  status of processors, and provides interfaces to retrieve information, maintain,
+  and dispatch.
+
+  MP Services Protocol may be consumed by ACPI module. The ACPI module may use this
+  protocol to retrieve data that are needed for an MP platform and report them to OS.
+  MP Services Protocol may also be used to program and configure processors, such
+  as MTRR synchronization for memory space attributes setting in DXE Services.
+  MP Services Protocol may be used by non-CPU DXE drivers to speed up platform boot
+  by taking advantage of the processing capabilities of the APs, for example, using
+  APs to help test system memory in parallel with other device initialization.
+  Diagnostics applications may also use this protocol for multi-processor.
+
+Copyright (c) 2006 - 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in the UEFI Platform Initialization Specification 1.2,
+  Volume 2:Driver Execution Environment Core Interface.
+
+**/
+
+#ifndef _MP_SERVICE_PROTOCOL_H_
+#define _MP_SERVICE_PROTOCOL_H_
+
+///
+/// Global ID for the EFI_MP_SERVICES_PROTOCOL.
+///
+#define EFI_MP_SERVICES_PROTOCOL_GUID \
+  { \
+    0x3fdda605, 0xa76e, 0x4f46, {0xad, 0x29, 0x12, 0xf4, 0x53, 0x1b, 0x3d, 0x08} \
+  }
+
+///
+/// Forward declaration for the EFI_MP_SERVICES_PROTOCOL.
+///
+typedef struct _EFI_MP_SERVICES_PROTOCOL EFI_MP_SERVICES_PROTOCOL;
+
+///
+/// Terminator for a list of failed CPUs returned by StartAllAPs().
+///
+#define END_OF_CPU_LIST    0xffffffff
+
+///
+/// This bit is used in the StatusFlag field of EFI_PROCESSOR_INFORMATION and
+/// indicates whether the processor is playing the role of BSP. If the bit is 1,
+/// then the processor is BSP. Otherwise, it is AP.
+///
+#define PROCESSOR_AS_BSP_BIT         0x00000001
+
+///
+/// This bit is used in the StatusFlag field of EFI_PROCESSOR_INFORMATION and
+/// indicates whether the processor is enabled. If the bit is 1, then the
+/// processor is enabled. Otherwise, it is disabled.
+///
+#define PROCESSOR_ENABLED_BIT        0x00000002
+
+///
+/// This bit is used in the StatusFlag field of EFI_PROCESSOR_INFORMATION and
+/// indicates whether the processor is healthy. If the bit is 1, then the
+/// processor is healthy. Otherwise, some fault has been detected for the processor.
+///
+#define PROCESSOR_HEALTH_STATUS_BIT  0x00000004
+
+///
+/// Structure that describes the pyhiscal location of a logical CPU.
+///
+typedef struct {
+  ///
+  /// Zero-based physical package number that identifies the cartridge of the processor.
+  ///
+  UINT32  Package;
+  ///
+  /// Zero-based physical core number within package of the processor.
+  ///
+  UINT32  Core;
+  ///
+  /// Zero-based logical thread number within core of the processor.
+  ///
+  UINT32  Thread;
+} EFI_CPU_PHYSICAL_LOCATION;
+
+///
+/// Structure that describes information about a logical CPU.
+///
+typedef struct {
+  ///
+  /// The unique processor ID determined by system hardware.  For IA32 and X64,
+  /// the processor ID is the same as the Local APIC ID. Only the lower 8 bits
+  /// are used, and higher bits are reserved.  For IPF, the lower 16 bits contains
+  /// id/eid, and higher bits are reserved.
+  ///
+  UINT64                     ProcessorId;
+  ///
+  /// Flags indicating if the processor is BSP or AP, if the processor is enabled
+  /// or disabled, and if the processor is healthy. Bits 3..31 are reserved and
+  /// must be 0.
+  ///
+  /// <pre>
+  /// BSP  ENABLED  HEALTH  Description
+  /// ===  =======  ======  ===================================================
+  ///  0      0       0     Unhealthy Disabled AP.
+  ///  0      0       1     Healthy Disabled AP.
+  ///  0      1       0     Unhealthy Enabled AP.
+  ///  0      1       1     Healthy Enabled AP.
+  ///  1      0       0     Invalid. The BSP can never be in the disabled state.
+  ///  1      0       1     Invalid. The BSP can never be in the disabled state.
+  ///  1      1       0     Unhealthy Enabled BSP.
+  ///  1      1       1     Healthy Enabled BSP.
+  /// </pre>
+  ///
+  UINT32                     StatusFlag;
+  ///
+  /// The physical location of the processor, including the physical package number
+  /// that identifies the cartridge, the physical core number within package, and
+  /// logical thread number within core.
+  ///
+  EFI_CPU_PHYSICAL_LOCATION  Location;
+} EFI_PROCESSOR_INFORMATION;
+
+/**
+  This service retrieves the number of logical processor in the platform
+  and the number of those logical processors that are enabled on this boot.
+  This service may only be called from the BSP.
+
+  This function is used to retrieve the following information:
+    - The number of logical processors that are present in the system.
+    - The number of enabled logical processors in the system at the instant
+      this call is made.
+
+  Because MP Service Protocol provides services to enable and disable processors
+  dynamically, the number of enabled logical processors may vary during the
+  course of a boot session.
+
+  If this service is called from an AP, then EFI_DEVICE_ERROR is returned.
+  If NumberOfProcessors or NumberOfEnabledProcessors is NULL, then
+  EFI_INVALID_PARAMETER is returned. Otherwise, the total number of processors
+  is returned in NumberOfProcessors, the number of currently enabled processor
+  is returned in NumberOfEnabledProcessors, and EFI_SUCCESS is returned.
+
+  @param[in]  This                        A pointer to the EFI_MP_SERVICES_PROTOCOL
+                                          instance.
+  @param[out] NumberOfProcessors          Pointer to the total number of logical
+                                          processors in the system, including the BSP
+                                          and disabled APs.
+  @param[out] NumberOfEnabledProcessors   Pointer to the number of enabled logical
+                                          processors that exist in system, including
+                                          the BSP.
+
+  @retval EFI_SUCCESS             The number of logical processors and enabled
+                                  logical processors was retrieved.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_INVALID_PARAMETER   NumberOfProcessors is NULL.
+  @retval EFI_INVALID_PARAMETER   NumberOfEnabledProcessors is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_GET_NUMBER_OF_PROCESSORS)(
+  IN  EFI_MP_SERVICES_PROTOCOL  *This,
+  OUT UINTN                     *NumberOfProcessors,
+  OUT UINTN                     *NumberOfEnabledProcessors
+  );
+
+/**
+  Gets detailed MP-related information on the requested processor at the
+  instant this call is made. This service may only be called from the BSP.
+
+  This service retrieves detailed MP-related information about any processor
+  on the platform. Note the following:
+    - The processor information may change during the course of a boot session.
+    - The information presented here is entirely MP related.
+
+  Information regarding the number of caches and their sizes, frequency of operation,
+  slot numbers is all considered platform-related information and is not provided
+  by this service.
+
+  @param[in]  This                  A pointer to the EFI_MP_SERVICES_PROTOCOL
+                                    instance.
+  @param[in]  ProcessorNumber       The handle number of processor.
+  @param[out] ProcessorInfoBuffer   A pointer to the buffer where information for
+                                    the requested processor is deposited.
+
+  @retval EFI_SUCCESS             Processor information was returned.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_INVALID_PARAMETER   ProcessorInfoBuffer is NULL.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist in the platform.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_GET_PROCESSOR_INFO)(
+  IN  EFI_MP_SERVICES_PROTOCOL   *This,
+  IN  UINTN                      ProcessorNumber,
+  OUT EFI_PROCESSOR_INFORMATION  *ProcessorInfoBuffer
+  );
+
+/**
+  This service executes a caller provided function on all enabled APs. APs can
+  run either simultaneously or one at a time in sequence. This service supports
+  both blocking and non-blocking requests. The non-blocking requests use EFI
+  events so the BSP can detect when the APs have finished. This service may only
+  be called from the BSP.
+
+  This function is used to dispatch all the enabled APs to the function specified
+  by Procedure.  If any enabled AP is busy, then EFI_NOT_READY is returned
+  immediately and Procedure is not started on any AP.
+
+  If SingleThread is TRUE, all the enabled APs execute the function specified by
+  Procedure one by one, in ascending order of processor handle number. Otherwise,
+  all the enabled APs execute the function specified by Procedure simultaneously.
+
+  If WaitEvent is NULL, execution is in blocking mode. The BSP waits until all
+  APs finish or TimeoutInMicroSecs expires. Otherwise, execution is in non-blocking
+  mode, and the BSP returns from this service without waiting for APs. If a
+  non-blocking mode is requested after the UEFI Event EFI_EVENT_GROUP_READY_TO_BOOT
+  is signaled, then EFI_UNSUPPORTED must be returned.
+
+  If the timeout specified by TimeoutInMicroseconds expires before all APs return
+  from Procedure, then Procedure on the failed APs is terminated. All enabled APs
+  are always available for further calls to EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()
+  and EFI_MP_SERVICES_PROTOCOL.StartupThisAP(). If FailedCpuList is not NULL, its
+  content points to the list of processor handle numbers in which Procedure was
+  terminated.
+
+  Note: It is the responsibility of the consumer of the EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()
+  to make sure that the nature of the code that is executed on the BSP and the
+  dispatched APs is well controlled. The MP Services Protocol does not guarantee
+  that the Procedure function is MP-safe. Hence, the tasks that can be run in
+  parallel are limited to certain independent tasks and well-controlled exclusive
+  code. EFI services and protocols may not be called by APs unless otherwise
+  specified.
+
+  In blocking execution mode, BSP waits until all APs finish or
+  TimeoutInMicroSeconds expires.
+
+  In non-blocking execution mode, BSP is freed to return to the caller and then
+  proceed to the next task without having to wait for APs. The following
+  sequence needs to occur in a non-blocking execution mode:
+
+    -# The caller that intends to use this MP Services Protocol in non-blocking
+       mode creates WaitEvent by calling the EFI CreateEvent() service.  The caller
+       invokes EFI_MP_SERVICES_PROTOCOL.StartupAllAPs(). If the parameter WaitEvent
+       is not NULL, then StartupAllAPs() executes in non-blocking mode. It requests
+       the function specified by Procedure to be started on all the enabled APs,
+       and releases the BSP to continue with other tasks.
+    -# The caller can use the CheckEvent() and WaitForEvent() services to check
+       the state of the WaitEvent created in step 1.
+    -# When the APs complete their task or TimeoutInMicroSecondss expires, the MP
+       Service signals WaitEvent by calling the EFI SignalEvent() function. If
+       FailedCpuList is not NULL, its content is available when WaitEvent is
+       signaled. If all APs returned from Procedure prior to the timeout, then
+       FailedCpuList is set to NULL. If not all APs return from Procedure before
+       the timeout, then FailedCpuList is filled in with the list of the failed
+       APs. The buffer is allocated by MP Service Protocol using AllocatePool().
+       It is the caller's responsibility to free the buffer with FreePool() service.
+    -# This invocation of SignalEvent() function informs the caller that invoked
+       EFI_MP_SERVICES_PROTOCOL.StartupAllAPs() that either all the APs completed
+       the specified task or a timeout occurred. The contents of FailedCpuList
+       can be examined to determine which APs did not complete the specified task
+       prior to the timeout.
+
+  @param[in]  This                    A pointer to the EFI_MP_SERVICES_PROTOCOL
+                                      instance.
+  @param[in]  Procedure               A pointer to the function to be run on
+                                      enabled APs of the system. See type
+                                      EFI_AP_PROCEDURE.
+  @param[in]  SingleThread            If TRUE, then all the enabled APs execute
+                                      the function specified by Procedure one by
+                                      one, in ascending order of processor handle
+                                      number.  If FALSE, then all the enabled APs
+                                      execute the function specified by Procedure
+                                      simultaneously.
+  @param[in]  WaitEvent               The event created by the caller with CreateEvent()
+                                      service.  If it is NULL, then execute in
+                                      blocking mode. BSP waits until all APs finish
+                                      or TimeoutInMicroSeconds expires.  If it's
+                                      not NULL, then execute in non-blocking mode.
+                                      BSP requests the function specified by
+                                      Procedure to be started on all the enabled
+                                      APs, and go on executing immediately. If
+                                      all return from Procedure, or TimeoutInMicroSeconds
+                                      expires, this event is signaled. The BSP
+                                      can use the CheckEvent() or WaitForEvent()
+                                      services to check the state of event.  Type
+                                      EFI_EVENT is defined in CreateEvent() in
+                                      the Unified Extensible Firmware Interface
+                                      Specification.
+  @param[in]  TimeoutInMicrosecsond   Indicates the time limit in microseconds for
+                                      APs to return from Procedure, either for
+                                      blocking or non-blocking mode. Zero means
+                                      infinity.  If the timeout expires before
+                                      all APs return from Procedure, then Procedure
+                                      on the failed APs is terminated. All enabled
+                                      APs are available for next function assigned
+                                      by EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()
+                                      or EFI_MP_SERVICES_PROTOCOL.StartupThisAP().
+                                      If the timeout expires in blocking mode,
+                                      BSP returns EFI_TIMEOUT.  If the timeout
+                                      expires in non-blocking mode, WaitEvent
+                                      is signaled with SignalEvent().
+  @param[in]  ProcedureArgument       The parameter passed into Procedure for
+                                      all APs.
+  @param[out] FailedCpuList           If NULL, this parameter is ignored. Otherwise,
+                                      if all APs finish successfully, then its
+                                      content is set to NULL. If not all APs
+                                      finish before timeout expires, then its
+                                      content is set to address of the buffer
+                                      holding handle numbers of the failed APs.
+                                      The buffer is allocated by MP Service Protocol,
+                                      and it's the caller's responsibility to
+                                      free the buffer with FreePool() service.
+                                      In blocking mode, it is ready for consumption
+                                      when the call returns. In non-blocking mode,
+                                      it is ready when WaitEvent is signaled.  The
+                                      list of failed CPU is terminated by
+                                      END_OF_CPU_LIST.
+
+  @retval EFI_SUCCESS             In blocking mode, all APs have finished before
+                                  the timeout expired.
+  @retval EFI_SUCCESS             In non-blocking mode, function has been dispatched
+                                  to all enabled APs.
+  @retval EFI_UNSUPPORTED         A non-blocking mode request was made after the
+                                  UEFI event EFI_EVENT_GROUP_READY_TO_BOOT was
+                                  signaled.
+  @retval EFI_DEVICE_ERROR        Caller processor is AP.
+  @retval EFI_NOT_STARTED         No enabled APs exist in the system.
+  @retval EFI_NOT_READY           Any enabled APs are busy.
+  @retval EFI_TIMEOUT             In blocking mode, the timeout expired before
+                                  all enabled APs have finished.
+  @retval EFI_INVALID_PARAMETER   Procedure is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_STARTUP_ALL_APS)(
+  IN  EFI_MP_SERVICES_PROTOCOL  *This,
+  IN  EFI_AP_PROCEDURE          Procedure,
+  IN  BOOLEAN                   SingleThread,
+  IN  EFI_EVENT                 WaitEvent               OPTIONAL,
+  IN  UINTN                     TimeoutInMicroSeconds,
+  IN  VOID                      *ProcedureArgument      OPTIONAL,
+  OUT UINTN                     **FailedCpuList         OPTIONAL
+  );
+
+/**
+  This service lets the caller get one enabled AP to execute a caller-provided
+  function. The caller can request the BSP to either wait for the completion
+  of the AP or just proceed with the next task by using the EFI event mechanism.
+  See EFI_MP_SERVICES_PROTOCOL.StartupAllAPs() for more details on non-blocking
+  execution support.  This service may only be called from the BSP.
+
+  This function is used to dispatch one enabled AP to the function specified by
+  Procedure passing in the argument specified by ProcedureArgument.  If WaitEvent
+  is NULL, execution is in blocking mode. The BSP waits until the AP finishes or
+  TimeoutInMicroSecondss expires. Otherwise, execution is in non-blocking mode.
+  BSP proceeds to the next task without waiting for the AP. If a non-blocking mode
+  is requested after the UEFI Event EFI_EVENT_GROUP_READY_TO_BOOT is signaled,
+  then EFI_UNSUPPORTED must be returned.
+
+  If the timeout specified by TimeoutInMicroseconds expires before the AP returns
+  from Procedure, then execution of Procedure by the AP is terminated. The AP is
+  available for subsequent calls to EFI_MP_SERVICES_PROTOCOL.StartupAllAPs() and
+  EFI_MP_SERVICES_PROTOCOL.StartupThisAP().
+
+  @param[in]  This                    A pointer to the EFI_MP_SERVICES_PROTOCOL
+                                      instance.
+  @param[in]  Procedure               A pointer to the function to be run on the
+                                      designated AP of the system. See type
+                                      EFI_AP_PROCEDURE.
+  @param[in]  ProcessorNumber         The handle number of the AP. The range is
+                                      from 0 to the total number of logical
+                                      processors minus 1. The total number of
+                                      logical processors can be retrieved by
+                                      EFI_MP_SERVICES_PROTOCOL.GetNumberOfProcessors().
+  @param[in]  WaitEvent               The event created by the caller with CreateEvent()
+                                      service.  If it is NULL, then execute in
+                                      blocking mode. BSP waits until this AP finish
+                                      or TimeoutInMicroSeconds expires.  If it's
+                                      not NULL, then execute in non-blocking mode.
+                                      BSP requests the function specified by
+                                      Procedure to be started on this AP,
+                                      and go on executing immediately. If this AP
+                                      return from Procedure or TimeoutInMicroSeconds
+                                      expires, this event is signaled. The BSP
+                                      can use the CheckEvent() or WaitForEvent()
+                                      services to check the state of event.  Type
+                                      EFI_EVENT is defined in CreateEvent() in
+                                      the Unified Extensible Firmware Interface
+                                      Specification.
+  @param[in]  TimeoutInMicrosecsond   Indicates the time limit in microseconds for
+                                      this AP to finish this Procedure, either for
+                                      blocking or non-blocking mode. Zero means
+                                      infinity.  If the timeout expires before
+                                      this AP returns from Procedure, then Procedure
+                                      on the AP is terminated. The
+                                      AP is available for next function assigned
+                                      by EFI_MP_SERVICES_PROTOCOL.StartupAllAPs()
+                                      or EFI_MP_SERVICES_PROTOCOL.StartupThisAP().
+                                      If the timeout expires in blocking mode,
+                                      BSP returns EFI_TIMEOUT.  If the timeout
+                                      expires in non-blocking mode, WaitEvent
+                                      is signaled with SignalEvent().
+  @param[in]  ProcedureArgument       The parameter passed into Procedure on the
+                                      specified AP.
+  @param[out] Finished                If NULL, this parameter is ignored.  In
+                                      blocking mode, this parameter is ignored.
+                                      In non-blocking mode, if AP returns from
+                                      Procedure before the timeout expires, its
+                                      content is set to TRUE. Otherwise, the
+                                      value is set to FALSE. The caller can
+                                      determine if the AP returned from Procedure
+                                      by evaluating this value.
+
+  @retval EFI_SUCCESS             In blocking mode, specified AP finished before
+                                  the timeout expires.
+  @retval EFI_SUCCESS             In non-blocking mode, the function has been
+                                  dispatched to specified AP.
+  @retval EFI_UNSUPPORTED         A non-blocking mode request was made after the
+                                  UEFI event EFI_EVENT_GROUP_READY_TO_BOOT was
+                                  signaled.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_TIMEOUT             In blocking mode, the timeout expired before
+                                  the specified AP has finished.
+  @retval EFI_NOT_READY           The specified AP is busy.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP or disabled AP.
+  @retval EFI_INVALID_PARAMETER   Procedure is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_STARTUP_THIS_AP)(
+  IN  EFI_MP_SERVICES_PROTOCOL  *This,
+  IN  EFI_AP_PROCEDURE          Procedure,
+  IN  UINTN                     ProcessorNumber,
+  IN  EFI_EVENT                 WaitEvent               OPTIONAL,
+  IN  UINTN                     TimeoutInMicroseconds,
+  IN  VOID                      *ProcedureArgument      OPTIONAL,
+  OUT BOOLEAN                   *Finished               OPTIONAL
+  );
+
+/**
+  This service switches the requested AP to be the BSP from that point onward.
+  This service changes the BSP for all purposes.   This call can only be performed
+  by the current BSP.
+
+  This service switches the requested AP to be the BSP from that point onward.
+  This service changes the BSP for all purposes. The new BSP can take over the
+  execution of the old BSP and continue seamlessly from where the old one left
+  off. This service may not be supported after the UEFI Event EFI_EVENT_GROUP_READY_TO_BOOT
+  is signaled.
+
+  If the BSP cannot be switched prior to the return from this service, then
+  EFI_UNSUPPORTED must be returned.
+
+  @param[in] This              A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
+  @param[in] ProcessorNumber   The handle number of AP that is to become the new
+                               BSP. The range is from 0 to the total number of
+                               logical processors minus 1. The total number of
+                               logical processors can be retrieved by
+                               EFI_MP_SERVICES_PROTOCOL.GetNumberOfProcessors().
+  @param[in] EnableOldBSP      If TRUE, then the old BSP will be listed as an
+                               enabled AP. Otherwise, it will be disabled.
+
+  @retval EFI_SUCCESS             BSP successfully switched.
+  @retval EFI_UNSUPPORTED         Switching the BSP cannot be completed prior to
+                                  this service returning.
+  @retval EFI_UNSUPPORTED         Switching the BSP is not supported.
+  @retval EFI_SUCCESS             The calling processor is an AP.
+  @retval EFI_NOT_FOUND           The processor with the handle specified by
+                                  ProcessorNumber does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the current BSP or
+                                  a disabled AP.
+  @retval EFI_NOT_READY           The specified AP is busy.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_SWITCH_BSP)(
+  IN EFI_MP_SERVICES_PROTOCOL  *This,
+  IN  UINTN                    ProcessorNumber,
+  IN  BOOLEAN                  EnableOldBSP
+  );
+
+/**
+  This service lets the caller enable or disable an AP from this point onward.
+  This service may only be called from the BSP.
+
+  This service allows the caller enable or disable an AP from this point onward.
+  The caller can optionally specify the health status of the AP by Health. If
+  an AP is being disabled, then the state of the disabled AP is implementation
+  dependent. If an AP is enabled, then the implementation must guarantee that a
+  complete initialization sequence is performed on the AP, so the AP is in a state
+  that is compatible with an MP operating system. This service may not be supported
+  after the UEFI Event EFI_EVENT_GROUP_READY_TO_BOOT is signaled.
+
+  If the enable or disable AP operation cannot be completed prior to the return
+  from this service, then EFI_UNSUPPORTED must be returned.
+
+  @param[in] This              A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
+  @param[in] ProcessorNumber   The handle number of AP.
+                               The range is from 0 to the total number of
+                               logical processors minus 1. The total number of
+                               logical processors can be retrieved by
+                               EFI_MP_SERVICES_PROTOCOL.GetNumberOfProcessors().
+  @param[in] EnableAP          Specifies the new state for the processor for
+                               enabled, FALSE for disabled.
+  @param[in] HealthFlag        If not NULL, a pointer to a value that specifies
+                               the new health status of the AP. This flag
+                               corresponds to StatusFlag defined in
+                               EFI_MP_SERVICES_PROTOCOL.GetProcessorInfo(). Only
+                               the PROCESSOR_HEALTH_STATUS_BIT is used. All other
+                               bits are ignored.  If it is NULL, this parameter
+                               is ignored.
+
+  @retval EFI_SUCCESS             The specified AP was enabled or disabled successfully.
+  @retval EFI_UNSUPPORTED         Enabling or disabling an AP cannot be completed
+                                  prior to this service returning.
+  @retval EFI_UNSUPPORTED         Enabling or disabling an AP is not supported.
+  @retval EFI_DEVICE_ERROR        The calling processor is an AP.
+  @retval EFI_NOT_FOUND           Processor with the handle specified by ProcessorNumber
+                                  does not exist.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_ENABLEDISABLEAP)(
+  IN  EFI_MP_SERVICES_PROTOCOL  *This,
+  IN  UINTN                     ProcessorNumber,
+  IN  BOOLEAN                   EnableAP,
+  IN  UINT32                    *HealthFlag OPTIONAL
+  );
+
+/**
+  This return the handle number for the calling processor.  This service may be
+  called from the BSP and APs.
+
+  This service returns the processor handle number for the calling processor.
+  The returned value is in the range from 0 to the total number of logical
+  processors minus 1. The total number of logical processors can be retrieved
+  with EFI_MP_SERVICES_PROTOCOL.GetNumberOfProcessors(). This service may be
+  called from the BSP and APs. If ProcessorNumber is NULL, then EFI_INVALID_PARAMETER
+  is returned. Otherwise, the current processors handle number is returned in
+  ProcessorNumber, and EFI_SUCCESS is returned.
+
+  @param[in] This              A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
+  @param[in] ProcessorNumber   Pointer to the handle number of AP.
+                               The range is from 0 to the total number of
+                               logical processors minus 1. The total number of
+                               logical processors can be retrieved by
+                               EFI_MP_SERVICES_PROTOCOL.GetNumberOfProcessors().
+
+  @retval EFI_SUCCESS             The current processor handle number was returned
+                                  in ProcessorNumber.
+  @retval EFI_INVALID_PARAMETER   ProcessorNumber is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MP_SERVICES_WHOAMI)(
+  IN EFI_MP_SERVICES_PROTOCOL  *This,
+  OUT UINTN                    *ProcessorNumber
+  );
+
+///
+/// When installed, the MP Services Protocol produces a collection of services
+/// that are needed for MP management.
+///
+/// Before the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled, the module
+/// that produces this protocol is required to place all APs into an idle state
+/// whenever the APs are disabled or the APs are not executing code as requested
+/// through the StartupAllAPs() or StartupThisAP() services. The idle state of
+/// an AP before the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled is
+/// implementation dependent.
+///
+/// After the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled, all the APs
+/// must be placed in the OS compatible CPU state as defined by the UEFI
+/// Specification. Implementations of this protocol may use the UEFI event
+/// EFI_EVENT_GROUP_READY_TO_BOOT to force APs into the OS compatible state as
+/// defined by the UEFI Specification. Modules that use this protocol must
+/// guarantee that all non-blocking mode requests on all APs have been completed
+/// before the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled. Since the
+/// order that event notification functions in the same event group are executed
+/// is not deterministic, an event of type EFI_EVENT_GROUP_READY_TO_BOOT cannot
+/// be used to guarantee that APs have completed their non-blocking mode requests.
+///
+/// When the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled, the StartAllAPs()
+/// and StartupThisAp() services must no longer support non-blocking mode requests.
+/// The support for SwitchBSP() and EnableDisableAP() may no longer be supported
+/// after this event is signaled. Since UEFI Applications and UEFI OS Loaders
+/// execute after the UEFI event EFI_EVENT_GROUP_READY_TO_BOOT is signaled, these
+/// UEFI images must be aware that the functionality of this protocol may be reduced.
+///
+struct _EFI_MP_SERVICES_PROTOCOL {
+  EFI_MP_SERVICES_GET_NUMBER_OF_PROCESSORS  GetNumberOfProcessors;
+  EFI_MP_SERVICES_GET_PROCESSOR_INFO        GetProcessorInfo;
+  EFI_MP_SERVICES_STARTUP_ALL_APS           StartupAllAPs;
+  EFI_MP_SERVICES_STARTUP_THIS_AP           StartupThisAP;
+  EFI_MP_SERVICES_SWITCH_BSP                SwitchBSP;
+  EFI_MP_SERVICES_ENABLEDISABLEAP           EnableDisableAP;
+  EFI_MP_SERVICES_WHOAMI                    WhoAmI;
+};
+
+extern EFI_GUID gEfiMpServiceProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Mtftp4.h b/MdePkg/Include/Protocol/Mtftp4.h
new file mode 100644
index 000000000000..e24751dd5a04
--- /dev/null
+++ b/MdePkg/Include/Protocol/Mtftp4.h
@@ -0,0 +1,593 @@
+/** @file
+  EFI Multicast Trivial File Transfer Protocol Definition
+
+Copyright (c) 2006 - 2011, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.0
+
+**/
+
+#ifndef __EFI_MTFTP4_PROTOCOL_H__
+#define __EFI_MTFTP4_PROTOCOL_H__
+
+#define EFI_MTFTP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x2FE800BE, 0x8F01, 0x4aa6, {0x94, 0x6B, 0xD7, 0x13, 0x88, 0xE1, 0x83, 0x3F } \
+  }
+
+#define EFI_MTFTP4_PROTOCOL_GUID \
+  { \
+    0x78247c57, 0x63db, 0x4708, {0x99, 0xc2, 0xa8, 0xb4, 0xa9, 0xa6, 0x1f, 0x6b } \
+  }
+
+typedef struct _EFI_MTFTP4_PROTOCOL EFI_MTFTP4_PROTOCOL;
+typedef struct _EFI_MTFTP4_TOKEN EFI_MTFTP4_TOKEN;
+
+//
+//MTFTP4 packet opcode definition
+//
+#define EFI_MTFTP4_OPCODE_RRQ                     1
+#define EFI_MTFTP4_OPCODE_WRQ                     2
+#define EFI_MTFTP4_OPCODE_DATA                    3
+#define EFI_MTFTP4_OPCODE_ACK                     4
+#define EFI_MTFTP4_OPCODE_ERROR                   5
+#define EFI_MTFTP4_OPCODE_OACK                    6
+#define EFI_MTFTP4_OPCODE_DIR                     7
+#define EFI_MTFTP4_OPCODE_DATA8                   8
+#define EFI_MTFTP4_OPCODE_ACK8                    9
+
+//
+// MTFTP4 error code definition
+//
+#define EFI_MTFTP4_ERRORCODE_NOT_DEFINED          0
+#define EFI_MTFTP4_ERRORCODE_FILE_NOT_FOUND       1
+#define EFI_MTFTP4_ERRORCODE_ACCESS_VIOLATION     2
+#define EFI_MTFTP4_ERRORCODE_DISK_FULL            3
+#define EFI_MTFTP4_ERRORCODE_ILLEGAL_OPERATION    4
+#define EFI_MTFTP4_ERRORCODE_UNKNOWN_TRANSFER_ID  5
+#define EFI_MTFTP4_ERRORCODE_FILE_ALREADY_EXISTS  6
+#define EFI_MTFTP4_ERRORCODE_NO_SUCH_USER         7
+#define EFI_MTFTP4_ERRORCODE_REQUEST_DENIED       8
+
+//
+// MTFTP4 pacekt definitions
+//
+#pragma pack(1)
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT8                   Filename[1];
+} EFI_MTFTP4_REQ_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT8                   Data[1];
+} EFI_MTFTP4_OACK_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT16                  Block;
+  UINT8                   Data[1];
+} EFI_MTFTP4_DATA_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT16                  Block[1];
+} EFI_MTFTP4_ACK_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT64                  Block;
+  UINT8                   Data[1];
+} EFI_MTFTP4_DATA8_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT64                  Block[1];
+} EFI_MTFTP4_ACK8_HEADER;
+
+typedef struct {
+  UINT16                  OpCode;
+  UINT16                  ErrorCode;
+  UINT8                   ErrorMessage[1];
+} EFI_MTFTP4_ERROR_HEADER;
+
+typedef union {
+  ///
+  /// Type of packets as defined by the MTFTPv4 packet opcodes.
+  ///
+  UINT16                  OpCode;
+  ///
+  /// Read request packet header.
+  ///
+  EFI_MTFTP4_REQ_HEADER   Rrq;
+  ///
+  /// Write request packet header.
+  ///
+  EFI_MTFTP4_REQ_HEADER   Wrq;
+  ///
+  /// Option acknowledge packet header.
+  ///
+  EFI_MTFTP4_OACK_HEADER  Oack;
+  ///
+  /// Data packet header.
+  ///
+  EFI_MTFTP4_DATA_HEADER  Data;
+  ///
+  /// Acknowledgement packet header.
+  ///
+  EFI_MTFTP4_ACK_HEADER   Ack;
+  ///
+  /// Data packet header with big block number.
+  ///
+  EFI_MTFTP4_DATA8_HEADER Data8;
+  ///
+  /// Acknowledgement header with big block num.
+  ///
+  EFI_MTFTP4_ACK8_HEADER  Ack8;
+  ///
+  /// Error packet header.
+  ///
+  EFI_MTFTP4_ERROR_HEADER Error;
+} EFI_MTFTP4_PACKET;
+
+#pragma pack()
+
+///
+/// MTFTP4 option definition.
+///
+typedef struct {
+  UINT8                   *OptionStr;
+  UINT8                   *ValueStr;
+} EFI_MTFTP4_OPTION;
+
+
+typedef struct {
+  BOOLEAN                 UseDefaultSetting;
+  EFI_IPv4_ADDRESS        StationIp;
+  EFI_IPv4_ADDRESS        SubnetMask;
+  UINT16                  LocalPort;
+  EFI_IPv4_ADDRESS        GatewayIp;
+  EFI_IPv4_ADDRESS        ServerIp;
+  UINT16                  InitialServerPort;
+  UINT16                  TryCount;
+  UINT16                  TimeoutValue;
+} EFI_MTFTP4_CONFIG_DATA;
+
+
+typedef struct {
+  EFI_MTFTP4_CONFIG_DATA  ConfigData;
+  UINT8                   SupportedOptionCount;
+  UINT8                   **SupportedOptoins;
+  UINT8                   UnsupportedOptionCount;
+  UINT8                   **UnsupportedOptoins;
+} EFI_MTFTP4_MODE_DATA;
+
+
+typedef struct {
+  EFI_IPv4_ADDRESS        GatewayIp;
+  EFI_IPv4_ADDRESS        ServerIp;
+  UINT16                  ServerPort;
+  UINT16                  TryCount;
+  UINT16                  TimeoutValue;
+} EFI_MTFTP4_OVERRIDE_DATA;
+
+//
+// Protocol interfaces definition
+//
+
+/**
+  A callback function that is provided by the caller to intercept
+  the EFI_MTFTP4_OPCODE_DATA or EFI_MTFTP4_OPCODE_DATA8 packets processed in the
+  EFI_MTFTP4_PROTOCOL.ReadFile() function, and alternatively to intercept
+  EFI_MTFTP4_OPCODE_OACK or EFI_MTFTP4_OPCODE_ERROR packets during a call to
+  EFI_MTFTP4_PROTOCOL.ReadFile(), WriteFile() or ReadDirectory().
+
+  @param  This        The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token       The token that the caller provided in the
+                      EFI_MTFTP4_PROTOCOL.ReadFile(), WriteFile()
+                      or ReadDirectory() function.
+  @param  PacketLen   Indicates the length of the packet.
+  @param  Packet      The pointer to an MTFTPv4 packet.
+
+  @retval EFI_SUCCESS The operation was successful.
+  @retval Others      Aborts the transfer process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_CHECK_PACKET)(
+  IN EFI_MTFTP4_PROTOCOL  *This,
+  IN EFI_MTFTP4_TOKEN     *Token,
+  IN UINT16               PacketLen,
+  IN EFI_MTFTP4_PACKET    *Paket
+  );
+
+/**
+  Timeout callback function.
+
+  @param  This           The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token          The token that is provided in the
+                         EFI_MTFTP4_PROTOCOL.ReadFile() or
+                         EFI_MTFTP4_PROTOCOL.WriteFile() or
+                         EFI_MTFTP4_PROTOCOL.ReadDirectory() functions
+                         by the caller.
+
+  @retval EFI_SUCCESS   The operation was successful.
+  @retval Others        Aborts download process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_TIMEOUT_CALLBACK)(
+  IN EFI_MTFTP4_PROTOCOL  *This,
+  IN EFI_MTFTP4_TOKEN     *Token
+  );
+
+/**
+  A callback function that the caller provides to feed data to the
+  EFI_MTFTP4_PROTOCOL.WriteFile() function.
+
+  @param  This   The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token  The token provided in the
+                 EFI_MTFTP4_PROTOCOL.WriteFile() by the caller.
+  @param  Length Indicates the length of the raw data wanted on input, and the
+                 length the data available on output.
+  @param  Buffer The pointer to the buffer where the data is stored.
+
+  @retval EFI_SUCCESS The operation was successful.
+  @retval Others      Aborts session.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_PACKET_NEEDED)(
+  IN  EFI_MTFTP4_PROTOCOL *This,
+  IN  EFI_MTFTP4_TOKEN    *Token,
+  IN  OUT UINT16          *Length,
+  OUT VOID                **Buffer
+  );
+
+
+/**
+  Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
+
+  @param  This     The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  ModeData The pointer to storage for the EFI MTFTPv4 Protocol driver mode data.
+
+  @retval EFI_SUCCESS           The configuration data was successfully returned.
+  @retval EFI_OUT_OF_RESOURCES  The required mode data could not be allocated.
+  @retval EFI_INVALID_PARAMETER This is NULL or ModeData is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_GET_MODE_DATA)(
+  IN  EFI_MTFTP4_PROTOCOL     *This,
+  OUT EFI_MTFTP4_MODE_DATA    *ModeData
+  );
+
+
+/**
+  Initializes, changes, or resets the default operational setting for this
+  EFI MTFTPv4 Protocol driver instance.
+
+  @param  This            The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  MtftpConfigData The pointer to the configuration data structure.
+
+  @retval EFI_SUCCESS           The EFI MTFTPv4 Protocol driver was configured successfully.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_ACCESS_DENIED     The EFI configuration could not be changed at this time because
+                                there is one MTFTP background operation in progress.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) has not finished yet.
+  @retval EFI_UNSUPPORTED       A configuration protocol (DHCP, BOOTP, RARP, etc.) could not
+                                be located when clients choose to use the default address
+                                settings.
+  @retval EFI_OUT_OF_RESOURCES  The EFI MTFTPv4 Protocol driver instance data could not be
+                                allocated.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred. The EFI
+                                 MTFTPv4 Protocol driver instance is not configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_CONFIGURE)(
+  IN EFI_MTFTP4_PROTOCOL       *This,
+  IN EFI_MTFTP4_CONFIG_DATA    *MtftpConfigData OPTIONAL
+  );
+
+
+/**
+  Gets information about a file from an MTFTPv4 server.
+
+  @param  This         The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  OverrideData Data that is used to override the existing parameters. If NULL,
+                       the default parameters that were set in the
+                       EFI_MTFTP4_PROTOCOL.Configure() function are used.
+  @param  Filename     The pointer to null-terminated ASCII file name string.
+  @param  ModeStr      The pointer to null-terminated ASCII mode string. If NULL, "octet" will be used.
+  @param  OptionCount  Number of option/value string pairs in OptionList.
+  @param  OptionList   The pointer to array of option/value string pairs. Ignored if
+                       OptionCount is zero.
+  @param  PacketLength The number of bytes in the returned packet.
+  @param  Packet       The pointer to the received packet. This buffer must be freed by
+                       the caller.
+
+  @retval EFI_SUCCESS              An MTFTPv4 OACK packet was received and is in the Packet.
+  @retval EFI_INVALID_PARAMETER    One or more of the following conditions is TRUE:
+                                   - This is NULL.
+                                   - Filename is NULL.
+                                   - OptionCount is not zero and OptionList is NULL.
+                                   - One or more options in OptionList have wrong format.
+                                   - PacketLength is NULL.
+                                   - One or more IPv4 addresses in OverrideData are not valid
+                                     unicast IPv4 addresses if OverrideData is not NULL.
+  @retval EFI_UNSUPPORTED          One or more options in the OptionList are in the
+                                   unsupported list of structure EFI_MTFTP4_MODE_DATA.
+  @retval EFI_NOT_STARTED          The EFI MTFTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING           When using a default address, configuration (DHCP, BOOTP,
+                                   RARP, etc.) has not finished yet.
+  @retval EFI_ACCESS_DENIED        The previous operation has not completed yet.
+  @retval EFI_OUT_OF_RESOURCES     Required system resources could not be allocated.
+  @retval EFI_TFTP_ERROR           An MTFTPv4 ERROR packet was received and is in the Packet.
+  @retval EFI_NETWORK_UNREACHABLE  An ICMP network unreachable error packet was received and the Packet is set to NULL.
+  @retval EFI_HOST_UNREACHABLE     An ICMP host unreachable error packet was received and the Packet is set to NULL.
+  @retval EFI_PROTOCOL_UNREACHABLE An ICMP protocol unreachable error packet was received and the Packet is set to NULL.
+  @retval EFI_PORT_UNREACHABLE     An ICMP port unreachable error packet was received and the Packet is set to NULL.
+  @retval EFI_ICMP_ERROR           Some other ICMP ERROR packet was received and is in the Buffer.
+  @retval EFI_PROTOCOL_ERROR       An unexpected MTFTPv4 packet was received and is in the Packet.
+  @retval EFI_TIMEOUT              No responses were received from the MTFTPv4 server.
+  @retval EFI_DEVICE_ERROR         An unexpected network error or system error occurred.
+  @retval EFI_NO_MEDIA             There was a media error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_GET_INFO)(
+  IN  EFI_MTFTP4_PROTOCOL      *This,
+  IN  EFI_MTFTP4_OVERRIDE_DATA *OverrideData   OPTIONAL,
+  IN  UINT8                    *Filename,
+  IN  UINT8                    *ModeStr        OPTIONAL,
+  IN  UINT8                    OptionCount,
+  IN  EFI_MTFTP4_OPTION        *OptionList,
+  OUT UINT32                   *PacketLength,
+  OUT EFI_MTFTP4_PACKET        **Packet        OPTIONAL
+  );
+
+/**
+  Parses the options in an MTFTPv4 OACK packet.
+
+  @param  This         The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  PacketLen    Length of the OACK packet to be parsed.
+  @param  Packet       The pointer to the OACK packet to be parsed.
+  @param  OptionCount  The pointer to the number of options in following OptionList.
+  @param  OptionList   The pointer to EFI_MTFTP4_OPTION storage. Call the EFI Boot
+                       Service FreePool() to release the OptionList if the options
+                       in this OptionList are not needed any more.
+
+  @retval EFI_SUCCESS           The OACK packet was valid and the OptionCount and
+                                OptionList parameters have been updated.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - PacketLen is 0.
+                                - Packet is NULL or Packet is not a valid MTFTPv4 packet.
+                                - OptionCount is NULL.
+  @retval EFI_NOT_FOUND         No options were found in the OACK packet.
+  @retval EFI_OUT_OF_RESOURCES  Storage for the OptionList array cannot be allocated.
+  @retval EFI_PROTOCOL_ERROR    One or more of the option fields is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_PARSE_OPTIONS)(
+  IN  EFI_MTFTP4_PROTOCOL      *This,
+  IN  UINT32                   PacketLen,
+  IN  EFI_MTFTP4_PACKET        *Packet,
+  OUT UINT32                   *OptionCount,
+  OUT EFI_MTFTP4_OPTION        **OptionList OPTIONAL
+  );
+
+
+/**
+  Downloads a file from an MTFTPv4 server.
+
+  @param  This  The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token The pointer to the token structure to provide the parameters that are
+                used in this operation.
+
+  @retval EFI_SUCCESS              The data file has been transferred successfully.
+  @retval EFI_OUT_OF_RESOURCES     Required system resources could not be allocated.
+  @retval EFI_BUFFER_TOO_SMALL     BufferSize is not zero but not large enough to hold the
+                                   downloaded data in downloading process.
+  @retval EFI_ABORTED              Current operation is aborted by user.
+  @retval EFI_NETWORK_UNREACHABLE  An ICMP network unreachable error packet was received.
+  @retval EFI_HOST_UNREACHABLE     An ICMP host unreachable error packet was received.
+  @retval EFI_PROTOCOL_UNREACHABLE An ICMP protocol unreachable error packet was received.
+  @retval EFI_PORT_UNREACHABLE     An ICMP port unreachable error packet was received.
+  @retval EFI_ICMP_ERROR           Some other  ICMP ERROR packet was received.
+  @retval EFI_TIMEOUT              No responses were received from the MTFTPv4 server.
+  @retval EFI_TFTP_ERROR           An MTFTPv4 ERROR packet was received.
+  @retval EFI_DEVICE_ERROR         An unexpected network error or system error occurred.
+  @retval EFI_NO_MEDIA             There was a media error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_READ_FILE)(
+  IN EFI_MTFTP4_PROTOCOL       *This,
+  IN EFI_MTFTP4_TOKEN          *Token
+  );
+
+
+
+/**
+  Sends a file to an MTFTPv4 server.
+
+  @param  This  The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token The pointer to the token structure to provide the parameters that are
+                used in this operation.
+
+  @retval EFI_SUCCESS           The upload session has started.
+  @retval EFI_UNSUPPORTED       The operation is not supported by this implementation.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_UNSUPPORTED       One or more options in the Token.OptionList are in
+                                the unsupported list of structure EFI_MTFTP4_MODE_DATA.
+  @retval EFI_NOT_STARTED       The EFI MTFTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_ALREADY_STARTED   This Token is already being used in another MTFTPv4 session.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_ACCESS_DENIED     The previous operation has not completed yet.
+  @retval EFI_DEVICE_ERROR      An unexpected network error or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_WRITE_FILE)(
+  IN EFI_MTFTP4_PROTOCOL       *This,
+  IN EFI_MTFTP4_TOKEN          *Token
+  );
+
+
+/**
+  Downloads a data file "directory" from an MTFTPv4 server. May be unsupported in some EFI
+  implementations.
+
+  @param  This  The pointer to the EFI_MTFTP4_PROTOCOL instance.
+  @param  Token The pointer to the token structure to provide the parameters that are
+                used in this operation.
+
+  @retval EFI_SUCCESS           The MTFTPv4 related file "directory" has been downloaded.
+  @retval EFI_UNSUPPORTED       The operation is not supported by this implementation.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_UNSUPPORTED       One or more options in the Token.OptionList are in
+                                the unsupported list of structure EFI_MTFTP4_MODE_DATA.
+  @retval EFI_NOT_STARTED       The EFI MTFTPv4 Protocol driver has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_ALREADY_STARTED   This Token is already being used in another MTFTPv4 session.
+  @retval EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval EFI_ACCESS_DENIED     The previous operation has not completed yet.
+  @retval EFI_DEVICE_ERROR      An unexpected network error or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_READ_DIRECTORY)(
+  IN EFI_MTFTP4_PROTOCOL       *This,
+  IN EFI_MTFTP4_TOKEN          *Token
+  );
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  @param  This The pointer to the EFI_MTFTP4_PROTOCOL instance.
+
+  @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval  EFI_NOT_STARTED       This EFI MTFTPv4 Protocol instance has not been started.
+  @retval  EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                 RARP, etc.) is not finished yet.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval  EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP4_POLL)(
+  IN EFI_MTFTP4_PROTOCOL       *This
+  );
+
+///
+/// The EFI_MTFTP4_PROTOCOL is designed to be used by UEFI drivers and applications
+/// to transmit and receive data files. The EFI MTFTPv4 Protocol driver uses
+/// the underlying EFI UDPv4 Protocol driver and EFI IPv4 Protocol driver.
+///
+struct _EFI_MTFTP4_PROTOCOL {
+  EFI_MTFTP4_GET_MODE_DATA     GetModeData;
+  EFI_MTFTP4_CONFIGURE         Configure;
+  EFI_MTFTP4_GET_INFO          GetInfo;
+  EFI_MTFTP4_PARSE_OPTIONS     ParseOptions;
+  EFI_MTFTP4_READ_FILE         ReadFile;
+  EFI_MTFTP4_WRITE_FILE        WriteFile;
+  EFI_MTFTP4_READ_DIRECTORY    ReadDirectory;
+  EFI_MTFTP4_POLL              Poll;
+};
+
+struct _EFI_MTFTP4_TOKEN {
+  ///
+  /// The status that is returned to the caller at the end of the operation
+  /// to indicate whether this operation completed successfully.
+  ///
+  EFI_STATUS                  Status;
+  ///
+  /// The event that will be signaled when the operation completes. If
+  /// set to NULL, the corresponding function will wait until the read or
+  /// write operation finishes. The type of Event must be
+  /// EVT_NOTIFY_SIGNAL. The Task Priority Level (TPL) of
+  /// Event must be lower than or equal to TPL_CALLBACK.
+  ///
+  EFI_EVENT                   Event;
+  ///
+  /// If not NULL, the data that will be used to override the existing configure data.
+  ///
+  EFI_MTFTP4_OVERRIDE_DATA    *OverrideData;
+  ///
+  /// The pointer to the null-terminated ASCII file name string.
+  ///
+  UINT8                       *Filename;
+  ///
+  /// The pointer to the null-terminated ASCII mode string. If NULL, "octet" is used.
+  ///
+  UINT8                       *ModeStr;
+  ///
+  /// Number of option/value string pairs.
+  ///
+  UINT32                      OptionCount;
+  ///
+  /// The pointer to an array of option/value string pairs. Ignored if OptionCount is zero.
+  ///
+  EFI_MTFTP4_OPTION           *OptionList;
+  ///
+  /// The size of the data buffer.
+  ///
+  UINT64                      BufferSize;
+  ///
+  /// The pointer to the data buffer. Data that is downloaded from the
+  /// MTFTPv4 server is stored here. Data that is uploaded to the
+  /// MTFTPv4 server is read from here. Ignored if BufferSize is zero.
+  ///
+  VOID                        *Buffer;
+  ///
+  /// The pointer to the context that will be used by CheckPacket,
+  /// TimeoutCallback and PacketNeeded.
+  ///
+  VOID                        *Context;
+  ///
+  /// The pointer to the callback function to check the contents of the received packet.
+  ///
+  EFI_MTFTP4_CHECK_PACKET     CheckPacket;
+  ///
+  /// The pointer to the function to be called when a timeout occurs.
+  ///
+  EFI_MTFTP4_TIMEOUT_CALLBACK TimeoutCallback;
+  ///
+  /// The pointer to the function to provide the needed packet contents.
+  ///
+  EFI_MTFTP4_PACKET_NEEDED    PacketNeeded;
+};
+
+extern EFI_GUID gEfiMtftp4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiMtftp4ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Mtftp6.h b/MdePkg/Include/Protocol/Mtftp6.h
new file mode 100644
index 000000000000..3273550e3369
--- /dev/null
+++ b/MdePkg/Include/Protocol/Mtftp6.h
@@ -0,0 +1,826 @@
+/** @file
+  UEFI Multicast Trivial File Transfer Protocol v6 Definition, which is built upon
+  the EFI UDPv6 Protocol and provides basic services for client-side unicast and/or
+  multicast TFTP operations.
+
+  Copyright (c) 2008 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_MTFTP6_PROTOCOL_H__
+#define __EFI_MTFTP6_PROTOCOL_H__
+
+
+#define EFI_MTFTP6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xd9760ff3, 0x3cca, 0x4267, {0x80, 0xf9, 0x75, 0x27, 0xfa, 0xfa, 0x42, 0x23 } \
+  }
+
+#define EFI_MTFTP6_PROTOCOL_GUID \
+  { \
+    0xbf0a78ba, 0xec29, 0x49cf, {0xa1, 0xc9, 0x7a, 0xe5, 0x4e, 0xab, 0x6a, 0x51 } \
+  }
+
+typedef struct _EFI_MTFTP6_PROTOCOL EFI_MTFTP6_PROTOCOL;
+typedef struct _EFI_MTFTP6_TOKEN    EFI_MTFTP6_TOKEN;
+
+///
+/// MTFTP Packet OpCodes
+///@{
+#define EFI_MTFTP6_OPCODE_RRQ      1 ///< The MTFTPv6 packet is a read request.
+#define EFI_MTFTP6_OPCODE_WRQ      2 ///< The MTFTPv6 packet is a write request.
+#define EFI_MTFTP6_OPCODE_DATA     3 ///< The MTFTPv6 packet is a data packet.
+#define EFI_MTFTP6_OPCODE_ACK      4 ///< The MTFTPv6 packet is an acknowledgement packet.
+#define EFI_MTFTP6_OPCODE_ERROR    5 ///< The MTFTPv6 packet is an error packet.
+#define EFI_MTFTP6_OPCODE_OACK     6 ///< The MTFTPv6 packet is an option acknowledgement packet.
+#define EFI_MTFTP6_OPCODE_DIR      7 ///< The MTFTPv6 packet is a directory query packet.
+#define EFI_MTFTP6_OPCODE_DATA8    8 ///< The MTFTPv6 packet is a data packet with a big block number.
+#define EFI_MTFTP6_OPCODE_ACK8     9 ///< The MTFTPv6 packet is an acknowledgement packet with a big block number.
+///@}
+
+///
+/// MTFTP ERROR Packet ErrorCodes
+///@{
+///
+/// The error code is not defined. See the error message in the packet (if any) for details.
+///
+#define EFI_MTFTP6_ERRORCODE_NOT_DEFINED           0
+///
+/// The file was not found.
+///
+#define EFI_MTFTP6_ERRORCODE_FILE_NOT_FOUND        1
+///
+/// There was an access violation.
+///
+#define EFI_MTFTP6_ERRORCODE_ACCESS_VIOLATION      2
+///
+/// The disk was full or its allocation was exceeded.
+///
+#define EFI_MTFTP6_ERRORCODE_DISK_FULL             3
+///
+/// The MTFTPv6 operation was illegal.
+///
+#define EFI_MTFTP6_ERRORCODE_ILLEGAL_OPERATION     4
+///
+/// The transfer ID is unknown.
+///
+#define EFI_MTFTP6_ERRORCODE_UNKNOWN_TRANSFER_ID   5
+///
+/// The file already exists.
+///
+#define EFI_MTFTP6_ERRORCODE_FILE_ALREADY_EXISTS   6
+///
+/// There is no such user.
+///
+#define EFI_MTFTP6_ERRORCODE_NO_SUCH_USER          7
+///
+/// The request has been denied due to option negotiation.
+///
+#define EFI_MTFTP6_ERRORCODE_REQUEST_DENIED        8
+///@}
+
+#pragma pack(1)
+
+///
+/// EFI_MTFTP6_REQ_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_RRQ for a read request
+  /// or OpCode = EFI_MTFTP6_OPCODE_WRQ for a write request.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The file name to be downloaded or uploaded.
+  ///
+  UINT8     Filename[1];
+} EFI_MTFTP6_REQ_HEADER;
+
+///
+/// EFI_MTFTP6_OACK_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_OACK.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The option strings in the option acknowledgement packet.
+  ///
+  UINT8     Data[1];
+} EFI_MTFTP6_OACK_HEADER;
+
+///
+/// EFI_MTFTP6_DATA_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_DATA.
+  ///
+  UINT16    OpCode;
+  ///
+  /// Block number of this data packet.
+  ///
+  UINT16    Block;
+  ///
+  /// The content of this data packet.
+  ///
+  UINT8     Data[1];
+} EFI_MTFTP6_DATA_HEADER;
+
+///
+/// EFI_MTFTP6_ACK_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_ACK.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The block number of the data packet that is being acknowledged.
+  ///
+  UINT16    Block[1];
+} EFI_MTFTP6_ACK_HEADER;
+
+///
+/// EFI_MTFTP6_DATA8_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_DATA8.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The block number of data packet.
+  ///
+  UINT64    Block;
+  ///
+  /// The content of this data packet.
+  ///
+  UINT8     Data[1];
+} EFI_MTFTP6_DATA8_HEADER;
+
+///
+/// EFI_MTFTP6_ACK8_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_ACK8.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The block number of the data packet that is being acknowledged.
+  ///
+  UINT64    Block[1];
+} EFI_MTFTP6_ACK8_HEADER;
+
+///
+/// EFI_MTFTP6_ERROR_HEADER
+///
+typedef struct {
+  ///
+  /// For this packet type, OpCode = EFI_MTFTP6_OPCODE_ERROR.
+  ///
+  UINT16    OpCode;
+  ///
+  /// The error number as defined by the MTFTPv6 packet error codes.
+  ///
+  UINT16    ErrorCode;
+  ///
+  /// Error message string.
+  ///
+  UINT8     ErrorMessage[1];
+} EFI_MTFTP6_ERROR_HEADER;
+
+///
+/// EFI_MTFTP6_PACKET
+///
+typedef union {
+  UINT16                   OpCode; ///< Type of packets as defined by the MTFTPv6 packet opcodes.
+  EFI_MTFTP6_REQ_HEADER    Rrq;    ///< Read request packet header.
+  EFI_MTFTP6_REQ_HEADER    Wrq;    ///< write request packet header.
+  EFI_MTFTP6_OACK_HEADER   Oack;   ///< Option acknowledge packet header.
+  EFI_MTFTP6_DATA_HEADER   Data;   ///< Data packet header.
+  EFI_MTFTP6_ACK_HEADER    Ack;    ///< Acknowledgement packet header.
+  EFI_MTFTP6_DATA8_HEADER  Data8;  ///< Data packet header with big block number.
+  EFI_MTFTP6_ACK8_HEADER   Ack8;   ///< Acknowledgement header with big block number.
+  EFI_MTFTP6_ERROR_HEADER  Error;  ///< Error packet header.
+} EFI_MTFTP6_PACKET;
+
+#pragma pack()
+
+///
+/// EFI_MTFTP6_CONFIG_DATA
+///
+typedef struct {
+  ///
+  /// The local IP address to use. Set to zero to let the underlying IPv6
+  /// driver choose a source address. If not zero it must be one of the
+  /// configured IP addresses in the underlying IPv6 driver.
+  ///
+  EFI_IPv6_ADDRESS       StationIp;
+  ///
+  /// Local port number. Set to zero to use the automatically assigned port number.
+  ///
+  UINT16                 LocalPort;
+  ///
+  /// The IP address of the MTFTPv6 server.
+  ///
+  EFI_IPv6_ADDRESS       ServerIp;
+  ///
+  /// The initial MTFTPv6 server port number. Request packets are
+  /// sent to this port. This number is almost always 69 and using zero
+  /// defaults to 69.
+  UINT16                 InitialServerPort;
+  ///
+  /// The number of times to transmit MTFTPv6 request packets and wait for a response.
+  ///
+  UINT16                 TryCount;
+  ///
+  /// The number of seconds to wait for a response after sending the MTFTPv6 request packet.
+  ///
+  UINT16                 TimeoutValue;
+} EFI_MTFTP6_CONFIG_DATA;
+
+///
+/// EFI_MTFTP6_MODE_DATA
+///
+typedef struct {
+  ///
+  /// The configuration data of this instance.
+  ///
+  EFI_MTFTP6_CONFIG_DATA  ConfigData;
+  ///
+  /// The number of option strings in the following SupportedOptions array.
+  ///
+  UINT8                   SupportedOptionCount;
+  ///
+  /// An array of null-terminated ASCII option strings that are recognized and supported by
+  /// this EFI MTFTPv6 Protocol driver implementation. The buffer is
+  /// read only to the caller and the caller should NOT free the buffer.
+  ///
+  UINT8                   **SupportedOptions;
+} EFI_MTFTP6_MODE_DATA;
+
+///
+/// EFI_MTFTP_OVERRIDE_DATA
+///
+typedef struct {
+  ///
+  /// IP address of the MTFTPv6 server. If set to all zero, the value that
+  /// was set by the EFI_MTFTP6_PROTOCOL.Configure() function will be used.
+  ///
+  EFI_IPv6_ADDRESS       ServerIp;
+  ///
+  /// MTFTPv6 server port number. If set to zero, it will use the value
+  /// that was set by the EFI_MTFTP6_PROTOCOL.Configure() function.
+  ///
+  UINT16                 ServerPort;
+  ///
+  /// Number of times to transmit MTFTPv6 request packets and wait
+  /// for a response. If set to zero, the value that was set by
+  /// theEFI_MTFTP6_PROTOCOL.Configure() function will be used.
+  ///
+  UINT16                 TryCount;
+  ///
+  /// Number of seconds to wait for a response after sending the
+  /// MTFTPv6 request packet. If set to zero, the value that was set by
+  /// the EFI_MTFTP6_PROTOCOL.Configure() function will be used.
+  ///
+  UINT16                 TimeoutValue;
+} EFI_MTFTP6_OVERRIDE_DATA;
+
+///
+/// EFI_MTFTP6_OPTION
+///
+typedef struct {
+  UINT8                  *OptionStr; ///< Pointer to the null-terminated ASCII MTFTPv6 option string.
+  UINT8                  *ValueStr;  ///< Pointer to the null-terminated ASCII MTFTPv6 value string.
+} EFI_MTFTP6_OPTION;
+
+/**
+  EFI_MTFTP6_TIMEOUT_CALLBACK is a callback function that the caller provides to capture the
+  timeout event in the EFI_MTFTP6_PROTOCOL.ReadFile(), EFI_MTFTP6_PROTOCOL.WriteFile() or
+  EFI_MTFTP6_PROTOCOL.ReadDirectory() functions.
+
+  Whenever a timeout occurs, the EFI MTFTPv6 Protocol driver will call the EFI_MTFTP6_TIMEOUT_CALLBACK
+  function to notify the caller of the timeout event. Any status code other than EFI_SUCCESS
+  that is returned from this function will abort the current download process.
+
+  @param[in] This          Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in] Token         The token that the caller provided in the EFI_MTFTP6_PROTOCOl.ReadFile(),
+                           WriteFile() or ReadDirectory() function.
+  @param[in] PacketLen     Indicates the length of the packet.
+  @param[in] Packet        Pointer to an MTFTPv6 packet.
+
+  @retval EFI_SUCCESS      Operation success.
+  @retval Others           Aborts session.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_CHECK_PACKET)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token,
+  IN UINT16                   PacketLen,
+  IN EFI_MTFTP6_PACKET        *Packet
+  );
+
+/**
+  EFI_MTFTP6_TIMEOUT_CALLBACK is a callback function that the caller provides to capture the
+  timeout event in the EFI_MTFTP6_PROTOCOL.ReadFile(), EFI_MTFTP6_PROTOCOL.WriteFile() or
+  EFI_MTFTP6_PROTOCOL.ReadDirectory() functions.
+
+  Whenever a timeout occurs, the EFI MTFTPv6 Protocol driver will call the EFI_MTFTP6_TIMEOUT_CALLBACK
+  function to notify the caller of the timeout event. Any status code other than EFI_SUCCESS
+  that is returned from this function will abort the current download process.
+
+  @param[in]      This     Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]      Token    The token that is provided in the EFI_MTFTP6_PROTOCOL.ReadFile() or
+                           EFI_MTFTP6_PROTOCOL.WriteFile() or EFI_MTFTP6_PROTOCOL.ReadDirectory()
+                           functions by the caller.
+
+  @retval EFI_SUCCESS      Operation success.
+  @retval Others           Aborts session.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_TIMEOUT_CALLBACK)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token
+  );
+
+/**
+  EFI_MTFTP6_PACKET_NEEDED is a callback function that the caller provides to feed data to the
+  EFI_MTFTP6_PROTOCOL.WriteFile() function.
+
+  EFI_MTFTP6_PACKET_NEEDED provides another mechanism for the caller to provide data to upload
+  other than a static buffer. The EFI MTFTP6 Protocol driver always calls EFI_MTFTP6_PACKET_NEEDED
+  to get packet data from the caller if no static buffer was given in the initial call to
+  EFI_MTFTP6_PROTOCOL.WriteFile() function. Setting *Length to zero signals the end of the session.
+  Returning a status code other than EFI_SUCCESS aborts the session.
+
+  @param[in]      This     Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]      Token    The token provided in the EFI_MTFTP6_PROTOCOL.WriteFile() by the caller.
+  @param[in, out] Length   Indicates the length of the raw data wanted on input, and the
+                           length the data available on output.
+  @param[out]     Buffer   Pointer to the buffer where the data is stored.
+
+  @retval EFI_SUCCESS      Operation success.
+  @retval Others           Aborts session.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_PACKET_NEEDED)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token,
+  IN OUT UINT16               *Length,
+  OUT VOID                    **Buffer
+  );
+
+struct _EFI_MTFTP6_TOKEN {
+  ///
+  /// The status that is returned to the caller at the end of the operation
+  /// to indicate whether this operation completed successfully.
+  /// Defined Status values are listed below.
+  ///
+  EFI_STATUS                  Status;
+  ///
+  /// The event that will be signaled when the operation completes. If
+  /// set to NULL, the corresponding function will wait until the read or
+  /// write operation finishes. The type of Event must be EVT_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                   Event;
+  ///
+  /// If not NULL, the data that will be used to override the existing
+  /// configure data.
+  ///
+  EFI_MTFTP6_OVERRIDE_DATA    *OverrideData;
+  ///
+  /// Pointer to the null-terminated ASCII file name string.
+  ///
+  UINT8                       *Filename;
+  ///
+  /// Pointer to the null-terminated ASCII mode string. If NULL, octet is used.
+  ///
+  UINT8                       *ModeStr;
+  ///
+  /// Number of option/value string pairs.
+  ///
+  UINT32                      OptionCount;
+  ///
+  /// Pointer to an array of option/value string pairs. Ignored if
+  /// OptionCount is zero. Both a remote server and this driver
+  /// implementation should support these options. If one or more
+  /// options are unrecognized by this implementation, it is sent to the
+  /// remote server without being changed.
+  ///
+  EFI_MTFTP6_OPTION           *OptionList;
+  ///
+  /// On input, the size, in bytes, of Buffer. On output, the number
+  /// of bytes transferred.
+  ///
+  UINT64                      BufferSize;
+  ///
+  /// Pointer to the data buffer. Data that is downloaded from the
+  /// MTFTPv6 server is stored here. Data that is uploaded to the
+  /// MTFTPv6 server is read from here. Ignored if BufferSize is zero.
+  ///
+  VOID                        *Buffer;
+  ///
+  /// Pointer to the context that will be used by CheckPacket,
+  /// TimeoutCallback and PacketNeeded.
+  ///
+  VOID                        *Context;
+  ///
+  /// Pointer to the callback function to check the contents of the
+  /// received packet.
+  ///
+  EFI_MTFTP6_CHECK_PACKET      CheckPacket;
+  ///
+  /// Pointer to the function to be called when a timeout occurs.
+  ///
+  EFI_MTFTP6_TIMEOUT_CALLBACK  TimeoutCallback;
+  ///
+  /// Pointer to the function to provide the needed packet contents.
+  /// Only used in WriteFile() operation.
+  ///
+  EFI_MTFTP6_PACKET_NEEDED     PacketNeeded;
+};
+
+/**
+  Read the current operational settings.
+
+  The GetModeData() function reads the current operational settings of this EFI MTFTPv6
+  Protocol driver instance.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[out] ModeData           The buffer in which the EFI MTFTPv6 Protocol driver mode
+                                 data is returned.
+
+  @retval  EFI_SUCCESS           The configuration data was successfully returned.
+  @retval  EFI_OUT_OF_RESOURCES  The required mode data could not be allocated.
+  @retval  EFI_INVALID_PARAMETER This is NULL or ModeData is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_GET_MODE_DATA)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  OUT EFI_MTFTP6_MODE_DATA    *ModeData
+  );
+
+/**
+  Initializes, changes, or resets the default operational setting for this EFI MTFTPv6
+  Protocol driver instance.
+
+  The Configure() function is used to set and change the configuration data for this EFI
+  MTFTPv6 Protocol driver instance. The configuration data can be reset to startup defaults by calling
+  Configure() with MtftpConfigData set to NULL. Whenever the instance is reset, any
+  pending operation is aborted. By changing the EFI MTFTPv6 Protocol driver instance configuration
+  data, the client can connect to different MTFTPv6 servers. The configuration parameters in
+  MtftpConfigData are used as the default parameters in later MTFTPv6 operations and can be
+  overridden in later operations.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  MtftpConfigData    Pointer to the configuration data structure.
+
+  @retval  EFI_SUCCESS           The EFI MTFTPv6 Protocol instance was configured successfully.
+  @retval  EFI_INVALID_PARAMETER One or more following conditions are TRUE:
+                                 - This is NULL.
+                                 - MtftpConfigData.StationIp is neither zero nor one
+                                   of the configured IP addresses in the underlying IPv6 driver.
+                                 - MtftpCofigData.ServerIp is not a valid IPv6 unicast address.
+  @retval  EFI_ACCESS_DENIED     - The configuration could not be changed at this time because there
+                                   is some MTFTP background operation in progress.
+                                 - MtftpCofigData.LocalPort is already in use.
+  @retval  EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                 address for this instance, but no source address was available for use.
+  @retval  EFI_OUT_OF_RESOURCES  The EFI MTFTPv6 Protocol driver instance data could not be
+                                 allocated.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred. The EFI
+                                 MTFTPv6 Protocol driver instance is not configured.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_CONFIGURE)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_CONFIG_DATA   *MtftpConfigData OPTIONAL
+);
+
+/**
+  Get information about a file from an MTFTPv6 server.
+
+  The GetInfo() function assembles an MTFTPv6 request packet with options, sends it to the
+  MTFTPv6 server, and may return an MTFTPv6 OACK, MTFTPv6 ERROR, or ICMP ERROR packet.
+  Retries occur only if no response packets are received from the MTFTPv6 server before the
+  timeout expires.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  OverrideData       Data that is used to override the existing parameters. If NULL, the
+                                 default parameters that were set in the EFI_MTFTP6_PROTOCOL.Configure()
+                                 function are used.
+  @param[in]  Filename           Pointer to null-terminated ASCII file name string.
+  @param[in]  ModeStr            Pointer to null-terminated ASCII mode string. If NULL, octet will be used
+  @param[in]  OptionCount        Number of option/value string pairs in OptionList.
+  @param[in]  OptionList         Pointer to array of option/value string pairs. Ignored if
+                                 OptionCount is zero.
+  @param[out] PacketLength       The number of bytes in the returned packet.
+  @param[out] Packet             The pointer to the received packet. This buffer must be freed by
+                                 the caller.
+
+  @retval  EFI_SUCCESS              An MTFTPv6 OACK packet was received and is in the Packet.
+  @retval  EFI_INVALID_PARAMETER    One or more of the following conditions is TRUE:
+                                    - This is NULL.
+                                    - Filename is NULL
+                                    - OptionCount is not zero and OptionList is NULL.
+                                    - One or more options in OptionList have wrong format.
+                                    - PacketLength is NULL.
+                                    - OverrideData.ServerIp is not valid unicast IPv6 addresses.
+  @retval  EFI_UNSUPPORTED          One or more options in the OptionList are unsupported by
+                                    this implementation.
+  @retval  EFI_NOT_STARTED          The EFI MTFTPv6 Protocol driver has not been started.
+  @retval  EFI_NO_MAPPING           The underlying IPv6 driver was responsible for choosing a source
+                                    address for this instance, but no source address was available for use.
+  @retval  EFI_ACCESS_DENIED        The previous operation has not completed yet.
+  @retval  EFI_OUT_OF_RESOURCES     Required system resources could not be allocated.
+  @retval  EFI_TFTP_ERROR           An MTFTPv6 ERROR packet was received and is in the Packet.
+  @retval  EFI_NETWORK_UNREACHABLE  An ICMP network unreachable error packet was received and the Packet is set to NULL.
+  @retval  EFI_HOST_UNREACHABLE     An ICMP host unreachable error packet was received and the Packet is set to NULL.
+  @retval  EFI_PROTOCOL_UNREACHABLE An ICMP protocol unreachable error packet was received and the Packet is set to NULL.
+  @retval  EFI_PORT_UNREACHABLE     An ICMP port unreachable error packet was received and the Packet is set to NULL.
+  @retval  EFI_ICMP_ERROR           Some other ICMP ERROR packet was received and the Packet is set to NULL.
+  @retval  EFI_PROTOCOL_ERROR       An unexpected MTFTPv6 packet was received and is in the Packet.
+  @retval  EFI_TIMEOUT              No responses were received from the MTFTPv6 server.
+  @retval  EFI_DEVICE_ERROR         An unexpected network error or system error occurred.
+  @retval  EFI_NO_MEDIA             There was a media error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_GET_INFO)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_OVERRIDE_DATA *OverrideData OPTIONAL,
+  IN UINT8                    *Filename,
+  IN UINT8                    *ModeStr OPTIONAL,
+  IN UINT8                    OptionCount,
+  IN EFI_MTFTP6_OPTION        *OptionList OPTIONAL,
+  OUT UINT32                  *PacketLength,
+  OUT EFI_MTFTP6_PACKET       **Packet OPTIONAL
+);
+
+/**
+  Parse the options in an MTFTPv6 OACK packet.
+
+  The ParseOptions() function parses the option fields in an MTFTPv6 OACK packet and
+  returns the number of options that were found and optionally a list of pointers to
+  the options in the packet.
+  If one or more of the option fields are not valid, then EFI_PROTOCOL_ERROR is returned
+  and *OptionCount and *OptionList stop at the last valid option.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  PacketLen          Length of the OACK packet to be parsed.
+  @param[in]  Packet             Pointer to the OACK packet to be parsed.
+  @param[out] OptionCount        Pointer to the number of options in the following OptionList.
+  @param[out] OptionList         Pointer to EFI_MTFTP6_OPTION storage. Each pointer in the
+                                 OptionList points to the corresponding MTFTP option buffer
+                                 in the Packet. Call the EFI Boot Service FreePool() to
+                                 release the OptionList if the options in this OptionList
+                                 are not needed any more.
+
+  @retval  EFI_SUCCESS           The OACK packet was valid and the OptionCount and
+                                 OptionList parameters have been updated.
+  @retval  EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                 - PacketLen is 0.
+                                 - Packet is NULL or Packet is not a valid MTFTPv6 packet.
+                                 - OptionCount is NULL.
+  @retval  EFI_NOT_FOUND         No options were found in the OACK packet.
+  @retval  EFI_OUT_OF_RESOURCES  Storage for the OptionList array can not be allocated.
+  @retval  EFI_PROTOCOL_ERROR    One or more of the option fields is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_PARSE_OPTIONS)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN UINT32                   PacketLen,
+  IN EFI_MTFTP6_PACKET        *Packet,
+  OUT UINT32                  *OptionCount,
+  OUT EFI_MTFTP6_OPTION       **OptionList OPTIONAL
+  );
+
+/**
+  Download a file from an MTFTPv6 server.
+
+  The ReadFile() function is used to initialize and start an MTFTPv6 download process and
+  optionally wait for completion. When the download operation completes, whether successfully or
+  not, the Token.Status field is updated by the EFI MTFTPv6 Protocol driver and then
+  Token.Event is signaled if it is not NULL.
+
+  Data can be downloaded from the MTFTPv6 server into either of the following locations:
+  - A fixed buffer that is pointed to by Token.Buffer
+  - A download service function that is pointed to by Token.CheckPacket
+
+  If both Token.Buffer and Token.CheckPacket are used, then Token.CheckPacket
+  will be called first. If the call is successful, the packet will be stored in Token.Buffer.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to the token structure to provide the parameters that are
+                                 used in this operation.
+
+  @retval  EFI_SUCCESS              The data file has been transferred successfully.
+  @retval  EFI_OUT_OF_RESOURCES     Required system resources could not be allocated.
+  @retval  EFI_BUFFER_TOO_SMALL     BufferSize is not zero but not large enough to hold the
+                                    downloaded data in downloading process.
+  @retval  EFI_ABORTED              Current operation is aborted by user.
+  @retval  EFI_NETWORK_UNREACHABLE  An ICMP network unreachable error packet was received.
+  @retval  EFI_HOST_UNREACHABLE     An ICMP host unreachable error packet was received.
+  @retval  EFI_PROTOCOL_UNREACHABLE An ICMP protocol unreachable error packet was received.
+  @retval  EFI_PORT_UNREACHABLE     An ICMP port unreachable error packet was received.
+  @retval  EFI_ICMP_ERROR           An ICMP ERROR packet was received.
+  @retval  EFI_TIMEOUT              No responses were received from the MTFTPv6 server.
+  @retval  EFI_TFTP_ERROR           An MTFTPv6 ERROR packet was received.
+  @retval  EFI_DEVICE_ERROR         An unexpected network error or system error occurred.
+  @retval  EFI_NO_MEDIA             There was a media error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_READ_FILE)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token
+  );
+
+/**
+  Send a file to an MTFTPv6 server. May be unsupported in some implementations.
+
+  The WriteFile() function is used to initialize an uploading operation with the given option list
+  and optionally wait for completion. If one or more of the options is not supported by the server, the
+  unsupported options are ignored and a standard TFTP process starts instead. When the upload
+  process completes, whether successfully or not, Token.Event is signaled, and the EFI MTFTPv6
+  Protocol driver updates Token.Status.
+
+  The caller can supply the data to be uploaded in the following two modes:
+  - Through the user-provided buffer
+  - Through a callback function
+
+  With the user-provided buffer, the Token.BufferSize field indicates the length of the buffer,
+  and the driver will upload the data in the buffer. With an EFI_MTFTP6_PACKET_NEEDED
+  callback function, the driver will call this callback function to get more data from the user to upload.
+  See the definition of EFI_MTFTP6_PACKET_NEEDED for more information. These two modes
+  cannot be used at the same time. The callback function will be ignored if the user provides the
+  buffer.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to the token structure to provide the parameters that are
+                                 used in this operation.
+
+  @retval  EFI_SUCCESS           The upload session has started.
+  @retval  EFI_UNSUPPORTED       The operation is not supported by this implementation.
+  @retval  EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Filename is NULL.
+                                 - Token.OptionCount is not zero and Token.OptionList is NULL.
+                                 - One or more options in Token.OptionList have wrong format.
+                                 - Token.Buffer and Token.PacketNeeded are both NULL.
+                                 - Token.OverrideData.ServerIp is not valid unicast IPv6 addresses.
+  @retval  EFI_UNSUPPORTED       One or more options in the Token.OptionList are not
+                                 supported by this implementation.
+  @retval  EFI_NOT_STARTED       The EFI MTFTPv6 Protocol driver has not been started.
+  @retval  EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                 address for this instance, but no source address was available for use.
+  @retval  EFI_ALREADY_STARTED   This Token is already being used in another MTFTPv6 session.
+  @retval  EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval  EFI_ACCESS_DENIED     The previous operation has not completed yet.
+  @retval  EFI_DEVICE_ERROR      An unexpected network error or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_WRITE_FILE)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token
+  );
+
+/**
+  Download a data file directory from an MTFTPv6 server. May be unsupported in some implementations.
+
+  The ReadDirectory() function is used to return a list of files on the MTFTPv6 server that are
+  logically (or operationally) related to Token.Filename. The directory request packet that is sent
+  to the server is built with the option list that was provided by caller, if present.
+
+  The file information that the server returns is put into either of the following locations:
+  - A fixed buffer that is pointed to by Token.Buffer
+  - A download service function that is pointed to by Token.CheckPacket
+
+  If both Token.Buffer and Token.CheckPacket are used, then Token.CheckPacket
+  will be called first. If the call is successful, the packet will be stored in Token.Buffer.
+
+  The returned directory listing in the Token.Buffer or EFI_MTFTP6_PACKET consists of a list
+  of two or three variable-length ASCII strings, each terminated by a null character, for each file in the
+  directory. If the multicast option is involved, the first field of each directory entry is the static
+  multicast IP address and UDP port number that is associated with the file name. The format of the
+  field is ip:ip:ip:ip:port. If the multicast option is not involved, this field and its terminating
+  null character are not present.
+
+  The next field of each directory entry is the file name and the last field is the file information string.
+  The information string contains the file size and the create/modify timestamp. The format of the
+  information string is filesize yyyy-mm-dd hh:mm:ss:ffff. The timestamp is
+  Coordinated Universal Time (UTC; also known as Greenwich Mean Time [GMT]).
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+  @param[in]  Token              Pointer to the token structure to provide the parameters that are
+                                 used in this operation.
+
+  @retval  EFI_SUCCESS           The MTFTPv6 related file "directory" has been downloaded.
+  @retval  EFI_UNSUPPORTED       The EFI MTFTPv6 Protocol driver does not support this function.
+  @retval  EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token.Filename is NULL.
+                                 - Token.OptionCount is not zero and Token.OptionList is NULL.
+                                 - One or more options in Token.OptionList have wrong format.
+                                 - Token.Buffer and Token.CheckPacket are both NULL.
+                                 - Token.OverrideData.ServerIp is not valid unicast IPv6 addresses.
+  @retval  EFI_UNSUPPORTED       One or more options in the Token.OptionList are not
+                                 supported by this implementation.
+  @retval  EFI_NOT_STARTED       The EFI MTFTPv6 Protocol driver has not been started.
+  @retval  EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                 address for this instance, but no source address was available for use.
+  @retval  EFI_ALREADY_STARTED   This Token is already being used in another MTFTPv6 session.
+  @retval  EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.
+  @retval  EFI_ACCESS_DENIED     The previous operation has not completed yet.
+  @retval  EFI_DEVICE_ERROR      An unexpected network error or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_READ_DIRECTORY)(
+  IN EFI_MTFTP6_PROTOCOL      *This,
+  IN EFI_MTFTP6_TOKEN         *Token
+);
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  The Poll() function can be used by network drivers and applications to increase the rate that data
+  packets are moved between the communications device and the transmit and receive queues.
+  In some systems, the periodic timer event in the managed network driver may not poll the
+  underlying communications device fast enough to transmit and/or receive all data packets without
+  missing incoming packets or dropping outgoing packets. Drivers and applications that are
+  experiencing packet loss should try calling the Poll() function more often.
+
+  @param[in]  This               Pointer to the EFI_MTFTP6_PROTOCOL instance.
+
+  @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval  EFI_NOT_STARTED       This EFI MTFTPv6 Protocol instance has not been started.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval  EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_MTFTP6_POLL)(
+  IN EFI_MTFTP6_PROTOCOL      *This
+  );
+
+///
+/// The EFI_MTFTP6_PROTOCOL is designed to be used by UEFI drivers and applications to transmit
+/// and receive data files. The EFI MTFTPv6 Protocol driver uses the underlying EFI UDPv6 Protocol
+/// driver and EFI IPv6 Protocol driver.
+///
+struct _EFI_MTFTP6_PROTOCOL {
+  EFI_MTFTP6_GET_MODE_DATA  GetModeData;
+  EFI_MTFTP6_CONFIGURE      Configure;
+  EFI_MTFTP6_GET_INFO       GetInfo;
+  EFI_MTFTP6_PARSE_OPTIONS  ParseOptions;
+  EFI_MTFTP6_READ_FILE      ReadFile;
+  EFI_MTFTP6_WRITE_FILE     WriteFile;
+  EFI_MTFTP6_READ_DIRECTORY ReadDirectory;
+  EFI_MTFTP6_POLL           Poll;
+};
+
+extern EFI_GUID gEfiMtftp6ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiMtftp6ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/NetworkInterfaceIdentifier.h b/MdePkg/Include/Protocol/NetworkInterfaceIdentifier.h
new file mode 100644
index 000000000000..1b7654503da0
--- /dev/null
+++ b/MdePkg/Include/Protocol/NetworkInterfaceIdentifier.h
@@ -0,0 +1,118 @@
+/** @file
+  EFI Network Interface Identifier Protocol.
+
+Copyright (c) 2006 - 2013, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in EFI Specification 1.10.
+
+**/
+
+#ifndef __EFI_NETWORK_INTERFACE_IDENTIFER_H__
+#define __EFI_NETWORK_INTERFACE_IDENTIFER_H__
+
+//
+// GUID retired from UEFI Specification 2.1b
+//
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID \
+  { \
+    0xE18541CD, 0xF755, 0x4f73, {0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29 } \
+  }
+
+//
+// GUID intruduced in UEFI Specification 2.1b
+//
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID_31 \
+  { \
+    0x1ACED566, 0x76ED, 0x4218, {0xBC, 0x81, 0x76, 0x7F, 0x1F, 0x97, 0x7A, 0x89 } \
+  }
+
+//
+// Revision defined in UEFI Specification 2.4
+//
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION    0x00020000
+
+
+///
+/// Revision defined in EFI1.1.
+///
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE_REVISION   EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION
+
+///
+/// Forward reference for pure ANSI compatability.
+///
+typedef struct _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL  EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL;
+
+///
+/// Protocol defined in EFI1.1.
+///
+typedef EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL   EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE;
+
+///
+/// An optional protocol that is used to describe details about the software
+/// layer that is used to produce the Simple Network Protocol.
+///
+struct _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL {
+  UINT64    Revision;   ///< The revision of the EFI_NETWORK_INTERFACE_IDENTIFIER protocol.
+  UINT64    Id;         ///< The address of the first byte of the identifying structure for this network
+                        ///< interface. This is only valid when the network interface is started
+                        ///< (see Start()). When the network interface is not started, this field is set to zero.
+  UINT64    ImageAddr;  ///< The address of the first byte of the identifying structure for this
+                        ///< network interface.  This is set to zero if there is no structure.
+  UINT32    ImageSize;  ///< The size of unrelocated network interface image.
+  CHAR8     StringId[4];///< A four-character ASCII string that is sent in the class identifier field of
+                        ///< option 60 in DHCP. For a Type of EfiNetworkInterfaceUndi, this field is UNDI.
+  UINT8     Type;       ///< Network interface type. This will be set to one of the values
+                        ///< in EFI_NETWORK_INTERFACE_TYPE.
+  UINT8     MajorVer;   ///< Major version number.
+  UINT8     MinorVer;   ///< Minor version number.
+  BOOLEAN   Ipv6Supported; ///< TRUE if the network interface supports IPv6; otherwise FALSE.
+  UINT16    IfNum;      ///< The network interface number that is being identified by this Network 
+                        ///< Interface Identifier Protocol. This field must be less than or 
+                        ///< equal to the (IFcnt | IFcntExt <<8 ) fields in the !PXE structure.
+
+};
+
+///
+///*******************************************************
+/// EFI_NETWORK_INTERFACE_TYPE
+///*******************************************************
+///
+typedef enum {
+  EfiNetworkInterfaceUndi = 1
+} EFI_NETWORK_INTERFACE_TYPE;
+
+///
+/// Forward reference for pure ANSI compatability.
+///
+typedef struct undiconfig_table  UNDI_CONFIG_TABLE;
+
+///
+/// The format of the configuration table for UNDI
+///
+struct undiconfig_table {
+  UINT32             NumberOfInterfaces;    ///< The number of NIC devices
+                                            ///< that this UNDI controls.
+  UINT32             reserved;
+  UNDI_CONFIG_TABLE  *nextlink;             ///< A pointer to the next UNDI
+                                            ///< configuration table.
+  ///
+  /// The length of this array is given in the NumberOfInterfaces field.
+  ///
+  struct {
+    VOID             *NII_InterfacePointer; ///< Pointer to the NII interface structure.
+    VOID             *DevicePathPointer;    ///< Pointer to the device path for this NIC.
+  } NII_entry[1]; 
+};
+
+extern EFI_GUID gEfiNetworkInterfaceIdentifierProtocolGuid;
+extern EFI_GUID gEfiNetworkInterfaceIdentifierProtocolGuid_31;
+
+#endif
diff --git a/MdePkg/Include/Protocol/NvmExpressPassthru.h b/MdePkg/Include/Protocol/NvmExpressPassthru.h
new file mode 100644
index 000000000000..15879e578d59
--- /dev/null
+++ b/MdePkg/Include/Protocol/NvmExpressPassthru.h
@@ -0,0 +1,286 @@
+/** @file
+  This protocol provides services that allow NVM Express commands to be sent to an
+  NVM Express controller or to a specific namespace in a NVM Express controller.
+  This protocol interface is optimized for storage.
+
+  Copyright (c) 2013 - 2015, 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_NVM_EXPRESS_PASS_THRU_H_
+#define _UEFI_NVM_EXPRESS_PASS_THRU_H_
+
+#define EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL_GUID \
+  { \
+    0x52c78312, 0x8edc, 0x4233, { 0x98, 0xf2, 0x1a, 0x1a, 0xa5, 0xe3, 0x88, 0xa5 } \
+  }
+
+typedef struct _EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL;
+
+typedef struct {
+  UINT32          Attributes;
+  UINT32          IoAlign;
+  UINT32          NvmeVersion;
+} EFI_NVM_EXPRESS_PASS_THRU_MODE;
+
+//
+// If this bit is set, then the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL interface is
+// for directly addressable namespaces.
+//
+#define EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_PHYSICAL        0x0001
+//
+// If this bit is set, then the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL interface is
+// for a single volume logical namespace comprised of multiple namespaces.
+//
+#define EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_LOGICAL         0x0002
+//
+// If this bit is set, then the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL interface
+// supports non-blocking I/O.
+//
+#define EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_NONBLOCKIO      0x0004
+//
+// If this bit is set, then the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL interface
+// supports NVM command set.
+//
+#define EFI_NVM_EXPRESS_PASS_THRU_ATTRIBUTES_CMD_SET_NVM     0x0008
+
+//
+// FusedOperation
+//
+#define NORMAL_CMD                  0x00
+#define FUSED_FIRST_CMD             0x01
+#define FUSED_SECOND_CMD            0x02
+
+typedef struct {
+  UINT32                            Opcode:8;
+  UINT32                            FusedOperation:2;
+  UINT32                            Reserved:22;
+} NVME_CDW0;
+
+//
+// Flags
+//
+#define CDW2_VALID                  0x01
+#define CDW3_VALID                  0x02
+#define CDW10_VALID                 0x04
+#define CDW11_VALID                 0x08
+#define CDW12_VALID                 0x10
+#define CDW13_VALID                 0x20
+#define CDW14_VALID                 0x40
+#define CDW15_VALID                 0x80
+
+//
+// Queue Type
+//
+#define NVME_ADMIN_QUEUE            0x00
+#define NVME_IO_QUEUE               0x01
+
+typedef struct {
+  NVME_CDW0                         Cdw0;
+  UINT8                             Flags;
+  UINT32                            Nsid;
+  UINT32                            Cdw2;
+  UINT32                            Cdw3;
+  UINT32                            Cdw10;
+  UINT32                            Cdw11;
+  UINT32                            Cdw12;
+  UINT32                            Cdw13;
+  UINT32                            Cdw14;
+  UINT32                            Cdw15;
+} EFI_NVM_EXPRESS_COMMAND;
+
+typedef struct {
+  UINT32                            DW0;
+  UINT32                            DW1;
+  UINT32                            DW2;
+  UINT32                            DW3;
+} EFI_NVM_EXPRESS_COMPLETION;
+
+typedef struct {
+  UINT64                            CommandTimeout;
+  VOID                              *TransferBuffer;
+  UINT32                            TransferLength;
+  VOID                              *MetadataBuffer;
+  UINT32                            MetadataLength;
+  UINT8                             QueueType;
+  EFI_NVM_EXPRESS_COMMAND           *NvmeCmd;
+  EFI_NVM_EXPRESS_COMPLETION        *NvmeCompletion;
+} EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET;
+
+//
+// Protocol function prototypes
+//
+/**
+  Sends an NVM Express Command Packet to an NVM Express controller or namespace. This function supports
+  both blocking I/O and non-blocking I/O. The blocking I/O functionality is required, and the non-blocking
+  I/O functionality is optional.
+
+
+  @param[in]     This                A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
+  @param[in]     NamespaceId         A 32 bit namespace ID as defined in the NVMe specification to which the NVM Express Command
+                                     Packet will be sent.  A value of 0 denotes the NVM Express controller, a value of all 0xFF's
+                                     (all bytes are 0xFF) in the namespace ID specifies that the command packet should be sent to
+                                     all valid namespaces.
+  @param[in,out] Packet              A pointer to the NVM Express Command Packet.
+  @param[in]     Event               If non-blocking I/O is not supported then Event is ignored, and blocking I/O is performed.
+                                     If Event is NULL, then blocking I/O is performed. If Event is not NULL and non-blocking I/O
+                                     is supported, then non-blocking I/O is performed, and Event will be signaled when the NVM
+                                     Express Command Packet completes. 
+
+  @retval EFI_SUCCESS                The NVM Express Command Packet was sent by the host. TransferLength bytes were transferred
+                                     to, or from DataBuffer.
+  @retval EFI_BAD_BUFFER_SIZE        The NVM Express Command Packet was not executed. The number of bytes that could be transferred
+                                     is returned in TransferLength.
+  @retval EFI_NOT_READY              The NVM Express Command Packet could not be sent because the controller is not ready. The caller
+                                     may retry again later.
+  @retval EFI_DEVICE_ERROR           A device error occurred while attempting to send the NVM Express Command Packet.
+  @retval EFI_INVALID_PARAMETER      NamespaceId or the contents of EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET are invalid. The NVM
+                                     Express Command Packet was not sent, so no additional status information is available.
+  @retval EFI_UNSUPPORTED            The command described by the NVM Express Command Packet is not supported by the NVM Express
+                                     controller. The NVM Express Command Packet was not sent so no additional status information
+                                     is available.
+  @retval EFI_TIMEOUT                A timeout occurred while waiting for the NVM Express Command Packet to execute.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_NVM_EXPRESS_PASS_THRU_PASSTHRU)(
+  IN     EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL          *This,
+  IN     UINT32                                      NamespaceId,
+  IN OUT EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET    *Packet,
+  IN     EFI_EVENT                                   Event OPTIONAL
+  );
+
+/**
+  Used to retrieve the next namespace ID for this NVM Express controller.
+
+  The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.GetNextNamespace() function retrieves the next valid
+  namespace ID on this NVM Express controller. 
+
+  If on input the value pointed to by NamespaceId is 0xFFFFFFFF, then the first valid namespace
+  ID defined on the NVM Express controller is returned in the location pointed to by NamespaceId
+  and a status of EFI_SUCCESS is returned.
+
+  If on input the value pointed to by NamespaceId is an invalid namespace ID other than 0xFFFFFFFF,
+  then EFI_INVALID_PARAMETER is returned.
+
+  If on input the value pointed to by NamespaceId is a valid namespace ID, then the next valid
+  namespace ID on the NVM Express controller is returned in the location pointed to by NamespaceId,
+  and EFI_SUCCESS is returned.
+
+  If the value pointed to by NamespaceId is the namespace ID of the last namespace on the NVM
+  Express controller, then EFI_NOT_FOUND is returned.
+
+  @param[in]     This           A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
+  @param[in,out] NamespaceId    On input, a pointer to a legal NamespaceId for an NVM Express
+                                namespace present on the NVM Express controller. On output, a
+                                pointer to the next NamespaceId of an NVM Express namespace on
+                                an NVM Express controller. An input value of 0xFFFFFFFF retrieves
+                                the first NamespaceId for an NVM Express namespace present on an
+                                NVM Express controller.
+
+  @retval EFI_SUCCESS           The Namespace ID of the next Namespace was returned.
+  @retval EFI_NOT_FOUND         There are no more namespaces defined on this controller.
+  @retval EFI_INVALID_PARAMETER NamespaceId is an invalid value other than 0xFFFFFFFF.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_NVM_EXPRESS_PASS_THRU_GET_NEXT_NAMESPACE)(
+  IN     EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL          *This,
+  IN OUT UINT32                                      *NamespaceId
+  );
+
+/**
+  Used to allocate and build a device path node for an NVM Express namespace on an NVM Express controller.
+
+  The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.BuildDevicePath() function allocates and builds a single device
+  path node for the NVM Express namespace specified by NamespaceId.
+
+  If the NamespaceId is not valid, then EFI_NOT_FOUND is returned.
+
+  If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned. 
+
+  If there are not enough resources to allocate the device path node, then EFI_OUT_OF_RESOURCES is returned.
+
+  Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of DevicePath are
+  initialized to describe the NVM Express namespace specified by NamespaceId, and EFI_SUCCESS is returned.
+
+  @param[in]     This                A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
+  @param[in]     NamespaceId         The NVM Express namespace ID  for which a device path node is to be
+                                     allocated and built. Caller must set the NamespaceId to zero if the
+                                     device path node will contain a valid UUID.
+  @param[in,out] DevicePath          A pointer to a single device path node that describes the NVM Express
+                                     namespace specified by NamespaceId. This function is responsible for
+                                     allocating the buffer DevicePath with the boot service AllocatePool().
+                                     It is the caller's responsibility to free DevicePath when the caller
+                                     is finished with DevicePath.
+  @retval EFI_SUCCESS                The device path node that describes the NVM Express namespace specified
+                                     by NamespaceId was allocated and returned in DevicePath.
+  @retval EFI_NOT_FOUND              The NamespaceId is not valid.
+  @retval EFI_INVALID_PARAMETER      DevicePath is NULL.
+  @retval EFI_OUT_OF_RESOURCES       There are not enough resources to allocate the DevicePath node.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_NVM_EXPRESS_PASS_THRU_BUILD_DEVICE_PATH)(
+  IN     EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL          *This,
+  IN     UINT32                                      NamespaceId,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL                    **DevicePath
+  );
+
+/**
+  Used to translate a device path node to a namespace ID.
+
+  The EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL.GetNamespace() function determines the namespace ID associated with the
+  namespace described by DevicePath.
+
+  If DevicePath is a device path node type that the NVM Express Pass Thru driver supports, then the NVM Express
+  Pass Thru driver will attempt to translate the contents DevicePath into a namespace ID.
+
+  If this translation is successful, then that namespace ID is returned in NamespaceId, and EFI_SUCCESS is returned
+
+  @param[in]  This                A pointer to the EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL instance.
+  @param[in]  DevicePath          A pointer to the device path node that describes an NVM Express namespace on
+                                  the NVM Express controller.
+  @param[out] NamespaceId         The NVM Express namespace ID contained in the device path node.
+
+  @retval EFI_SUCCESS             DevicePath was successfully translated to NamespaceId.
+  @retval EFI_INVALID_PARAMETER   If DevicePath or NamespaceId are NULL, then EFI_INVALID_PARAMETER is returned.
+  @retval EFI_UNSUPPORTED         If DevicePath is not a device path node type that the NVM Express Pass Thru driver
+                                  supports, then EFI_UNSUPPORTED is returned.
+  @retval EFI_NOT_FOUND           If DevicePath is a device path node type that the NVM Express Pass Thru driver
+                                  supports, but there is not a valid translation from DevicePath to a namespace ID,
+                                  then EFI_NOT_FOUND is returned.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_NVM_EXPRESS_PASS_THRU_GET_NAMESPACE)(
+  IN     EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL          *This,
+  IN     EFI_DEVICE_PATH_PROTOCOL                    *DevicePath,
+     OUT UINT32                                      *NamespaceId
+  );
+
+//
+// Protocol Interface Structure
+//
+struct _EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL {
+  EFI_NVM_EXPRESS_PASS_THRU_MODE                     *Mode;
+  EFI_NVM_EXPRESS_PASS_THRU_PASSTHRU                 PassThru;
+  EFI_NVM_EXPRESS_PASS_THRU_GET_NEXT_NAMESPACE       GetNextNamespace;
+  EFI_NVM_EXPRESS_PASS_THRU_BUILD_DEVICE_PATH        BuildDevicePath;
+  EFI_NVM_EXPRESS_PASS_THRU_GET_NAMESPACE            GetNamespace;
+};
+
+extern EFI_GUID gEfiNvmExpressPassThruProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Pcd.h b/MdePkg/Include/Protocol/Pcd.h
new file mode 100644
index 000000000000..e75b4e513bbc
--- /dev/null
+++ b/MdePkg/Include/Protocol/Pcd.h
@@ -0,0 +1,864 @@
+/** @file
+  Native Platform Configuration Database (PCD) Protocol
+
+  Different with the EFI_PCD_PROTOCOL defined in PI 1.2 specification, the native
+  PCD protocol provide interfaces for dynamic and dynamic-ex type PCD. 
+  The interfaces in dynamic type PCD do not require the token space guid as parameter,
+  but interfaces in dynamic-ex type PCD require token space guid as parameter.
+  
+Copyright (c) 2006 - 2013, 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 __PCD_H__
+#define __PCD_H__
+
+extern EFI_GUID gPcdProtocolGuid;
+
+#define PCD_PROTOCOL_GUID \
+  { 0x11b34006, 0xd85b, 0x4d0a, { 0xa2, 0x90, 0xd5, 0xa5, 0x71, 0x31, 0xe, 0xf7 } }
+
+#define PCD_INVALID_TOKEN_NUMBER ((UINTN) 0)
+
+
+/**
+  Sets the SKU value for subsequent calls to set or get PCD token values.
+
+  SetSku() sets the SKU Id to be used for subsequent calls to set or get PCD values. 
+  SetSku() is normally called only once by the system.
+
+  For each item (token), the database can hold a single value that applies to all SKUs, 
+  or multiple values, where each value is associated with a specific SKU Id. Items with multiple, 
+  SKU-specific values are called SKU enabled. 
+  
+  The SKU Id of zero is reserved as a default. The valid SkuId range is 1 to 255.  
+  For tokens that are not SKU enabled, the system ignores any set SKU Id and works with the 
+  single value for that token. For SKU-enabled tokens, the system will use the SKU Id set by the 
+  last call to SetSku(). If no SKU Id is set or the currently set SKU Id isn't valid for the specified token, 
+  the system uses the default SKU Id. If the system attempts to use the default SKU Id and no value has been 
+  set for that Id, the results are unpredictable.
+
+  @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and 
+                    set values associated with a PCD token.
+
+
+**/
+typedef 
+VOID
+(EFIAPI *PCD_PROTOCOL_SET_SKU)(
+  IN  UINTN                  SkuId
+  );
+
+
+
+/**
+  Retrieves an 8-bit value for a given PCD token.
+
+  Retrieves the current byte-sized value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT8 value.
+  
+**/
+typedef
+UINT8
+(EFIAPI *PCD_PROTOCOL_GET8)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 16-bit value for a given PCD token.
+
+  Retrieves the current 16-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT16 value.
+  
+**/
+typedef
+UINT16
+(EFIAPI *PCD_PROTOCOL_GET16)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 32-bit value for a given PCD token.
+
+  Retrieves the current 32-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT32 value.
+  
+**/
+typedef
+UINT32
+(EFIAPI *PCD_PROTOCOL_GET32)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 64-bit value for a given PCD token.
+
+  Retrieves the current 64-bit value for a PCD token number.  
+  If the TokenNumber is invalid, the results are unpredictable.
+  
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The UINT64 value.
+  
+**/
+typedef
+UINT64
+(EFIAPI *PCD_PROTOCOL_GET64)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a pointer to a value for a given PCD token.
+
+  Retrieves the current pointer to the buffer for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The pointer to the buffer to be retrived.
+  
+**/
+typedef
+VOID *
+(EFIAPI *PCD_PROTOCOL_GET_POINTER)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a Boolean value for a given PCD token.
+
+  Retrieves the current boolean value for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The Boolean value.
+  
+**/
+typedef
+BOOLEAN
+(EFIAPI *PCD_PROTOCOL_GET_BOOLEAN)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves the size of the value for a given PCD token.
+
+  Retrieves the current size of a particular PCD token.  
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size of the value for the PCD token.
+  
+**/
+typedef
+UINTN
+(EFIAPI *PCD_PROTOCOL_GET_SIZE)(
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves an 8-bit value for a given PCD token.
+
+  Retrieves the 8-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 8-bit value for the PCD token.
+  
+**/
+typedef
+UINT8
+(EFIAPI *PCD_PROTOCOL_GET_EX_8)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 16-bit value for a given PCD token.
+
+  Retrieves the 16-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 16-bit value for the PCD token.
+  
+**/
+typedef
+UINT16
+(EFIAPI *PCD_PROTOCOL_GET_EX_16)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a 32-bit value for a given PCD token.
+
+  Retrieves the 32-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 32-bit value for the PCD token.
+  
+**/
+typedef
+UINT32
+(EFIAPI *PCD_PROTOCOL_GET_EX_32)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves an 64-bit value for a given PCD token.
+
+  Retrieves the 64-bit value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size 64-bit value for the PCD token.
+  
+**/
+typedef
+UINT64
+(EFIAPI *PCD_PROTOCOL_GET_EX_64)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a pointer to a value for a given PCD token.
+
+  Retrieves the current pointer to the buffer for a PCD token number.  
+  Do not make any assumptions about the alignment of the pointer that 
+  is returned by this function call.  If the TokenNumber is invalid, 
+  the results are unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The pointer to the buffer to be retrieved.
+  
+**/
+typedef
+VOID *
+(EFIAPI *PCD_PROTOCOL_GET_EX_POINTER)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves a Boolean value for a given PCD token.
+
+  Retrieves the Boolean value of a particular PCD token.  
+  If the TokenNumber is invalid or the token space
+  specified by Guid does not exist, the results are 
+  unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size Boolean value for the PCD token.
+  
+**/
+typedef
+BOOLEAN
+(EFIAPI *PCD_PROTOCOL_GET_EX_BOOLEAN)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Retrieves the size of the value for a given PCD token.
+
+  Retrieves the current size of a particular PCD token.  
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]  Guid        The token space for the token number.
+  @param[in]  TokenNumber The PCD token number. 
+
+  @return The size of the value for the PCD token.
+  
+**/
+typedef
+UINTN
+(EFIAPI *PCD_PROTOCOL_GET_EX_SIZE)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber
+  );
+
+
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET8)(
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  );
+
+
+
+/**
+  Sets a 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET16)(
+  IN UINTN              TokenNumber,
+  IN UINT16             Value
+  );
+
+
+
+/**
+  Sets a 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET32)(
+  IN UINTN              TokenNumber,
+  IN UINT32             Value
+  );
+
+
+
+/**
+  Sets a 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET64)(
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  );
+
+
+
+/**
+  Sets a value of a specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]      TokenNumber  The PCD token number. 
+  @param[in, out] SizeOfBuffer A pointer to the length of the value being set for the PCD token.  
+                               On input, if the SizeOfValue is greater than the maximum size supported 
+                               for this TokenNumber then the output value of SizeOfValue will reflect 
+                               the maximum size supported for this TokenNumber.
+  @param[in]      Buffer       The buffer to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_POINTER)(
+  IN      UINTN             TokenNumber,
+  IN OUT  UINTN             *SizeOfBuffer,
+  IN      VOID              *Buffer
+  );
+
+
+
+/**
+  Sets a Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_BOOLEAN)(
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  );
+
+
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_8)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  );
+
+
+
+/**
+  Sets an 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_16)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  );
+
+
+
+/**
+  Sets a 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_32)(
+  IN CONST EFI_GUID     *Guid,
+  IN UINTN              TokenNumber,
+  IN UINT32             Value
+  );
+
+
+
+/**
+  Sets a 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_64)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  );
+
+
+
+/**
+  Sets a value of a specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid            The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber     The PCD token number. 
+  @param[in, out] SizeOfBuffer A pointer to the length of the value being set for the PCD token.  
+                              On input, if the SizeOfValue is greater than the maximum size supported 
+                              for this TokenNumber then the output value of SizeOfValue will reflect 
+                              the maximum size supported for this TokenNumber.
+  @param[in]  Buffer          The buffer to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_POINTER)(
+  IN CONST EFI_GUID          *Guid,
+  IN       UINTN             TokenNumber,
+  IN OUT   UINTN             *SizeOfBuffer,
+  IN       VOID              *Buffer
+  );
+
+
+
+/**
+  Sets a Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the 
+  size of the value being set is compatible with the Token's existing definition.  
+  If it is not, an error will be returned.
+
+  @param[in]  Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  TokenNumber The PCD token number. 
+  @param[in]  Value       The value to set for the PCD token.
+
+  @retval EFI_SUCCESS  The procedure returned successfully.
+  @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data 
+                                  being set was incompatible with a call to this function.  
+                                  Use GetSize() to retrieve the size of the target data.
+  @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_SET_EX_BOOLEAN)(
+  IN CONST EFI_GUID    *Guid,
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  );
+  
+
+
+/**
+  Callback on SET function prototype definition.
+
+  This notification function serves two purposes. 
+  Firstly, it notifies the module which did the registration that the value 
+  of this PCD token has been set. Secondly, it provides a mechanism for the 
+  module that did the registration to intercept the set operation and override 
+  the value that has been set, if necessary. After the invocation of the callback function, 
+  TokenData will be used by PCD service DXE driver to modify the internal data in 
+  PCD database.
+
+  @param[in]  CallBackGuid    The PCD token GUID being set.
+  @param[in]  CallBackToken   The PCD token number being set.
+  @param[in, out] TokenData   A pointer to the token data being set.
+  @param[in]  TokenDataSize   The size, in bytes, of the data being set.
+
+  @retval VOID
+
+**/
+typedef
+VOID
+(EFIAPI *PCD_PROTOCOL_CALLBACK)(
+  IN CONST EFI_GUID         *CallBackGuid, OPTIONAL
+  IN       UINTN            CallBackToken,
+  IN OUT   VOID             *TokenData,
+  IN       UINTN            TokenDataSize
+  );
+
+
+
+/**
+  Specifies a function to be called anytime the value of a designated token is changed.
+
+  @param[in]  TokenNumber       The PCD token number. 
+  @param[in]  Guid              The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  CallBackFunction  The function prototype called when the value associated with the CallBackToken is set.  
+
+  @retval EFI_SUCCESS   The PCD service has successfully established a call event 
+                        for the CallBackToken requested.
+  @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_CALLBACK_ONSET)(
+  IN  CONST EFI_GUID          *Guid, OPTIONAL
+  IN  UINTN                   TokenNumber,
+  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
+  );
+
+
+
+/**
+  Cancels a previously set callback function for a particular PCD token number.
+
+  @param[in]  TokenNumber      The PCD token number. 
+  @param[in]  Guid             The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]  CallBackFunction The function prototype called when the value associated with the CallBackToken is set.  
+
+  @retval EFI_SUCCESS   The PCD service has successfully established a call event 
+                        for the CallBackToken requested.
+  @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_CANCEL_CALLBACK)(
+  IN  CONST EFI_GUID          *Guid, OPTIONAL
+  IN  UINTN                   TokenNumber,
+  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
+  );
+
+
+
+/**
+  Retrieves the next valid token number in a given namespace.  
+  
+  This is useful since the PCD infrastructure contains a sparse list of token numbers, 
+  and one cannot a priori know what token numbers are valid in the database.
+  
+  If TokenNumber is 0 and Guid is not NULL, then the first token from the token space specified by Guid is returned.  
+  If TokenNumber is not 0 and Guid is not NULL, then the next token in the token space specified by Guid is returned.  
+  If TokenNumber is 0 and Guid is NULL, then the first token in the default token space is returned.  
+  If TokenNumber is not 0 and Guid is NULL, then the next token in the default token space is returned.  
+  The token numbers in the default token space may not be related to token numbers in token spaces that are named by Guid.  
+  If the next token number can be retrieved, then it is returned in TokenNumber, and EFI_SUCCESS is returned.  
+  If TokenNumber represents the last token number in the token space specified by Guid, then EFI_NOT_FOUND is returned.  
+  If TokenNumber is not present in the token space specified by Guid, then EFI_NOT_FOUND is returned.
+
+
+  @param[in]      Guid    The 128-bit unique value that designates the namespace from which to retrieve the next token. 
+                          This is an optional parameter that may be NULL. If this parameter is NULL, then a request is 
+                          being made to retrieve tokens from the default token space.
+  @param[in,out]  TokenNumber 
+                          A pointer to the PCD token number to use to find the subsequent token number.  
+
+  @retval EFI_SUCCESS   The PCD service has retrieved the next valid token number.
+  @retval EFI_NOT_FOUND The PCD service could not find data from the requested token number.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_GET_NEXT_TOKEN)(
+  IN      CONST EFI_GUID      *Guid, OPTIONAL
+  IN OUT  UINTN               *TokenNumber
+  );
+
+
+
+/**
+  Retrieves the next valid PCD token namespace for a given namespace.
+
+  Gets the next valid token namespace for a given namespace. This is useful to traverse the valid
+  token namespaces on a platform.
+
+  @param[in, out]   Guid    An indirect pointer to EFI_GUID. On input it designates a known token namespace
+                            from which the search will start. On output, it designates the next valid token
+                            namespace on the platform. If *Guid is NULL, then the GUID of the first token
+                            space of the current platform is returned. If the search cannot locate the next valid
+                            token namespace, an error is returned and the value of *Guid is undefined.
+
+  @retval   EFI_SUCCESS   The PCD service retrieved the value requested.
+  @retval   EFI_NOT_FOUND The PCD service could not find the next valid token namespace.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *PCD_PROTOCOL_GET_NEXT_TOKENSPACE)(
+  IN  OUT    CONST EFI_GUID      **Guid
+  );
+
+///
+/// This service abstracts the ability to set/get Platform Configuration Database (PCD).
+///
+typedef struct {
+  PCD_PROTOCOL_SET_SKU              SetSku;
+
+  PCD_PROTOCOL_GET8                 Get8;
+  PCD_PROTOCOL_GET16                Get16;
+  PCD_PROTOCOL_GET32                Get32;
+  PCD_PROTOCOL_GET64                Get64;
+  PCD_PROTOCOL_GET_POINTER          GetPtr;
+  PCD_PROTOCOL_GET_BOOLEAN          GetBool;
+  PCD_PROTOCOL_GET_SIZE             GetSize;
+
+  PCD_PROTOCOL_GET_EX_8             Get8Ex;
+  PCD_PROTOCOL_GET_EX_16            Get16Ex;
+  PCD_PROTOCOL_GET_EX_32            Get32Ex;
+  PCD_PROTOCOL_GET_EX_64            Get64Ex;
+  PCD_PROTOCOL_GET_EX_POINTER       GetPtrEx;
+  PCD_PROTOCOL_GET_EX_BOOLEAN       GetBoolEx;
+  PCD_PROTOCOL_GET_EX_SIZE          GetSizeEx;
+
+  PCD_PROTOCOL_SET8                 Set8;
+  PCD_PROTOCOL_SET16                Set16;
+  PCD_PROTOCOL_SET32                Set32;
+  PCD_PROTOCOL_SET64                Set64;
+  PCD_PROTOCOL_SET_POINTER          SetPtr;
+  PCD_PROTOCOL_SET_BOOLEAN          SetBool;
+
+  PCD_PROTOCOL_SET_EX_8             Set8Ex;
+  PCD_PROTOCOL_SET_EX_16            Set16Ex;
+  PCD_PROTOCOL_SET_EX_32            Set32Ex;
+  PCD_PROTOCOL_SET_EX_64            Set64Ex;
+  PCD_PROTOCOL_SET_EX_POINTER       SetPtrEx;
+  PCD_PROTOCOL_SET_EX_BOOLEAN       SetBoolEx;
+
+  PCD_PROTOCOL_CALLBACK_ONSET       CallbackOnSet;
+  PCD_PROTOCOL_CANCEL_CALLBACK      CancelCallback;
+  PCD_PROTOCOL_GET_NEXT_TOKEN       GetNextToken;
+  PCD_PROTOCOL_GET_NEXT_TOKENSPACE  GetNextTokenSpace;
+} PCD_PROTOCOL;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PcdInfo.h b/MdePkg/Include/Protocol/PcdInfo.h
new file mode 100644
index 000000000000..e34967e0a3e8
--- /dev/null
+++ b/MdePkg/Include/Protocol/PcdInfo.h
@@ -0,0 +1,105 @@
+/** @file
+  Native Platform Configuration Database (PCD) INFO PROTOCOL.
+
+  The protocol that provides additional information about items that reside in the PCD database.
+
+  Different with the EFI_GET_PCD_INFO_PROTOCOL defined in PI 1.2.1 specification,
+  the native PCD INFO PROTOCOL provide interfaces for dynamic and dynamic-ex type PCD. 
+  The interfaces for dynamic type PCD do not require the token space guid as parameter,
+  but interfaces for dynamic-ex type PCD require token space guid as parameter.
+
+  Copyright (c) 2013, 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 __PCD_INFO_H__
+#define __PCD_INFO_H__
+
+extern EFI_GUID gGetPcdInfoProtocolGuid;
+
+#define GET_PCD_INFO_PROTOCOL_GUID \
+  { 0x5be40f57, 0xfa68, 0x4610, { 0xbb, 0xbf, 0xe9, 0xc5, 0xfc, 0xda, 0xd3, 0x65 } }
+
+///
+/// The forward declaration for GET_PCD_INFO_PROTOCOL.
+///
+typedef struct _GET_PCD_INFO_PROTOCOL  GET_PCD_INFO_PROTOCOL;
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *GET_PCD_INFO_PROTOCOL_GET_INFO) (
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *GET_PCD_INFO_PROTOCOL_GET_INFO_EX) (
+  IN CONST  EFI_GUID        *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+typedef
+UINTN
+(EFIAPI *GET_PCD_INFO_PROTOCOL_GET_SKU) (
+  VOID
+);
+
+///
+/// This is the PCD service to use when querying for some additional data that can be contained in the
+/// PCD database.
+///
+struct _GET_PCD_INFO_PROTOCOL {
+  ///
+  /// Retrieve additional information associated with a PCD.
+  ///
+  GET_PCD_INFO_PROTOCOL_GET_INFO             GetInfo;
+  GET_PCD_INFO_PROTOCOL_GET_INFO_EX          GetInfoEx;
+  ///
+  /// Retrieve the currently set SKU Id.
+  ///
+  GET_PCD_INFO_PROTOCOL_GET_SKU              GetSku;
+};
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/PciEnumerationComplete.h b/MdePkg/Include/Protocol/PciEnumerationComplete.h
new file mode 100644
index 000000000000..c817774cb3c5
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciEnumerationComplete.h
@@ -0,0 +1,30 @@
+/** @file
+  PCI Enumeration Complete Protocol as defined in the PI 1.1 specification.
+  This protocol indicates that pci enumeration complete
+
+  Copyright (c) 2009, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2
+  Volume 5: Standards
+
+**/
+
+#ifndef _PCI_ENUMERATION_COMPLETE_H_
+#define _PCI_ENUMERATION_COMPLETE_H_
+
+#define EFI_PCI_ENUMERATION_COMPLETE_GUID \
+  {  \
+   0x30cfe3e7, 0x3de1, 0x4586, { 0xbe, 0x20, 0xde, 0xab, 0xa1, 0xb3, 0xb7, 0x93  } \
+  }
+
+extern EFI_GUID gEfiPciEnumerationCompleteProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciHostBridgeResourceAllocation.h b/MdePkg/Include/Protocol/PciHostBridgeResourceAllocation.h
new file mode 100644
index 000000000000..2d41ac152990
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciHostBridgeResourceAllocation.h
@@ -0,0 +1,428 @@
+/** @file
+  This file declares PCI Host Bridge Resource Allocation Protocol which 
+  provides the basic interfaces to abstract a PCI host bridge resource allocation. 
+  This protocol is mandatory if the system includes PCI devices.
+  
+Copyright (c) 2007 - 2010, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards.
+  
+**/
+
+#ifndef _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
+#define _PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_H_
+
+//
+// This file must be included because EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL
+// uses EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS
+//
+#include <Protocol/PciRootBridgeIo.h>
+
+///
+/// Global ID for the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL.
+///
+#define EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GUID \
+  { \
+    0xCF8034BE, 0x6768, 0x4d8b, {0xB7,0x39,0x7C,0xCE,0x68,0x3A,0x9F,0xBE } \
+  }
+
+///
+/// Forward declaration for EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL.
+///
+typedef struct _EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL;
+
+/// If this bit is set, then the PCI Root Bridge does not
+/// support separate windows for Non-prefetchable and Prefetchable
+/// memory. A PCI bus driver needs to include requests for Prefetchable
+/// memory in the Non-prefetchable memory pool.
+///
+#define EFI_PCI_HOST_BRIDGE_COMBINE_MEM_PMEM  1
+
+///
+/// If this bit is set, then the PCI Root Bridge supports
+/// 64 bit memory windows.  If this bit is not set,
+/// the PCI bus driver needs to include requests for 64 bit
+/// memory address in the corresponding 32 bit memory pool.
+///
+#define EFI_PCI_HOST_BRIDGE_MEM64_DECODE   2
+
+///
+/// A UINT64 value that contains the status of a PCI resource requested 
+/// in the Configuration parameter returned by GetProposedResources()
+/// The legal values are EFI_RESOURCE_SATISFIED and EFI_RESOURCE_NOT_SATISFIED
+///
+typedef UINT64 EFI_RESOURCE_ALLOCATION_STATUS;
+
+///
+/// The request of this resource type could be fulfilled.  Used in the 
+/// Configuration parameter returned by GetProposedResources() to identify
+/// a PCI resources request that can be satisfied.
+///
+#define EFI_RESOURCE_SATISFIED      0x0000000000000000ULL
+
+///
+/// The request of this resource type could not be fulfilled for its
+/// absence in the host bridge resource pool.  Used in the Configuration parameter 
+/// returned by GetProposedResources() to identify a PCI resources request that
+/// can not be satisfied.
+///
+#define EFI_RESOURCE_NOT_SATISFIED  0xFFFFFFFFFFFFFFFFULL
+
+///
+/// This  enum is used to specify the phase of the PCI enumaeration process.
+///
+typedef enum {
+  ///
+  /// Reset the host bridge PCI apertures and internal data structures.
+  /// PCI enumerator should issue this notification before starting fresh
+  /// enumeration process. Enumeration cannot be restarted after sending
+  /// any other notification such as EfiPciHostBridgeBeginBusAllocation.
+  ///
+  EfiPciHostBridgeBeginEnumeration,
+
+  ///
+  /// The bus allocation phase is about to begin. No specific action
+  /// is required here. This notification can be used to perform any
+  /// chipset specific programming.  
+  ///
+  EfiPciHostBridgeBeginBusAllocation,
+
+  ///
+  /// The bus allocation and bus programming phase is complete. No specific
+  /// action is required here. This notification can be used to perform any
+  /// chipset specific programming.  
+  ///
+  EfiPciHostBridgeEndBusAllocation,
+  
+  ///
+  /// The resource allocation phase is about to begin.No specific action is
+  /// required here. This notification can be used to perform any chipset specific programming.  
+  ///
+  EfiPciHostBridgeBeginResourceAllocation,
+  
+  ///
+  /// Allocate resources per previously submitted requests for all the PCI Root
+  /// Bridges. These resource settings are returned on the next call to
+  /// GetProposedResources().  
+  ///
+  EfiPciHostBridgeAllocateResources,
+  
+  ///
+  /// Program the Host Bridge hardware to decode previously allocated resources
+  /// (proposed resources) for all the PCI Root Bridges.
+  ///
+  EfiPciHostBridgeSetResources,
+  
+  ///
+  /// De-allocate previously allocated resources previously for all the PCI
+  /// Root Bridges and reset the I/O and memory apertures to initial state.  
+  ///
+  EfiPciHostBridgeFreeResources,
+  
+  ///
+  /// The resource allocation phase is completed.  No specific action is required
+  /// here. This notification can be used to perform any chipset specific programming.  
+  ///
+  EfiPciHostBridgeEndResourceAllocation,
+
+  ///
+  /// The Host Bridge Enumeration is completed. No specific action is required here.
+  /// This notification can be used to perform any chipset specific programming.
+  ///
+  EfiPciHostBridgeEndEnumeration,
+  EfiMaxPciHostBridgeEnumerationPhase
+} EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE;
+
+///
+/// Definitions of 2 notification points.
+///
+typedef enum {
+  ///
+  /// This notification is only applicable to PCI-PCI bridges and
+  /// indicates that the PCI enumerator is about to begin enumerating
+  /// the bus behind the PCI-PCI Bridge. This notification is sent after
+  /// the primary bus number, the secondary bus number and the subordinate
+  /// bus number registers in the PCI-PCI Bridge are programmed to valid
+  /// (not necessary final) values
+  ///
+  EfiPciBeforeChildBusEnumeration,
+
+  ///
+  /// This notification is sent before the PCI enumerator probes BAR registers
+  /// for every valid PCI function.  
+  ///
+  EfiPciBeforeResourceCollection
+} EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE;
+
+/**
+  These are the notifications from the PCI bus driver that it is about to enter a certain phase of the PCI 
+  enumeration process.
+
+  @param[in] This    The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                     instance.
+  @param[in] Phase   The phase during enumeration.
+
+  @retval EFI_SUCCESS             The notification was accepted without any errors.
+  @retval EFI_INVALID_PARAMETER   The Phase is invalid.
+  @retval EFI_NOT_READY           This phase cannot be entered at this time. For example, this error 
+                                  is valid for a Phase of EfiPciHostBridgeAllocateResources if 
+                                  SubmitResources() has not been called for one or more 
+                                  PCI root bridges before this call.
+  @retval EFI_DEVICE_ERROR        Programming failed due to a hardware error. This error is valid for 
+                                  a Phase of EfiPciHostBridgeSetResources.
+  @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a lack of resources. 
+                                  This error is valid for a Phase of EfiPciHostBridgeAllocateResources
+                                  if the previously submitted resource requests cannot be fulfilled or were only 
+                                  partially fulfilled
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_NOTIFY_PHASE)(
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL  *This,
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE     Phase
+  );
+
+/**
+  Returns the device handle of the next PCI root bridge that is associated with this host bridge.
+
+  @param[in]     This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                                    instance.
+  @param[in,out] RootBridgeHandle   Returns the device handle of the next PCI root bridge. On input, it holds the 
+                                    RootBridgeHandle that was returned by the most recent call to 
+                                    GetNextRootBridge(). If RootBridgeHandle is NULL on input, the handle 
+                                    for the first PCI root bridge is returned.
+
+  @retval EFI_SUCCESS             The requested attribute information was returned.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not an EFI_HANDLE that was returned 
+                                  on a previous call to GetNextRootBridge().
+  @retval EFI_NOT_FOUND           There are no more PCI root bridge device handles.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_NEXT_ROOT_BRIDGE)(
+  IN     EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL  *This,
+  IN OUT EFI_HANDLE                                        *RootBridgeHandle
+  );
+
+/**
+  Returns the allocation attributes of a PCI root bridge.
+
+  @param[in]  This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                                 instance.
+  @param[in]  RootBridgeHandle   The device handle of the PCI root bridge in which the caller is interested.
+  @param[out] Attribute          The pointer to attributes of the PCI root bridge.
+
+  @retval EFI_SUCCESS             The requested attribute information was returned.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_INVALID_PARAMETER   Attributes is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_ATTRIBUTES)(
+  IN  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL   *This,
+  IN  EFI_HANDLE                                         RootBridgeHandle,
+  OUT UINT64                                             *Attributes
+  );
+
+/**
+  Sets up the specified PCI root bridge for the bus enumeration process.
+
+  @param[in]  This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                                 instance.
+  @param[in]  RootBridgeHandle   The PCI root bridge to be set up.
+  @param[out] Configuration      The pointer to the pointer to the PCI bus resource descriptor.
+
+  @retval EFI_SUCCESS             The PCI root bridge was set up and the bus range was returned in 
+                                  Configuration.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_DEVICE_ERROR        Programming failed due to a hardware error.
+  @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_START_BUS_ENUMERATION)(
+  IN  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL   *This,
+  IN  EFI_HANDLE                                         RootBridgeHandle,
+  OUT VOID                                               **Configuration
+  );
+
+/**
+  Programs the PCI root bridge hardware so that it decodes the specified PCI bus range.
+
+  @param[in] This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL
+                                instance.  
+  @param[in] RootBridgeHandle   The PCI root bridge whose bus range is to be programmed.
+  @param[in] Configuration      The pointer to the PCI bus resource descriptor.
+
+  @retval EFI_SUCCESS             The bus range for the PCI root bridge was programmed.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_INVALID_PARAMETER   Configuration is NULL
+  @retval EFI_INVALID_PARAMETER   Configuration does not point to a valid ACPI (2.0 & 3.0) 
+                                  resource descriptor.
+  @retval EFI_INVALID_PARAMETER   Configuration does not include a valid ACPI 2.0 bus resource
+                                  descriptor.
+  @retval EFI_INVALID_PARAMETER   Configuration includes valid ACPI (2.0 & 3.0) resource 
+                                  descriptors other than bus descriptors.
+  @retval EFI_INVALID_PARAMETER   Configuration contains one or more invalid ACPI resource 
+                                  descriptors.
+  @retval EFI_INVALID_PARAMETER   "Address Range Minimum" is invalid for this root bridge.
+  @retval EFI_INVALID_PARAMETER   "Address Range Length" is invalid for this root bridge.
+  @retval EFI_DEVICE_ERROR        Programming failed due to a hardware error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SET_BUS_NUMBERS)(
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL   *This,
+  IN EFI_HANDLE                                         RootBridgeHandle,
+  IN VOID                                               *Configuration
+  );
+
+/**
+  Submits the I/O and memory resource requirements for the specified PCI root bridge.
+
+  @param[in] This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                                instance.
+  @param[in] RootBridgeHandle   The PCI root bridge whose I/O and memory resource requirements are being 
+                                submitted.
+  @param[in] Configuration      The pointer to the PCI I/O and PCI memory resource descriptor.
+
+  @retval EFI_SUCCESS             The I/O and memory resource requests for a PCI root bridge were 
+                                  accepted.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_INVALID_PARAMETER   Configuration is NULL.
+  @retval EFI_INVALID_PARAMETER   Configuration does not point to a valid ACPI (2.0 & 3.0) 
+                                  resource descriptor.
+  @retval EFI_INVALID_PARAMETER   Configuration includes requests for one or more resource 
+                                  types that are not supported by this PCI root bridge. This error will 
+                                  happen if the caller did not combine resources according to 
+                                  Attributes that were returned by GetAllocAttributes().
+  @retval EFI_INVALID_PARAMETER   "Address Range Maximum" is invalid.
+  @retval EFI_INVALID_PARAMETER   "Address Range Length" is invalid for this PCI root bridge.
+  @retval EFI_INVALID_PARAMETER   "Address Space Granularity" is invalid for this PCI root bridge.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SUBMIT_RESOURCES)(
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL   *This,
+  IN EFI_HANDLE                                         RootBridgeHandle,
+  IN VOID                                               *Configuration
+  );
+
+/**
+  Returns the proposed resource settings for the specified PCI root bridge.
+
+  @param[in]  This               The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL 
+                                 instance.
+  @param[in]  RootBridgeHandle   The PCI root bridge handle.
+  @param[out] Configuration      The pointer to the pointer to the PCI I/O and memory resource descriptor.
+
+  @retval EFI_SUCCESS             The requested parameters were returned.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_DEVICE_ERROR        Programming failed due to a hardware error.
+  @retval EFI_OUT_OF_RESOURCES    The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_PROPOSED_RESOURCES)(
+  IN  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL  *This,
+  IN  EFI_HANDLE                                        RootBridgeHandle,
+  OUT VOID                                              **Configuration
+  );
+
+/**
+  Provides the hooks from the PCI bus driver to every PCI controller (device/function) at various 
+  stages of the PCI enumeration process that allow the host bridge driver to preinitialize individual 
+  PCI controllers before enumeration.
+
+  @param[in]  This                  The pointer to the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL instance.
+  @param[in]  RootBridgeHandle      The associated PCI root bridge handle.
+  @param[in]  PciAddress            The address of the PCI device on the PCI bus.
+  @param[in]  Phase                 The phase of the PCI device enumeration.
+
+  @retval EFI_SUCCESS             The requested parameters were returned.
+  @retval EFI_INVALID_PARAMETER   RootBridgeHandle is not a valid root bridge handle.
+  @retval EFI_INVALID_PARAMETER   Phase is not a valid phase that is defined in 
+                                  EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE.
+  @retval EFI_DEVICE_ERROR        Programming failed due to a hardware error. The PCI enumerator 
+                                  should not enumerate this device, including its child devices if it is 
+                                  a PCI-to-PCI bridge.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_PREPROCESS_CONTROLLER)(
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL  *This,
+  IN EFI_HANDLE                                        RootBridgeHandle,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS       PciAddress,
+  IN EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE      Phase
+  );
+
+///
+/// Provides the basic interfaces to abstract a PCI host bridge resource allocation.
+///
+struct _EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL {
+  ///
+  /// The notification from the PCI bus enumerator that it is about to enter
+  /// a certain phase during the enumeration process.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_NOTIFY_PHASE           NotifyPhase;
+  
+  ///
+  /// Retrieves the device handle for the next PCI root bridge that is produced by the
+  /// host bridge to which this instance of the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL is attached.  
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_NEXT_ROOT_BRIDGE   GetNextRootBridge;
+  
+  ///
+  /// Retrieves the allocation-related attributes of a PCI root bridge.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_ATTRIBUTES         GetAllocAttributes;
+  
+  ///
+  /// Sets up a PCI root bridge for bus enumeration.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_START_BUS_ENUMERATION  StartBusEnumeration;
+  
+  ///
+  /// Sets up the PCI root bridge so that it decodes a specific range of bus numbers.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SET_BUS_NUMBERS        SetBusNumbers;
+  
+  ///
+  /// Submits the resource requirements for the specified PCI root bridge.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_SUBMIT_RESOURCES       SubmitResources;
+  
+  ///
+  /// Returns the proposed resource assignment for the specified PCI root bridges.
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_GET_PROPOSED_RESOURCES GetProposedResources;
+  
+  ///
+  /// Provides hooks from the PCI bus driver to every PCI controller
+  /// (device/function) at various stages of the PCI enumeration process that
+  /// allow the host bridge driver to preinitialize individual PCI controllers
+  /// before enumeration.  
+  ///
+  EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL_PREPROCESS_CONTROLLER  PreprocessController;
+};
+
+extern EFI_GUID gEfiPciHostBridgeResourceAllocationProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciHotPlugInit.h b/MdePkg/Include/Protocol/PciHotPlugInit.h
new file mode 100644
index 000000000000..65701773825d
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciHotPlugInit.h
@@ -0,0 +1,278 @@
+/** @file
+  This file declares EFI PCI Hot Plug Init Protocol.
+  
+  This protocol provides the necessary functionality to initialize the Hot Plug 
+  Controllers (HPCs) and the buses that they control. This protocol also provides 
+  information regarding resource padding.
+  
+  @par Note: 
+    This protocol is required only on platforms that support one or more PCI Hot
+    Plug* slots or CardBus sockets.  
+
+  The EFI_PCI_HOT_PLUG_INIT_PROTOCOL provides a mechanism for the PCI bus enumerator
+  to properly initialize the HPCs and CardBus sockets that require initialization. 
+  The HPC initialization takes place before the PCI enumeration process is complete. 
+  There cannot be more than one instance of this protocol in a system. This protocol 
+  is installed on its own separate handle.  
+  
+  Because the system may include multiple HPCs, one instance of this protocol 
+  should represent all of them. The protocol functions use the device path of 
+  the HPC to identify the HPC. When the PCI bus enumerator finds a root HPC, it 
+  will call EFI_PCI_HOT_PLUG_INIT_PROTOCOL.InitializeRootHpc(). If InitializeRootHpc()
+  is unable to initialize a root HPC, the PCI enumerator will ignore that root HPC 
+  and continue the enumeration process. If the HPC is not initialized, the devices 
+  that it controls may not be initialized, and no resource padding will be provided.
+
+  From the standpoint of the PCI bus enumerator, HPCs are divided into the following 
+  two classes:
+
+    - Root HPC:
+        These HPCs must be initialized by calling InitializeRootHpc() during the 
+        enumeration process. These HPCs will also require resource padding. The 
+        platform code must have a priori knowledge of these devices and must know 
+        how to initialize them. There may not be any way to access their PCI 
+        configuration space before the PCI enumerator programs all the upstream
+        bridges and thus enables the path to these devices. The PCI bus enumerator 
+        is responsible for determining the PCI bus address of the HPC before it 
+        calls InitializeRootHpc().
+    - Nonroot HPC:
+        These HPCs will not need explicit initialization during enumeration process. 
+        These HPCs will require resource padding. The platform code does not have 
+        to have a priori knowledge of these devices.
+
+  Copyright (c) 2007 - 2009, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+
+**/
+
+#ifndef _EFI_PCI_HOT_PLUG_INIT_H_
+#define _EFI_PCI_HOT_PLUG_INIT_H_
+
+///
+/// Global ID for the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
+///
+#define EFI_PCI_HOT_PLUG_INIT_PROTOCOL_GUID \
+  { \
+    0xaa0e8bc1, 0xdabc, 0x46b0, {0xa8, 0x44, 0x37, 0xb8, 0x16, 0x9b, 0x2b, 0xea } \
+  }
+
+///
+/// Forward declaration for EFI_PCI_HOT_PLUG_INIT_PROTOCOL
+///
+typedef struct _EFI_PCI_HOT_PLUG_INIT_PROTOCOL EFI_PCI_HOT_PLUG_INIT_PROTOCOL;
+
+///
+/// Describes the current state of an HPC
+///
+typedef UINT16 EFI_HPC_STATE;
+
+///
+/// The HPC initialization function was called and the HPC completed 
+/// initialization, but it was not enabled for some reason. The HPC may be 
+/// disabled in hardware, or it may be disabled due to user preferences, 
+/// hardware failure, or other reasons. No resource padding is required.
+///
+#define  EFI_HPC_STATE_INITIALIZED    0x01
+
+///
+/// The HPC initialization function was called, the HPC completed 
+/// initialization, and it was enabled. Resource padding is required.
+///
+#define  EFI_HPC_STATE_ENABLED        0x02
+
+///
+/// Location definition for PCI Hot Plug Controller
+///
+typedef struct{
+  ///
+  /// 
+  /// The device path to the root HPC. An HPC cannot control its parent buses.
+  /// The PCI bus driver requires this information so that it can pass the 
+  /// correct HpcPciAddress to the InitializeRootHpc() and GetResourcePadding() 
+  /// functions. 
+  ///
+  EFI_DEVICE_PATH_PROTOCOL  *HpcDevicePath;
+  ///
+  /// The device path to the Hot Plug Bus (HPB) that is controlled by the root 
+  /// HPC. The PCI bus driver uses this information to check if a particular PCI 
+  /// bus has hot-plug slots.  The device path of a PCI bus is the same as the 
+  /// device path of its parent. For Standard(PCI) Hot Plug Controllers (SHPCs) 
+  /// and PCI Express*, HpbDevicePath is the same as HpcDevicePath.
+  ///
+  EFI_DEVICE_PATH_PROTOCOL  *HpbDevicePath;
+} EFI_HPC_LOCATION;
+
+///
+/// Describes how resource padding should be applied
+///
+typedef enum {
+  ///
+  /// Apply the padding at a PCI bus level. In other words, the resources
+  /// that are allocated to the bus containing hot-plug slots are padded by
+  /// the specified amount. If the hot-plug bus is behind a PCI-to-PCI
+  /// bridge, the PCI-to-PCI bridge apertures will indicate the padding
+  ///
+  EfiPaddingPciBus,
+  ///
+  /// Apply the padding at a PCI root bridge level. If a PCI root bridge
+  /// includes more than one hot-plug bus, the resource padding requests
+  /// for these buses are added together and the resources that are
+  /// allocated to the root bridge are padded by the specified amount. This
+  /// strategy may reduce the total amount of padding, but requires
+  /// reprogramming of PCI-to-PCI bridges in a hot-add event. If the hotplug
+  /// bus is behind a PCI-to-PCI bridge, the PCI-to-PCI bridge
+  /// apertures do not indicate the padding for that bus.  
+  ///
+  EfiPaddingPciRootBridge
+} EFI_HPC_PADDING_ATTRIBUTES;
+
+/**
+  Returns a list of root Hot Plug Controllers (HPCs) that require initialization
+  during the boot process.
+
+  This procedure returns a list of root HPCs. The PCI bus driver must initialize 
+  these controllers during the boot process. The PCI bus driver may or may not be 
+  able to detect these HPCs. If the platform includes a PCI-to-CardBus bridge, it 
+  can be included in this list if it requires initialization.  The HpcList must be 
+  self consistent. An HPC cannot control any of its parent buses. Only one HPC can 
+  control a PCI bus. Because this list includes only root HPCs, no HPC in the list 
+  can be a child of another HPC. This policy must be enforced by the 
+  EFI_PCI_HOT_PLUG_INIT_PROTOCOL.   The PCI bus driver may not check for such 
+  invalid conditions.  The callee allocates the buffer HpcList
+
+  @param[in]  This       Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
+  @param[out] HpcCount   The number of root HPCs that were returned.
+  @param[out] HpcList    The list of root HPCs. HpcCount defines the number of
+                         elements in this list.
+
+  @retval EFI_SUCCESS             HpcList was returned.
+  @retval EFI_OUT_OF_RESOURCES    HpcList was not returned due to insufficient 
+                                  resources.
+  @retval EFI_INVALID_PARAMETER   HpcCount is NULL or HpcList is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_ROOT_HPC_LIST)(
+  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
+  OUT UINTN                           *HpcCount,
+  OUT EFI_HPC_LOCATION                **HpcList
+  );
+
+/**
+  Initializes one root Hot Plug Controller (HPC). This process may causes
+  initialization of its subordinate buses.
+  
+  This function initializes the specified HPC. At the end of initialization, 
+  the hot-plug slots or sockets (controlled by this HPC) are powered and are 
+  connected to the bus. All the necessary registers in the HPC are set up. For 
+  a Standard (PCI) Hot Plug Controller (SHPC), the registers that must be set 
+  up are defined in the PCI Standard Hot Plug Controller and Subsystem 
+  Specification.  
+
+  @param[in]  This            Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
+  @param[in]  HpcDevicePath   The device path to the HPC that is being initialized.
+  @param[in]  HpcPciAddress   The address of the HPC function on the PCI bus.
+  @param[in]  Event           The event that should be signaled when the HPC 
+                              initialization is complete.  Set to NULL if the 
+                              caller wants to wait until the entire initialization 
+                              process is complete.
+  @param[out] HpcState        The state of the HPC hardware. The state is 
+                              EFI_HPC_STATE_INITIALIZED or EFI_HPC_STATE_ENABLED.
+
+  @retval EFI_SUCCESS             If Event is NULL, the specific HPC was successfully
+                                  initialized. If Event is not NULL, Event will be 
+                                  signaled at a later time when initialization is complete.
+  @retval EFI_UNSUPPORTED         This instance of EFI_PCI_HOT_PLUG_INIT_PROTOCOL
+                                  does not support the specified HPC.
+  @retval EFI_OUT_OF_RESOURCES    Initialization failed due to insufficient
+                                  resources.
+  @retval EFI_INVALID_PARAMETER   HpcState is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INITIALIZE_ROOT_HPC)(
+  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
+  IN  EFI_DEVICE_PATH_PROTOCOL        *HpcDevicePath,
+  IN  UINT64                          HpcPciAddress,
+  IN  EFI_EVENT                       Event,           OPTIONAL
+  OUT EFI_HPC_STATE                   *HpcState
+  );
+
+/**
+  Returns the resource padding that is required by the PCI bus that is controlled
+  by the specified Hot Plug Controller (HPC).
+
+  This function returns the resource padding that is required by the PCI bus that
+  is controlled by the specified HPC. This member function is called for all the 
+  root HPCs and nonroot HPCs that are detected by the PCI bus enumerator. This 
+  function will be called before PCI resource allocation is completed. This function 
+  must be called after all the root HPCs, with the possible exception of a 
+  PCI-to-CardBus bridge, have completed initialization.
+
+  @param[in]  This            Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL instance.
+  @param[in]  HpcDevicePath   The device path to the HPC.
+  @param[in]  HpcPciAddress   The address of the HPC function on the PCI bus.
+  @param[in]  HpcState        The state of the HPC hardware.
+  @param[out] Padding         The amount of resource padding that is required by the
+                              PCI bus under the control of the specified HPC.
+  @param[out] Attributes      Describes how padding is accounted for. The padding
+                              is returned in the form of ACPI 2.0 resource descriptors.
+
+  @retval EFI_SUCCESS             The resource padding was successfully returned.
+  @retval EFI_UNSUPPORTED         This instance of the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
+                                  does not support the specified HPC.
+  @retval EFI_NOT_READY           This function was called before HPC initialization
+                                  is complete.
+  @retval EFI_INVALID_PARAMETER   HpcState or Padding or Attributes is NULL.
+  @retval EFI_OUT_OF_RESOURCES    ACPI 2.0 resource descriptors for Padding
+                                  cannot be allocated due to insufficient resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_HOT_PLUG_PADDING)(
+  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
+  IN  EFI_DEVICE_PATH_PROTOCOL        *HpcDevicePath,
+  IN  UINT64                          HpcPciAddress,
+  OUT EFI_HPC_STATE                   *HpcState,
+  OUT VOID                            **Padding,
+  OUT EFI_HPC_PADDING_ATTRIBUTES      *Attributes
+  );
+
+///
+/// This protocol provides the necessary functionality to initialize the
+/// Hot Plug Controllers (HPCs) and the buses that they control. This protocol
+/// also provides information regarding resource padding.
+///
+struct _EFI_PCI_HOT_PLUG_INIT_PROTOCOL {
+  ///
+  /// Returns a list of root HPCs and the buses that they control.
+  ///
+  EFI_GET_ROOT_HPC_LIST     GetRootHpcList;
+  
+  ///
+  /// Initializes the specified root HPC.
+  ///
+  EFI_INITIALIZE_ROOT_HPC   InitializeRootHpc;
+  
+  ///
+  /// Returns the resource padding that is required by the HPC.
+  ///
+  EFI_GET_HOT_PLUG_PADDING  GetResourcePadding;
+};
+
+extern EFI_GUID gEfiPciHotPlugInitProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciHotPlugRequest.h b/MdePkg/Include/Protocol/PciHotPlugRequest.h
new file mode 100644
index 000000000000..c96b789b5695
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciHotPlugRequest.h
@@ -0,0 +1,170 @@
+/** @file
+  Provides services to notify the PCI bus driver that some events have happened 
+  in a hot-plug controller (such as a PC Card socket, or PHPC), and to ask the 
+  PCI bus driver to create or destroy handles for PCI-like devices.
+
+  A hot-plug capable PCI bus driver should produce the EFI PCI Hot Plug Request 
+  protocol. When a PCI device or a PCI-like device (for example, 32-bit PC Card)
+  is installed after PCI bus does the enumeration, the PCI bus driver can be 
+  notified through this protocol. For example, when a 32-bit PC Card is inserted
+  into the PC Card socket, the PC Card bus driver can call interface of this
+  protocol to notify PCI bus driver to allocate resource and create handles for
+  this PC Card.
+  
+  The EFI_PCI_HOTPLUG_REQUEST_PROTOCOL is installed by the PCI bus driver on a 
+  separate handle when PCI bus driver starts up. There is only one instance in 
+  the system.  Any driver that wants to use this protocol must locate it globally.
+  The EFI_PCI_HOTPLUG_REQUEST_PROTOCOL allows the driver of hot-plug controller, 
+  for example, PC Card Bus driver, to notify PCI bus driver that an event has 
+  happened in the hot-plug controller, and the PCI bus driver is requested to 
+  create (add) or destroy (remove) handles for the specified PCI-like devices. 
+  For example, when a 32-bit PC Card is inserted, this protocol interface will 
+  be called with an add operation, and the PCI bus driver will enumerate and 
+  start the devices inserted; when a 32-bit PC Card is removed, this protocol 
+  interface will be called with a remove operation, and the PCI bus driver will 
+  stop the devices and destroy their handles.  The existence of this protocol 
+  represents the capability of the PCI bus driver. If this protocol exists in
+  system, it means PCI bus driver is hot-plug capable, thus together with the 
+  effort of PC Card bus driver, hot-plug of PC Card can be supported. Otherwise,
+  the hot-plug capability is not provided.  
+  
+  Copyright (c) 2006 - 2009, 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.             
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+  
+**/
+
+#ifndef __PCI_HOTPLUG_REQUEST_H_
+#define __PCI_HOTPLUG_REQUEST_H_
+
+///
+/// Global ID for EFI_PCI_HOTPLUG_REQUEST_PROTOCOL
+///
+#define EFI_PCI_HOTPLUG_REQUEST_PROTOCOL_GUID \
+  { \
+    0x19cb87ab, 0x2cb9, 0x4665, {0x83, 0x60, 0xdd, 0xcf, 0x60, 0x54, 0xf7, 0x9d} \
+  }
+
+///
+/// Forward declaration for EFI_PCI_HOTPLUG_REQUEST_PROTOCOL
+///
+typedef struct _EFI_PCI_HOTPLUG_REQUEST_PROTOCOL  EFI_PCI_HOTPLUG_REQUEST_PROTOCOL;
+
+///
+/// Enumeration of PCI hot plug operations
+/// 
+typedef enum {
+  ///
+  /// The PCI bus driver is requested to create handles for the specified devices.
+  /// An array of EFI_HANDLE is returned, with a NULL element marking the end of
+  /// the array.
+  ///
+  EfiPciHotPlugRequestAdd,
+
+  ///
+  /// The PCI bus driver is requested to destroy handles for the specified devices.
+  ///
+  EfiPciHotplugRequestRemove
+} EFI_PCI_HOTPLUG_OPERATION;
+
+/**
+  This function is used to notify PCI bus driver that some events happened in a
+  hot-plug controller, and the PCI bus driver is requested to start or stop 
+  specified PCI-like devices.
+  
+  This function allows the PCI bus driver to be notified to act as requested when
+  a hot-plug event has happened on the hot-plug controller. Currently, the 
+  operations include add operation and remove operation.  If it is a add operation,
+  the PCI bus driver will enumerate, allocate resources for devices behind the 
+  hot-plug controller, and create handle for the device specified by RemainingDevicePath.
+  The RemainingDevicePath is an optional parameter. If it is not NULL, only the 
+  specified device is started; if it is NULL, all devices behind the hot-plug 
+  controller are started.  The newly created handles of PC Card functions are 
+  returned in the ChildHandleBuffer, together with the number of child handle in
+  NumberOfChildren.  If it is a remove operation, when NumberOfChildren contains
+  a non-zero value, child handles specified in ChildHandleBuffer are stopped and
+  destroyed; otherwise, PCI bus driver is notified to stop managing the controller
+  handle.  
+    
+    @param[in] This                    A pointer to the EFI_PCI_HOTPLUG_REQUEST_PROTOCOL 
+                                       instance.
+    @param[in] Operation               The operation the PCI bus driver is requested 
+                                       to make. 
+    @param[in] Controller              The handle of the hot-plug controller.
+    @param[in] RemainingDevicePath     The remaining device path for the PCI-like
+                                       hot-plug device.  It only contains device
+                                       path nodes behind the hot-plug controller. 
+                                       It is an optional parameter and only valid
+                                       when the Operation is a add operation. If 
+                                       it is NULL, all devices behind the PC Card 
+                                       socket are started.
+    @param[in,out] NumberOfChildren    The number of child handles. For an add 
+                                       operation, it is an output parameter.  For
+                                       a remove operation, it's an input parameter.
+                                       When it contains a non-zero value, children
+                                       handles specified in ChildHandleBuffer are
+                                       destroyed.  Otherwise, PCI bus driver is 
+                                       notified to stop managing the controller 
+                                       handle.
+    @param[in,out] ChildHandleBuffer   The buffer which contains the child handles. 
+                                       For an add operation, it is an output 
+                                       parameter and contains all newly created 
+                                       child handles.  For a remove operation, it
+                                       contains child handles to be destroyed when
+                                       NumberOfChildren contains a non-zero value.
+                                       It can be NULL when NumberOfChildren is 0.
+                                       It's the caller's responsibility to allocate
+                                       and free memory for this buffer.
+  
+  @retval EFI_SUCCESS             The handles for the specified device have been 
+                                  created or destroyed as requested, and for an 
+                                  add operation, the new handles are returned in 
+                                  ChildHandleBuffer.
+  @retval EFI_INVALID_PARAMETER   Operation is not a legal value.
+  @retval EFI_INVALID_PARAMETER   Controller is NULL or not a valid handle.
+  @retval EFI_INVALID_PARAMETER   NumberOfChildren is NULL.
+  @retval EFI_INVALID_PARAMETER   ChildHandleBuffer is NULL while Operation is 
+                                  remove and NumberOfChildren contains a non-zero 
+                                  value.
+  @retval EFI_INVALID_PARAMETER   ChildHandleBuffer is NULL while Operation is add.
+  @retval EFI_OUT_OF_RESOURCES    There are no enough resources to start the 
+                                  devices.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_HOTPLUG_REQUEST_NOTIFY)(
+  IN     EFI_PCI_HOTPLUG_REQUEST_PROTOCOL  *This,
+  IN     EFI_PCI_HOTPLUG_OPERATION         Operation,
+  IN     EFI_HANDLE                        Controller,
+  IN     EFI_DEVICE_PATH_PROTOCOL          *RemainingDevicePath  OPTIONAL,
+  IN OUT UINT8                             *NumberOfChildren,
+  IN OUT EFI_HANDLE                        *ChildHandleBuffer
+  );
+
+///
+/// Provides services to notify PCI bus driver that some events have happened in 
+/// a hot-plug controller (for example, PC Card socket, or PHPC), and ask PCI bus 
+/// driver to create or destroy handles for the PCI-like devices.
+///
+struct _EFI_PCI_HOTPLUG_REQUEST_PROTOCOL {
+  ///
+  /// Notify the PCI bus driver that some events have happened in a hot-plug 
+  /// controller (for example, PC Card socket, or PHPC), and ask PCI bus driver 
+  /// to create or destroy handles for the PCI-like devices. See Section 0 for 
+  /// a detailed description.
+  ///
+  EFI_PCI_HOTPLUG_REQUEST_NOTIFY  Notify;
+};
+
+extern EFI_GUID gEfiPciHotPlugRequestProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciIo.h b/MdePkg/Include/Protocol/PciIo.h
new file mode 100644
index 000000000000..5bbc54350149
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciIo.h
@@ -0,0 +1,558 @@
+/** @file
+  EFI PCI I/O Protocol provides the basic Memory, I/O, PCI configuration, 
+  and DMA interfaces that a driver uses to access its PCI controller.
+
+  Copyright (c) 2006 - 2010, 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 __PCI_IO_H__
+#define __PCI_IO_H__
+
+///
+/// Global ID for the PCI I/O Protocol
+///
+#define EFI_PCI_IO_PROTOCOL_GUID \
+  { \
+    0x4cf5b200, 0x68b8, 0x4ca5, {0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x2, 0x9a } \
+  }
+
+typedef struct _EFI_PCI_IO_PROTOCOL  EFI_PCI_IO_PROTOCOL;
+
+///
+/// *******************************************************
+/// EFI_PCI_IO_PROTOCOL_WIDTH
+/// *******************************************************
+///
+typedef enum {
+  EfiPciIoWidthUint8      = 0,
+  EfiPciIoWidthUint16,
+  EfiPciIoWidthUint32,
+  EfiPciIoWidthUint64,
+  EfiPciIoWidthFifoUint8,
+  EfiPciIoWidthFifoUint16,
+  EfiPciIoWidthFifoUint32,
+  EfiPciIoWidthFifoUint64,
+  EfiPciIoWidthFillUint8,
+  EfiPciIoWidthFillUint16,
+  EfiPciIoWidthFillUint32,
+  EfiPciIoWidthFillUint64,
+  EfiPciIoWidthMaximum
+} EFI_PCI_IO_PROTOCOL_WIDTH;
+
+//
+// Complete PCI address generater
+//
+#define EFI_PCI_IO_PASS_THROUGH_BAR               0xff    ///< Special BAR that passes a memory or I/O cycle through unchanged
+#define EFI_PCI_IO_ATTRIBUTE_MASK                 0x077f  ///< All the following I/O and Memory cycles
+#define EFI_PCI_IO_ATTRIBUTE_ISA_MOTHERBOARD_IO   0x0001  ///< I/O cycles 0x0000-0x00FF (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_ISA_IO               0x0002  ///< I/O cycles 0x0100-0x03FF or greater (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO       0x0004  ///< I/O cycles 0x3C6, 0x3C8, 0x3C9 (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY           0x0008  ///< MEM cycles 0xA0000-0xBFFFF (24 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_VGA_IO               0x0010  ///< I/O cycles 0x3B0-0x3BB and 0x3C0-0x3DF (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO       0x0020  ///< I/O cycles 0x1F0-0x1F7, 0x3F6, 0x3F7 (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO     0x0040  ///< I/O cycles 0x170-0x177, 0x376, 0x377 (10 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE 0x0080  ///< Map a memory range so writes are combined
+#define EFI_PCI_IO_ATTRIBUTE_IO                   0x0100  ///< Enable the I/O decode bit in the PCI Config Header
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY               0x0200  ///< Enable the Memory decode bit in the PCI Config Header
+#define EFI_PCI_IO_ATTRIBUTE_BUS_MASTER           0x0400  ///< Enable the DMA bit in the PCI Config Header
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_CACHED        0x0800  ///< Map a memory range so all r/w accesses are cached
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_DISABLE       0x1000  ///< Disable a memory range
+#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_DEVICE      0x2000  ///< Clear for an add-in PCI Device
+#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_ROM         0x4000  ///< Clear for a physical PCI Option ROM accessed through ROM BAR
+#define EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE   0x8000  ///< Clear for PCI controllers that can not genrate a DAC
+#define EFI_PCI_IO_ATTRIBUTE_ISA_IO_16            0x10000 ///< I/O cycles 0x0100-0x03FF or greater (16 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO_16    0x20000 ///< I/O cycles 0x3C6, 0x3C8, 0x3C9 (16 bit decode)
+#define EFI_PCI_IO_ATTRIBUTE_VGA_IO_16            0x40000 ///< I/O cycles 0x3B0-0x3BB and 0x3C0-0x3DF (16 bit decode)
+
+#define EFI_PCI_DEVICE_ENABLE                     (EFI_PCI_IO_ATTRIBUTE_IO | EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER)
+#define EFI_VGA_DEVICE_ENABLE                     (EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_IO)
+
+///
+/// *******************************************************
+/// EFI_PCI_IO_PROTOCOL_OPERATION
+/// *******************************************************
+///
+typedef enum {
+  ///
+  /// A read operation from system memory by a bus master.
+  ///
+  EfiPciIoOperationBusMasterRead,
+  ///
+  /// A write operation from system memory by a bus master.
+  ///
+  EfiPciIoOperationBusMasterWrite,
+  ///
+  /// Provides both read and write access to system memory by both the processor and a
+  /// bus master. The buffer is coherent from both the processor's and the bus master's point of view.
+  ///
+  EfiPciIoOperationBusMasterCommonBuffer,
+  EfiPciIoOperationMaximum
+} EFI_PCI_IO_PROTOCOL_OPERATION;
+
+///
+/// *******************************************************
+/// EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION
+/// *******************************************************
+///
+typedef enum {
+  ///
+  /// Retrieve the PCI controller's current attributes, and return them in Result.
+  ///
+  EfiPciIoAttributeOperationGet,
+  ///
+  /// Set the PCI controller's current attributes to Attributes.
+  ///
+  EfiPciIoAttributeOperationSet,
+  ///
+  /// Enable the attributes specified by the bits that are set in Attributes for this PCI controller.
+  ///
+  EfiPciIoAttributeOperationEnable,
+  ///
+  /// Disable the attributes specified by the bits that are set in Attributes for this PCI controller.
+  ///
+  EfiPciIoAttributeOperationDisable,
+  ///
+  /// Retrieve the PCI controller's supported attributes, and return them in Result.
+  ///
+  EfiPciIoAttributeOperationSupported,
+  EfiPciIoAttributeOperationMaximum
+} EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION;
+
+/**                                                                 
+  Reads from the memory space of a PCI controller. Returns either when the polling exit criteria is
+  satisfied or after a defined duration.                                                           
+          
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
+  @param  Width                 Signifies the width of the memory or I/O operations.
+  @param  BarIndex              The BAR index of the standard PCI Configuration header to use as the
+                                base address for the memory operation to perform.                   
+  @param  Offset                The offset within the selected BAR to start the memory operation.
+  @param  Mask                  Mask used for the polling criteria.
+  @param  Value                 The comparison value used for the polling exit criteria.
+  @param  Delay                 The number of 100 ns units to poll.
+  @param  Result                Pointer to the last value read from the memory location.
+                                
+  @retval EFI_SUCCESS           The last data returned from the access matched the poll exit criteria.
+  @retval EFI_UNSUPPORTED       BarIndex not valid for this PCI controller.
+  @retval EFI_UNSUPPORTED       Offset is not valid for the BarIndex of this PCI controller.
+  @retval EFI_TIMEOUT           Delay expired before a match occurred.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_POLL_IO_MEM)(
+  IN EFI_PCI_IO_PROTOCOL           *This,
+  IN  EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN  UINT8                        BarIndex,
+  IN  UINT64                       Offset,
+  IN  UINT64                       Mask,
+  IN  UINT64                       Value,
+  IN  UINT64                       Delay,
+  OUT UINT64                       *Result
+  );
+
+/**                                                                 
+  Enable a PCI driver to access PCI controller registers in the PCI memory or I/O space.
+          
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
+  @param  Width                 Signifies the width of the memory or I/O operations.
+  @param  BarIndex              The BAR index of the standard PCI Configuration header to use as the
+                                base address for the memory or I/O operation to perform.                    
+  @param  Offset                The offset within the selected BAR to start the memory or I/O operation.                                
+  @param  Count                 The number of memory or I/O operations to perform.
+  @param  Buffer                For read operations, the destination buffer to store the results. For write
+                                operations, the source buffer to write data from.                          
+  
+  @retval EFI_SUCCESS           The data was read from or written to the PCI controller.
+  @retval EFI_UNSUPPORTED       BarIndex not valid for this PCI controller.
+  @retval EFI_UNSUPPORTED       The address range specified by Offset, Width, and Count is not
+                                valid for the PCI BAR specified by BarIndex.                  
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_IO_MEM)(
+  IN EFI_PCI_IO_PROTOCOL              *This,
+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN     UINT8                        BarIndex,
+  IN     UINT64                       Offset,
+  IN     UINTN                        Count,
+  IN OUT VOID                         *Buffer
+  );
+
+typedef struct {
+  ///
+  /// Read PCI controller registers in the PCI memory or I/O space.
+  ///
+  EFI_PCI_IO_PROTOCOL_IO_MEM  Read;
+  ///
+  /// Write PCI controller registers in the PCI memory or I/O space.
+  ///
+  EFI_PCI_IO_PROTOCOL_IO_MEM  Write;
+} EFI_PCI_IO_PROTOCOL_ACCESS;
+
+/**                                                                 
+  Enable a PCI driver to access PCI controller registers in PCI configuration space.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  Width                 Signifies the width of the memory operations.
+  @param  Offset                The offset within the PCI configuration space for the PCI controller.
+  @param  Count                 The number of PCI configuration operations to perform.
+  @param  Buffer                For read operations, the destination buffer to store the results. For write
+                                operations, the source buffer to write data from.
+  
+                                  
+  @retval EFI_SUCCESS           The data was read from or written to the PCI controller.
+  @retval EFI_UNSUPPORTED       The address range specified by Offset, Width, and Count is not
+                                valid for the PCI configuration header of the PCI controller.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.                                 
+  @retval EFI_INVALID_PARAMETER Buffer is NULL or Width is invalid.                                
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_CONFIG)(
+  IN EFI_PCI_IO_PROTOCOL              *This,
+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN     UINT32                       Offset,
+  IN     UINTN                        Count,
+  IN OUT VOID                         *Buffer
+  );
+
+typedef struct {
+  ///
+  /// Read PCI controller registers in PCI configuration space.
+  ///
+  EFI_PCI_IO_PROTOCOL_CONFIG  Read;
+  ///
+  /// Write PCI controller registers in PCI configuration space.
+  ///
+  EFI_PCI_IO_PROTOCOL_CONFIG  Write;
+} EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS;
+
+/**                                                                 
+  Enables a PCI driver to copy one region of PCI memory space to another region of PCI
+  memory space.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
+  @param  Width                 Signifies the width of the memory operations.
+  @param  DestBarIndex          The BAR index in the standard PCI Configuration header to use as the
+                                base address for the memory operation to perform.                   
+  @param  DestOffset            The destination offset within the BAR specified by DestBarIndex to
+                                start the memory writes for the copy operation.                   
+  @param  SrcBarIndex           The BAR index in the standard PCI Configuration header to use as the
+                                base address for the memory operation to perform.                   
+  @param  SrcOffset             The source offset within the BAR specified by SrcBarIndex to start
+                                the memory reads for the copy operation.                          
+  @param  Count                 The number of memory operations to perform. Bytes moved is Width
+                                size * Count, starting at DestOffset and SrcOffset.             
+                                
+  @retval EFI_SUCCESS           The data was copied from one memory region to another memory region.
+  @retval EFI_UNSUPPORTED       DestBarIndex not valid for this PCI controller.
+  @retval EFI_UNSUPPORTED       SrcBarIndex not valid for this PCI controller.
+  @retval EFI_UNSUPPORTED       The address range specified by DestOffset, Width, and Count
+                                is not valid for the PCI BAR specified by DestBarIndex.    
+  @retval EFI_UNSUPPORTED       The address range specified by SrcOffset, Width, and Count is
+                                not valid for the PCI BAR specified by SrcBarIndex.          
+  @retval EFI_INVALID_PARAMETER Width is invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_COPY_MEM)(
+  IN EFI_PCI_IO_PROTOCOL              *This,
+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN     UINT8                        DestBarIndex,
+  IN     UINT64                       DestOffset,
+  IN     UINT8                        SrcBarIndex,
+  IN     UINT64                       SrcOffset,
+  IN     UINTN                        Count
+  );
+
+/**                                                                 
+  Provides the PCI controller-specific addresses needed to access system memory.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
+  @param  Operation             Indicates if the bus master is going to read or write to system memory.
+  @param  HostAddress           The system memory address to map to the PCI controller.
+  @param  NumberOfBytes         On input the number of bytes to map. On output the number of bytes
+                                that were mapped.                                                 
+  @param  DeviceAddress         The resulting map address for the bus master PCI controller to use to
+                                access the hosts HostAddress.                                        
+  @param  Mapping               A resulting value to pass to Unmap().
+                                  
+  @retval EFI_SUCCESS           The range was mapped for the returned NumberOfBytes.
+  @retval EFI_UNSUPPORTED       The HostAddress cannot be mapped as a common buffer.                                
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_DEVICE_ERROR      The system hardware could not map the requested address.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_MAP)(
+  IN EFI_PCI_IO_PROTOCOL                *This,
+  IN     EFI_PCI_IO_PROTOCOL_OPERATION  Operation,
+  IN     VOID                           *HostAddress,
+  IN OUT UINTN                          *NumberOfBytes,
+  OUT    EFI_PHYSICAL_ADDRESS           *DeviceAddress,
+  OUT    VOID                           **Mapping
+  );
+
+/**                                                                 
+  Completes the Map() operation and releases any corresponding resources.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.                                      
+  @param  Mapping               The mapping value returned from Map().
+                                  
+  @retval EFI_SUCCESS           The range was unmapped.
+  @retval EFI_DEVICE_ERROR      The data was not committed to the target system memory.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_UNMAP)(
+  IN EFI_PCI_IO_PROTOCOL           *This,
+  IN  VOID                         *Mapping
+  );
+
+/**                                                                 
+  Allocates pages that are suitable for an EfiPciIoOperationBusMasterCommonBuffer
+  mapping.                                                                       
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
+  @param  Type                  This parameter is not used and must be ignored.
+  @param  MemoryType            The type of memory to allocate, EfiBootServicesData or
+                                EfiRuntimeServicesData.                               
+  @param  Pages                 The number of pages to allocate.                                
+  @param  HostAddress           A pointer to store the base system memory address of the
+                                allocated range.                                        
+  @param  Attributes            The requested bit mask of attributes for the allocated range.
+                                  
+  @retval EFI_SUCCESS           The requested memory pages were allocated.
+  @retval EFI_UNSUPPORTED       Attributes is unsupported. The only legal attribute bits are
+                                MEMORY_WRITE_COMBINE and MEMORY_CACHED.                     
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The memory pages could not be allocated.  
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER)(
+  IN EFI_PCI_IO_PROTOCOL           *This,
+  IN  EFI_ALLOCATE_TYPE            Type,
+  IN  EFI_MEMORY_TYPE              MemoryType,
+  IN  UINTN                        Pages,
+  OUT VOID                         **HostAddress,
+  IN  UINT64                       Attributes
+  );
+
+/**                                                                 
+  Frees memory that was allocated with AllocateBuffer().
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  Pages                 The number of pages to free.                                
+  @param  HostAddress           The base system memory address of the allocated range.                                    
+                                  
+  @retval EFI_SUCCESS           The requested memory pages were freed.
+  @retval EFI_INVALID_PARAMETER The memory range specified by HostAddress and Pages
+                                was not allocated with AllocateBuffer().
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_FREE_BUFFER)(
+  IN EFI_PCI_IO_PROTOCOL           *This,
+  IN  UINTN                        Pages,
+  IN  VOID                         *HostAddress
+  );
+
+/**                                                                 
+  Flushes all PCI posted write transactions from a PCI host bridge to system memory.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+                                  
+  @retval EFI_SUCCESS           The PCI posted write transactions were flushed from the PCI host
+                                bridge to system memory.                                        
+  @retval EFI_DEVICE_ERROR      The PCI posted write transactions were not flushed from the PCI
+                                host bridge due to a hardware error.                           
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_FLUSH)(
+  IN EFI_PCI_IO_PROTOCOL  *This
+  );
+
+/**                                                                 
+  Retrieves this PCI controller's current PCI bus number, device number, and function number.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  SegmentNumber         The PCI controller's current PCI segment number.
+  @param  BusNumber             The PCI controller's current PCI bus number.
+  @param  DeviceNumber          The PCI controller's current PCI device number.
+  @param  FunctionNumber        The PCI controller's current PCI function number.
+                                  
+  @retval EFI_SUCCESS           The PCI controller location was returned.                                                       
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                              
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_LOCATION)(
+  IN EFI_PCI_IO_PROTOCOL          *This,
+  OUT UINTN                       *SegmentNumber,
+  OUT UINTN                       *BusNumber,
+  OUT UINTN                       *DeviceNumber,
+  OUT UINTN                       *FunctionNumber
+  );
+
+/**                                                                 
+  Performs an operation on the attributes that this PCI controller supports. The operations include
+  getting the set of supported attributes, retrieving the current attributes, setting the current  
+  attributes, enabling attributes, and disabling attributes.                                       
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  Operation             The operation to perform on the attributes for this PCI controller.
+  @param  Attributes            The mask of attributes that are used for Set, Enable, and Disable
+                                operations.                                                      
+  @param  Result                A pointer to the result mask of attributes that are returned for the Get
+                                and Supported operations.                                               
+                                  
+  @retval EFI_SUCCESS           The operation on the PCI controller's attributes was completed.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                              
+  @retval EFI_UNSUPPORTED       one or more of the bits set in                               
+                                Attributes are not supported by this PCI controller or one of
+                                its parent bridges when Operation is Set, Enable or Disable.
+                                       
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_ATTRIBUTES)(
+  IN EFI_PCI_IO_PROTOCOL                       *This,
+  IN  EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION  Operation,
+  IN  UINT64                                   Attributes,
+  OUT UINT64                                   *Result OPTIONAL
+  );
+
+/**                                                                 
+  Gets the attributes that this PCI controller supports setting on a BAR using
+  SetBarAttributes(), and retrieves the list of resource descriptors for a BAR.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  BarIndex              The BAR index of the standard PCI Configuration header to use as the
+                                base address for resource range. The legal range for this field is 0..5.
+  @param  Supports              A pointer to the mask of attributes that this PCI controller supports
+                                setting for this BAR with SetBarAttributes().                        
+  @param  Resources             A pointer to the ACPI 2.0 resource descriptors that describe the current
+                                configuration of this BAR of the PCI controller.                        
+                                  
+  @retval EFI_SUCCESS           If Supports is not NULL, then the attributes that the PCI       
+                                controller supports are returned in Supports. If Resources      
+                                is not NULL, then the ACPI 2.0 resource descriptors that the PCI
+                                controller is currently using are returned in Resources.          
+  @retval EFI_INVALID_PARAMETER Both Supports and Attributes are NULL.
+  @retval EFI_UNSUPPORTED       BarIndex not valid for this PCI controller.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to allocate
+                                Resources.                                                 
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES)(
+  IN EFI_PCI_IO_PROTOCOL             *This,
+  IN  UINT8                          BarIndex,
+  OUT UINT64                         *Supports, OPTIONAL
+  OUT VOID                           **Resources OPTIONAL
+  );
+
+/**                                                                 
+  Sets the attributes for a range of a BAR on a PCI controller.
+            
+  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.  
+  @param  Attributes            The mask of attributes to set for the resource range specified by
+                                BarIndex, Offset, and Length.                                    
+  @param  BarIndex              The BAR index of the standard PCI Configuration header to use as the
+                                base address for resource range. The legal range for this field is 0..5.
+  @param  Offset                A pointer to the BAR relative base address of the resource range to be
+                                modified by the attributes specified by Attributes.                   
+  @param  Length                A pointer to the length of the resource range to be modified by the
+                                attributes specified by Attributes.                                
+                                  
+  @retval EFI_SUCCESS           The set of attributes specified by Attributes for the resource      
+                                range specified by BarIndex, Offset, and Length were                
+                                set on the PCI controller, and the actual resource range is returned
+                                in Offset and Length.                                               
+  @retval EFI_INVALID_PARAMETER Offset or Length is NULL.
+  @retval EFI_UNSUPPORTED       BarIndex not valid for this PCI controller.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the attributes on the
+                                resource range specified by BarIndex, Offset, and          
+                                Length.                                                    
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES)(
+  IN EFI_PCI_IO_PROTOCOL              *This,
+  IN     UINT64                       Attributes,
+  IN     UINT8                        BarIndex,
+  IN OUT UINT64                       *Offset,
+  IN OUT UINT64                       *Length
+  );
+
+///
+/// The EFI_PCI_IO_PROTOCOL provides the basic Memory, I/O, PCI configuration, 
+/// and DMA interfaces used to abstract accesses to PCI controllers. 
+/// There is one EFI_PCI_IO_PROTOCOL instance for each PCI controller on a PCI bus. 
+/// A device driver that wishes to manage a PCI controller in a system will have to 
+/// retrieve the EFI_PCI_IO_PROTOCOL instance that is associated with the PCI controller. 
+///
+struct _EFI_PCI_IO_PROTOCOL {
+  EFI_PCI_IO_PROTOCOL_POLL_IO_MEM         PollMem;
+  EFI_PCI_IO_PROTOCOL_POLL_IO_MEM         PollIo;
+  EFI_PCI_IO_PROTOCOL_ACCESS              Mem;
+  EFI_PCI_IO_PROTOCOL_ACCESS              Io;
+  EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS       Pci;
+  EFI_PCI_IO_PROTOCOL_COPY_MEM            CopyMem;
+  EFI_PCI_IO_PROTOCOL_MAP                 Map;
+  EFI_PCI_IO_PROTOCOL_UNMAP               Unmap;
+  EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER     AllocateBuffer;
+  EFI_PCI_IO_PROTOCOL_FREE_BUFFER         FreeBuffer;
+  EFI_PCI_IO_PROTOCOL_FLUSH               Flush;
+  EFI_PCI_IO_PROTOCOL_GET_LOCATION        GetLocation;
+  EFI_PCI_IO_PROTOCOL_ATTRIBUTES          Attributes;
+  EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES  GetBarAttributes;
+  EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES  SetBarAttributes;
+  
+  ///
+  /// The size, in bytes, of the ROM image.
+  ///
+  UINT64                                  RomSize;
+
+  ///
+  /// A pointer to the in memory copy of the ROM image. The PCI Bus Driver is responsible 
+  /// for allocating memory for the ROM image, and copying the contents of the ROM to memory. 
+  /// The contents of this buffer are either from the PCI option ROM that can be accessed 
+  /// through the ROM BAR of the PCI controller, or it is from a platform-specific location. 
+  /// The Attributes() function can be used to determine from which of these two sources 
+  /// the RomImage buffer was initialized.
+  /// 
+  VOID                                    *RomImage;
+};
+
+extern EFI_GUID gEfiPciIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciOverride.h b/MdePkg/Include/Protocol/PciOverride.h
new file mode 100644
index 000000000000..c1edcc52fa5f
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciOverride.h
@@ -0,0 +1,46 @@
+/** @file
+  This file declares EFI PCI Override protocol which provides the interface between
+  the PCI bus driver/PCI Host Bridge Resource Allocation driver and an implementation's
+  driver to describe the unique features of a platform.
+  This protocol is optional.
+
+  Copyright (c) 2009, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2
+  Volume 5: Standards
+
+**/
+
+#ifndef _PCI_OVERRIDE_H_
+#define _PCI_OVERRIDE_H_
+
+///
+/// EFI_PCI_OVERRIDE_PROTOCOL has the same structure with EFI_PCI_PLATFORM_PROTOCOL
+///
+#include <Protocol/PciPlatform.h>
+
+///
+/// Global ID for the EFI_PCI_OVERRIDE_PROTOCOL
+///
+#define EFI_PCI_OVERRIDE_GUID \
+  { \
+    0xb5b35764, 0x460c, 0x4a06, {0x99, 0xfc, 0x77, 0xa1, 0x7c, 0x1b, 0x5c, 0xeb} \
+  }
+
+///
+/// Declaration for EFI_PCI_OVERRIDE_PROTOCOL
+///
+typedef EFI_PCI_PLATFORM_PROTOCOL EFI_PCI_OVERRIDE_PROTOCOL;
+
+
+extern EFI_GUID   gEfiPciOverrideProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciPlatform.h b/MdePkg/Include/Protocol/PciPlatform.h
new file mode 100644
index 000000000000..056f92b1ef53
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciPlatform.h
@@ -0,0 +1,344 @@
+/** @file
+  This file declares PlatfromOpRom protocols that provide the interface between 
+  the PCI bus driver/PCI Host Bridge Resource Allocation driver and a platform-specific 
+  driver to describe the unique features of a platform. 
+  This protocol is optional.
+  
+Copyright (c) 2007 - 2010, 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.
+
+  @par Revision Reference:
+  This Protocol is defined in UEFI Platform Initialization Specification 1.2 
+  Volume 5: Standards
+
+**/
+
+#ifndef _PCI_PLATFORM_H_
+#define _PCI_PLATFORM_H_
+
+///
+/// This file must be included because the EFI_PCI_PLATFORM_PROTOCOL uses
+/// EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE.
+///
+#include <Protocol/PciHostBridgeResourceAllocation.h>
+
+///
+/// Global ID for the EFI_PCI_PLATFORM_PROTOCOL.
+///
+#define EFI_PCI_PLATFORM_PROTOCOL_GUID \
+  { \
+    0x7d75280, 0x27d4, 0x4d69, {0x90, 0xd0, 0x56, 0x43, 0xe2, 0x38, 0xb3, 0x41} \
+  }
+
+///
+/// Forward declaration for EFI_PCI_PLATFORM_PROTOCOL.
+///
+typedef struct _EFI_PCI_PLATFORM_PROTOCOL EFI_PCI_PLATFORM_PROTOCOL;
+
+///
+/// EFI_PCI_PLATFORM_POLICY that is a bitmask with the following legal combinations:
+///   - EFI_RESERVE_NONE_IO_ALIAS:<BR>
+///       Does not set aside either ISA or VGA I/O resources during PCI
+///       enumeration. By using this selection, the platform indicates that it does
+///       not want to support a PCI device that requires ISA or legacy VGA
+///       resources. If a PCI device driver asks for these resources, the request
+///       will be turned down.
+///   - EFI_RESERVE_ISA_IO_ALIAS | EFI_RESERVE_VGA_IO_ALIAS:<BR>
+///       Sets aside the ISA I/O range and all the aliases during PCI
+///       enumeration. VGA I/O ranges and aliases are included in ISA alias
+///       ranges. In this scheme, seventy-five percent of the I/O space remains unused.
+///       By using this selection, the platform indicates that it wants to support
+///       PCI devices that require the following, at the cost of wasted I/O space:
+///       ISA range and its aliases
+///       Legacy VGA range and its aliases
+///       The PCI bus driver will not allocate I/O addresses out of the ISA I/O
+///       range and its aliases. The following are the ISA I/O ranges:
+///         - n100..n3FF
+///         - n500..n7FF
+///         - n900..nBFF
+///         - nD00..nFFF
+///
+///       In this case, the PCI bus driver will ask the PCI host bridge driver for
+///       larger I/O ranges. The PCI host bridge driver is not aware of the ISA
+///       aliasing policy and merely attempts to allocate the requested ranges.
+///       The first device that requests the legacy VGA range will get all the
+///       legacy VGA range plus its aliased addresses forwarded to it. The first
+///       device that requests the legacy ISA range will get all the legacy ISA
+///       range, plus its aliased addresses, forwarded to it.
+///   - EFI_RESERVE_ISA_IO_NO_ALIAS | EFI_RESERVE_VGA_IO_ALIAS:<BR>
+///       Sets aside the ISA I/O range (0x100 - 0x3FF) during PCI enumeration
+///       and the aliases of the VGA I/O ranges. By using this selection, the
+///       platform indicates that it will support VGA devices that require VGA
+///       ranges, including those that require VGA aliases. The platform further
+///       wants to support non-VGA devices that ask for the ISA range (0x100 -
+///       3FF), but not if it also asks for the ISA aliases. The PCI bus driver will
+///       not allocate I/O addresses out of the legacy ISA I/O range (0x100 -
+///       0x3FF) range or the aliases of the VGA I/O range. If a PCI device
+///       driver asks for the ISA I/O ranges, including aliases, the request will be
+///       turned down. The first device that requests the legacy VGA range will
+///       get all the legacy VGA range plus its aliased addresses forwarded to
+///       it. When the legacy VGA device asks for legacy VGA ranges and its
+///       aliases, all the upstream PCI-to-PCI bridges must be set up to perform
+///       10-bit decode on legacy VGA ranges. To prevent two bridges from
+///       positively decoding the same address, all PCI-to-PCI bridges that are
+///       peers to this bridge will have to be set up to not decode ISA aliased
+///       ranges. In that case, all the devices behind the peer bridges can
+///       occupy only I/O addresses that are not ISA aliases. This is a limitation
+///       of PCI-to-PCI bridges and is described in the white paper PCI-to-PCI
+///       Bridges and Card Bus Controllers on Windows 2000, Windows XP,
+///       and Windows Server 2003. The PCI enumeration process must be
+///       cognizant of this restriction.
+///   - EFI_RESERVE_ISA_IO_NO_ALIAS | EFI_RESERVE_VGA_IO_NO_ALIAS:<BR>
+///       Sets aside the ISA I/O range (0x100 - 0x3FF) during PCI enumeration.
+///       VGA I/O ranges are included in the ISA range. By using this selection,
+///       the platform indicates that it wants to support PCI devices that require
+///       the ISA range and legacy VGA range, but it does not want to support
+///       devices that require ISA alias ranges or VGA alias ranges. The PCI
+///       bus driver will not allocate I/O addresses out of the legacy ISA I/O
+///       range (0x100-0x3FF). If a PCI device driver asks for the ISA I/O
+///       ranges, including aliases, the request will be turned down. By using
+///       this selection, the platform indicates that it will support VGA devices
+///       that require VGA ranges, but it will not support VGA devices that
+///       require VGA aliases. To truly support 16-bit VGA decode, all the PCIto-
+///       PCI bridges that are upstream to a VGA device, as well as
+///       upstream to the parent PCI root bridge, must support 16-bit VGA I/O
+///       decode. See the PCI-to-PCI Bridge Architecture Specification for
+///       information regarding the 16-bit VGA decode support. This
+///       requirement must hold true for every VGA device in the system. If any
+///       of these bridges does not support 16-bit VGA decode, it will positively
+///       decode all the aliases of the VGA I/O ranges and this selection must
+///       be treated like EFI_RESERVE_ISA_IO_NO_ALIAS |
+///       EFI_RESERVE_VGA_IO_ALIAS.
+///
+typedef UINT32  EFI_PCI_PLATFORM_POLICY;
+
+///
+/// Does not set aside either ISA or VGA I/O resources during PCI
+/// enumeration.
+///
+#define     EFI_RESERVE_NONE_IO_ALIAS        0x0000
+
+///
+/// Sets aside ISA I/O range and all aliases:
+///   - n100..n3FF
+///   - n500..n7FF
+///   - n900..nBFF
+///   - nD00..nFFF.
+///
+#define     EFI_RESERVE_ISA_IO_ALIAS         0x0001
+
+///
+/// Sets aside ISA I/O range 0x100-0x3FF.
+///
+#define     EFI_RESERVE_ISA_IO_NO_ALIAS      0x0002
+
+///
+/// Sets aside VGA I/O ranges and all aliases.
+///
+#define     EFI_RESERVE_VGA_IO_ALIAS         0x0004
+
+///
+/// Sets aside VGA I/O ranges
+///
+#define     EFI_RESERVE_VGA_IO_NO_ALIAS      0x0008
+
+///
+/// EFI_PCI_EXECUTION_PHASE is used to call a platform protocol and execute
+/// platform-specific code.
+///
+typedef enum {
+  ///
+  /// The phase that indicates the entry point to the PCI Bus Notify phase. This
+  /// platform hook is called before the PCI bus driver calls the
+  /// EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL driver.
+  ///
+  BeforePciHostBridge = 0,
+  ///
+  /// The phase that indicates the entry point to the PCI Bus Notify phase. This
+  /// platform hook is called before the PCI bus driver calls the
+  /// EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL driver.
+  ///
+  ChipsetEntry = 0,
+  ///
+  /// The phase that indicates the exit point to the Chipset Notify phase before
+  /// returning to the PCI Bus Driver Notify phase. This platform hook is called after
+  /// the PCI bus driver calls the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL
+  /// driver.
+  ///
+  AfterPciHostBridge = 1,
+  ///
+  /// The phase that indicates the exit point to the Chipset Notify phase before
+  /// returning to the PCI Bus Driver Notify phase. This platform hook is called after
+  /// the PCI bus driver calls the EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PROTOCOL
+  /// driver.
+  ///
+  ChipsetExit = 1,
+  MaximumChipsetPhase
+} EFI_PCI_EXECUTION_PHASE;
+
+typedef EFI_PCI_EXECUTION_PHASE EFI_PCI_CHIPSET_EXECUTION_PHASE;
+
+/**
+  The notification from the PCI bus enumerator to the platform that it is
+  about to enter a certain phase during the enumeration process.
+
+  The PlatformNotify() function can be used to notify the platform driver so that
+  it can perform platform-specific actions. No specific actions are required.
+  Eight notification points are defined at this time. More synchronization points
+  may be added as required in the future. The PCI bus driver calls the platform driver
+  twice for every Phase-once before the PCI Host Bridge Resource Allocation Protocol
+  driver is notified, and once after the PCI Host Bridge Resource Allocation Protocol
+  driver has been notified.
+  This member function may not perform any error checking on the input parameters. It
+  also does not return any error codes. If this member function detects any error condition,
+  it needs to handle those errors on its own because there is no way to surface any
+  errors to the caller.
+
+  @param[in] This           The pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
+  @param[in] HostBridge     The handle of the host bridge controller.
+  @param[in] Phase          The phase of the PCI bus enumeration.
+  @param[in] ExecPhase      Defines the execution phase of the PCI chipset driver.
+
+  @retval EFI_SUCCESS   The function completed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_PLATFORM_PHASE_NOTIFY)(
+  IN EFI_PCI_PLATFORM_PROTOCOL                      *This,
+  IN EFI_HANDLE                                     HostBridge,
+  IN EFI_PCI_HOST_BRIDGE_RESOURCE_ALLOCATION_PHASE  Phase,
+  IN EFI_PCI_EXECUTION_PHASE                        ExecPhase
+  );
+
+/**
+  The notification from the PCI bus enumerator to the platform for each PCI
+  controller at several predefined points during PCI controller initialization.
+
+  The PlatformPrepController() function can be used to notify the platform driver so that
+  it can perform platform-specific actions. No specific actions are required.
+  Several notification points are defined at this time. More synchronization points may be
+  added as required in the future. The PCI bus driver calls the platform driver twice for
+  every PCI controller-once before the PCI Host Bridge Resource Allocation Protocol driver
+  is notified, and once after the PCI Host Bridge Resource Allocation Protocol driver has
+  been notified.
+  This member function may not perform any error checking on the input parameters. It also
+  does not return any error codes. If this member function detects any error condition, it
+  needs to handle those errors on its own because there is no way to surface any errors to
+  the caller.
+
+  @param[in] This           The pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
+  @param[in] HostBridge     The associated PCI host bridge handle.
+  @param[in] RootBridge     The associated PCI root bridge handle.
+  @param[in] PciAddress     The address of the PCI device on the PCI bus.
+  @param[in] Phase          The phase of the PCI controller enumeration.
+  @param[in] ExecPhase      Defines the execution phase of the PCI chipset driver.
+
+  @retval EFI_SUCCESS   The function completed successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_PLATFORM_PREPROCESS_CONTROLLER)(
+  IN EFI_PCI_PLATFORM_PROTOCOL                     *This,
+  IN EFI_HANDLE                                    HostBridge,
+  IN EFI_HANDLE                                    RootBridge,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS   PciAddress,
+  IN EFI_PCI_CONTROLLER_RESOURCE_ALLOCATION_PHASE  Phase,
+  IN EFI_PCI_EXECUTION_PHASE                       ExecPhase
+  );
+
+/**
+  Retrieves the platform policy regarding enumeration.
+
+  The GetPlatformPolicy() function retrieves the platform policy regarding PCI
+  enumeration. The PCI bus driver and the PCI Host Bridge Resource Allocation Protocol
+  driver can call this member function to retrieve the policy.
+
+  @param[in]  This        The pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
+  @param[out] PciPolicy   The platform policy with respect to VGA and ISA aliasing.
+
+  @retval EFI_SUCCESS             The function completed successfully.
+  @retval EFI_INVALID_PARAMETER   PciPolicy is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_PLATFORM_GET_PLATFORM_POLICY)(
+  IN  CONST EFI_PCI_PLATFORM_PROTOCOL  *This,
+  OUT       EFI_PCI_PLATFORM_POLICY    *PciPolicy
+  );
+
+/**
+  Gets the PCI device's option ROM from a platform-specific location.
+
+  The GetPciRom() function gets the PCI device's option ROM from a platform-specific location.
+  The option ROM will be loaded into memory. This member function is used to return an image
+  that is packaged as a PCI 2.2 option ROM. The image may contain both legacy and EFI option
+  ROMs. See the UEFI 2.0 Specification for details. This member function can be used to return
+  option ROM images for embedded controllers. Option ROMs for embedded controllers are typically
+  stored in platform-specific storage, and this member function can retrieve it from that storage
+  and return it to the PCI bus driver. The PCI bus driver will call this member function before
+  scanning the ROM that is attached to any controller, which allows a platform to specify a ROM
+  image that is different from the ROM image on a PCI card.
+
+  @param[in]  This        The pointer to the EFI_PCI_PLATFORM_PROTOCOL instance.
+  @param[in]  PciHandle   The handle of the PCI device.
+  @param[out] RomImage    If the call succeeds, the pointer to the pointer to the option ROM image.
+                          Otherwise, this field is undefined. The memory for RomImage is allocated
+                          by EFI_PCI_PLATFORM_PROTOCOL.GetPciRom() using the EFI Boot Service AllocatePool().
+                          It is the caller's responsibility to free the memory using the EFI Boot Service
+                          FreePool(), when the caller is done with the option ROM.
+  @param[out] RomSize     If the call succeeds, a pointer to the size of the option ROM size. Otherwise,
+                          this field is undefined.
+
+  @retval EFI_SUCCESS            The option ROM was available for this device and loaded into memory.
+  @retval EFI_NOT_FOUND          No option ROM was available for this device.
+  @retval EFI_OUT_OF_RESOURCES   No memory was available to load the option ROM.
+  @retval EFI_DEVICE_ERROR       An error occurred in obtaining the option ROM.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_PLATFORM_GET_PCI_ROM)(
+  IN  CONST EFI_PCI_PLATFORM_PROTOCOL  *This,
+  IN        EFI_HANDLE                 PciHandle,
+  OUT       VOID                       **RomImage,
+  OUT       UINTN                      *RomSize
+  );
+
+///
+/// This protocol provides the interface between the PCI bus driver/PCI Host
+/// Bridge Resource Allocation driver and a platform-specific driver to describe
+/// the unique features of a platform.
+///
+struct _EFI_PCI_PLATFORM_PROTOCOL {
+  ///
+  /// The notification from the PCI bus enumerator to the platform that it is about to 
+  /// enter a certain phase during the enumeration process.
+  ///
+  EFI_PCI_PLATFORM_PHASE_NOTIFY          PlatformNotify;
+  ///
+  /// The notification from the PCI bus enumerator to the platform for each PCI 
+  /// controller at several predefined points during PCI controller initialization.
+  /// 
+  EFI_PCI_PLATFORM_PREPROCESS_CONTROLLER PlatformPrepController;
+  /// 
+  /// Retrieves the platform policy regarding enumeration.
+  ///
+  EFI_PCI_PLATFORM_GET_PLATFORM_POLICY   GetPlatformPolicy;
+  ///
+  /// Gets the PCI device's option ROM from a platform-specific location.
+  ///
+  EFI_PCI_PLATFORM_GET_PCI_ROM           GetPciRom;
+};
+
+extern EFI_GUID   gEfiPciPlatformProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PciRootBridgeIo.h b/MdePkg/Include/Protocol/PciRootBridgeIo.h
new file mode 100644
index 000000000000..382dae7b97bd
--- /dev/null
+++ b/MdePkg/Include/Protocol/PciRootBridgeIo.h
@@ -0,0 +1,442 @@
+/** @file
+  PCI Root Bridge I/O protocol as defined in the UEFI 2.0 specification.
+
+  PCI Root Bridge I/O protocol is used by PCI Bus Driver to perform PCI Memory, PCI I/O, 
+  and PCI Configuration cycles on a PCI Root Bridge. It also provides services to perform 
+  defferent types of bus mastering DMA.
+
+  Copyright (c) 2006 - 2011, 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 __PCI_ROOT_BRIDGE_IO_H__
+#define __PCI_ROOT_BRIDGE_IO_H__
+
+#include <Library/BaseLib.h>
+
+#define EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
+  { \
+    0x2f707ebb, 0x4a1a, 0x11d4, {0x9a, 0x38, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+
+///
+/// *******************************************************
+/// EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH
+/// *******************************************************
+///
+typedef enum {
+  EfiPciWidthUint8,
+  EfiPciWidthUint16,
+  EfiPciWidthUint32,
+  EfiPciWidthUint64,
+  EfiPciWidthFifoUint8,
+  EfiPciWidthFifoUint16,
+  EfiPciWidthFifoUint32,
+  EfiPciWidthFifoUint64,
+  EfiPciWidthFillUint8,
+  EfiPciWidthFillUint16,
+  EfiPciWidthFillUint32,
+  EfiPciWidthFillUint64,
+  EfiPciWidthMaximum
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH;
+
+///
+/// *******************************************************
+/// EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION
+/// *******************************************************
+///
+typedef enum {
+  ///
+  /// A read operation from system memory by a bus master that is not capable of producing
+  /// PCI dual address cycles.
+  ///
+  EfiPciOperationBusMasterRead,
+  ///
+  /// A write operation from system memory by a bus master that is not capable of producing
+  /// PCI dual address cycles.
+  ///
+  EfiPciOperationBusMasterWrite,
+  ///
+  /// Provides both read and write access to system memory by both the processor and a bus
+  /// master that is not capable of producing PCI dual address cycles.
+  ///
+  EfiPciOperationBusMasterCommonBuffer,
+  ///
+  /// A read operation from system memory by a bus master that is capable of producing PCI
+  /// dual address cycles.
+  ///
+  EfiPciOperationBusMasterRead64,
+  ///
+  /// A write operation to system memory by a bus master that is capable of producing PCI
+  /// dual address cycles.
+  ///
+  EfiPciOperationBusMasterWrite64,
+  ///
+  /// Provides both read and write access to system memory by both the processor and a bus
+  /// master that is capable of producing PCI dual address cycles.
+  ///
+  EfiPciOperationBusMasterCommonBuffer64,
+  EfiPciOperationMaximum
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION;
+
+#define EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO          0x0001
+#define EFI_PCI_ATTRIBUTE_ISA_IO                      0x0002
+#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO              0x0004
+#define EFI_PCI_ATTRIBUTE_VGA_MEMORY                  0x0008
+#define EFI_PCI_ATTRIBUTE_VGA_IO                      0x0010
+#define EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO              0x0020
+#define EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO            0x0040
+#define EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE        0x0080
+#define EFI_PCI_ATTRIBUTE_MEMORY_CACHED               0x0800
+#define EFI_PCI_ATTRIBUTE_MEMORY_DISABLE              0x1000
+#define EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE          0x8000
+#define EFI_PCI_ATTRIBUTE_ISA_IO_16                   0x10000
+#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO_16           0x20000
+#define EFI_PCI_ATTRIBUTE_VGA_IO_16                   0x40000
+
+#define EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER   (EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE | EFI_PCI_ATTRIBUTE_MEMORY_CACHED | EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE)
+
+#define EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER (~EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER)
+
+#define EFI_PCI_ADDRESS(bus, dev, func, reg) \
+  (UINT64) ( \
+  (((UINTN) bus) << 24) | \
+  (((UINTN) dev) << 16) | \
+  (((UINTN) func) << 8) | \
+  (((UINTN) (reg)) < 256 ? ((UINTN) (reg)) : (UINT64) (LShiftU64 ((UINT64) (reg), 32))))
+
+typedef struct {
+  UINT8   Register;
+  UINT8   Function;
+  UINT8   Device;
+  UINT8   Bus;
+  UINT32  ExtendedRegister;
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS;
+
+/**                                                                 
+  Reads from the I/O space of a PCI Root Bridge. Returns when either the polling exit criteria is
+  satisfied or after a defined duration.
+          
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Width                 Signifies the width of the memory or I/O operations.
+  @param  Address               The base address of the memory or I/O operations.  
+  @param  Mask                  Mask used for the polling criteria.
+  @param  Value                 The comparison value used for the polling exit criteria.
+  @param  Delay                 The number of 100 ns units to poll.
+  @param  Result                Pointer to the last value read from the memory location.
+                                
+  @retval EFI_SUCCESS           The last data returned from the access matched the poll exit criteria.
+  @retval EFI_TIMEOUT           Delay expired before a match occurred.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL           *This,
+  IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN  UINT64                                   Address,
+  IN  UINT64                                   Mask,
+  IN  UINT64                                   Value,
+  IN  UINT64                                   Delay,
+  OUT UINT64                                   *Result
+  );
+
+/**                                                                 
+  Enables a PCI driver to access PCI controller registers in the PCI root bridge memory space.
+          
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Width                 Signifies the width of the memory operations.
+  @param  Address               The base address of the memory operations.                                  
+  @param  Count                 The number of memory operations to perform.
+  @param  Buffer                For read operations, the destination buffer to store the results. For write
+                                operations, the source buffer to write data from.                          
+  
+  @retval EFI_SUCCESS           The data was read from or written to the PCI root bridge.  
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              *This,
+  IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN     UINT64                                   Address,
+  IN     UINTN                                    Count,
+  IN OUT VOID                                     *Buffer
+  );
+
+typedef struct {
+  ///
+  /// Read PCI controller registers in the PCI root bridge memory space.
+  ///
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM  Read;
+  ///
+  /// Write PCI controller registers in the PCI root bridge memory space.
+  ///
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM  Write;
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS;
+
+/**                                                                 
+  Enables a PCI driver to copy one region of PCI root bridge memory space to another region of PCI
+  root bridge memory space.                                                                       
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL instance.
+  @param  Width                 Signifies the width of the memory operations.
+  @param  DestAddress           The destination address of the memory operation.                                
+  @param  SrcAddress            The source address of the memory operation.                                
+  @param  Count                 The number of memory operations to perform.    
+                                
+  @retval EFI_SUCCESS           The data was copied from one memory region to another memory region.  
+  @retval EFI_INVALID_PARAMETER Width is invalid for this PCI root bridge.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              *This,
+  IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN     UINT64                                   DestAddress,
+  IN     UINT64                                   SrcAddress,
+  IN     UINTN                                    Count
+  );
+
+/**                                                                 
+  Provides the PCI controller-specific addresses required to access system memory from a
+  DMA bus master.                                                                        
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Operation             Indicates if the bus master is going to read or write to system memory.
+  @param  HostAddress           The system memory address to map to the PCI controller.
+  @param  NumberOfBytes         On input the number of bytes to map. On output the number of bytes
+                                that were mapped.                                                 
+  @param  DeviceAddress         The resulting map address for the bus master PCI controller to use to
+                                access the hosts HostAddress.                                        
+  @param  Mapping               A resulting value to pass to Unmap().
+                                  
+  @retval EFI_SUCCESS           The range was mapped for the returned NumberOfBytes.
+  @retval EFI_UNSUPPORTED       The HostAddress cannot be mapped as a common buffer.                                
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_DEVICE_ERROR      The system hardware could not map the requested address.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL                *This,
+  IN     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION  Operation,
+  IN     VOID                                       *HostAddress,
+  IN OUT UINTN                                      *NumberOfBytes,
+  OUT    EFI_PHYSICAL_ADDRESS                       *DeviceAddress,
+  OUT    VOID                                       **Mapping
+  );
+
+/**                                                                 
+  Completes the Map() operation and releases any corresponding resources.
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Mapping               The mapping value returned from Map().
+                                  
+  @retval EFI_SUCCESS           The range was unmapped.
+  @retval EFI_INVALID_PARAMETER Mapping is not a value that was returned by Map().
+  @retval EFI_DEVICE_ERROR      The data was not committed to the target system memory.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL           *This,
+  IN  VOID                                     *Mapping
+  );
+
+/**                                                                 
+  Allocates pages that are suitable for an EfiPciOperationBusMasterCommonBuffer or
+  EfiPciOperationBusMasterCommonBuffer64 mapping.                                 
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Type                  This parameter is not used and must be ignored.
+  @param  MemoryType            The type of memory to allocate, EfiBootServicesData or
+                                EfiRuntimeServicesData.                               
+  @param  Pages                 The number of pages to allocate.                                
+  @param  HostAddress           A pointer to store the base system memory address of the
+                                allocated range.                                        
+  @param  Attributes            The requested bit mask of attributes for the allocated range.
+                                  
+  @retval EFI_SUCCESS           The requested memory pages were allocated.
+  @retval EFI_UNSUPPORTED       Attributes is unsupported. The only legal attribute bits are
+                                MEMORY_WRITE_COMBINE and MEMORY_CACHED.                     
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The memory pages could not be allocated.  
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              *This,
+  IN     EFI_ALLOCATE_TYPE                        Type,
+  IN     EFI_MEMORY_TYPE                          MemoryType,
+  IN     UINTN                                    Pages,
+  IN OUT VOID                                     **HostAddress,
+  IN     UINT64                                   Attributes
+  );
+
+/**                                                                 
+  Frees memory that was allocated with AllocateBuffer().
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Pages                 The number of pages to free.                                
+  @param  HostAddress           The base system memory address of the allocated range.                                    
+                                  
+  @retval EFI_SUCCESS           The requested memory pages were freed.
+  @retval EFI_INVALID_PARAMETER The memory range specified by HostAddress and Pages
+                                was not allocated with AllocateBuffer().
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL           *This,
+  IN  UINTN                                    Pages,
+  IN  VOID                                     *HostAddress
+  );
+
+/**                                                                 
+  Flushes all PCI posted write transactions from a PCI host bridge to system memory.
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+                                  
+  @retval EFI_SUCCESS           The PCI posted write transactions were flushed from the PCI host
+                                bridge to system memory.                                        
+  @retval EFI_DEVICE_ERROR      The PCI posted write transactions were not flushed from the PCI
+                                host bridge due to a hardware error.                           
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  *This
+  );
+
+/**                                                                 
+  Gets the attributes that a PCI root bridge supports setting with SetAttributes(), and the
+  attributes that a PCI root bridge is currently using.                                    
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Supports              A pointer to the mask of attributes that this PCI root bridge supports
+                                setting with SetAttributes().                                         
+  @param  Attributes            A pointer to the mask of attributes that this PCI root bridge is currently
+                                using.                                                                      
+                                
+  @retval EFI_SUCCESS           If Supports is not NULL, then the attributes that the PCI root     
+                                bridge supports is returned in Supports. If Attributes is          
+                                not NULL, then the attributes that the PCI root bridge is currently
+                                using is returned in Attributes.                                   
+  @retval EFI_INVALID_PARAMETER Both Supports and Attributes are NULL.
+                                
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL           *This,
+  OUT UINT64                                   *Supports,
+  OUT UINT64                                   *Attributes
+  );
+
+/**                                                                 
+  Sets attributes for a resource range on a PCI root bridge.
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Attributes            The mask of attributes to set.
+  @param  ResourceBase          A pointer to the base address of the resource range to be modified by the
+                                attributes specified by Attributes.
+  @param  ResourceLength        A pointer to the length of the resource range to be modified by the
+                                attributes specified by Attributes.                                                                                                              
+                                
+  @retval EFI_SUCCESS           The set of attributes specified by Attributes for the resource   
+                                range specified by ResourceBase and ResourceLength               
+                                were set on the PCI root bridge, and the actual resource range is
+                                returned in ResuourceBase and ResourceLength.                    
+  @retval EFI_UNSUPPORTED       A bit is set in Attributes that is not supported by the PCI Root
+                                Bridge.                                                         
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to set the attributes on the                              
+                                resource range specified by BaseAddress and Length.        
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                               
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES)(
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL              *This,
+  IN     UINT64                                   Attributes,
+  IN OUT UINT64                                   *ResourceBase,
+  IN OUT UINT64                                   *ResourceLength
+  );
+
+/**                                                                 
+  Retrieves the current resource settings of this PCI root bridge in the form of a set of ACPI 2.0
+  resource descriptors.                                                                           
+            
+  @param  This                  A pointer to the EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.
+  @param  Resources             A pointer to the ACPI 2.0 resource descriptors that describe the current
+                                configuration of this PCI root bridge.                                  
+                                
+  @retval EFI_SUCCESS           The current configuration of this PCI root bridge was returned in
+                                Resources.                                                                                                                       
+  @retval EFI_UNSUPPORTED       The current configuration of this PCI root bridge could not be
+                                retrieved.                                                                          
+                                       
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION)(
+  IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL          *This,
+  OUT VOID                                     **Resources
+  );
+
+///
+/// Provides the basic Memory, I/O, PCI configuration, and DMA interfaces that are 
+/// used to abstract accesses to PCI controllers behind a PCI Root Bridge Controller. 
+///
+struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL {
+  ///
+  /// The EFI_HANDLE of the PCI Host Bridge of which this PCI Root Bridge is a member.
+  ///
+  EFI_HANDLE                                      ParentHandle;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM     PollMem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM     PollIo;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Mem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Io;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Pci;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM        CopyMem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP             Map;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP           Unmap;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER     FreeBuffer;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH           Flush;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES  GetAttributes;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES  SetAttributes;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION   Configuration;
+  
+  ///
+  /// The segment number that this PCI root bridge resides.
+  ///
+  UINT32                                          SegmentNumber;
+};
+
+extern EFI_GUID gEfiPciRootBridgeIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PiPcd.h b/MdePkg/Include/Protocol/PiPcd.h
new file mode 100644
index 000000000000..84d2aa444bd5
--- /dev/null
+++ b/MdePkg/Include/Protocol/PiPcd.h
@@ -0,0 +1,424 @@
+/** @file
+  Platform Configuration Database (PCD) Protocol defined in PI 1.2 Vol3
+
+  A platform database that contains a variety of current platform settings or
+  directives that can be accessed by a driver or application.
+  PI PCD protocol only provide the accessing interfaces for Dynamic-Ex type PCD.
+
+  Callers to this protocol must be at a TPL_APPLICATION task priority level.
+  This is the base PCD service API that provides an abstraction for accessing configuration content in
+  the platform. It a seamless mechanism for extracting information regardless of where the
+  information is stored (such as in Read-only data, or an EFI Variable).
+  This protocol allows access to data through size-granular APIs and provides a mechanism for a
+  firmware component to monitor specific settings and be alerted when a setting is changed.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  PI Version 1.2 Vol 3.
+**/
+
+#ifndef __PI_PCD_H__
+#define __PI_PCD_H__
+
+extern EFI_GUID gEfiPcdProtocolGuid;
+
+#define EFI_PCD_PROTOCOL_GUID \
+  { 0x13a3f0f6, 0x264a, 0x3ef0, { 0xf2, 0xe0, 0xde, 0xc5, 0x12, 0x34, 0x2f, 0x34 } }
+
+#define EFI_PCD_INVALID_TOKEN_NUMBER ((UINTN) 0)
+
+/**
+  SetSku() sets the SKU Id to be used for subsequent calls to set or get PCD values. SetSku() is
+  normally called only once by the system.
+  For each item (token), the database can hold a single value that applies to all SKUs, or multiple
+  values, where each value is associated with a specific SKU Id. Items with multiple, SKU-specific
+  values are called SKU enabled.
+  The SKU Id of zero is reserved as a default. The valid SkuId range is 1 to 255. For tokens that are
+  not SKU enabled, the system ignores any set SKU Id and works with the single value for that token.
+  For SKU-enabled tokens, the system will use the SKU Id set by the last call to SetSku(). If no SKU
+  Id is set or the currently set SKU Id isn't valid for the specified token, the system uses the default
+  SKU Id. If the system attempts to use the default SKU Id and no value has been set for that Id, the
+  results are unpredictable.
+
+  @param[in]  SkuId   The SKU value to set.
+**/
+typedef
+VOID
+(EFIAPI *EFI_PCD_PROTOCOL_SET_SKU)(
+  IN UINTN SkuId
+);
+
+/**
+  Retrieves an 8-bit value for a given PCD token.
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return 8-bit value for a given PCD token.
+**/
+typedef
+UINT8
+(EFIAPI *EFI_PCD_PROTOCOL_GET_8)(
+  IN CONST EFI_GUID   *Guid,
+  IN       UINTN      TokenNumber
+);
+
+/**
+  Retrieves the current word-sized value for a PCD token number.
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return word-sized value for a given PCD token.
+**/
+typedef
+UINT16
+(EFIAPI *EFI_PCD_PROTOCOL_GET_16)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current 32-bit sized value for a PCD token number.
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return 32-bit value for a given PCD token.
+**/
+typedef
+UINT32
+(EFIAPI *EFI_PCD_PROTOCOL_GET_32)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the 64-bit sized value for a PCD token number.
+  If the TokenNumber is invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return 64-bit value for a given PCD token.
+
+**/
+typedef
+UINT64
+(EFIAPI *EFI_PCD_PROTOCOL_GET_64)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current pointer to the value for a PCD token number. Do not make any assumptions
+  about the alignment of the pointer that is returned by this function call. If the TokenNumber is
+  invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return pointer to a value for a given PCD token.
+**/
+typedef
+VOID *
+(EFIAPI *EFI_PCD_PROTOCOL_GET_POINTER)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current BOOLEAN-sized value for a PCD token number. If the TokenNumber is
+  invalid, the results are unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return Boolean value for a given PCD token.
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_PCD_PROTOCOL_GET_BOOLEAN)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Retrieves the current size of a particular PCD token. If the TokenNumber is invalid, the results are
+  unpredictable.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+
+  @return the size of the value for a given PCD token.
+**/
+typedef
+UINTN
+(EFIAPI *EFI_PCD_PROTOCOL_GET_SIZE)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber
+);
+
+/**
+  Sets an 8-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    Value       The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_8)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT8     Value
+);
+
+/**
+  Sets an 16-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    Value       The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_16)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT16    Value
+);
+
+/**
+  Sets an 32-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    Value       The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_32)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT32    Value
+);
+
+/**
+  Sets an 64-bit value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    Value       The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_64)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        UINT64    Value
+);
+
+/**
+  Sets a value of a specified size for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    SizeOfValue The length of the value being set for the PCD token. If too large of a length is
+                            specified, upon return from this function the value of SizeOfValue will
+                            reflect the maximum size for the PCD token.
+  @param[in]    Buffer      A pointer to the buffer containing the value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_POINTER)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN OUT    UINTN     *SizeOfValue,
+  IN        VOID      *Buffer
+);
+
+/**
+  Sets a Boolean value for a given PCD token.
+
+  When the PCD service sets a value, it will check to ensure that the size of the value being set is
+  compatible with the Token's existing definition. If it is not, an error will be returned.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[in]    Value       The value to set for the PCD token.
+
+  @retval   EFI_SUCCESS             The PCD service has set the value requested
+  @retval   EFI_INVALID_PARAMETER   The PCD service determined that the size of the data being set was
+                                    incompatible with a call to this function. Use GetSizeEx() to
+                                    retrieve the size of the target data.
+  @retval   EFI_NOT_FOUND           The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_SET_BOOLEAN)(
+  IN CONST  EFI_GUID  *Guid,
+  IN        UINTN     TokenNumber,
+  IN        BOOLEAN   Value
+);
+
+typedef
+VOID
+(EFIAPI *EFI_PCD_PROTOCOL_CALLBACK)(
+  IN     EFI_GUID *Guid           OPTIONAL,
+  IN     UINTN    CallBackToken,
+  IN OUT VOID     *TokenData,
+  IN     UINTN    TokenDataSize
+);
+
+/**
+  Specifies a function to be called anytime the value of a designated token is changed.
+
+  @param[in]    Guid              The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    CallBackToken     The PCD token number to monitor.
+  @param[in]    CallBackFunction  The function prototype called when the value associated with the CallBackToken is set.
+
+  @retval EFI_SUCCESS     The PCD service has successfully established a call event for the CallBackToken requested.
+  @retval EFI_NOT_FOUND   The PCD service could not find the referenced token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_CALLBACK_ON_SET)(
+  IN CONST  EFI_GUID                  *Guid           OPTIONAL,
+  IN        UINTN                     CallBackToken,
+  IN        EFI_PCD_PROTOCOL_CALLBACK CallBackFunction
+);
+
+/**
+  Cancels a callback function that was set through a previous call to the CallBackOnSet function.
+
+  @param[in]    Guid              The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    CallBackToken     The PCD token number to monitor.
+  @param[in]    CallBackFunction  The function prototype called when the value associated with the CallBackToken is set.
+
+  @retval EFI_SUCCESS     The PCD service has successfully established a call event for the CallBackToken requested.
+  @retval EFI_NOT_FOUND   The PCD service could not find the referenced token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_CANCEL_CALLBACK)(
+  IN CONST  EFI_GUID                  *Guid OPTIONAL,
+  IN        UINTN                     CallBackToken,
+  IN        EFI_PCD_PROTOCOL_CALLBACK CallBackFunction
+);
+
+/**
+  Gets the next valid token number in a given namespace. This is useful since the PCD infrastructure
+  contains a sparse list of token numbers, and one cannot a priori know what token numbers are valid
+  in the database.
+
+  @param[in]    Guid              The 128-bit unique value that designates the namespace from which to retrieve the next token.
+  @param[in]    TokenNumber       A pointer to the PCD token number to use to find the subsequent token number. To
+                                  retrieve the "first" token, have the pointer reference a TokenNumber value of 0.
+  @retval EFI_SUCCESS           The PCD service has retrieved the value requested
+  @retval EFI_NOT_FOUND         The PCD service could not find data from the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_GET_NEXT_TOKEN)(
+  IN CONST  EFI_GUID  *Guid, OPTIONAL
+  IN        UINTN     *TokenNumber
+);
+
+/**
+  Gets the next valid token namespace for a given namespace. This is useful to traverse the valid
+  token namespaces on a platform.
+
+  @param[in, out]   Guid    An indirect pointer to EFI_GUID. On input it designates a known token namespace
+                            from which the search will start. On output, it designates the next valid token
+                            namespace on the platform. If *Guid is NULL, then the GUID of the first token
+                            space of the current platform is returned. If the search cannot locate the next valid
+                            token namespace, an error is returned and the value of *Guid is undefined.
+
+  @retval   EFI_SUCCESS   The PCD service retrieved the value requested.
+  @retval   EFI_NOT_FOUND The PCD service could not find the next valid token namespace.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCD_PROTOCOL_GET_NEXT_TOKEN_SPACE)(
+  IN OUT CONST EFI_GUID **Guid
+);
+
+typedef struct _EFI_PCD_PROTOCOL {
+  EFI_PCD_PROTOCOL_SET_SKU              SetSku;
+  EFI_PCD_PROTOCOL_GET_8                Get8;
+  EFI_PCD_PROTOCOL_GET_16               Get16;
+  EFI_PCD_PROTOCOL_GET_32               Get32;
+  EFI_PCD_PROTOCOL_GET_64               Get64;
+  EFI_PCD_PROTOCOL_GET_POINTER          GetPtr;
+  EFI_PCD_PROTOCOL_GET_BOOLEAN          GetBool;
+  EFI_PCD_PROTOCOL_GET_SIZE             GetSize;
+  EFI_PCD_PROTOCOL_SET_8                Set8;
+  EFI_PCD_PROTOCOL_SET_16               Set16;
+  EFI_PCD_PROTOCOL_SET_32               Set32;
+  EFI_PCD_PROTOCOL_SET_64               Set64;
+  EFI_PCD_PROTOCOL_SET_POINTER          SetPtr;
+  EFI_PCD_PROTOCOL_SET_BOOLEAN          SetBool;
+  EFI_PCD_PROTOCOL_CALLBACK_ON_SET      CallbackOnSet;
+  EFI_PCD_PROTOCOL_CANCEL_CALLBACK      CancelCallback;
+  EFI_PCD_PROTOCOL_GET_NEXT_TOKEN       GetNextToken;
+  EFI_PCD_PROTOCOL_GET_NEXT_TOKEN_SPACE GetNextTokenSpace;
+} EFI_PCD_PROTOCOL;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PiPcdInfo.h b/MdePkg/Include/Protocol/PiPcdInfo.h
new file mode 100644
index 000000000000..1b39f0de520a
--- /dev/null
+++ b/MdePkg/Include/Protocol/PiPcdInfo.h
@@ -0,0 +1,83 @@
+/** @file
+  Platform Configuration Database (PCD) Info Protocol defined in PI 1.2.1 Vol3.
+
+  The protocol that provides additional information about items that reside in the PCD database.
+
+  Copyright (c) 2013, 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.
+
+  @par Revision Reference:
+  PI Version 1.2.1 Vol 3.
+**/
+
+#ifndef __PI_PCD_INFO_H__
+#define __PI_PCD_INFO_H__
+
+extern EFI_GUID gEfiGetPcdInfoProtocolGuid;
+
+#define EFI_GET_PCD_INFO_PROTOCOL_GUID \
+  { 0xfd0f4478,  0xefd, 0x461d, { 0xba, 0x2d, 0xe5, 0x8c, 0x45, 0xfd, 0x5f, 0x5e } }
+
+///
+/// The forward declaration for EFI_GET_PCD_INFO_PROTOCOL.
+///
+typedef struct _EFI_GET_PCD_INFO_PROTOCOL  EFI_GET_PCD_INFO_PROTOCOL;
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+
+  @retval  EFI_SUCCESS      The PCD information was returned successfully
+  @retval  EFI_NOT_FOUND    The PCD service could not find the requested token number.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_PCD_INFO_PROTOCOL_GET_INFO) (
+  IN CONST  EFI_GUID        *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       EFI_PCD_INFO    *PcdInfo
+);
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+typedef
+UINTN
+(EFIAPI *EFI_GET_PCD_INFO_PROTOCOL_GET_SKU) (
+  VOID
+);
+
+///
+/// Callers to this protocol must be at a TPL_APPLICATION task priority level.
+/// This is the PCD service to use when querying for some additional data that can be contained in the
+/// PCD database.
+///
+struct _EFI_GET_PCD_INFO_PROTOCOL {
+  ///
+  /// Retrieve additional information associated with a PCD.
+  ///
+  EFI_GET_PCD_INFO_PROTOCOL_GET_INFO    GetInfo;
+  ///
+  /// Retrieve the currently set SKU Id.
+  ///
+  EFI_GET_PCD_INFO_PROTOCOL_GET_SKU     GetSku;
+};
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Pkcs7Verify.h b/MdePkg/Include/Protocol/Pkcs7Verify.h
new file mode 100644
index 000000000000..267cbc81fa13
--- /dev/null
+++ b/MdePkg/Include/Protocol/Pkcs7Verify.h
@@ -0,0 +1,221 @@
+/** @file
+  EFI_PKCS7_VERIFY_PROTOCOL as defined in UEFI 2.5.
+  The EFI_PKCS7_VERIFY_PROTOCOL is used to verify data signed using PKCS#7
+  formatted authentication. The PKCS#7 data to be verified must be binary
+  DER encoded.
+  PKCS#7 is a general-purpose cryptographic standard (defined by RFC2315,
+  available at http://tools.ietf.org/html/rfc2315).
+
+Copyright (c) 2015, 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_PKCS7_VERIFY_PROTOCOL_H__
+#define __EFI_PKCS7_VERIFY_PROTOCOL_H__
+
+#include <Guid/ImageAuthentication.h>
+
+///
+/// Global ID for the PKCS7 Verification Protocol
+///
+#define EFI_PKCS7_VERIFY_PROTOCOL_GUID \
+  { \
+    0x47889fb2, 0xd671, 0x4fab, {0xa0, 0xca, 0xdf, 0x0e, 0x44, 0xdf, 0x70, 0xd6 } \
+  }
+
+typedef struct _EFI_PKCS7_VERIFY_PROTOCOL EFI_PKCS7_VERIFY_PROTOCOL;
+
+
+/**
+  Processes a buffer containing binary DER-encoded PKCS7 signature.
+  The signed data content may be embedded within the buffer or separated. Funtion
+  verifies the signature of the content is valid and signing certificate was not
+  revoked and is contained within a list of trusted signers.
+
+  @param[in]     This                 Pointer to EFI_PKCS7_VERIFY_PROTOCOL instance.
+  @param[in]     SignedData           Points to buffer containing ASN.1 DER-encoded PKCS7
+                                      signature.
+  @param[in]     SignedDataSize       The size of SignedData buffer in bytes.
+  @param[in]     InData               In case of detached signature, InData points to
+                                      buffer containing the raw message data previously
+                                      signed and to be verified by function. In case of
+                                      SignedData containing embedded data, InData must be
+                                      NULL.
+  @param[in]     InDataSize           When InData is used, the size of InData buffer in
+                                      bytes. When InData is NULL. This parameter must be
+                                      0.
+  @param[in]     AllowedDb            Pointer to a list of pointers to EFI_SIGNATURE_LIST
+                                      structures. The list is terminated by a null
+                                      pointer. The EFI_SIGNATURE_LIST structures contain
+                                      lists of X.509 certificates of approved signers.
+                                      Function recognizes signer certificates of type
+                                      EFI_CERT_X509_GUID. Any hash certificate in AllowedDb
+                                      list is ignored by this function. Function returns
+                                      success if signer of the buffer is within this list
+                                      (and not within RevokedDb). This parameter is
+                                      required.
+  @param[in]     RevokedDb            Optional pointer to a list of pointers to
+                                      EFI_SIGNATURE_LIST structures. The list is terminated
+                                      by a null pointer. List of X.509 certificates of
+                                      revoked signers and revoked file hashes. Except as
+                                      noted in description of TimeStampDb signature
+                                      verification will always fail if the signer of the
+                                      file or the hash of the data component of the buffer
+                                      is in RevokedDb list. This list is optional and
+                                      caller may pass Null or pointer to NULL if not
+                                      required.
+  @param[in]     TimeStampDb          Optional pointer to a list of pointers to
+                                      EFI_SIGNATURE_LIST structures. The list is terminated
+                                      by a null pointer. This parameter can be used to pass
+                                      a list of X.509 certificates of trusted time stamp
+                                      signers. This list is optional and caller must pass
+                                      Null or pointer to NULL if not required.
+  @param[out]    Content              On input, points to an optional caller-allocated
+                                      buffer into which the function will copy the content
+                                      portion of the file after verification succeeds.
+                                      This parameter is optional and if NULL, no copy of
+                                      content from file is performed.
+  @param[in,out] ContentSize          On input, points to the size in bytes of the optional
+                                      buffer Content previously allocated by caller. On
+                                      output, if the verification succeeds, the value
+                                      referenced by ContentSize will contain the actual
+                                      size of the content from signed file. If ContentSize
+                                      indicates the caller-allocated buffer is too small
+                                      to contain content, an error is returned, and
+                                      ContentSize will be updated with the required size.
+                                      This parameter must be 0 if Content is Null.
+
+  @retval EFI_SUCCESS                 Content signature was verified against hash of
+                                      content, the signer's certificate was not found in
+                                      RevokedDb, and was found in AllowedDb or if in signer
+                                      is found in both AllowedDb and RevokedDb, the
+                                      signing was allowed by reference to TimeStampDb as
+                                      described above, and no hash matching content hash
+                                      was found in RevokedDb.
+  @retval EFI_SECURITY_VIOLATION      The SignedData buffer was correctly formatted but
+                                      signer was in RevokedDb or not in AllowedDb. Also
+                                      returned if matching content hash found in RevokedDb.
+  @retval EFI_COMPROMISED_DATA        Calculated hash differs from signed hash.
+  @retval EFI_INVALID_PARAMETER       SignedData is NULL or SignedDataSize is zero.
+                                      AllowedDb is NULL.
+  @retval EFI_INVALID_PARAMETER       Content is not NULL and ContentSize is NULL.
+  @retval EFI_ABORTED                 Unsupported or invalid format in TimeStampDb,
+                                      RevokedDb or AllowedDb list contents was detected.
+  @retval EFI_NOT_FOUND               Content not found because InData is NULL and no
+                                      content embedded in SignedData.
+  @retval EFI_UNSUPPORTED             The SignedData buffer was not correctly formatted
+                                      for processing by the function.
+  @retval EFI_UNSUPPORTED             Signed data embedded in SignedData but InData is not
+                                      NULL.
+  @retval EFI_BUFFER_TOO_SMALL        The size of buffer indicated by ContentSize is too
+                                      small to hold the content. ContentSize updated to
+                                      required size.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PKCS7_VERIFY_BUFFER) (
+  IN EFI_PKCS7_VERIFY_PROTOCOL    *This,
+  IN VOID                         *SignedData,
+  IN UINTN                        SignedDataSize,
+  IN VOID                         *InData          OPTIONAL,
+  IN UINTN                        InDataSize,
+  IN EFI_SIGNATURE_LIST           **AllowedDb,
+  IN EFI_SIGNATURE_LIST           **RevokedDb      OPTIONAL,
+  IN EFI_SIGNATURE_LIST           **TimeStampDb    OPTIONAL,
+  OUT VOID                        *Content         OPTIONAL,
+  IN OUT UINTN                    *ContentSize
+  );
+
+/**
+  Processes a buffer containing binary DER-encoded detached PKCS7 signature.
+  The hash of the signed data content is calculated and passed by the caller. Function
+  verifies the signature of the content is valid and signing certificate was not revoked
+  and is contained within a list of trusted signers.
+
+  @param[in]     This                 Pointer to EFI_PKCS7_VERIFY_PROTOCOL instance.
+  @param[in]     Signature            Points to buffer containing ASN.1 DER-encoded PKCS
+                                      detached signature.
+  @param[in]     SignatureSize        The size of Signature buffer in bytes.
+  @param[in]     InHash               InHash points to buffer containing the caller
+                                      calculated hash of the data. The parameter may not
+                                      be NULL.
+  @param[in]     InHashSize           The size in bytes of InHash buffer.
+  @param[in]     AllowedDb            Pointer to a list of pointers to EFI_SIGNATURE_LIST
+                                      structures. The list is terminated by a null
+                                      pointer. The EFI_SIGNATURE_LIST structures contain
+                                      lists of X.509 certificates of approved signers.
+                                      Function recognizes signer certificates of type
+                                      EFI_CERT_X509_GUID. Any hash certificate in AllowedDb
+                                      list is ignored by this function. Function returns
+                                      success if signer of the buffer is within this list
+                                      (and not within RevokedDb). This parameter is
+                                      required.
+  @param[in]     RevokedDb            Optional pointer to a list of pointers to
+                                      EFI_SIGNATURE_LIST structures. The list is terminated
+                                      by a null pointer. List of X.509 certificates of
+                                      revoked signers and revoked file hashes. Signature
+                                      verification will always fail if the signer of the
+                                      file or the hash of the data component of the buffer
+                                      is in RevokedDb list. This parameter is optional
+                                      and caller may pass Null if not required.
+  @param[in]     TimeStampDb          Optional pointer to a list of pointers to
+                                      EFI_SIGNATURE_LIST structures. The list is terminated
+                                      by a null pointer. This parameter can be used to pass
+                                      a list of X.509 certificates of trusted time stamp
+                                      counter-signers.
+
+  @retval EFI_SUCCESS                 Signed hash was verified against caller-provided
+                                      hash of content, the signer's certificate was not
+                                      found in RevokedDb, and was found in AllowedDb or
+                                      if in signer is found in both AllowedDb and
+                                      RevokedDb, the signing was allowed by reference to
+                                      TimeStampDb as described above, and no hash matching
+                                      content hash was found in RevokedDb.
+  @retval EFI_SECURITY_VIOLATION      The SignedData buffer was correctly formatted but
+                                      signer was in RevokedDb or not in AllowedDb. Also
+                                      returned if matching content hash found in RevokedDb.
+  @retval EFI_COMPROMISED_DATA        Caller provided hash differs from signed hash. Or,
+                                      caller and encrypted hash are different sizes.
+  @retval EFI_INVALID_PARAMETER       Signature is NULL or SignatureSize is zero. InHash
+                                      is NULL or InHashSize is zero. AllowedDb is NULL.
+  @retval EFI_ABORTED                 Unsupported or invalid format in TimeStampDb,
+                                      RevokedDb or AllowedDb list contents was detected.
+  @retval EFI_UNSUPPORTED             The Signature buffer was not correctly formatted
+                                      for processing by the function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PKCS7_VERIFY_SIGNATURE) (
+  IN EFI_PKCS7_VERIFY_PROTOCOL   *This,
+  IN VOID                        *Signature,
+  IN UINTN                       SignatureSize,
+  IN VOID                        *InHash,
+  IN UINTN                       InHashSize,
+  IN EFI_SIGNATURE_LIST          **AllowedDb,
+  IN EFI_SIGNATURE_LIST          **RevokedDb       OPTIONAL,
+  IN EFI_SIGNATURE_LIST          **TimeStampDb     OPTIONAL
+  );
+
+///
+/// The EFI_PKCS7_VERIFY_PROTOCOL is used to verify data signed using PKCS7
+/// structure. The PKCS7 data to be verified must be ASN.1 (DER) encoded.
+/// SHA256 must be supported as digest algorithm with RSA digest encryption.
+/// Support of other hash algorithms is optional.
+///
+struct _EFI_PKCS7_VERIFY_PROTOCOL {
+  EFI_PKCS7_VERIFY_BUFFER         VerifyBuffer;
+  EFI_PKCS7_VERIFY_SIGNATURE      VerifySignature;
+};
+
+extern EFI_GUID gEfiPkcs7VerifyProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PlatformDriverOverride.h b/MdePkg/Include/Protocol/PlatformDriverOverride.h
new file mode 100644
index 000000000000..c84d12d1f02f
--- /dev/null
+++ b/MdePkg/Include/Protocol/PlatformDriverOverride.h
@@ -0,0 +1,140 @@
+/** @file
+  Platform Driver Override protocol as defined in the UEFI 2.1 specification.
+
+  Copyright (c) 2006 - 2011, 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 __EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_H__
+#define __EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_H__
+
+///
+/// Global ID for the Platform Driver Override Protocol
+///
+#define EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL_GUID \
+  { \
+    0x6b30c738, 0xa391, 0x11d4, {0x9a, 0x3b, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL  EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL;
+
+//
+// Prototypes for the Platform Driver Override Protocol
+//
+
+/**                                                                 
+  Retrieves the image handle of the platform override driver for a controller in the system.
+    
+  @param  This                  A pointer to the EFI_PLATFORM_DRIVER_OVERRIDE_
+                                PROTOCOL instance.                            
+  @param  ControllerHandle      The device handle of the controller to check if a driver override
+                                exists.                                                          
+  @param  DriverImageHandle     On input, a pointer to the previous driver image handle returned
+                                by GetDriver(). On output, a pointer to the next driver         
+                                image handle.                                                   
+                                
+  @retval EFI_SUCCESS           The driver override for ControllerHandle was returned in
+                                DriverImageHandle.                                      
+  @retval EFI_NOT_FOUND         A driver override for ControllerHandle was not found.
+  @retval EFI_INVALID_PARAMETER The handle specified by ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER DriverImageHandle is not a handle that was returned on a
+                                previous call to GetDriver().                           
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER)(
+  IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL              *This,
+  IN     EFI_HANDLE                                     ControllerHandle,
+  IN OUT EFI_HANDLE                                     *DriverImageHandle
+  );
+
+/**                                                                 
+  Retrieves the device path of the platform override driver for a controller in the system.
+    
+  @param  This                  A pointer to the EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL instance.
+  @param  ControllerHandle      The device handle of the controller to check if a driver override
+                                exists.                                                          
+  @param  DriverImagePath       On input, a pointer to the previous driver device path returned by
+                                GetDriverPath(). On output, a pointer to the next driver
+                                device path. Passing in a pointer to NULL will return the first
+                                driver device path for ControllerHandle.
+                                
+  @retval EFI_SUCCESS           The driver override for ControllerHandle was returned in
+                                DriverImageHandle.                                      
+  @retval EFI_UNSUPPORTED       The operation is not supported.                                
+  @retval EFI_NOT_FOUND         A driver override for ControllerHandle was not found.
+  @retval EFI_INVALID_PARAMETER The handle specified by ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER DriverImagePath is not a device path that was returned on a
+                                previous call to GetDriverPath().                          
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH)(
+  IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL              *This,
+  IN     EFI_HANDLE                                     ControllerHandle,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL                       **DriverImagePath
+  );
+
+/**                                                                 
+  Used to associate a driver image handle with a device path that was returned on a prior call to the
+  GetDriverPath() service. This driver image handle will then be available through the               
+  GetDriver() service.                                                                               
+    
+  @param  This                  A pointer to the EFI_PLATFORM_DRIVER_OVERRIDE_
+                                PROTOCOL instance.                            
+  @param  ControllerHandle      The device handle of the controller.                                                             
+  @param  DriverImagePath       A pointer to the driver device path that was returned in a prior
+                                call to GetDriverPath().                                                                        
+  @param  DriverImageHandle     The driver image handle that was returned by LoadImage()
+                                when the driver specified by DriverImagePath was loaded 
+                                into memory.                                            
+                                
+  @retval EFI_SUCCESS           The association between DriverImagePath and                   
+                                DriverImageHandle was established for the controller specified
+                                by ControllerHandle.                                                                            
+  @retval EFI_UNSUPPORTED       The operation is not supported.                                
+  @retval EFI_NOT_FOUND         DriverImagePath is not a device path that was returned on a prior
+                                call to GetDriverPath() for the controller specified by          
+                                ControllerHandle.                                                
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+  @retval EFI_INVALID_PARAMETER DriverImagePath is not a valid device path.
+  @retval EFI_INVALID_PARAMETER DriverImageHandle is not a valid image handle.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED)(
+  IN EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL          *This,
+  IN EFI_HANDLE                                     ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL                       *DriverImagePath,
+  IN EFI_HANDLE                                     DriverImageHandle
+  );
+
+///
+/// This protocol matches one or more drivers to a controller. A platform driver 
+/// produces this protocol, and it is installed on a separate handle. This protocol 
+/// is used by the ConnectController() boot service to select the best driver 
+/// for a controller. All of the drivers returned by this protocol have a higher 
+/// precedence than drivers found from an EFI Bus Specific Driver Override Protocol 
+/// or drivers found from the general UEFI driver Binding search algorithm. If more 
+/// than one driver is returned by this protocol, then the drivers are returned in 
+/// order from highest precedence to lowest precedence.
+///
+struct _EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL {
+  EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER       GetDriver;
+  EFI_PLATFORM_DRIVER_OVERRIDE_GET_DRIVER_PATH  GetDriverPath;
+  EFI_PLATFORM_DRIVER_OVERRIDE_DRIVER_LOADED    DriverLoaded;
+};
+
+extern EFI_GUID gEfiPlatformDriverOverrideProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PlatformToDriverConfiguration.h b/MdePkg/Include/Protocol/PlatformToDriverConfiguration.h
new file mode 100644
index 000000000000..8343cb8beaf9
--- /dev/null
+++ b/MdePkg/Include/Protocol/PlatformToDriverConfiguration.h
@@ -0,0 +1,355 @@
+/** @file
+  UEFI Platform to Driver Configuration Protocol is defined in UEFI specification.
+  
+  This is a protocol that is optionally produced by the platform and optionally consumed 
+  by a UEFI Driver in its Start() function. This protocol allows the driver to receive 
+  configuration information as part of being started.
+
+  Copyright (c) 2006 - 2016, 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 __PLATFORM_TO_DRIVER_CONFIGUARTION_H__
+#define __PLATFORM_TO_DRIVER_CONFIGUARTION_H__
+
+#define EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL_GUID  \
+  { 0x642cd590, 0x8059, 0x4c0a, { 0xa9, 0x58, 0xc5, 0xec, 0x7, 0xd2, 0x3c, 0x4b } }
+
+
+typedef struct _EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL;
+
+
+/**
+  The UEFI driver must call Query early in the Start() function
+  before any time consuming operations are performed. If
+  ChildHandle is NULL the driver is requesting information from
+  the platform about the ControllerHandle that is being started.
+  Information returned from Query may lead to the drivers Start()
+  function failing.
+  If the UEFI driver is a bus driver and producing a ChildHandle,
+  the driver must call Query after the child handle has been created
+  and an EFI_DEVICE_PATH_PROTOCOL has been placed on that handle,
+  but before any time consuming operation is performed. If information
+  return by Query may lead the driver to decide to not create the
+  ChildHandle. The driver must then cleanup and remove the ChildHandle
+  from the system.
+  The UEFI driver repeatedly calls Query, processes the information
+  returned by the platform, and calls Response passing in the
+  arguments returned from Query. The Instance value passed into
+  Response must be the same value passed into the corresponding
+  call to Query. The UEFI driver must continuously call Query and
+  Response until EFI_NOT_FOUND is returned by Query.
+  If the UEFI driver does not recognize the ParameterTypeGuid, it
+  calls Response with a ConfigurationAction of
+  EfiPlatformConfigurationActionUnsupportedGuid. The UEFI driver
+  must then continue calling Query and Response until EFI_NOT_FOUND
+  is returned by Query. This gives the platform an opportunity to
+  pass additional configuration settings using a different
+  ParameterTypeGuid that may be supported by the driver.
+  An Instance value of zero means return the first ParameterBlock
+  in the set of unprocessed parameter blocks. The driver should
+  increment the Instance value by one for each successive call to Query.
+
+  @param This                 A pointer to the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL instance.
+  
+  @param ControllerHandle     The handle the platform will return
+                              configuration information about.
+  
+  @param ChildHandle          The handle of the child controller to
+                              return information on. This is an optional
+                              parameter that may be NULL. It will be
+                              NULL for device drivers and for bus
+                              drivers that attempt to get options for
+                              the bus controller. It will not be NULL
+                              for a bus driver that attempts to get
+                              options for one of its child controllers.
+  
+  
+  @param Instance             Pointer to the Instance value. Zero means
+                              return the first query data. The caller should
+                              increment this value by one each time to retrieve
+                              successive data.
+
+  @param ParameterTypeGuid    An EFI_GUID that defines the contents
+                              of ParameterBlock. UEFI drivers must
+                              use the ParameterTypeGuid to determine
+                              how to parse the ParameterBlock. The caller
+                              should not attempt to free ParameterTypeGuid.
+
+  @param ParameterBlock       The platform returns a pointer to the
+                              ParameterBlock structure which
+                              contains details about the
+                              configuration parameters specific to
+                              the ParameterTypeGuid. This structure
+                              is defined based on the protocol and
+                              may be different for different
+                              protocols. UEFI driver decodes this
+                              structure and its contents based on
+                              ParameterTypeGuid. ParameterBlock is
+                              allocated by the platform and the
+                              platform is responsible for freeing
+                              the ParameterBlock after Result is
+                              called.
+
+  @param ParameterBlockSize   The platform returns the size of
+                              the ParameterBlock in bytes.
+
+
+  @retval EFI_SUCCESS           The platform return parameter
+                                information for ControllerHandle.
+
+  @retval EFI_NOT_FOUND         No more unread Instance exists.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER Instance is NULL.
+
+  @retval EFI_DEVICE_ERROR      A device error occurred while
+                                attempting to return parameter block
+                                information for the controller
+                                specified by ControllerHandle and
+                                ChildHandle.
+
+  @retval EFI_OUT_RESOURCES     There are not enough resources
+                                available to set the configuration
+                                options for the controller specified
+                                by ControllerHandle and ChildHandle.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PLATFORM_TO_DRIVER_CONFIGURATION_QUERY)(
+  IN CONST  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL *This,
+  IN CONST  EFI_HANDLE  ControllerHandle,
+  IN CONST  EFI_HANDLE  ChildHandle OPTIONAL,
+  IN CONST  UINTN       *Instance,
+  OUT       EFI_GUID    **ParameterTypeGuid,
+  OUT       VOID        **ParameterBlock,
+  OUT       UINTN       *ParameterBlockSize
+);
+
+typedef enum {
+  ///
+  ///  The controller specified by ControllerHandle is still
+  ///  in a usable state, and its configuration has been updated
+  ///  via parsing the ParameterBlock. If required by the
+  ///  parameter block, and the module supports an NVRAM store,
+  ///  the configuration information from PB was successfully
+  ///  saved to the NVRAM. No actions are required before
+  ///  this controller can be used again with the updated
+  ///  configuration settings.
+  ///
+  EfiPlatformConfigurationActionNone              = 0,
+  
+  ///
+  ///  The driver has detected that the controller specified
+  ///  by ControllerHandle is not in a usable state and 
+  ///  needs to be stopped. The calling agent can use the
+  ///  DisconnectControservice to perform this operation, and
+  ///  it should be performed as soon as possible.  
+  ///
+  EfiPlatformConfigurationActionStopController    = 1,
+  
+  ///
+  ///  This controller specified by ControllerHandle needs to
+  ///  be stopped and restarted before it can be used again.
+  ///  The calling agent can use the DisconnectController()
+  ///  and ConnectController() services to perform this
+  ///  operation. The restart operation can be delayed until
+  ///  all of the configuration options have been set.  
+  ///
+  EfiPlatformConfigurationActionRestartController = 2,
+  
+  ///
+  ///  A configuration change has been made that requires the
+  ///  platform to be restarted before the controller
+  ///  specified by ControllerHandle can be used again. The
+  ///  calling agent can use the ResetSystem() services to
+  ///  perform this operation. The restart operation can be
+  ///  delayed until all of the configuration options have
+  ///  been set.  
+  ///
+  EfiPlatformConfigurationActionRestartPlatform   = 3,
+
+  ///
+  ///  The controller specified by ControllerHandle is still
+  ///  in a usable state; its configuration has been updated
+  ///  via parsing the ParameterBlock. The driver tried to
+  ///  update the driver's private NVRAM store with
+  ///  information from ParameterBlock and failed. No actions
+  ///  are required before this controller can be used again
+  ///  with the updated configuration settings, but these
+  ///  configuration settings are not guaranteed to persist
+  ///  after ControllerHandle is stopped. 
+  /// 
+  EfiPlatformConfigurationActionNvramFailed       = 4,
+
+  ///
+  /// The controller specified by ControllerHandle is still
+  /// in a usable state; its configuration has not been updated
+  /// via parsing the ParameterBlock. The driver did not support
+  /// the ParameterBlock format identified by ParameterTypeGuid.
+  /// No actions are required before this controller can be used
+  /// again. On additional Query calls from this ControllerHandle,
+  /// the platform should stop returning a ParameterBlock
+  /// qualified by this same ParameterTypeGuid. If no other
+  /// ParameterTypeGuid is supported by the platform, Query
+  /// should return EFI_NOT_FOUND.
+  ///
+  EfiPlatformConfigurationActionUnsupportedGuid   = 5,
+  EfiPlatformConfigurationActionMaximum
+} EFI_PLATFORM_CONFIGURATION_ACTION;
+
+
+/**
+  The UEFI driver repeatedly calls Query, processes the
+  information returned by the platform, and calls Response passing
+  in the arguments returned from Query. The UEFI driver must
+  continuously call Query until EFI_NOT_FOUND is returned. For
+  every call to Query that returns EFI_SUCCESS a corrisponding
+  call to Response is required passing in the same
+  ContollerHandle, ChildHandle, Instance, ParameterTypeGuid,
+  ParameterBlock, and ParameterBlockSize. The UEFI driver may
+  update values in ParameterBlock based on rules defined by
+  ParameterTypeGuid. The platform is responsible for freeing
+  ParameterBlock and the UEFI driver must not try to free it.
+
+  @param This                A pointer to the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL instance.
+
+  @param ControllerHandle    The handle the driver is returning
+                             configuration information about.
+
+  @param ChildHandle         The handle of the child controller to
+                             return information on. This is an optional
+                             parameter that may be NULL. It will be
+                             NULL for device drivers, and for bus
+                             drivers that attempt to get options for
+                             the bus controller. It will not be NULL
+                             for a bus driver that attempts to get
+                             options for one of its child controllers.
+                             Instance Instance data returned from
+                             Query().
+
+  @param Instance            Instance data passed to Query().
+
+  @param ParameterTypeGuid   ParameterTypeGuid returned from Query.
+
+  @param ParameterBlock      ParameterBlock returned from Query.
+
+  @param ParameterBlockSize  The ParameterBlock size returned from Query.
+
+  @param ConfigurationAction The driver tells the platform what
+                             action is required for ParameterBlock to
+                             take effect.
+  
+  
+  @retval EFI_SUCCESS           The platform return parameter information
+                                for ControllerHandle.
+  
+  @retval EFI_NOT_FOUND         Instance was not found.
+  
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+ 
+  @retval EFI_INVALID_PARAMETER Instance is zero.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PLATFORM_TO_DRIVER_CONFIGURATION_RESPONSE)(
+  IN CONST  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL *This,
+  IN CONST  EFI_HANDLE  ControllerHandle,
+  IN CONST  EFI_HANDLE  ChildHandle OPTIONAL,
+  IN CONST  UINTN       *Instance,
+  IN CONST  EFI_GUID    *ParameterTypeGuid,
+  IN CONST  VOID        *ParameterBlock,
+  IN CONST  UINTN       ParameterBlockSize ,
+  IN CONST  EFI_PLATFORM_CONFIGURATION_ACTION ConfigurationAction
+);
+
+
+///
+/// The EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL is used by the
+/// UEFI driver to query the platform for configuration information.
+/// The UEFI driver calls Query() multiple times to get
+/// configuration information from the platform. For every call to
+/// Query() there must be a matching call to Response() so the
+/// UEFI driver can inform the platform how it used the
+/// information passed in from Query(). It's legal for a UEFI
+/// driver to use Response() to inform the platform it does not
+/// understand the data returned via Query() and thus no action was
+/// taken.
+///
+struct _EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL {
+  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_QUERY    Query;
+  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_RESPONSE Response;
+};
+
+
+
+#define EFI_PLATFORM_TO_DRIVER_CONFIGURATION_CLP_GUID   \
+  {0x345ecc0e, 0xcb6, 0x4b75, { 0xbb, 0x57, 0x1b, 0x12, 0x9c, 0x47, 0x33,0x3e } }
+
+/**
+   
+  ParameterTypeGuid provides the support for parameters
+  communicated through the DMTF SM CLP Specification 1.0 Final
+  Standard to be used to configure the UEFI driver. In this
+  section the producer of the
+  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL is platform
+  firmware and the consumer is the UEFI driver. Note: if future
+  versions of the DMTF SM CLP Specification require changes to the
+  parameter block definition, a newer ParameterTypeGuid will be
+  used.
+**/
+typedef struct {
+  CHAR8   *CLPCommand;        ///<  A pointer to the null-terminated UTF-8 string that specifies the DMTF SM CLP command
+                              ///<  line that the driver is required to parse and process when this function is called. 
+                              ///<  See the DMTF SM CLP Specification 1.0 Final Standard for details on the 
+                              ///<  format and syntax of the CLP command line string. CLPCommand buffer
+                              ///<  is allocated by the producer of the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOOL.
+  UINT32  CLPCommandLength;   ///< The length of the CLP Command in bytes.
+  CHAR8   *CLPReturnString;   ///<  A pointer to the null-terminated UTF-8 string that indicates the CLP return status
+                              ///<  that the driver is required to provide to the calling agent.
+                              ///<  The calling agent may parse and/ or pass
+                              ///<  this for processing and user feedback. The SM CLP Command Response string
+                              ///<  buffer is filled in by the UEFI driver in the "keyword=value" format
+                              ///<  described in the SM CLP Specification, unless otherwise requested via the SM
+                              ///<  CLP Coutput option in the Command Line string buffer. UEFI driver's support
+                              ///<  for this default "keyword=value" output format is required if the UEFI
+                              ///<  driver supports this protocol, while support for other SM CLP output
+                              ///<  formats is optional (the UEFI Driver should return an EFI_UNSUPPORTED if
+                              ///<  the SM CLP Coutput option requested by the caller is not supported by the
+                              ///<  UEFI Driver). CLPReturnString buffer is allocated by the consumer of the
+                              ///<  EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOC OL and undefined prior to the call to
+                              ///<  Response().  
+  UINT32  CLPReturnStringLength; ///< The length of the CLP return status string in bytes.
+  UINT8   CLPCmdStatus;       ///<  SM CLP Command Status (see DMTF SM CLP Specification 1.0 Final Standard -
+                              ///<  Table 4) CLPErrorValue SM CLP Processing Error Value (see DMTF SM
+                              ///<  CLP Specification 1.0 Final Standard - Table 6). This field is filled in by
+                              ///<  the consumer of the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOC 
+                              ///<  OL and undefined prior to the call to Response().  
+  UINT8   CLPErrorValue;      ///<  SM CLP Processing Error Value (see DMTF SM CLP Specification 1.0 Final Standard - Table 6).
+                              ///<  This field is filled in by the consumer of the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOCOL and undefined prior to the call to Response().                              
+  UINT16  CLPMsgCode;         ///<  Bit 15: OEM Message Code Flag 0 = Message Code is an SM CLP Probable
+                              ///<  Cause Value. (see SM CLP Specification Table 11) 1 = Message Code is OEM
+                              ///<  Specific Bits 14-0: Message Code This field is filled in by the consumer of
+                              ///<  the EFI_PLATFORM_TO_DRIVER_CONFIGURATION_PROTOC OL and undefined prior to the call to
+                              ///<  Response(). 
+
+} EFI_CONFIGURE_CLP_PARAMETER_BLK;
+
+
+
+extern EFI_GUID gEfiPlatformToDriverConfigurationClpGuid;
+
+extern EFI_GUID gEfiPlatformToDriverConfigurationProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/PxeBaseCode.h b/MdePkg/Include/Protocol/PxeBaseCode.h
new file mode 100644
index 000000000000..497d97204712
--- /dev/null
+++ b/MdePkg/Include/Protocol/PxeBaseCode.h
@@ -0,0 +1,934 @@
+/** @file
+  EFI PXE Base Code Protocol definitions, which is used to access PXE-compatible 
+  devices for network access and network booting.
+
+Copyright (c) 2006 - 2010, 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. 
+
+  @par Revision Reference:          
+  This Protocol is introduced in EFI Specification 1.10.           
+
+**/
+#ifndef __PXE_BASE_CODE_PROTOCOL_H__
+#define __PXE_BASE_CODE_PROTOCOL_H__
+
+///
+/// PXE Base Code protocol.
+///
+#define EFI_PXE_BASE_CODE_PROTOCOL_GUID \
+  { \
+    0x03c4e603, 0xac28, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_PXE_BASE_CODE_PROTOCOL  EFI_PXE_BASE_CODE_PROTOCOL;
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_PXE_BASE_CODE_PROTOCOL  EFI_PXE_BASE_CODE;
+
+///
+/// Default IP TTL and ToS.
+///
+#define DEFAULT_TTL 16
+#define DEFAULT_ToS 0
+
+///
+/// ICMP error format.
+///
+typedef struct {
+  UINT8   Type;
+  UINT8   Code;
+  UINT16  Checksum;
+  union {
+    UINT32  reserved;
+    UINT32  Mtu;
+    UINT32  Pointer;
+    struct {
+      UINT16  Identifier;
+      UINT16  Sequence;
+    } Echo;
+  } u;
+  UINT8 Data[494];
+} EFI_PXE_BASE_CODE_ICMP_ERROR;
+
+///
+/// TFTP error format.
+///
+typedef struct {
+  UINT8 ErrorCode;
+  CHAR8 ErrorString[127];
+} EFI_PXE_BASE_CODE_TFTP_ERROR;
+
+///
+/// IP Receive Filter definitions.
+///
+#define EFI_PXE_BASE_CODE_MAX_IPCNT 8
+
+///
+/// IP Receive Filter structure.
+///
+typedef struct {
+  UINT8           Filters;
+  UINT8           IpCnt;
+  UINT16          reserved;
+  EFI_IP_ADDRESS  IpList[EFI_PXE_BASE_CODE_MAX_IPCNT];
+} EFI_PXE_BASE_CODE_IP_FILTER;
+
+#define EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP            0x0001
+#define EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST             0x0002
+#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS           0x0004
+#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST 0x0008
+
+///
+/// ARP cache entries.
+///
+typedef struct {
+  EFI_IP_ADDRESS  IpAddr;
+  EFI_MAC_ADDRESS MacAddr;
+} EFI_PXE_BASE_CODE_ARP_ENTRY;
+
+///
+/// ARP route table entries.
+///
+typedef struct {
+  EFI_IP_ADDRESS  IpAddr;
+  EFI_IP_ADDRESS  SubnetMask;
+  EFI_IP_ADDRESS  GwAddr;
+} EFI_PXE_BASE_CODE_ROUTE_ENTRY;
+
+//
+// UDP definitions
+//
+typedef UINT16  EFI_PXE_BASE_CODE_UDP_PORT;
+
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP    0x0001
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT  0x0002
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP   0x0004
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT 0x0008
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER    0x0010
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_MAY_FRAGMENT  0x0020
+
+//
+// Discover() definitions
+//
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP         0
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_MS_WINNT_RIS      1
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_INTEL_LCM         2
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_DOSUNDI           3
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_NEC_ESMPRO        4
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_WSoD          5
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_LCCM          6
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_CA_UNICENTER_TNG  7
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_HP_OPENVIEW       8
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_9         9
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_10        10
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_11        11
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_NOT_USED_12       12
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_INSTALL    13
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_BOOT       14
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REMBO             15
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_BEOBOOT           16
+//
+// 17 through 32767 are reserved
+// 32768 through 65279 are for vendor use
+// 65280 through 65534 are reserved
+//
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_PXETEST   65535
+
+#define EFI_PXE_BASE_CODE_BOOT_LAYER_MASK     0x7FFF
+#define EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL  0x0000
+
+//
+// PXE Tag definition that identifies the processor 
+// and programming environment of the client system.
+// These identifiers are defined by IETF:
+// http://www.ietf.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xml
+//
+#if defined (MDE_CPU_IA32)
+#define EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE    0x0006
+#elif defined (MDE_CPU_IPF) 
+#define EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE    0x0002
+#elif defined (MDE_CPU_X64)
+#define EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE    0x0007
+#elif defined (MDE_CPU_ARM)
+#define EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE    0x000A
+#elif defined (MDE_CPU_AARCH64)
+#define EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE    0x000B
+#endif
+
+
+///
+/// Discover() server list structure.
+///
+typedef struct {
+  UINT16          Type;
+  BOOLEAN         AcceptAnyResponse;
+  UINT8           Reserved;
+  EFI_IP_ADDRESS  IpAddr;
+} EFI_PXE_BASE_CODE_SRVLIST;
+
+///
+/// Discover() information override structure.
+///
+typedef struct {
+  BOOLEAN                   UseMCast;
+  BOOLEAN                   UseBCast;
+  BOOLEAN                   UseUCast;
+  BOOLEAN                   MustUseList;
+  EFI_IP_ADDRESS            ServerMCastIp;
+  UINT16                    IpCnt;
+  EFI_PXE_BASE_CODE_SRVLIST SrvList[1];
+} EFI_PXE_BASE_CODE_DISCOVER_INFO;
+
+///
+/// TFTP opcode definitions.
+///
+typedef enum {
+  EFI_PXE_BASE_CODE_TFTP_FIRST,
+  EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
+  EFI_PXE_BASE_CODE_TFTP_READ_FILE,
+  EFI_PXE_BASE_CODE_TFTP_WRITE_FILE,
+  EFI_PXE_BASE_CODE_TFTP_READ_DIRECTORY,
+  EFI_PXE_BASE_CODE_MTFTP_GET_FILE_SIZE,
+  EFI_PXE_BASE_CODE_MTFTP_READ_FILE,
+  EFI_PXE_BASE_CODE_MTFTP_READ_DIRECTORY,
+  EFI_PXE_BASE_CODE_MTFTP_LAST
+} EFI_PXE_BASE_CODE_TFTP_OPCODE;
+
+///
+/// MTFTP information. This information is required
+/// to start or join a multicast TFTP session. It is also required to
+/// perform the "get file size" and "read directory" operations of MTFTP.
+///
+typedef struct {
+  EFI_IP_ADDRESS              MCastIp;
+  EFI_PXE_BASE_CODE_UDP_PORT  CPort;
+  EFI_PXE_BASE_CODE_UDP_PORT  SPort;
+  UINT16                      ListenTimeout;
+  UINT16                      TransmitTimeout;
+} EFI_PXE_BASE_CODE_MTFTP_INFO;
+
+///
+/// DHCPV4 Packet structure.
+///
+typedef struct {
+  UINT8   BootpOpcode;
+  UINT8   BootpHwType;
+  UINT8   BootpHwAddrLen;
+  UINT8   BootpGateHops;
+  UINT32  BootpIdent;
+  UINT16  BootpSeconds;
+  UINT16  BootpFlags;
+  UINT8   BootpCiAddr[4];
+  UINT8   BootpYiAddr[4];
+  UINT8   BootpSiAddr[4];
+  UINT8   BootpGiAddr[4];
+  UINT8   BootpHwAddr[16];
+  UINT8   BootpSrvName[64];
+  UINT8   BootpBootFile[128];
+  UINT32  DhcpMagik;
+  UINT8   DhcpOptions[56];
+} EFI_PXE_BASE_CODE_DHCPV4_PACKET;
+
+///
+/// DHCPV6 Packet structure.
+///
+typedef struct {
+  UINT32  MessageType:8;
+  UINT32  TransactionId:24;
+  UINT8   DhcpOptions[1024];
+} EFI_PXE_BASE_CODE_DHCPV6_PACKET;
+
+///
+/// Packet structure.
+///
+typedef union {
+  UINT8                           Raw[1472];
+  EFI_PXE_BASE_CODE_DHCPV4_PACKET Dhcpv4;
+  EFI_PXE_BASE_CODE_DHCPV6_PACKET Dhcpv6;
+} EFI_PXE_BASE_CODE_PACKET;
+
+//
+// PXE Base Code Mode structure
+//
+#define EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES   8
+#define EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES 8
+
+///
+/// EFI_PXE_BASE_CODE_MODE.
+/// The data values in this structure are read-only and 
+/// are updated by the code that produces the
+/// EFI_PXE_BASE_CODE_PROTOCOL functions.
+///
+typedef struct {
+  BOOLEAN                       Started;
+  BOOLEAN                       Ipv6Available;
+  BOOLEAN                       Ipv6Supported;
+  BOOLEAN                       UsingIpv6;
+  BOOLEAN                       BisSupported;
+  BOOLEAN                       BisDetected;
+  BOOLEAN                       AutoArp;
+  BOOLEAN                       SendGUID;
+  BOOLEAN                       DhcpDiscoverValid;
+  BOOLEAN                       DhcpAckReceived;
+  BOOLEAN                       ProxyOfferReceived;
+  BOOLEAN                       PxeDiscoverValid;
+  BOOLEAN                       PxeReplyReceived;
+  BOOLEAN                       PxeBisReplyReceived;
+  BOOLEAN                       IcmpErrorReceived;
+  BOOLEAN                       TftpErrorReceived;
+  BOOLEAN                       MakeCallbacks;
+  UINT8                         TTL;
+  UINT8                         ToS;
+  EFI_IP_ADDRESS                StationIp;
+  EFI_IP_ADDRESS                SubnetMask;
+  EFI_PXE_BASE_CODE_PACKET      DhcpDiscover;
+  EFI_PXE_BASE_CODE_PACKET      DhcpAck;
+  EFI_PXE_BASE_CODE_PACKET      ProxyOffer;
+  EFI_PXE_BASE_CODE_PACKET      PxeDiscover;
+  EFI_PXE_BASE_CODE_PACKET      PxeReply;
+  EFI_PXE_BASE_CODE_PACKET      PxeBisReply;
+  EFI_PXE_BASE_CODE_IP_FILTER   IpFilter;
+  UINT32                        ArpCacheEntries;
+  EFI_PXE_BASE_CODE_ARP_ENTRY   ArpCache[EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES];
+  UINT32                        RouteTableEntries;
+  EFI_PXE_BASE_CODE_ROUTE_ENTRY RouteTable[EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES];
+  EFI_PXE_BASE_CODE_ICMP_ERROR  IcmpError;
+  EFI_PXE_BASE_CODE_TFTP_ERROR  TftpError;
+} EFI_PXE_BASE_CODE_MODE;
+
+//
+// PXE Base Code Interface Function definitions
+//
+
+/**                                                                 
+  Enables the use of the PXE Base Code Protocol functions.
+
+  This function enables the use of the PXE Base Code Protocol functions. If the
+  Started field of the EFI_PXE_BASE_CODE_MODE structure is already TRUE, then
+  EFI_ALREADY_STARTED will be returned. If UseIpv6 is TRUE, then IPv6 formatted
+  addresses will be used in this session. If UseIpv6 is FALSE, then IPv4 formatted
+  addresses will be used in this session. If UseIpv6 is TRUE, and the Ipv6Supported
+  field of the EFI_PXE_BASE_CODE_MODE structure is FALSE, then EFI_UNSUPPORTED will
+  be returned. If there is not enough memory or other resources to start the PXE
+  Base Code Protocol, then EFI_OUT_OF_RESOURCES will be returned. Otherwise, the
+  PXE Base Code Protocol will be started, and all of the fields of the EFI_PXE_BASE_CODE_MODE
+  structure will be initialized as follows:
+    StartedSet to TRUE.
+    Ipv6SupportedUnchanged.
+    Ipv6AvailableUnchanged.
+    UsingIpv6Set to UseIpv6.
+    BisSupportedUnchanged.
+    BisDetectedUnchanged.
+    AutoArpSet to TRUE.
+    SendGUIDSet to FALSE.
+    TTLSet to DEFAULT_TTL.
+    ToSSet to DEFAULT_ToS.
+    DhcpCompletedSet to FALSE.
+    ProxyOfferReceivedSet to FALSE.
+    StationIpSet to an address of all zeros.
+    SubnetMaskSet to a subnet mask of all zeros.
+    DhcpDiscoverZero-filled.
+    DhcpAckZero-filled.
+    ProxyOfferZero-filled.
+    PxeDiscoverValidSet to FALSE.
+    PxeDiscoverZero-filled.
+    PxeReplyValidSet to FALSE.
+    PxeReplyZero-filled.
+    PxeBisReplyValidSet to FALSE.
+    PxeBisReplyZero-filled.
+    IpFilterSet the Filters field to 0 and the IpCnt field to 0.
+    ArpCacheEntriesSet to 0.
+    ArpCacheZero-filled.
+    RouteTableEntriesSet to 0.
+    RouteTableZero-filled.
+    IcmpErrorReceivedSet to FALSE.
+    IcmpErrorZero-filled.
+    TftpErroReceivedSet to FALSE.
+    TftpErrorZero-filled.
+    MakeCallbacksSet to TRUE if the PXE Base Code Callback Protocol is available.
+    Set to FALSE if the PXE Base Code Callback Protocol is not available.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  UseIpv6               Specifies the type of IP addresses that are to be used during the session
+                                that is being started. Set to TRUE for IPv6 addresses, and FALSE for     
+                                IPv4 addresses.                                                                                                   
+                                
+  @retval EFI_SUCCESS           The PXE Base Code Protocol was started.
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this oper  
+  @retval EFI_UNSUPPORTED       UseIpv6 is TRUE, but the Ipv6Supported field of the
+                                EFI_PXE_BASE_CODE_MODE structure is FALSE.  
+  @retval EFI_ALREADY_STARTED   The PXE Base Code Protocol is already in the started state.                                   
+  @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
+                                EFI_PXE_BASE_CODE_PROTOCOL structure.      
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough memory or other resources to start the                                          
+                                PXE Base Code Protocol.                                         
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_START)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN BOOLEAN                               UseIpv6
+  );
+
+/**                                                                 
+  Disables the use of the PXE Base Code Protocol functions.
+
+  This function stops all activity on the network device. All the resources allocated
+  in Start() are released, the Started field of the EFI_PXE_BASE_CODE_MODE structure is
+  set to FALSE and EFI_SUCCESS is returned. If the Started field of the EFI_PXE_BASE_CODE_MODE
+  structure is already FALSE, then EFI_NOT_STARTED will be returned.
+  
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+ 
+  @retval EFI_SUCCESS           The PXE Base Code Protocol was stopped.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is already in the stopped state.  
+  @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
+                                EFI_PXE_BASE_CODE_PROTOCOL structure.                  
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.                                
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_STOP)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL    *This
+  );
+
+/**                                                                 
+  Attempts to complete a DHCPv4 D.O.R.A. (discover / offer / request / acknowledge) or DHCPv6
+  S.A.R.R (solicit / advertise / request / reply) sequence.
+
+  This function attempts to complete the DHCP sequence. If this sequence is completed,
+  then EFI_SUCCESS is returned, and the DhcpCompleted, ProxyOfferReceived, StationIp,
+  SubnetMask, DhcpDiscover, DhcpAck, and ProxyOffer fields of the EFI_PXE_BASE_CODE_MODE
+  structure are filled in.
+  If SortOffers is TRUE, then the cached DHCP offer packets will be sorted before
+  they are tried. If SortOffers is FALSE, then the cached DHCP offer packets will
+  be tried in the order in which they are received. Please see the Preboot Execution
+  Environment (PXE) Specification for additional details on the implementation of DHCP.
+  This function can take at least 31 seconds to timeout and return control to the
+  caller. If the DHCP sequence does not complete, then EFI_TIMEOUT will be returned.
+  If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
+  then the DHCP sequence will be stopped and EFI_ABORTED will be returned.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  SortOffers            TRUE if the offers received should be sorted. Set to FALSE to try the
+                                offers in the order that they are received.                          
+ 
+  @retval EFI_SUCCESS           Valid DHCP has completed.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
+                                EFI_PXE_BASE_CODE_PROTOCOL structure.                  
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.                                
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough memory to complete the DHCP Protocol.
+  @retval EFI_ABORTED           The callback function aborted the DHCP Protocol.
+  @retval EFI_TIMEOUT           The DHCP Protocol timed out.
+  @retval EFI_ICMP_ERROR        An ICMP error packet was received during the DHCP session.
+  @retval EFI_NO_RESPONSE       Valid PXE offer was not received.
+                                     
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_DHCP)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN BOOLEAN                               SortOffers
+  );
+
+/**                                                                 
+  Attempts to complete the PXE Boot Server and/or boot image discovery sequence.
+
+  This function attempts to complete the PXE Boot Server and/or boot image discovery
+  sequence. If this sequence is completed, then EFI_SUCCESS is returned, and the
+  PxeDiscoverValid, PxeDiscover, PxeReplyReceived, and PxeReply fields of the
+  EFI_PXE_BASE_CODE_MODE structure are filled in. If UseBis is TRUE, then the
+  PxeBisReplyReceived and PxeBisReply fields of the EFI_PXE_BASE_CODE_MODE structure
+  will also be filled in. If UseBis is FALSE, then PxeBisReplyValid will be set to FALSE.
+  In the structure referenced by parameter Info, the PXE Boot Server list, SrvList[],
+  has two uses: It is the Boot Server IP address list used for unicast discovery
+  (if the UseUCast field is TRUE), and it is the list used for Boot Server verification
+  (if the MustUseList field is TRUE). Also, if the MustUseList field in that structure
+  is TRUE and the AcceptAnyResponse field in the SrvList[] array is TRUE, any Boot
+  Server reply of that type will be accepted. If the AcceptAnyResponse field is
+  FALSE, only responses from Boot Servers with matching IP addresses will be accepted.
+  This function can take at least 10 seconds to timeout and return control to the
+  caller. If the Discovery sequence does not complete, then EFI_TIMEOUT will be
+  returned. Please see the Preboot Execution Environment (PXE) Specification for
+  additional details on the implementation of the Discovery sequence.
+  If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
+  then the Discovery sequence is stopped and EFI_ABORTED will be returned.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  Type                  The type of bootstrap to perform.
+  @param  Layer                 The pointer to the boot server layer number to discover, which must be
+                                PXE_BOOT_LAYER_INITIAL when a new server type is being            
+                                discovered.                                                       
+  @param  UseBis                TRUE if Boot Integrity Services are to be used. FALSE otherwise.                                
+  @param  Info                  The pointer to a data structure that contains additional information on the
+                                type of discovery operation that is to be performed.                   
+                                  
+  @retval EFI_SUCCESS           The Discovery sequence has been completed.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.                                
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough memory to complete Discovery.
+  @retval EFI_ABORTED           The callback function aborted the Discovery sequence.
+  @retval EFI_TIMEOUT           The Discovery sequence timed out.
+  @retval EFI_ICMP_ERROR        An ICMP error packet was received during the PXE discovery
+                                session.                                                  
+                                       
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_DISCOVER)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL           *This,
+  IN UINT16                               Type,
+  IN UINT16                               *Layer,
+  IN BOOLEAN                              UseBis,
+  IN EFI_PXE_BASE_CODE_DISCOVER_INFO      *Info   OPTIONAL
+  );
+
+/**                                                                 
+  Used to perform TFTP and MTFTP services.
+
+  This function is used to perform TFTP and MTFTP services. This includes the
+  TFTP operations to get the size of a file, read a directory, read a file, and
+  write a file. It also includes the MTFTP operations to get the size of a file,
+  read a directory, and read a file. The type of operation is specified by Operation.
+  If the callback function that is invoked during the TFTP/MTFTP operation does
+  not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, then EFI_ABORTED will
+  be returned.
+  For read operations, the return data will be placed in the buffer specified by
+  BufferPtr. If BufferSize is too small to contain the entire downloaded file,
+  then EFI_BUFFER_TOO_SMALL will be returned and BufferSize will be set to zero
+  or the size of the requested file (the size of the requested file is only returned
+  if the TFTP server supports TFTP options). If BufferSize is large enough for the
+  read operation, then BufferSize will be set to the size of the downloaded file,
+  and EFI_SUCCESS will be returned. Applications using the PxeBc.Mtftp() services
+  should use the get-file-size operations to determine the size of the downloaded
+  file prior to using the read-file operations--especially when downloading large
+  (greater than 64 MB) files--instead of making two calls to the read-file operation.
+  Following this recommendation will save time if the file is larger than expected
+  and the TFTP server does not support TFTP option extensions. Without TFTP option
+  extension support, the client has to download the entire file, counting and discarding
+  the received packets, to determine the file size.
+  For write operations, the data to be sent is in the buffer specified by BufferPtr.
+  BufferSize specifies the number of bytes to send. If the write operation completes
+  successfully, then EFI_SUCCESS will be returned.
+  For TFTP "get file size" operations, the size of the requested file or directory
+  is returned in BufferSize, and EFI_SUCCESS will be returned. If the TFTP server
+  does not support options, the file will be downloaded into a bit bucket and the
+  length of the downloaded file will be returned. For MTFTP "get file size" operations,
+  if the MTFTP server does not support the "get file size" option, EFI_UNSUPPORTED
+  will be returned.
+  This function can take up to 10 seconds to timeout and return control to the caller.
+  If the TFTP sequence does not complete, EFI_TIMEOUT will be returned.
+  If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
+  then the TFTP sequence is stopped and EFI_ABORTED will be returned.
+  The format of the data returned from a TFTP read directory operation is a null-terminated
+  filename followed by a null-terminated information string, of the form
+  "size year-month-day hour:minute:second" (i.e. %d %d-%d-%d %d:%d:%f - note that
+  the seconds field can be a decimal number), where the date and time are UTC. For
+  an MTFTP read directory command, there is additionally a null-terminated multicast
+  IP address preceding the filename of the form %d.%d.%d.%d for IP v4. The final
+  entry is itself null-terminated, so that the final information string is terminated
+  with two null octets.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  Operation             The type of operation to perform.
+  @param  BufferPtr             A pointer to the data buffer.                                                                     
+  @param  Overwrite             Only used on write file operations. TRUE if a file on a remote server can
+                                be overwritten.                                                          
+  @param  BufferSize            For get-file-size operations, *BufferSize returns the size of the
+                                requested file.                                                  
+  @param  BlockSize             The requested block size to be used during a TFTP transfer.
+  @param  ServerIp              The TFTP / MTFTP server IP address.
+  @param  Filename              A Null-terminated ASCII string that specifies a directory name or a file
+                                name.                                                                   
+  @param  Info                  The pointer to the MTFTP information.
+  @param  DontUseBuffer         Set to FALSE for normal TFTP and MTFTP read file operation.                       
+                                  
+  @retval EFI_SUCCESS           The TFTP/MTFTP operation was completed.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.                                
+  @retval EFI_BUFFER_TOO_SMALL  The buffer is not large enough to complete the read operation.   
+  @retval EFI_ABORTED           The callback function aborted the TFTP/MTFTP operation.
+  @retval EFI_TIMEOUT           The TFTP/MTFTP operation timed out.
+  @retval EFI_ICMP_ERROR        An ICMP error packet was received during the MTFTP session.
+  @retval EFI_TFTP_ERROR        A TFTP error packet was received during the MTFTP session.
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_MTFTP)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL                *This,
+  IN EFI_PXE_BASE_CODE_TFTP_OPCODE             Operation,
+  IN OUT VOID                                  *BufferPtr OPTIONAL,
+  IN BOOLEAN                                   Overwrite,
+  IN OUT UINT64                                *BufferSize,
+  IN UINTN                                     *BlockSize OPTIONAL,
+  IN EFI_IP_ADDRESS                            *ServerIp,
+  IN UINT8                                     *Filename  OPTIONAL,
+  IN EFI_PXE_BASE_CODE_MTFTP_INFO              *Info      OPTIONAL,
+  IN BOOLEAN                                   DontUseBuffer
+  );
+
+/**                                                                 
+  Writes a UDP packet to the network interface.
+
+  This function writes a UDP packet specified by the (optional HeaderPtr and)
+  BufferPtr parameters to the network interface. The UDP header is automatically
+  built by this routine. It uses the parameters OpFlags, DestIp, DestPort, GatewayIp,
+  SrcIp, and SrcPort to build this header. If the packet is successfully built and
+  transmitted through the network interface, then EFI_SUCCESS will be returned.
+  If a timeout occurs during the transmission of the packet, then EFI_TIMEOUT will
+  be returned. If an ICMP error occurs during the transmission of the packet, then
+  the IcmpErrorReceived field is set to TRUE, the IcmpError field is filled in and
+  EFI_ICMP_ERROR will be returned. If the Callback Protocol does not return
+  EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, then EFI_ABORTED will be returned.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  OpFlags               The UDP operation flags. 
+  @param  DestIp                The destination IP address.
+  @param  DestPort              The destination UDP port number.                                                                         
+  @param  GatewayIp             The gateway IP address.                                                 
+  @param  SrcIp                 The source IP address.
+  @param  SrcPort               The source UDP port number.
+  @param  HeaderSize            An optional field which may be set to the length of a header at
+                                HeaderPtr to be prefixed to the data at BufferPtr.             
+  @param  HeaderPtr             If HeaderSize is not NULL, a pointer to a header to be prefixed to the
+                                data at BufferPtr.                                                    
+  @param  BufferSize            A pointer to the size of the data at BufferPtr.
+  @param  BufferPtr             A pointer to the data to be written.
+                                  
+  @retval EFI_SUCCESS           The UDP Write operation was completed.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                
+  @retval EFI_BAD_BUFFER_SIZE   The buffer is too long to be transmitted.  
+  @retval EFI_ABORTED           The callback function aborted the UDP Write operation.
+  @retval EFI_TIMEOUT           The UDP Write operation timed out.
+  @retval EFI_ICMP_ERROR        An ICMP error packet was received during the UDP write session.  
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_UDP_WRITE)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL                *This,
+  IN UINT16                                    OpFlags,
+  IN EFI_IP_ADDRESS                            *DestIp,
+  IN EFI_PXE_BASE_CODE_UDP_PORT                *DestPort,
+  IN EFI_IP_ADDRESS                            *GatewayIp,  OPTIONAL
+  IN EFI_IP_ADDRESS                            *SrcIp,      OPTIONAL
+  IN OUT EFI_PXE_BASE_CODE_UDP_PORT            *SrcPort,    OPTIONAL
+  IN UINTN                                     *HeaderSize, OPTIONAL
+  IN VOID                                      *HeaderPtr,  OPTIONAL
+  IN UINTN                                     *BufferSize,
+  IN VOID                                      *BufferPtr
+  );
+
+/**                                                                 
+  Reads a UDP packet from the network interface.
+
+  This function reads a UDP packet from a network interface. The data contents
+  are returned in (the optional HeaderPtr and) BufferPtr, and the size of the
+  buffer received is returned in BufferSize. If the input BufferSize is smaller
+  than the UDP packet received (less optional HeaderSize), it will be set to the
+  required size, and EFI_BUFFER_TOO_SMALL will be returned. In this case, the
+  contents of BufferPtr are undefined, and the packet is lost. If a UDP packet is
+  successfully received, then EFI_SUCCESS will be returned, and the information
+  from the UDP header will be returned in DestIp, DestPort, SrcIp, and SrcPort if
+  they are not NULL.
+  Depending on the values of OpFlags and the DestIp, DestPort, SrcIp, and SrcPort
+  input values, different types of UDP packet receive filtering will be performed.
+  The following tables summarize these receive filter operations.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  OpFlags               The UDP operation flags. 
+  @param  DestIp                The destination IP address.
+  @param  DestPort              The destination UDP port number.
+  @param  SrcIp                 The source IP address.
+  @param  SrcPort               The source UDP port number.
+  @param  HeaderSize            An optional field which may be set to the length of a header at
+                                HeaderPtr to be prefixed to the data at BufferPtr.             
+  @param  HeaderPtr             If HeaderSize is not NULL, a pointer to a header to be prefixed to the
+                                data at BufferPtr.                                                    
+  @param  BufferSize            A pointer to the size of the data at BufferPtr.
+  @param  BufferPtr             A pointer to the data to be read.
+                                  
+  @retval EFI_SUCCESS           The UDP Read operation was completed.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.
+  @retval EFI_BUFFER_TOO_SMALL  The packet is larger than Buffer can hold.
+  @retval EFI_ABORTED           The callback function aborted the UDP Read operation.
+  @retval EFI_TIMEOUT           The UDP Read operation timed out.  
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_UDP_READ)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL                *This,
+  IN UINT16                                    OpFlags,
+  IN OUT EFI_IP_ADDRESS                        *DestIp,     OPTIONAL
+  IN OUT EFI_PXE_BASE_CODE_UDP_PORT            *DestPort,   OPTIONAL
+  IN OUT EFI_IP_ADDRESS                        *SrcIp,      OPTIONAL
+  IN OUT EFI_PXE_BASE_CODE_UDP_PORT            *SrcPort,    OPTIONAL
+  IN UINTN                                     *HeaderSize, OPTIONAL
+  IN VOID                                      *HeaderPtr,  OPTIONAL
+  IN OUT UINTN                                 *BufferSize,
+  IN VOID                                      *BufferPtr
+  );
+
+/**                                                                 
+  Updates the IP receive filters of a network device and enables software filtering.
+  
+  The NewFilter field is used to modify the network device's current IP receive
+  filter settings and to enable a software filter. This function updates the IpFilter
+  field of the EFI_PXE_BASE_CODE_MODE structure with the contents of NewIpFilter.
+  The software filter is used when the USE_FILTER in OpFlags is set to UdpRead().
+  The current hardware filter remains in effect no matter what the settings of OpFlags
+  are, so that the meaning of ANY_DEST_IP set in OpFlags to UdpRead() is from those
+  packets whose reception is enabled in hardware - physical NIC address (unicast),
+  broadcast address, logical address or addresses (multicast), or all (promiscuous).
+  UdpRead() does not modify the IP filter settings.
+  Dhcp(), Discover(), and Mtftp() set the IP filter, and return with the IP receive
+  filter list emptied and the filter set to EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP.
+  If an application or driver wishes to preserve the IP receive filter settings,
+  it will have to preserve the IP receive filter settings before these calls, and
+  use SetIpFilter() to restore them after the calls. If incompatible filtering is
+  requested (for example, PROMISCUOUS with anything else), or if the device does not
+  support a requested filter setting and it cannot be accommodated in software
+  (for example, PROMISCUOUS not supported), EFI_INVALID_PARAMETER will be returned.
+  The IPlist field is used to enable IPs other than the StationIP. They may be
+  multicast or unicast. If IPcnt is set as well as EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP,
+  then both the StationIP and the IPs from the IPlist will be used.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  NewFilter             The pointer to the new set of IP receive filters.
+  
+  @retval EFI_SUCCESS           The IP receive filter settings were updated.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                  
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_IP_FILTER)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN EFI_PXE_BASE_CODE_IP_FILTER           *NewFilter
+  );
+
+/**                                                                 
+  Uses the ARP protocol to resolve a MAC address.
+  
+  This function uses the ARP protocol to resolve a MAC address. The UsingIpv6 field
+  of the EFI_PXE_BASE_CODE_MODE structure is used to determine if IPv4 or IPv6
+  addresses are being used. The IP address specified by IpAddr is used to resolve
+  a MAC address. If the ARP protocol succeeds in resolving the specified address,
+  then the ArpCacheEntries and ArpCache fields of the EFI_PXE_BASE_CODE_MODE structure
+  are updated, and EFI_SUCCESS is returned. If MacAddr is not NULL, the resolved
+  MAC address is placed there as well.
+  If the PXE Base Code protocol is in the stopped state, then EFI_NOT_STARTED is
+  returned. If the ARP protocol encounters a timeout condition while attempting
+  to resolve an address, then EFI_TIMEOUT is returned. If the Callback Protocol
+  does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, then EFI_ABORTED is
+  returned.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  IpAddr                The pointer to the IP address that is used to resolve a MAC address.
+  @param  MacAddr               If not NULL, a pointer to the MAC address that was resolved with the
+                                ARP protocol.                                                       
+                                  
+  @retval EFI_SUCCESS           The IP or MAC address was resolved.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                
+  @retval EFI_DEVICE_ERROR      The network device encountered an error during this operation.  
+  @retval EFI_ABORTED           The callback function aborted the ARP Protocol.
+  @retval EFI_TIMEOUT           The ARP Protocol encountered a timeout condition.
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_ARP)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN EFI_IP_ADDRESS                        *IpAddr,
+  IN EFI_MAC_ADDRESS                       *MacAddr OPTIONAL
+  );
+
+/**                                                                 
+  Updates the parameters that affect the operation of the PXE Base Code Protocol.
+  
+  This function sets parameters that affect the operation of the PXE Base Code Protocol.
+  The parameter specified by NewAutoArp is used to control the generation of ARP
+  protocol packets. If NewAutoArp is TRUE, then ARP Protocol packets will be generated
+  as required by the PXE Base Code Protocol. If NewAutoArp is FALSE, then no ARP
+  Protocol packets will be generated. In this case, the only mappings that are
+  available are those stored in the ArpCache of the EFI_PXE_BASE_CODE_MODE structure.
+  If there are not enough mappings in the ArpCache to perform a PXE Base Code Protocol
+  service, then the service will fail. This function updates the AutoArp field of
+  the EFI_PXE_BASE_CODE_MODE structure to NewAutoArp.
+  The SetParameters() call must be invoked after a Callback Protocol is installed
+  to enable the use of callbacks.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  NewAutoArp            If not NULL, a pointer to a value that specifies whether to replace the
+                                current value of AutoARP.                                              
+  @param  NewSendGUID           If not NULL, a pointer to a value that specifies whether to replace the
+                                current value of SendGUID.                                             
+  @param  NewTTL                If not NULL, a pointer to be used in place of the current value of TTL,
+                                the "time to live" field of the IP header.                           
+  @param  NewToS                If not NULL, a pointer to be used in place of the current value of ToS,
+                                the "type of service" field of the IP header.                        
+  @param  NewMakeCallback       If not NULL, a pointer to a value that specifies whether to replace the
+                                current value of the MakeCallback field of the Mode structure.                                                                
+                                  
+  @retval EFI_SUCCESS           The new parameters values were updated.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                  
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_PARAMETERS)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN BOOLEAN                               *NewAutoArp,     OPTIONAL
+  IN BOOLEAN                               *NewSendGUID,    OPTIONAL
+  IN UINT8                                 *NewTTL,         OPTIONAL
+  IN UINT8                                 *NewToS,         OPTIONAL
+  IN BOOLEAN                               *NewMakeCallback OPTIONAL
+  );
+
+/**                                                                 
+  Updates the station IP address and/or subnet mask values of a network device.
+  
+  This function updates the station IP address and/or subnet mask values of a network
+  device.
+  The NewStationIp field is used to modify the network device's current IP address.
+  If NewStationIP is NULL, then the current IP address will not be modified. Otherwise,
+  this function updates the StationIp field of the EFI_PXE_BASE_CODE_MODE structure
+  with NewStationIp.
+  The NewSubnetMask field is used to modify the network device's current subnet
+  mask. If NewSubnetMask is NULL, then the current subnet mask will not be modified.
+  Otherwise, this function updates the SubnetMask field of the EFI_PXE_BASE_CODE_MODE
+  structure with NewSubnetMask.
+    
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  NewStationIp          The pointer to the new IP address to be used by the network device.  
+  @param  NewSubnetMask         The pointer to the new subnet mask to be used by the network device.                                 
+                                  
+  @retval EFI_SUCCESS           The new station IP address and/or subnet mask were updated.
+  @retval EFI_NOT_STARTED       The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.                                  
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_STATION_IP)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  IN EFI_IP_ADDRESS                        *NewStationIp,   OPTIONAL
+  IN EFI_IP_ADDRESS                        *NewSubnetMask   OPTIONAL
+  );
+
+/**                                                                 
+  Updates the contents of the cached DHCP and Discover packets.
+  
+  The pointers to the new packets are used to update the contents of the cached
+  packets in the EFI_PXE_BASE_CODE_MODE structure.
+    
+  @param  This                   The pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
+  @param  NewDhcpDiscoverValid   The pointer to a value that will replace the current
+                                 DhcpDiscoverValid field.                        
+  @param  NewDhcpAckReceived     The pointer to a value that will replace the current
+                                 DhcpAckReceived field.                          
+  @param  NewProxyOfferReceived  The pointer to a value that will replace the current
+                                 ProxyOfferReceived field.                       
+  @param  NewPxeDiscoverValid    The pointer to a value that will replace the current     
+                                 ProxyOfferReceived field.                       
+  @param  NewPxeReplyReceived    The pointer to a value that will replace the current
+                                 PxeReplyReceived field.                         
+  @param  NewPxeBisReplyReceived The pointer to a value that will replace the current
+                                 PxeBisReplyReceived field.                      
+  @param  NewDhcpDiscover        The pointer to the new cached DHCP Discover packet contents.   
+  @param  NewDhcpAck             The pointer to the new cached DHCP Ack packet contents.
+  @param  NewProxyOffer          The pointer to the new cached Proxy Offer packet contents.
+  @param  NewPxeDiscover         The pointer to the new cached PXE Discover packet contents.
+  @param  NewPxeReply            The pointer to the new cached PXE Reply packet contents.
+  @param  NewPxeBisReply         The pointer to the new cached PXE BIS Reply packet contents.
+                                   
+  @retval EFI_SUCCESS            The cached packet contents were updated.
+  @retval EFI_NOT_STARTED        The PXE Base Code Protocol is in the stopped state.
+  @retval EFI_INVALID_PARAMETER  This is NULL or not point to a valid EFI_PXE_BASE_CODE_PROTOCOL structure.
+                                                                      
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_PACKETS)(
+  IN EFI_PXE_BASE_CODE_PROTOCOL            *This,
+  BOOLEAN                                  *NewDhcpDiscoverValid,   OPTIONAL
+  BOOLEAN                                  *NewDhcpAckReceived,     OPTIONAL
+  BOOLEAN                                  *NewProxyOfferReceived,  OPTIONAL
+  BOOLEAN                                  *NewPxeDiscoverValid,    OPTIONAL
+  BOOLEAN                                  *NewPxeReplyReceived,    OPTIONAL
+  BOOLEAN                                  *NewPxeBisReplyReceived, OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewDhcpDiscover,        OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewDhcpAck,             OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewProxyOffer,          OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewPxeDiscover,         OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewPxeReply,            OPTIONAL
+  IN EFI_PXE_BASE_CODE_PACKET              *NewPxeBisReply          OPTIONAL
+  );
+
+//
+// PXE Base Code Protocol structure
+//
+#define EFI_PXE_BASE_CODE_PROTOCOL_REVISION   0x00010000
+
+//
+// Revision defined in EFI1.1
+// 
+#define EFI_PXE_BASE_CODE_INTERFACE_REVISION  EFI_PXE_BASE_CODE_PROTOCOL_REVISION
+
+///
+/// The EFI_PXE_BASE_CODE_PROTOCOL is used to control PXE-compatible devices.
+/// An EFI_PXE_BASE_CODE_PROTOCOL will be layered on top of an
+/// EFI_MANAGED_NETWORK_PROTOCOL protocol in order to perform packet level transactions.
+/// The EFI_PXE_BASE_CODE_PROTOCOL handle also supports the
+/// EFI_LOAD_FILE_PROTOCOL protocol. This provides a clean way to obtain control from the
+/// boot manager if the boot path is from the remote device.
+///
+struct _EFI_PXE_BASE_CODE_PROTOCOL {
+  ///
+  ///  The revision of the EFI_PXE_BASE_CODE_PROTOCOL. All future revisions must 
+  ///  be backwards compatible. If a future version is not backwards compatible 
+  ///  it is not the same GUID.
+  ///
+  UINT64                            Revision;
+  EFI_PXE_BASE_CODE_START           Start;
+  EFI_PXE_BASE_CODE_STOP            Stop;
+  EFI_PXE_BASE_CODE_DHCP            Dhcp;
+  EFI_PXE_BASE_CODE_DISCOVER        Discover;
+  EFI_PXE_BASE_CODE_MTFTP           Mtftp;
+  EFI_PXE_BASE_CODE_UDP_WRITE       UdpWrite;
+  EFI_PXE_BASE_CODE_UDP_READ        UdpRead;
+  EFI_PXE_BASE_CODE_SET_IP_FILTER   SetIpFilter;
+  EFI_PXE_BASE_CODE_ARP             Arp;
+  EFI_PXE_BASE_CODE_SET_PARAMETERS  SetParameters;
+  EFI_PXE_BASE_CODE_SET_STATION_IP  SetStationIp;
+  EFI_PXE_BASE_CODE_SET_PACKETS     SetPackets;
+  ///
+  /// The pointer to the EFI_PXE_BASE_CODE_MODE data for this device.
+  ///
+  EFI_PXE_BASE_CODE_MODE            *Mode;
+};
+
+extern EFI_GUID gEfiPxeBaseCodeProtocolGuid;
+
+#endif 
diff --git a/MdePkg/Include/Protocol/PxeBaseCodeCallBack.h b/MdePkg/Include/Protocol/PxeBaseCodeCallBack.h
new file mode 100644
index 000000000000..f653fdf7ff2c
--- /dev/null
+++ b/MdePkg/Include/Protocol/PxeBaseCodeCallBack.h
@@ -0,0 +1,130 @@
+/** @file
+  It is invoked when the PXE Base Code Protocol is about to transmit, has received, 
+  or is waiting to receive a packet.
+
+Copyright (c) 2006 - 2010, 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.             
+
+  @par Revision Reference:          
+  This Protocol is introduced in EFI Specification 1.10
+
+**/
+
+#ifndef _PXE_BASE_CODE_CALLBACK_H_
+#define _PXE_BASE_CODE_CALLBACK_H_
+
+///
+/// Call Back Definitions.
+///
+#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID \
+  { \
+    0x245dca21, 0xfb7b, 0x11d3, {0x8f, 0x01, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+///
+/// UEFI Revision Number Definition.
+///
+#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION 0x00010000
+
+///
+/// EFI 1.1 Revision Number defintion.
+///
+#define EFI_PXE_BASE_CODE_CALLBACK_INTERFACE_REVISION  \
+        EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION
+
+///
+/// UEFI Protocol name.
+///
+typedef struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL  EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL;
+
+///
+/// EFI1.1 Protocol name.
+/// 
+typedef EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL   EFI_PXE_BASE_CODE_CALLBACK;
+
+///
+/// Event type list for PXE Base Code Protocol function.
+///
+typedef enum {
+  EFI_PXE_BASE_CODE_FUNCTION_FIRST,
+  EFI_PXE_BASE_CODE_FUNCTION_DHCP,
+  EFI_PXE_BASE_CODE_FUNCTION_DISCOVER,
+  EFI_PXE_BASE_CODE_FUNCTION_MTFTP,
+  EFI_PXE_BASE_CODE_FUNCTION_UDP_WRITE,
+  EFI_PXE_BASE_CODE_FUNCTION_UDP_READ,
+  EFI_PXE_BASE_CODE_FUNCTION_ARP,
+  EFI_PXE_BASE_CODE_FUNCTION_IGMP,
+  EFI_PXE_BASE_CODE_PXE_FUNCTION_LAST
+} EFI_PXE_BASE_CODE_FUNCTION;
+
+///
+/// Callback status type.
+///
+typedef enum {
+  EFI_PXE_BASE_CODE_CALLBACK_STATUS_FIRST,
+  EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
+  EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT,
+  EFI_PXE_BASE_CODE_CALLBACK_STATUS_LAST
+} EFI_PXE_BASE_CODE_CALLBACK_STATUS;
+
+/**                                                                 
+  Callback function that is invoked when the PXE Base Code Protocol is about to transmit, has
+  received, or is waiting to receive a packet.                                                 
+  
+  This function is invoked when the PXE Base Code Protocol is about to transmit, has received,
+  or is waiting to receive a packet. Parameters Function and Received specify the type of event.
+  Parameters PacketLen and Packet specify the packet that generated the event. If these fields
+  are zero and NULL respectively, then this is a status update callback. If the operation specified
+  by Function is to continue, then CALLBACK_STATUS_CONTINUE should be returned. If the operation
+  specified by Function should be aborted, then CALLBACK_STATUS_ABORT should be returned. Due to
+  the polling nature of UEFI device drivers, a callback function should not execute for more than 5 ms.
+  The SetParameters() function must be called after a Callback Protocol is installed to enable the
+  use of callbacks.
+  
+  @param  This                  The pointer to the EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL instance.
+  @param  Function              The PXE Base Code Protocol function that is waiting for an event.                                                              
+  @param  Received              TRUE if the callback is being invoked due to a receive event. FALSE if
+                                the callback is being invoked due to a transmit event.                
+  @param  PacketLen             The length, in bytes, of Packet. This field will have a value of zero if
+                                this is a wait for receive event.                                       
+  @param  Packet                If Received is TRUE, a pointer to the packet that was just received;
+                                otherwise a pointer to the packet that is about to be transmitted.  
+                                  
+  @retval EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE if Function specifies a continue operation    
+  @retval EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT    if Function specifies an abort operation
+                                   
+**/
+typedef 
+EFI_PXE_BASE_CODE_CALLBACK_STATUS 
+(EFIAPI *EFI_PXE_CALLBACK)(
+  IN EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL  *This,
+  IN EFI_PXE_BASE_CODE_FUNCTION           Function,
+  IN BOOLEAN                              Received,
+  IN UINT32                               PacketLen,
+  IN EFI_PXE_BASE_CODE_PACKET             *Packet     OPTIONAL
+  );
+
+///
+/// Protocol that is invoked when the PXE Base Code Protocol is about 
+/// to transmit, has received, or is waiting to receive a packet.
+///
+struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL {
+  ///
+  ///  The revision of the EFI_PXE_BASE_CODE_PROTOCOL. All future revisions must 
+  ///  be backwards compatible. If a future version is not backwards compatible 
+  ///  it is not the same GUID.
+  ///
+  UINT64            Revision;
+  EFI_PXE_CALLBACK  Callback;
+};
+
+extern EFI_GUID gEfiPxeBaseCodeCallbackProtocolGuid;
+
+#endif 
+
diff --git a/MdePkg/Include/Protocol/RamDisk.h b/MdePkg/Include/Protocol/RamDisk.h
new file mode 100644
index 000000000000..61353fbbd7c9
--- /dev/null
+++ b/MdePkg/Include/Protocol/RamDisk.h
@@ -0,0 +1,106 @@
+/** @file
+  This file defines the EFI RAM Disk Protocol.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.6
+
+**/
+
+#ifndef __RAM_DISK_PROTOCOL_H__
+#define __RAM_DISK_PROTOCOL_H__
+
+//
+// EFI RAM Disk Protocol GUID value
+//
+#define EFI_RAM_DISK_PROTOCOL_GUID \
+  { 0xab38a0df, 0x6873, 0x44a9, { 0x87, 0xe6, 0xd4, 0xeb, 0x56, 0x14, 0x84, 0x49 }};
+
+//
+// Forward reference for pure ANSI compatability
+//
+typedef struct _EFI_RAM_DISK_PROTOCOL  EFI_RAM_DISK_PROTOCOL;
+
+/**
+  Register a RAM disk with specified address, size and type.
+
+  @param[in]  RamDiskBase    The base address of registered RAM disk.
+  @param[in]  RamDiskSize    The size of registered RAM disk.
+  @param[in]  RamDiskType    The type of registered RAM disk. The GUID can be
+                             any of the values defined in section 9.3.6.9, or a
+                             vendor defined GUID.
+  @param[in]  ParentDevicePath
+                             Pointer to the parent device path. If there is no
+                             parent device path then ParentDevicePath is NULL.
+  @param[out] DevicePath     On return, points to a pointer to the device path
+                             of the RAM disk device.
+                             If ParentDevicePath is not NULL, the returned
+                             DevicePath is created by appending a RAM disk node
+                             to the parent device path. If ParentDevicePath is
+                             NULL, the returned DevicePath is a RAM disk device
+                             path without appending. This function is
+                             responsible for allocating the buffer DevicePath
+                             with the boot service AllocatePool().
+
+  @retval EFI_SUCCESS             The RAM disk is registered successfully.
+  @retval EFI_INVALID_PARAMETER   DevicePath or RamDiskType is NULL.
+                                  RamDiskSize is 0.
+  @retval EFI_ALREADY_STARTED     A Device Path Protocol instance to be created
+                                  is already present in the handle database.
+  @retval EFI_OUT_OF_RESOURCES    The RAM disk register operation fails due to
+                                  resource limitation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RAM_DISK_REGISTER_RAMDISK) (
+  IN UINT64                       RamDiskBase,
+  IN UINT64                       RamDiskSize,
+  IN EFI_GUID                     *RamDiskType,
+  IN EFI_DEVICE_PATH              *ParentDevicePath     OPTIONAL,
+  OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath
+  );
+
+/**
+  Unregister a RAM disk specified by DevicePath.
+
+  @param[in] DevicePath      A pointer to the device path that describes a RAM
+                             Disk device.
+
+  @retval EFI_SUCCESS             The RAM disk is unregistered successfully.
+  @retval EFI_INVALID_PARAMETER   DevicePath is NULL.
+  @retval EFI_UNSUPPORTED         The device specified by DevicePath is not a
+                                  valid ramdisk device path and not supported
+                                  by the driver.
+  @retval EFI_NOT_FOUND           The RAM disk pointed by DevicePath doesn't
+                                  exist.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RAM_DISK_UNREGISTER_RAMDISK) (
+  IN  EFI_DEVICE_PATH_PROTOCOL    *DevicePath
+  );
+
+///
+/// RAM Disk Protocol structure.
+///
+struct _EFI_RAM_DISK_PROTOCOL {
+  EFI_RAM_DISK_REGISTER_RAMDISK        Register;
+  EFI_RAM_DISK_UNREGISTER_RAMDISK      Unregister;
+};
+
+///
+/// RAM Disk Protocol GUID variable.
+///
+extern EFI_GUID gEfiRamDiskProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/RealTimeClock.h b/MdePkg/Include/Protocol/RealTimeClock.h
new file mode 100644
index 000000000000..7a70ae37a5aa
--- /dev/null
+++ b/MdePkg/Include/Protocol/RealTimeClock.h
@@ -0,0 +1,36 @@
+/** @file
+  Real Time clock Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  This code abstracts time and data functions. Used to provide
+  Time and date related EFI runtime services.
+
+  The GetTime (), SetTime (), GetWakeupTime (), and SetWakeupTime () UEFI 2.0
+  services are added to the EFI system table and the 
+  EFI_REAL_TIME_CLOCK_ARCH_PROTOCOL_GUID protocol is registered with a NULL 
+  pointer.
+
+  No CRC of the EFI system table is required, since that is done in the DXE core.
+
+  Copyright (c) 2006 - 2009, 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 __ARCH_PROTOCOL_REAL_TIME_CLOCK_H__
+#define __ARCH_PROTOCOL_REAL_TIME_CLOCK_H__
+
+///
+/// Global ID for the Real Time Clock Architectural Protocol
+///
+#define EFI_REAL_TIME_CLOCK_ARCH_PROTOCOL_GUID \
+  { 0x27CFAC87, 0x46CC, 0x11d4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } }
+
+extern EFI_GUID gEfiRealTimeClockArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/RegularExpressionProtocol.h b/MdePkg/Include/Protocol/RegularExpressionProtocol.h
new file mode 100644
index 000000000000..5582e12d36e8
--- /dev/null
+++ b/MdePkg/Include/Protocol/RegularExpressionProtocol.h
@@ -0,0 +1,178 @@
+/** @file
+  This section defines the Regular Expression Protocol. This protocol isused to match
+  Unicode strings against Regular Expression patterns.
+
+Copyright (c) 2015, 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 __REGULAR_EXPRESSION_PROTOCOL_H__
+#define __REGULAR_EXPRESSION_PROTOCOL_H__
+
+#define EFI_REGULAR_EXPRESSION_PROTOCOL_GUID \
+  { \
+    0xB3F79D9A, 0x436C, 0xDC11, {0xB0, 0x52, 0xCD, 0x85, 0xDF, 0x52, 0x4C, 0xE6 } \
+  }
+
+#define EFI_REGEX_SYNTAX_TYPE_POSIX_EXTENDED_GUID \
+  { \
+    0x5F05B20F, 0x4A56, 0xC231, {0xFA, 0x0B, 0xA7, 0xB1, 0xF1, 0x10, 0x04, 0x1D } \
+  }
+
+#define EFI_REGEX_SYNTAX_TYPE_PERL_GUID \
+  { \
+    0x63E60A51, 0x497D, 0xD427, {0xC4, 0xA5, 0xB8, 0xAB, 0xDC, 0x3A, 0xAE, 0xB6 } \
+  }
+
+#define EFI_REGEX_SYNTAX_TYPE_ECMA_262_GUID \
+  { \
+    0x9A473A4A, 0x4CEB, 0xB95A, {0x41, 0x5E, 0x5B, 0xA0, 0xBC, 0x63, 0x9B, 0x2E } \
+  }
+
+typedef struct _EFI_REGULAR_EXPRESSION_PROTOCOL  EFI_REGULAR_EXPRESSION_PROTOCOL;
+
+
+typedef struct {
+  CONST CHAR16 *CapturePtr; // Pointer to the start of the captured sub-expression
+                            // within matched String.
+
+  UINTN        Length;      // Length of captured sub-expression.
+} EFI_REGEX_CAPTURE;
+
+typedef EFI_GUID EFI_REGEX_SYNTAX_TYPE;
+
+//
+// Protocol member functions
+//
+/**
+  Returns information about the regular expression syntax types supported
+  by the implementation.
+
+  This                     A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL
+                           instance.
+
+  RegExSyntaxTypeListSize  On input, the size in bytes of RegExSyntaxTypeList.
+                           On output with a return code of EFI_SUCCESS, the
+                           size in bytes of the data returned in
+                           RegExSyntaxTypeList. On output with a return code
+                           of EFI_BUFFER_TOO_SMALL, the size of
+                           RegExSyntaxTypeListrequired to obtain the list.
+
+  RegExSyntaxTypeList      A caller-allocated memory buffer filled by the
+                           driver with one EFI_REGEX_SYNTAX_TYPEelement
+                           for each supported Regular expression syntax
+                           type. The list must not change across multiple
+                           calls to the same driver. The first syntax
+                           type in the list is the default type for the
+                           driver.
+
+  @retval EFI_SUCCESS            The regular expression syntax types list
+                                 was returned successfully.
+  @retval EFI_UNSUPPORTED        The service is not supported by this driver.
+  @retval EFI_DEVICE_ERROR       The list of syntax types could not be
+                                 retrieved due to a hardware or firmware error.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer RegExSyntaxTypeList is too small
+                                 to hold the result.
+  @retval EFI_INVALID_PARAMETER  RegExSyntaxTypeListSize is NULL
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGULAR_EXPRESSION_GET_INFO) (
+  IN     EFI_REGULAR_EXPRESSION_PROTOCOL *This,
+  IN OUT UINTN                           *RegExSyntaxTypeListSize,
+  OUT    EFI_REGEX_SYNTAX_TYPE           *RegExSyntaxTypeList
+  );
+
+/**
+  Checks if the input string matches to the regular expression pattern.
+
+  This          A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL instance.
+                Type EFI_REGULAR_EXPRESSION_PROTOCOL is defined in Section
+                XYZ.
+
+  String        A pointer to a NULL terminated string to match against the
+                regular expression string specified by Pattern.
+
+  Pattern       A pointer to a NULL terminated string that represents the
+                regular expression.
+
+  SyntaxType    A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
+                regular expression syntax type to use. May be NULL in which
+                case the function will use its default regular expression
+                syntax type.
+
+  Result        On return, points to TRUE if String fully matches against
+                the regular expression Pattern using the regular expression
+                SyntaxType. Otherwise, points to FALSE.
+
+  Captures      A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
+                the captured groups in the event of a match. The full
+                sub-string match is put in Captures[0], and the results of N
+                capturing groups are put in Captures[1:N]. If Captures is
+                NULL, then this function doesn't allocate the memory for the
+                array and does not build up the elements. It only returns the
+                number of matching patterns in CapturesCount. If Captures is
+                not NULL, this function returns a pointer to an array and
+                builds up the elements in the array. CapturesCount is also
+                updated to the number of matching patterns found. It is the
+                caller's responsibility to free the memory pool in Captures
+                and in each CapturePtr in the array elements.
+
+  CapturesCount On output, CapturesCount is the number of matching patterns
+                found in String. Zero means no matching patterns were found
+                in the string.
+
+  @retval EFI_SUCCESS            The regular expression string matching
+                                 completed successfully.
+  @retval EFI_UNSUPPORTED        The regular expression syntax specified by
+                                 SyntaxTypeis not supported by this driver.
+  @retval EFI_DEVICE_ERROR       The regular expression string matching
+                                 failed due to a hardware or firmware error.
+  @retval EFI_INVALID_PARAMETER  String, Pattern, Result, or CapturesCountis
+                                 NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGULAR_EXPRESSION_MATCH) (
+  IN  EFI_REGULAR_EXPRESSION_PROTOCOL *This,
+  IN  CHAR16                          *String,
+  IN  CHAR16                          *Pattern,
+  IN  EFI_REGEX_SYNTAX_TYPE           *SyntaxType, OPTIONAL
+  OUT BOOLEAN                         *Result,
+  OUT EFI_REGEX_CAPTURE               **Captures, OPTIONAL
+  OUT UINTN                           *CapturesCount
+  );
+
+struct _EFI_REGULAR_EXPRESSION_PROTOCOL {
+  EFI_REGULAR_EXPRESSION_MATCH     MatchString;
+  EFI_REGULAR_EXPRESSION_GET_INFO  GetInfo;
+} ;
+
+extern EFI_GUID gEfiRegularExpressionProtocolGuid;
+
+//
+// For regular expression rules specified in the POSIX Extended Regular
+// Expression (ERE) Syntax:
+//
+extern EFI_GUID gEfiRegexSyntaxTypePosixExtendedGuid;
+
+//
+// For regular expression rules specifiedin the ECMA 262 Specification
+//
+extern EFI_GUID gEfiRegexSyntaxTypeEcma262Guid;
+
+//
+// For regular expression rules specified in the Perl standard:
+//
+extern EFI_GUID gEfiRegexSyntaxTypePerlGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ReportStatusCodeHandler.h b/MdePkg/Include/Protocol/ReportStatusCodeHandler.h
new file mode 100644
index 000000000000..5926e551d85c
--- /dev/null
+++ b/MdePkg/Include/Protocol/ReportStatusCodeHandler.h
@@ -0,0 +1,94 @@
+/** @file
+  This protocol provide registering and unregistering services to status code 
+  consumers while in DXE.
+  
+  Copyright (c) 2007 - 2009, 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 __REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+#define __REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+
+#define EFI_RSC_HANDLER_PROTOCOL_GUID \
+  { \
+    0x86212936, 0xe76, 0x41c8, {0xa0, 0x3a, 0x2a, 0xf2, 0xfc, 0x1c, 0x39, 0xe2} \
+  }
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RSC_HANDLER_CALLBACK)(
+  IN EFI_STATUS_CODE_TYPE   CodeType,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN UINT32                 Instance,
+  IN EFI_GUID               *CallerId,
+  IN EFI_STATUS_CODE_DATA   *Data
+);
+
+/**
+  Register the callback function for ReportStatusCode() notification.
+  
+  When this function is called the function pointer is added to an internal list and any future calls to
+  ReportStatusCode() will be forwarded to the Callback function. During the bootservices,
+  this is the callback for which this service can be invoked. The report status code router
+  will create an event such that the callback function is only invoked at the TPL for which it was
+  registered. The entity that registers for the callback should also register for an event upon
+  generation of exit boot services and invoke the unregister service.
+  If the handler does not have a TPL dependency, it should register for a callback at TPL high. The
+  router infrastructure will support making callbacks at runtime, but the caller for runtime invocation
+  must meet the following criteria:
+  1. must be a runtime driver type so that its memory is not reclaimed
+  2. not unregister at exit boot services so that the router will still have its callback address
+  3. the caller must be self-contained (eg. Not call out into any boot-service interfaces) and be
+  runtime safe, in general.
+  
+  @param[in] Callback   A pointer to a function of type EFI_RSC_HANDLER_CALLBACK that is called when
+                        a call to ReportStatusCode() occurs.
+  @param[in] Tpl        TPL at which callback can be safely invoked.   
+  
+  @retval  EFI_SUCCESS              Function was successfully registered.
+  @retval  EFI_INVALID_PARAMETER    The callback function was NULL.
+  @retval  EFI_OUT_OF_RESOURCES     The internal buffer ran out of space. No more functions can be
+                                    registered.
+  @retval  EFI_ALREADY_STARTED      The function was already registered. It can't be registered again.                              
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RSC_HANDLER_REGISTER)(
+  IN EFI_RSC_HANDLER_CALLBACK   Callback,
+  IN EFI_TPL                    Tpl
+);
+
+/**
+  Remove a previously registered callback function from the notification list.
+  
+  A callback function must be unregistered before it is deallocated. It is important that any registered
+  callbacks that are not runtime complaint be unregistered when ExitBootServices() is called.
+  
+  @param[in]  Callback  A pointer to a function of type EFI_RSC_HANDLER_CALLBACK that is to be
+                        unregistered.
+                        
+  @retval EFI_SUCCESS           The function was successfully unregistered.
+  @retval EFI_INVALID_PARAMETER The callback function was NULL.
+  @retval EFI_NOT_FOUND         The callback function was not found to be unregistered.                        
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RSC_HANDLER_UNREGISTER)(
+  IN EFI_RSC_HANDLER_CALLBACK Callback
+);
+
+typedef struct {
+  EFI_RSC_HANDLER_REGISTER Register;
+  EFI_RSC_HANDLER_UNREGISTER Unregister;
+} EFI_RSC_HANDLER_PROTOCOL;
+
+extern EFI_GUID gEfiRscHandlerProtocolGuid;
+
+#endif // __REPORT_STATUS_CODE_HANDLER_H__
diff --git a/MdePkg/Include/Protocol/Reset.h b/MdePkg/Include/Protocol/Reset.h
new file mode 100644
index 000000000000..bcd9329ba091
--- /dev/null
+++ b/MdePkg/Include/Protocol/Reset.h
@@ -0,0 +1,31 @@
+/** @file
+  Reset Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  Used to provide ResetSystem runtime services
+
+  The ResetSystem () UEFI 2.0 service is added to the EFI system table and the 
+  EFI_RESET_ARCH_PROTOCOL_GUID protocol is registered with a NULL pointer.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_RESET_H__
+#define __ARCH_PROTOCOL_RESET_H__
+
+///
+/// Global ID for the Reset Architectural Protocol
+///
+#define EFI_RESET_ARCH_PROTOCOL_GUID  \
+  { 0x27CFAC88, 0x46CC, 0x11d4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } }
+
+extern EFI_GUID gEfiResetArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Rest.h b/MdePkg/Include/Protocol/Rest.h
new file mode 100644
index 000000000000..512dd08ec230
--- /dev/null
+++ b/MdePkg/Include/Protocol/Rest.h
@@ -0,0 +1,94 @@
+/** @file
+  This file defines the EFI REST Protocol interface.
+
+  Copyright (c) 2015, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_REST_PROTOCOL_H__
+#define __EFI_REST_PROTOCOL_H__
+
+#include <Protocol/Http.h>
+
+#define EFI_REST_PROTOCOL_GUID \
+  { \
+    0x0db48a36, 0x4e54, 0xea9c, {0x9b, 0x09, 0x1e, 0xa5, 0xbe, 0x3a, 0x66, 0x0b } \
+  }
+
+typedef struct _EFI_REST_PROTOCOL EFI_REST_PROTOCOL;
+
+/**
+  Provides a simple HTTP-like interface to send and receive resources from a REST
+  service.
+
+  The SendReceive() function sends an HTTP request to this REST service, and returns a
+  response when the data is retrieved from the service. RequestMessage contains the HTTP
+  request to the REST resource identified by RequestMessage.Request.Url. The
+  ResponseMessage is the returned HTTP response for that request, including any HTTP
+  status.
+
+  @param[in]  This                Pointer to EFI_REST_PROTOCOL instance for a particular
+                                  REST service.
+  @param[in]  RequestMessage      Pointer to the HTTP request data for this resource.
+  @param[out] ResponseMessage     Pointer to the HTTP response data obtained for this
+                                  requested.
+
+  @retval EFI_SUCCESS             Operation succeeded.
+  @retval EFI_INVALID_PARAMETER   This, RequestMessage, or ResponseMessage are NULL.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REST_SEND_RECEIVE) (
+  IN  EFI_REST_PROTOCOL         *This,
+  IN  EFI_HTTP_MESSAGE          *RequestMessage,
+  OUT EFI_HTTP_MESSAGE          *ResponseMessage
+  );
+
+/**
+  The GetServiceTime() function is an optional interface to obtain the current time from
+  this REST service instance. If this REST service does not support retrieving the time,
+  this function returns EFI_UNSUPPORTED.
+
+  @param[in]  This                Pointer to EFI_REST_PROTOCOL instance.
+  @param[out] Time                A pointer to storage to receive a snapshot of the
+                                  current time of the REST service.
+
+  @retval EFI_SUCCESS             Operation succeeded
+  @retval EFI_INVALID_PARAMETER   This or Time are NULL.
+  @retval EFI_UNSUPPORTED         The RESTful service does not support returning the
+                                  time.
+  @retval EFI_DEVICE_ERROR        An unexpected system or network error occurred.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REST_GET_TIME) (
+  IN  EFI_REST_PROTOCOL         *This,
+  OUT EFI_TIME                  *Time
+  );
+
+///
+/// The EFI REST protocol is designed to be used by EFI drivers and applications to send
+/// and receive resources from a RESTful service. This protocol abstracts REST
+/// (Representational State Transfer) client functionality. This EFI protocol could be
+/// implemented to use an underlying EFI HTTP protocol, or it could rely on other
+/// interfaces that abstract HTTP access to the resources.
+///
+struct _EFI_REST_PROTOCOL {
+  EFI_REST_SEND_RECEIVE         SendReceive;
+  EFI_REST_GET_TIME             GetServiceTime;
+};
+
+extern EFI_GUID gEfiRestProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Rng.h b/MdePkg/Include/Protocol/Rng.h
new file mode 100644
index 000000000000..95cfdc95d7ce
--- /dev/null
+++ b/MdePkg/Include/Protocol/Rng.h
@@ -0,0 +1,156 @@
+/** @file
+  EFI_RNG_PROTOCOL as defined in UEFI 2.4.
+  The UEFI Random Number Generator Protocol is used to provide random bits for use 
+  in applications, or entropy for seeding other random number generators.
+
+Copyright (c) 2013, 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_RNG_PROTOCOL_H__
+#define __EFI_RNG_PROTOCOL_H__
+
+///
+/// Global ID for the Random Number Generator Protocol
+///
+#define EFI_RNG_PROTOCOL_GUID \
+  { \
+    0x3152bca5, 0xeade, 0x433d, {0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44 } \
+  }
+
+typedef struct _EFI_RNG_PROTOCOL EFI_RNG_PROTOCOL;
+
+///
+/// A selection of EFI_RNG_PROTOCOL algorithms.
+/// The algorithms listed are optional, not meant to be exhaustive and be argmented by 
+/// vendors or other industry standards.
+///
+
+typedef EFI_GUID EFI_RNG_ALGORITHM;
+
+///
+/// The algorithms corresponds to SP800-90 as defined in
+/// NIST SP 800-90, "Recommendation for Random Number Generation Using Deterministic Random
+/// Bit Generators", March 2007.
+///
+#define EFI_RNG_ALGORITHM_SP800_90_HASH_256_GUID \
+  { \
+    0xa7af67cb, 0x603b, 0x4d42, {0xba, 0x21, 0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96 } \
+  }
+#define EFI_RNG_ALGORITHM_SP800_90_HMAC_256_GUID \
+  { \
+    0xc5149b43, 0xae85, 0x4f53, {0x99, 0x82, 0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7 } \
+  }
+#define EFI_RNG_ALGORITHM_SP800_90_CTR_256_GUID \
+  { \
+    0x44f0de6e, 0x4d8c, 0x4045, {0xa8, 0xc7, 0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e } \
+  }
+///
+/// The algorithms correspond to X9.31 as defined in
+/// NIST, "Recommended Random Number Generator Based on ANSI X9.31 Appendix A.2.4 Using
+/// the 3-Key Triple DES and AES Algorithm", January 2005.
+///
+#define EFI_RNG_ALGORITHM_X9_31_3DES_GUID \
+  { \
+    0x63c4785a, 0xca34, 0x4012, {0xa3, 0xc8, 0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46 } \
+  }
+#define EFI_RNG_ALGORITHM_X9_31_AES_GUID \
+  { \
+    0xacd03321, 0x777e, 0x4d3d, {0xb1, 0xc8, 0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9 } \
+  }
+///
+/// The "raw" algorithm, when supported, is intended to provide entropy directly from
+/// the source, without it going through some deterministic random bit generator.
+///
+#define EFI_RNG_ALGORITHM_RAW \
+  { \
+    0xe43176d7, 0xb6e8, 0x4827, {0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61 } \
+  }
+
+/**
+  Returns information about the random number generation implementation.
+
+  @param[in]     This                 A pointer to the EFI_RNG_PROTOCOL instance.
+  @param[in,out] RNGAlgorithmListSize On input, the size in bytes of RNGAlgorithmList. 
+                                      On output with a return code of EFI_SUCCESS, the size
+                                      in bytes of the data returned in RNGAlgorithmList. On output
+                                      with a return code of EFI_BUFFER_TOO_SMALL,
+                                      the size of RNGAlgorithmList required to obtain the list.
+  @param[out] RNGAlgorithmList        A caller-allocated memory buffer filled by the driver
+                                      with one EFI_RNG_ALGORITHM element for each supported
+                                      RNG algorithm. The list must not change across multiple
+                                      calls to the same driver. The first algorithm in the list
+                                      is the default algorithm for the driver.
+
+  @retval EFI_SUCCESS                 The RNG algorithm list was returned successfully.
+  @retval EFI_UNSUPPORTED             The services is not supported by this driver.
+  @retval EFI_DEVICE_ERROR            The list of algorithms could not be retrieved due to a
+                                      hardware or firmware error.
+  @retval EFI_INVALID_PARAMETER       One or more of the parameters are incorrect.
+  @retval EFI_BUFFER_TOO_SMALL        The buffer RNGAlgorithmList is too small to hold the result.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RNG_GET_INFO) (
+  IN EFI_RNG_PROTOCOL             *This,
+  IN OUT UINTN                    *RNGAlgorithmListSize,
+  OUT EFI_RNG_ALGORITHM           *RNGAlgorithmList
+  );
+
+/**
+  Produces and returns an RNG value using either the default or specified RNG algorithm.
+
+  @param[in]  This                    A pointer to the EFI_RNG_PROTOCOL instance.
+  @param[in]  RNGAlgorithm            A pointer to the EFI_RNG_ALGORITHM that identifies the RNG
+                                      algorithm to use. May be NULL in which case the function will
+                                      use its default RNG algorithm.
+  @param[in]  RNGValueLength          The length in bytes of the memory buffer pointed to by
+                                      RNGValue. The driver shall return exactly this numbers of bytes.
+  @param[out] RNGValue                A caller-allocated memory buffer filled by the driver with the
+                                      resulting RNG value.
+
+  @retval EFI_SUCCESS                 The RNG value was returned successfully.
+  @retval EFI_UNSUPPORTED             The algorithm specified by RNGAlgorithm is not supported by
+                                      this driver.
+  @retval EFI_DEVICE_ERROR            An RNG value could not be retrieved due to a hardware or
+                                      firmware error.
+  @retval EFI_NOT_READY               There is not enough random data available to satisfy the length
+                                      requested by RNGValueLength.
+  @retval EFI_INVALID_PARAMETER       RNGValue is NULL or RNGValueLength is zero.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RNG_GET_RNG) (
+  IN EFI_RNG_PROTOCOL            *This,
+  IN EFI_RNG_ALGORITHM           *RNGAlgorithm, OPTIONAL
+  IN UINTN                       RNGValueLength,
+  OUT UINT8                      *RNGValue
+  );
+
+///
+/// The Random Number Generator (RNG) protocol provides random bits for use in 
+/// applications, or entropy for seeding other random number generators.
+///
+struct _EFI_RNG_PROTOCOL {
+  EFI_RNG_GET_INFO                GetInfo;
+  EFI_RNG_GET_RNG                 GetRNG;
+};
+
+extern EFI_GUID gEfiRngProtocolGuid;
+extern EFI_GUID gEfiRngAlgorithmSp80090Hash256Guid;
+extern EFI_GUID gEfiRngAlgorithmSp80090Hmac256Guid;
+extern EFI_GUID gEfiRngAlgorithmSp80090Ctr256Guid;
+extern EFI_GUID gEfiRngAlgorithmX9313DesGuid;
+extern EFI_GUID gEfiRngAlgorithmX931AesGuid;
+extern EFI_GUID gEfiRngAlgorithmRaw;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Runtime.h b/MdePkg/Include/Protocol/Runtime.h
new file mode 100644
index 000000000000..21e9b75fb756
--- /dev/null
+++ b/MdePkg/Include/Protocol/Runtime.h
@@ -0,0 +1,128 @@
+/** @file
+  Runtime Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  Allows the runtime functionality of the DXE Foundation to be contained 
+  in a separate driver. It also provides hooks for the DXE Foundation to 
+  export information that is needed at runtime. As such, this protocol allows 
+  services to the DXE Foundation to manage runtime drivers and events. 
+  This protocol also implies that the runtime services required to transition 
+  to virtual mode, SetVirtualAddressMap() and ConvertPointer(), have been 
+  registered into the UEFI Runtime Table in the UEFI System Table. This protocol 
+  must be produced by a runtime DXE driver and may only be consumed by the DXE Foundation.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_RUNTIME_H__
+#define __ARCH_PROTOCOL_RUNTIME_H__
+
+///
+/// Global ID for the Runtime Architectural Protocol
+///
+#define EFI_RUNTIME_ARCH_PROTOCOL_GUID \
+  { 0xb7dfb4e1, 0x52f, 0x449f, {0x87, 0xbe, 0x98, 0x18, 0xfc, 0x91, 0xb7, 0x33 } }
+
+typedef struct _EFI_RUNTIME_ARCH_PROTOCOL  EFI_RUNTIME_ARCH_PROTOCOL;
+
+///
+/// LIST_ENTRY from BaseType 
+///
+typedef LIST_ENTRY EFI_LIST_ENTRY;
+
+typedef struct _EFI_RUNTIME_IMAGE_ENTRY  EFI_RUNTIME_IMAGE_ENTRY;
+
+///
+/// EFI_RUNTIME_IMAGE_ENTRY
+///
+struct _EFI_RUNTIME_IMAGE_ENTRY {
+  ///
+  /// Start of image that has been loaded in memory. It is a pointer 
+  /// to either the DOS header or PE header of the image.
+  ///
+  VOID                    *ImageBase;
+  ///
+  /// Size in bytes of the image represented by ImageBase.
+  ///
+  UINT64                  ImageSize;
+  ///
+  /// Information about the fix-ups that were performed on ImageBase when it was
+  /// loaded into memory.
+  ///
+  VOID                    *RelocationData;
+  ///
+  /// The ImageHandle passed into ImageBase when it was loaded.
+  ///
+  EFI_HANDLE              Handle;
+  ///
+  /// Entry for this node in the EFI_RUNTIME_ARCHITECTURE_PROTOCOL.ImageHead list.
+  ///
+  EFI_LIST_ENTRY          Link;
+};
+
+typedef struct _EFI_RUNTIME_EVENT_ENTRY  EFI_RUNTIME_EVENT_ENTRY;
+
+///
+/// EFI_RUNTIME_EVENT_ENTRY
+///
+struct _EFI_RUNTIME_EVENT_ENTRY {
+  ///
+  /// The same as Type passed into CreateEvent().
+  ///
+  UINT32                  Type;
+  ///
+  /// The same as NotifyTpl passed into CreateEvent().
+  ///
+  EFI_TPL                 NotifyTpl;
+  ///
+  /// The same as NotifyFunction passed into CreateEvent().
+  ///
+  EFI_EVENT_NOTIFY        NotifyFunction;
+  ///
+  /// The same as NotifyContext passed into CreateEvent().
+  ///
+  VOID                    *NotifyContext;
+  ///
+  /// The EFI_EVENT returned by CreateEvent(). Event must be in runtime memory.
+  ///
+  EFI_EVENT               *Event;
+  ///
+  /// Entry for this node in the
+  /// EFI_RUNTIME_ARCHITECTURE_PROTOCOL.EventHead list.
+  ///
+  EFI_LIST_ENTRY          Link;
+};
+
+///
+/// Allows the runtime functionality of the DXE Foundation to be contained in a 
+/// separate driver. It also provides hooks for the DXE Foundation to export 
+/// information that is needed at runtime. As such, this protocol allows the DXE 
+/// Foundation to manage runtime drivers and events. This protocol also implies 
+/// that the runtime services required to transition to virtual mode, 
+/// SetVirtualAddressMap() and ConvertPointer(), have been registered into the 
+/// EFI Runtime Table in the EFI System Partition.  This protocol must be produced 
+/// by a runtime DXE driver and may only be consumed by the DXE Foundation.
+///
+struct _EFI_RUNTIME_ARCH_PROTOCOL {
+  EFI_LIST_ENTRY          ImageHead;    ///< A list of type EFI_RUNTIME_IMAGE_ENTRY.
+  EFI_LIST_ENTRY          EventHead;    ///< A list of type EFI_RUNTIME_EVENT_ENTRY.
+  UINTN                   MemoryDescriptorSize;   ///< Size of a memory descriptor that is returned by GetMemoryMap().
+  UINT32                  MemoryDesciptorVersion; ///< Version of a memory descriptor that is returned by GetMemoryMap().
+  UINTN                   MemoryMapSize;///< Size of the memory map in bytes contained in MemoryMapPhysical and MemoryMapVirtual. 
+  EFI_MEMORY_DESCRIPTOR   *MemoryMapPhysical;     ///< Pointer to a runtime buffer that contains a copy of 
+                                                  ///< the memory map returned via GetMemoryMap().
+  EFI_MEMORY_DESCRIPTOR   *MemoryMapVirtual;      ///< Pointer to MemoryMapPhysical that is updated to virtual mode after SetVirtualAddressMap().
+  BOOLEAN                 VirtualMode;  ///< Boolean that is TRUE if SetVirtualAddressMap() has been called.
+  BOOLEAN                 AtRuntime;    ///< Boolean that is TRUE if ExitBootServices () has been called.
+};
+
+extern EFI_GUID gEfiRuntimeArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/S3SaveState.h b/MdePkg/Include/Protocol/S3SaveState.h
new file mode 100644
index 000000000000..c25e103f7692
--- /dev/null
+++ b/MdePkg/Include/Protocol/S3SaveState.h
@@ -0,0 +1,176 @@
+/** @file
+  S3 Save State Protocol as defined in PI1.2 Specification VOLUME 5 Standard.
+
+  This protocol is used by DXE PI module to store or record various IO operations 
+  to be replayed during an S3 resume.
+  This protocol is not required for all platforms.
+  
+  Copyright (c) 2009 - 2011, 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.             
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Volume 5: 
+  Standards
+
+**/
+
+#ifndef __S3_SAVE_STATE_H__
+#define __S3_SAVE_STATE_H__
+
+#define EFI_S3_SAVE_STATE_PROTOCOL_GUID \
+    { 0xe857caf6, 0xc046, 0x45dc, { 0xbe, 0x3f, 0xee, 0x7, 0x65, 0xfb, 0xa8, 0x87 }}
+
+
+typedef VOID *EFI_S3_BOOT_SCRIPT_POSITION;
+
+typedef struct _EFI_S3_SAVE_STATE_PROTOCOL  EFI_S3_SAVE_STATE_PROTOCOL;
+
+/**
+  Record operations that need to be replayed during an S3 resume.
+  
+  This function is used to store an OpCode to be replayed as part of the S3 resume boot path. It is
+  assumed this protocol has platform specific mechanism to store the OpCode set and replay them
+  during the S3 resume.
+  
+  @param[in]    This    A pointer to the EFI_S3_SAVE_STATE_PROTOCOL instance.
+  @param[in]    OpCode  The operation code (opcode) number.
+  @param[in]    ...     Argument list that is specific to each opcode. See the following subsections for the
+                        definition of each opcode.
+                        
+  @retval EFI_SUCCESS           The operation succeeded. A record was added into the specified
+                                script table.                    
+  @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script is not supported.
+  @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.                       
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_S3_SAVE_STATE_WRITE)(
+   IN CONST EFI_S3_SAVE_STATE_PROTOCOL  *This,
+   IN       UINT16                      OpCode,
+   ...
+);
+
+/**
+  Record operations that need to be replayed during an S3 resume.
+  
+  This function is used to store an OpCode to be replayed as part of the S3 resume boot path. It is
+  assumed this protocol has platform specific mechanism to store the OpCode set and replay them
+  during the S3 resume.
+  The opcode is inserted before or after the specified position in the boot script table. If Position is
+  NULL then that position is after the last opcode in the table (BeforeOrAfter is TRUE) or before
+  the first opcode in the table (BeforeOrAfter is FALSE). The position which is pointed to by
+  Position upon return can be used for subsequent insertions.
+  
+  This function has a variable parameter list. The exact parameter list depends on the OpCode that is
+  passed into the function. If an unsupported OpCode or illegal parameter list is passed in, this
+  function returns EFI_INVALID_PARAMETER.
+  If there are not enough resources available for storing more scripts, this function returns
+  EFI_OUT_OF_RESOURCES.
+  OpCode values of 0x80 - 0xFE are reserved for implementation specific functions.
+  
+  @param[in]        This            A pointer to the EFI_S3_SAVE_STATE_PROTOCOL instance.
+  @param[in]        BeforeOrAfter   Specifies whether the opcode is stored before (TRUE) or after (FALSE) the position
+                                    in the boot script table specified by Position. If Position is NULL or points to
+                                    NULL then the new opcode is inserted at the beginning of the table (if TRUE) or end
+                                    of the table (if FALSE).
+  @param[in, out]   Position        On entry, specifies the position in the boot script table where the opcode will be
+                                    inserted, either before or after, depending on BeforeOrAfter. On exit, specifies
+                                    the position of the inserted opcode in the boot script table.
+  @param[in]        OpCode          The operation code (opcode) number. See "Related Definitions" in Write() for the
+                                    defined opcode types.
+  @param[in]        ...             Argument list that is specific to each opcode. See the following subsections for the
+                                    definition of each opcode. 
+                                    
+  @retval EFI_SUCCESS               The operation succeeded. An opcode was added into the script.
+  @retval EFI_INVALID_PARAMETER     The Opcode is an invalid opcode value.
+  @retval EFI_INVALID_PARAMETER     The Position is not a valid position in the boot script table.
+  @retval EFI_OUT_OF_RESOURCES      There is insufficient memory to store the boot script table.                                                                       
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_S3_SAVE_STATE_INSERT)(
+   IN CONST EFI_S3_SAVE_STATE_PROTOCOL  *This,
+   IN       BOOLEAN                     BeforeOrAfter,
+   IN OUT   EFI_S3_BOOT_SCRIPT_POSITION *Position       OPTIONAL,
+   IN       UINT16                      OpCode,
+   ...
+);
+
+/**
+  Find a label within the boot script table and, if not present, optionally create it.
+  
+  If the label Label is already exists in the boot script table, then no new label is created, the
+  position of the Label is returned in *Position and EFI_SUCCESS is returned.
+  If the label Label does not already exist and CreateIfNotFound is TRUE, then it will be
+  created before or after the specified position and EFI_SUCCESS is returned.
+  If the label Label does not already exist and CreateIfNotFound is FALSE, then
+  EFI_NOT_FOUND is returned.
+  
+  @param[in]      This                A pointer to the EFI_S3_SAVE_STATE_PROTOCOL instance.
+  @param[in]      BeforeOrAfter       Specifies whether the label is stored before (TRUE) or after (FALSE) the position in
+                                      the boot script table specified by Position. If Position is NULL or points to
+                                      NULL then the new label is inserted at the beginning of the table (if TRUE) or end of
+                                      the table (if FALSE).
+  @param[in]      CreateIfNotFound    Specifies whether the label will be created if the label does not exists (TRUE) or not (FALSE).
+  @param[in, out] Position            On entry, specifies the position in the boot script table where the label will be inserted,
+                                      either before or after, depending on BeforeOrAfter. On exit, specifies the position
+                                      of the inserted label in the boot script table.
+  @param[in]      Label               Points to the label which will be inserted in the boot script table.
+  
+  @retval    EFI_SUCCESS              The label already exists or was inserted.
+  @retval    EFI_NOT_FOUND            The label did not already exist and CreateifNotFound was FALSE.
+  @retval    EFI_INVALID_PARAMETER    The Label is NULL or points to an empty string.
+  @retval    EFI_INVALID_PARAMETER    The Position is not a valid position in the boot script table.
+  @retval    EFI_OUT_OF_RESOURCES     There is insufficient memory to store the boot script.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_S3_SAVE_STATE_LABEL)(
+   IN CONST  EFI_S3_SAVE_STATE_PROTOCOL      *This,
+   IN        BOOLEAN                         BeforeOrAfter,
+   IN        BOOLEAN                         CreateIfNotFound,
+   IN OUT    EFI_S3_BOOT_SCRIPT_POSITION     *Position OPTIONAL,
+   IN CONST  CHAR8                           *Label
+);
+
+/**
+  Compare two positions in the boot script table and return their relative position.
+  
+  This function compares two positions in the boot script table and returns their relative positions. If
+  Position1 is before Position2, then -1 is returned. If Position1 is equal to Position2,
+  then 0 is returned. If Position1 is after Position2, then 1 is returned.
+  
+  @param[in]    This                A pointer to the EFI_S3_SAVE_STATE_PROTOCOL instance.
+  @param[in]    Position1           The positions in the boot script table to compare.
+  @param[in]    Position2           The positions in the boot script table to compare.
+  @param[out]   RelativePosition    On return, points to the result of the comparison.
+  
+  @retval   EFI_SUCCESS             The operation succeeded.
+  @retval   EFI_INVALID_PARAMETER   The Position1 or Position2 is not a valid position in the boot script table.
+  @retval   EFI_INVALID_PARAMETER   The RelativePosition is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_S3_SAVE_STATE_COMPARE)(
+   IN CONST EFI_S3_SAVE_STATE_PROTOCOL          *This,
+   IN       EFI_S3_BOOT_SCRIPT_POSITION         Position1,
+   IN       EFI_S3_BOOT_SCRIPT_POSITION         Position2,
+   OUT      UINTN                               *RelativePosition
+);
+
+struct _EFI_S3_SAVE_STATE_PROTOCOL {
+  EFI_S3_SAVE_STATE_WRITE   Write;
+  EFI_S3_SAVE_STATE_INSERT  Insert;
+  EFI_S3_SAVE_STATE_LABEL   Label;
+  EFI_S3_SAVE_STATE_COMPARE Compare;
+};
+
+extern EFI_GUID gEfiS3SaveStateProtocolGuid;
+
+#endif // __S3_SAVE_STATE_H__
diff --git a/MdePkg/Include/Protocol/S3SmmSaveState.h b/MdePkg/Include/Protocol/S3SmmSaveState.h
new file mode 100644
index 000000000000..3cdfec7a1701
--- /dev/null
+++ b/MdePkg/Include/Protocol/S3SmmSaveState.h
@@ -0,0 +1,46 @@
+/** @file
+  S3 SMM Save State Protocol as defined in PI1.2 Specification VOLUME 5 Standard.
+
+  The EFI_S3_SMM_SAVE_STATE_PROTOCOL publishes the PI SMMboot script abstractions
+  On an S3 resume boot path the data stored via this protocol is replayed in the order it was stored.
+  The order of replay is the order either of the S3 Save State Protocol or S3 SMM Save State Protocol
+  Write() functions were called during the boot process. Insert(), Label(), and
+  Compare() operations are ordered relative other S3 SMM Save State Protocol write() operations
+  and the order relative to S3 State Save Write() operations is not defined. Due to these ordering
+  restrictions it is recommended that the S3 State Save Protocol be used during the DXE phase when
+  every possible.
+  The EFI_S3_SMM_SAVE_STATE_PROTOCOL can be called at runtime and
+  EFI_OUT_OF_RESOURCES may be returned from a runtime call. It is the responsibility of the
+  platform to ensure enough memory resource exists to save the system state. It is recommended that
+  runtime calls be minimized by the caller.
+  
+  Copyright (c) 2009, 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.   
+
+  @par Revision Reference:
+  This PPI is defined in UEFI Platform Initialization Specification 1.2 Volume 5: 
+  Standards          
+
+**/
+
+#ifndef __S3_SMM_SAVE_STATE_H__
+#define __S3_SMM_SAVE_STATE_H__
+
+#include <Protocol/S3SaveState.h>
+
+#define EFI_S3_SMM_SAVE_STATE_PROTOCOL_GUID \
+    {0x320afe62, 0xe593, 0x49cb, { 0xa9, 0xf1, 0xd4, 0xc2, 0xf4, 0xaf, 0x1, 0x4c }}
+    
+
+typedef EFI_S3_SAVE_STATE_PROTOCOL EFI_S3_SMM_SAVE_STATE_PROTOCOL;
+
+extern EFI_GUID gEfiS3SmmSaveStateProtocolGuid;
+    
+#endif // __S3_SMM_SAVE_STATE_H__
+
diff --git a/MdePkg/Include/Protocol/ScsiIo.h b/MdePkg/Include/Protocol/ScsiIo.h
new file mode 100644
index 000000000000..833fb1ceeffa
--- /dev/null
+++ b/MdePkg/Include/Protocol/ScsiIo.h
@@ -0,0 +1,317 @@
+/** @file
+  EFI_SCSI_IO_PROTOCOL as defined in UEFI 2.0.
+  This protocol is used by code, typically drivers, running in the EFI boot 
+  services environment to access SCSI devices. In particular, functions for 
+  managing devices on SCSI buses are defined here.
+
+  Copyright (c) 2006 - 2013, 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 __EFI_SCSI_IO_PROTOCOL_H__
+#define __EFI_SCSI_IO_PROTOCOL_H__
+
+#define EFI_SCSI_IO_PROTOCOL_GUID \
+  { \
+    0x932f47e6, 0x2362, 0x4002, {0x80, 0x3e, 0x3c, 0xd5, 0x4b, 0x13, 0x8f, 0x85 } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_SCSI_IO_PROTOCOL EFI_SCSI_IO_PROTOCOL;
+
+//
+// SCSI Device type information, defined in the SCSI Primary Commands standard (e.g., SPC-4)
+//
+#define EFI_SCSI_IO_TYPE_DISK                                  0x00    ///< Disk device
+#define EFI_SCSI_IO_TYPE_TAPE                                  0x01    ///< Tape device
+#define EFI_SCSI_IO_TYPE_PRINTER                               0x02    ///< Printer
+#define EFI_SCSI_IO_TYPE_PROCESSOR                             0x03    ///< Processor
+#define EFI_SCSI_IO_TYPE_WORM                                  0x04    ///< Write-once read-multiple
+#define EFI_SCSI_IO_TYPE_CDROM                                 0x05    ///< CD or DVD device
+#define EFI_SCSI_IO_TYPE_SCANNER                               0x06    ///< Scanner device
+#define EFI_SCSI_IO_TYPE_OPTICAL                               0x07    ///< Optical memory device
+#define EFI_SCSI_IO_TYPE_MEDIUMCHANGER                         0x08    ///< Medium Changer device
+#define EFI_SCSI_IO_TYPE_COMMUNICATION                         0x09    ///< Communications device
+#define MFI_SCSI_IO_TYPE_A                                     0x0A    ///< Obsolete
+#define MFI_SCSI_IO_TYPE_B                                     0x0B    ///< Obsolete
+#define MFI_SCSI_IO_TYPE_RAID                                  0x0C    ///< Storage array controller device (e.g., RAID)
+#define MFI_SCSI_IO_TYPE_SES                                   0x0D    ///< Enclosure services device
+#define MFI_SCSI_IO_TYPE_RBC                                   0x0E    ///< Simplified direct-access device (e.g., magnetic disk)
+#define MFI_SCSI_IO_TYPE_OCRW                                  0x0F    ///< Optical card reader/writer device
+#define MFI_SCSI_IO_TYPE_BRIDGE                                0x10    ///< Bridge Controller Commands
+#define MFI_SCSI_IO_TYPE_OSD                                   0x11    ///< Object-based Storage Device
+#define EFI_SCSI_IO_TYPE_RESERVED_LOW                          0x12    ///< Reserved (low)
+#define EFI_SCSI_IO_TYPE_RESERVED_HIGH                         0x1E    ///< Reserved (high)
+#define EFI_SCSI_IO_TYPE_UNKNOWN                               0x1F    ///< Unknown no device type
+
+//
+// SCSI Data Direction definition
+//
+#define EFI_SCSI_IO_DATA_DIRECTION_READ                        0
+#define EFI_SCSI_IO_DATA_DIRECTION_WRITE                       1
+#define EFI_SCSI_IO_DATA_DIRECTION_BIDIRECTIONAL               2
+
+//
+// SCSI Host Adapter Status definition
+//
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_OK                     0x00
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND        0x09    ///< timeout when processing the command
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_TIMEOUT                0x0b    ///< timeout when waiting for the command processing
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_MESSAGE_REJECT         0x0d    ///< a message reject was received when processing command
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_BUS_RESET              0x0e    ///< a bus reset was detected
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_PARITY_ERROR           0x0f
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED   0x10    ///< the adapter failed in issuing request sense command
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT      0x11    ///< selection timeout
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN  0x12    ///< data overrun or data underrun
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_BUS_FREE               0x13    ///< Unexepected bus free
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_PHASE_ERROR            0x14    ///< Target bus phase sequence failure
+#define EFI_SCSI_IO_STATUS_HOST_ADAPTER_OTHER                  0x7f
+
+
+//
+// SCSI Target Status definition
+//
+#define EFI_SCSI_IO_STATUS_TARGET_GOOD                         0x00
+#define EFI_SCSI_IO_STATUS_TARGET_CHECK_CONDITION              0x02    ///< check condition
+#define EFI_SCSI_IO_STATUS_TARGET_CONDITION_MET                0x04    ///< condition met
+#define EFI_SCSI_IO_STATUS_TARGET_BUSY                         0x08    ///< busy
+#define EFI_SCSI_IO_STATUS_TARGET_INTERMEDIATE                 0x10    ///< intermediate
+#define EFI_SCSI_IO_STATUS_TARGET_INTERMEDIATE_CONDITION_MET   0x14    ///< intermediate-condition met
+#define EFI_SCSI_IO_STATUS_TARGET_RESERVATION_CONFLICT         0x18    ///< reservation conflict
+#define EFI_SCSI_IO_STATUS_TARGET_COMMOND_TERMINATED           0x22    ///< command terminated
+#define EFI_SCSI_IO_STATUS_TARGET_QUEUE_FULL                   0x28    ///< queue full
+
+typedef struct {
+  ///
+  /// The timeout, in 100 ns units, to use for the execution of this SCSI
+  /// Request Packet. A Timeout value of 0 means that this function
+  /// will wait indefinitely for the SCSI Request Packet to execute. If
+  /// Timeout is greater than zero, then this function will return
+  /// EFI_TIMEOUT if the time required to execute the SCSI Request
+  /// Packet is greater than Timeout.
+  ///
+  UINT64                              Timeout;
+  ///
+  /// A pointer to the data buffer to transfer between the SCSI
+  /// controller and the SCSI device for SCSI READ command
+  ///
+  VOID                                *InDataBuffer;
+  ///
+  /// A pointer to the data buffer to transfer between the SCSI
+  /// controller and the SCSI device for SCSI WRITE command.
+  ///
+  VOID                                *OutDataBuffer;
+  ///
+  /// A pointer to the sense data that was generated by the execution of
+  /// the SCSI Request Packet.
+  ///
+  VOID                                *SenseData;
+  ///
+  /// A pointer to buffer that contains the Command Data Block to
+  /// send to the SCSI device.
+  ///
+  VOID                                *Cdb;
+  ///
+  /// On Input, the size, in bytes, of InDataBuffer. On output, the
+  /// number of bytes transferred between the SCSI controller and the SCSI device.
+  ///
+  UINT32                              InTransferLength;
+  ///
+  /// On Input, the size, in bytes of OutDataBuffer. On Output, the
+  /// Number of bytes transferred between SCSI Controller and the SCSI device.
+  ///
+  UINT32                              OutTransferLength;
+  ///
+  /// The length, in bytes, of the buffer Cdb. The standard values are
+  /// 6, 10, 12, and 16, but other values are possible if a variable length CDB is used.
+  ///
+  UINT8                               CdbLength;
+  ///
+  /// The direction of the data transfer. 0 for reads, 1 for writes. A
+  /// value of 2 is Reserved for Bi-Directional SCSI commands.
+  ///
+  UINT8                               DataDirection;
+  ///
+  /// The status of the SCSI Host Controller that produces the SCSI
+  /// bus where the SCSI device attached when the SCSI Request
+  /// Packet was executed on the SCSI Controller.
+  ///
+  UINT8                               HostAdapterStatus;
+  ///
+  /// The status returned by the SCSI device when the SCSI Request
+  /// Packet was executed.
+  ///
+  UINT8                               TargetStatus;
+  ///
+  /// On input, the length in bytes of the SenseData buffer. On
+  /// output, the number of bytes written to the SenseData buffer.
+  ///
+  UINT8                               SenseDataLength;
+} EFI_SCSI_IO_SCSI_REQUEST_PACKET;
+
+/**
+  Retrieves the device type information of the SCSI Controller.
+
+  @param  This       Protocol instance pointer.
+  @param  DeviceType A pointer to the device type information
+                     retrieved from the SCSI Controller.
+
+  @retval EFI_SUCCESS           Retrieved the device type information successfully.
+  @retval EFI_INVALID_PARAMETER The DeviceType is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_IO_PROTOCOL_GET_DEVICE_TYPE)(
+  IN  EFI_SCSI_IO_PROTOCOL            *This,
+  OUT UINT8                           *DeviceType
+  );
+
+/**
+  Retrieves the device location in the SCSI channel.
+
+  @param  This   Protocol instance pointer.
+  @param  Target A pointer to the Target ID of a SCSI device
+                 on the SCSI channel.
+  @param  Lun    A pointer to the LUN of the SCSI device on
+                 the SCSI channel.
+
+  @retval EFI_SUCCESS           Retrieves the device location successfully.
+  @retval EFI_INVALID_PARAMETER The Target or Lun is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_IO_PROTOCOL_GET_DEVICE_LOCATION)(
+  IN EFI_SCSI_IO_PROTOCOL           *This,
+  IN OUT UINT8                      **Target,
+  OUT UINT64                        *Lun
+  );
+
+/**
+  Resets the SCSI Bus that the SCSI Controller is attached to.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS      The SCSI bus is reset successfully.
+  @retval EFI_DEVICE_ERROR Errors encountered when resetting the SCSI bus.
+  @retval EFI_UNSUPPORTED  The bus reset operation is not supported by the
+                           SCSI Host Controller.
+  @retval EFI_TIMEOUT      A timeout occurred while attempting to reset
+                            the SCSI bus.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_IO_PROTOCOL_RESET_BUS)(
+  IN EFI_SCSI_IO_PROTOCOL     *This
+  );
+
+/**
+  Resets the SCSI Controller that the device handle specifies.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS      Reset the SCSI controller successfully.
+  @retval EFI_DEVICE_ERROR Errors were encountered when resetting the
+                           SCSI Controller.
+  @retval EFI_UNSUPPORTED  The SCSI bus does not support a device
+                           reset operation.
+  @retval EFI_TIMEOUT      A timeout occurred while attempting to
+                           reset the SCSI Controller.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_IO_PROTOCOL_RESET_DEVICE)(
+  IN EFI_SCSI_IO_PROTOCOL     *This
+  );
+
+
+/**
+  Sends a SCSI Request Packet to the SCSI Controller for execution.
+
+  @param  This    Protocol instance pointer.
+  @param  Packet  The SCSI request packet to send to the SCSI
+                  Controller specified by the device handle.
+  @param  Event   If the SCSI bus to which the SCSI device is attached
+                  does not support non-blocking I/O, then Event is
+                  ignored, and blocking I/O is performed.
+                  If Event is NULL, then blocking I/O is performed.
+                  If Event is not NULL and non-blocking I/O is
+                  supported, then non-blocking I/O is performed,
+                  and Event will be signaled when the SCSI Request
+                  Packet completes.
+
+  @retval EFI_SUCCESS               The SCSI Request Packet was sent by the host
+                                    successfully, and TransferLength bytes were
+                                    transferred to/from DataBuffer. See
+                                    HostAdapterStatus, TargetStatus,
+                                    SenseDataLength, and SenseData in that order
+                                    for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE       The SCSI Request Packet was executed,
+                                    but the entire DataBuffer could not be transferred.
+                                    The actual number of bytes transferred is returned
+                                    in TransferLength. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+  @retval EFI_NOT_READY             The SCSI Request Packet could not be sent because
+                                    there are too many SCSI Command Packets already
+                                    queued.The caller may retry again later.
+  @retval EFI_DEVICE_ERROR          A device error occurred while attempting to send
+                                    the SCSI Request Packet. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+  @retval EFI_INVALID_PARAMETER     The contents of CommandPacket are invalid.
+                                    The SCSI Request Packet was not sent, so no
+                                    additional status information is available.
+  @retval EFI_UNSUPPORTED           The command described by the SCSI Request Packet
+                                    is not supported by the SCSI initiator(i.e., SCSI
+                                    Host Controller). The SCSI Request Packet was not
+                                    sent, so no additional status information is
+                                    available.
+  @retval EFI_TIMEOUT               A timeout occurred while waiting for the SCSI
+                                    Request Packet to execute. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_IO_PROTOCOL_EXEC_SCSI_COMMAND)(
+  IN EFI_SCSI_IO_PROTOCOL                   *This,
+  IN OUT  EFI_SCSI_IO_SCSI_REQUEST_PACKET   *Packet,
+  IN EFI_EVENT                              Event  OPTIONAL
+  );
+
+///
+/// Provides services to manage and communicate with SCSI devices.
+///
+struct _EFI_SCSI_IO_PROTOCOL {
+  EFI_SCSI_IO_PROTOCOL_GET_DEVICE_TYPE      GetDeviceType;
+  EFI_SCSI_IO_PROTOCOL_GET_DEVICE_LOCATION  GetDeviceLocation;
+  EFI_SCSI_IO_PROTOCOL_RESET_BUS            ResetBus;
+  EFI_SCSI_IO_PROTOCOL_RESET_DEVICE         ResetDevice;
+  EFI_SCSI_IO_PROTOCOL_EXEC_SCSI_COMMAND    ExecuteScsiCommand;    
+
+  ///
+  /// Supplies the alignment requirement for any buffer used in a data transfer. 
+  /// IoAlign values of 0 and 1 mean that the buffer can be placed anywhere in memory. 
+  /// Otherwise, IoAlign must be a power of 2, and the requirement is that the 
+  /// start address of a buffer must be evenly divisible by IoAlign with no remainder.
+  ///
+  UINT32                                    IoAlign;
+};
+
+extern EFI_GUID gEfiScsiIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ScsiPassThru.h b/MdePkg/Include/Protocol/ScsiPassThru.h
new file mode 100644
index 000000000000..baf0d2bfc7fe
--- /dev/null
+++ b/MdePkg/Include/Protocol/ScsiPassThru.h
@@ -0,0 +1,383 @@
+/** @file
+  SCSI Pass Through protocol as defined in EFI 1.1.
+  This protocol allows information about a SCSI channel to be collected, 
+  and allows SCSI Request Packets to be sent to any SCSI devices on a SCSI
+  channel even if those devices are not boot devices. This protocol is attached 
+  to the device handle of each SCSI channel in a system that the protocol 
+  supports, and can be used for diagnostics. It may also be used to build 
+  a Block I/O driver for SCSI hard drives and SCSI CD-ROM or DVD drives to
+  allow those devices to become boot devices.
+
+  Copyright (c) 2006 - 2008, 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 __SCSI_PASS_THROUGH_H__
+#define __SCSI_PASS_THROUGH_H__
+
+#define EFI_SCSI_PASS_THRU_PROTOCOL_GUID \
+  { \
+    0xa59e8fcf, 0xbda0, 0x43bb, {0x90, 0xb1, 0xd3, 0x73, 0x2e, 0xca, 0xa8, 0x77 } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_SCSI_PASS_THRU_PROTOCOL  EFI_SCSI_PASS_THRU_PROTOCOL;
+
+#define EFI_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL    0x0001
+#define EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL     0x0002
+#define EFI_SCSI_PASS_THRU_ATTRIBUTES_NONBLOCKIO  0x0004
+
+//
+// SCSI Host Adapter Status definition
+//
+#define EFI_SCSI_STATUS_HOST_ADAPTER_OK                     0x00
+#define EFI_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND        0x09  // timeout when processing the command
+#define EFI_SCSI_STATUS_HOST_ADAPTER_TIMEOUT                0x0b  // timeout when waiting for the command processing
+#define EFI_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT         0x0d  // a message reject was received when processing command
+#define EFI_SCSI_STATUS_HOST_ADAPTER_BUS_RESET              0x0e  // a bus reset was detected
+#define EFI_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR           0x0f
+#define EFI_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED   0x10  // the adapter failed in issuing request sense command
+#define EFI_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT      0x11  // selection timeout
+#define EFI_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN  0x12  // data overrun or data underrun
+#define EFI_SCSI_STATUS_HOST_ADAPTER_BUS_FREE               0x13  // Unexepected bus free
+#define EFI_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR            0x14  // Target bus phase sequence failure
+#define EFI_SCSI_STATUS_HOST_ADAPTER_OTHER                  0x7f
+
+//
+// SCSI Target Status definition
+//
+#define EFI_SCSI_STATUS_TARGET_GOOD                       0x00
+#define EFI_SCSI_STATUS_TARGET_CHECK_CONDITION            0x02  // check condition
+#define EFI_SCSI_STATUS_TARGET_CONDITION_MET              0x04  // condition met
+#define EFI_SCSI_STATUS_TARGET_BUSY                       0x08  // busy
+#define EFI_SCSI_STATUS_TARGET_INTERMEDIATE               0x10  // intermediate
+#define EFI_SCSI_STATUS_TARGET_INTERMEDIATE_CONDITION_MET 0x14  // intermediate-condition met
+#define EFI_SCSI_STATUS_TARGET_RESERVATION_CONFLICT       0x18  // reservation conflict
+#define EFI_SCSI_STATUS_TARGET_COMMOND_TERMINATED         0x22  // command terminated
+#define EFI_SCSI_STATUS_TARGET_QUEUE_FULL                 0x28  // queue full
+
+typedef struct {
+  ///
+  /// The timeout, in 100 ns units, to use for the execution of this SCSI
+  /// Request Packet. A Timeout value of 0 means that this function
+  /// will wait indefinitely for the SCSI Request Packet to execute. If
+  /// Timeout is greater than zero, then this function will return
+  /// EFI_TIMEOUT if the time required to execute the SCSI Request
+  /// Packet is greater than Timeout.
+  ///
+  UINT64  Timeout;
+  ///
+  /// A pointer to the data buffer to transfer between the SCSI
+  /// controller and the SCSI device. Must be aligned to the boundary
+  /// specified in the IoAlign field of the
+  /// EFI_SCSI_PASS_THRU_MODE structure.
+  ///
+  VOID    *DataBuffer;
+  ///
+  /// A pointer to the sense data that was generated by the execution of
+  /// the SCSI Request Packet.
+  ///
+  VOID    *SenseData;
+  ///
+  /// A pointer to buffer that contains the Command Data Block to
+  /// send to the SCSI device.
+  ///
+  VOID    *Cdb;
+  ///
+  /// On Input, the size, in bytes, of InDataBuffer. On output, the
+  /// number of bytes transferred between the SCSI controller and the SCSI device.
+  ///
+  UINT32  TransferLength;
+  ///
+  /// The length, in bytes, of the buffer Cdb. The standard values are
+  /// 6, 10, 12, and 16, but other values are possible if a variable length CDB is used.
+  ///
+  UINT8   CdbLength;
+  ///
+  /// The direction of the data transfer. 0 for reads, 1 for writes. A
+  /// value of 2 is Reserved for Bi-Directional SCSI commands.
+  ///
+  UINT8   DataDirection;
+  ///
+  /// The status of the SCSI Host Controller that produces the SCSI
+  /// bus where the SCSI device attached when the SCSI Request
+  /// Packet was executed on the SCSI Controller.
+  ///
+  UINT8   HostAdapterStatus;
+  ///
+  /// The status returned by the SCSI device when the SCSI Request
+  /// Packet was executed.
+  ///
+  UINT8   TargetStatus;
+  ///
+  /// On input, the length in bytes of the SenseData buffer. On
+  /// output, the number of bytes written to the SenseData buffer.
+  ///
+  UINT8   SenseDataLength;
+} EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET;
+
+typedef struct {
+  ///
+  /// A Null-terminated Unicode string that represents the printable name of the SCSI controller.
+  ///
+  CHAR16  *ControllerName;
+  ///
+  /// A Null-terminated Unicode string that represents the printable name of the SCSI channel.
+  ///
+  CHAR16  *ChannelName;
+  ///
+  /// The Target ID of the host adapter on the SCSI channel.
+  ///
+  UINT32  AdapterId;
+  ///
+  /// Additional information on the attributes of the SCSI channel.
+  ///
+  UINT32  Attributes;
+  ///
+  /// Supplies the alignment requirement for any buffer used in a data transfer.
+  ///
+  UINT32  IoAlign;
+} EFI_SCSI_PASS_THRU_MODE;
+
+/**
+  Sends a SCSI Request Packet to a SCSI device that is attached to 
+  the SCSI channel. This function supports both blocking I/O and 
+  non-blocking I/O.  The blocking I/O functionality is required, 
+  and the non-blocking I/O functionality is optional.
+
+  @param  This   Protocol instance pointer.
+  @param  Target The Target ID of the SCSI device to
+                 send the SCSI Request Packet.
+  @param  Lun    The LUN of the SCSI device to send the
+                 SCSI Request Packet.
+  @param  Packet A pointer to the SCSI Request Packet to send
+                 to the SCSI device specified by Target and Lun.
+  @param  Event  If non-blocking I/O is not supported then Event
+                 is ignored, and blocking I/O is performed.
+                 If Event is NULL, then blocking I/O is performed.
+                 If Event is not NULL and non blocking I/O is
+                 supported, then non-blocking I/O is performed,
+                 and Event will be signaled when the SCSI Request
+                 Packet completes
+
+  @retval EFI_SUCCESS               The SCSI Request Packet was sent by the host, and
+                                    TransferLength bytes were transferred to/from
+                                    DataBuffer. See HostAdapterStatus, TargetStatus,
+                                    SenseDataLength, and SenseData in that order
+                                    for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE       The SCSI Request Packet was executed, but the
+                                    entire DataBuffer could not be transferred.
+                                    The actual number of bytes transferred is returned
+                                    in TransferLength. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+  @retval EFI_NOT_READY             The SCSI Request Packet could not be sent because
+                                    there are too many SCSI Request Packets already
+                                    queued.  The caller may retry again later.
+  @retval EFI_DEVICE_ERROR          A device error occurred while attempting to send
+                                    the SCSI Request Packet. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+  @retval EFI_INVALID_PARAMETER     Target, Lun, or the contents of ScsiRequestPacket
+                                    are invalid. The SCSI Request Packet was not sent,
+                                    so no additional status information is available.
+  @retval EFI_UNSUPPORTED           The command described by the SCSI Request Packet
+                                    is not supported by the host adapter. The SCSI
+                                    Request Packet was not sent, so no additional
+                                    status information is available.
+  @retval EFI_TIMEOUT               A timeout occurred while waiting for the SCSI
+                                    Request Packet to execute. See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in
+                                    that order for additional status information.
+                                    
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_PASSTHRU)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL                          *This,
+  IN UINT32                                               Target,
+  IN UINT64                                               Lun,
+  IN OUT EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET           *Packet,
+  IN EFI_EVENT                                            Event   OPTIONAL
+  );
+
+/**
+  Used to retrieve the list of legal Target IDs for SCSI devices 
+  on a SCSI channel.
+
+  @param  This   Protocol instance pointer.
+  @param  Target On input, a pointer to the Target ID of a
+                 SCSI device present on the SCSI channel.
+                 On output, a pointer to the Target ID of
+                 the next SCSI device present on a SCSI channel.
+                 An input value of 0xFFFFFFFF retrieves the
+                 Target ID of the first SCSI device present on
+                 a SCSI channel.
+  @param  Lun    On input, a pointer to the LUN of a SCSI device
+                 present on the SCSI channel. On output, a pointer
+                 to the LUN of the next SCSI device present on a
+                 SCSI channel.
+
+  @retval EFI_SUCCESS           The Target ID of the next SCSI device on the SCSI
+                                channel was returned in Target and Lun.
+  @retval EFI_NOT_FOUND         There are no more SCSI devices on this SCSI channel.
+  @retval EFI_INVALID_PARAMETER Target is not 0xFFFFFFFF, and Target and Lun were
+                                 not returned on a previous call to GetNextDevice().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_GET_NEXT_DEVICE)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL            *This,
+  IN OUT UINT32                             *Target,
+  IN OUT UINT64                             *Lun
+  );
+
+/**
+  Used to allocate and build a device path node for a SCSI device 
+  on a SCSI channel.
+
+  @param  This       Protocol instance pointer.
+  @param  Target     The Target ID of the SCSI device for which
+                     a device path node is to be allocated and built.
+  @param  Lun        The LUN of the SCSI device for which a device
+                     path node is to be allocated and built.
+  @param  DevicePath A pointer to a single device path node that
+                     describes the SCSI device specified by
+                     Target and Lun. This function is responsible
+                     for allocating the buffer DevicePath with the boot
+                     service AllocatePool().  It is the caller's
+                     responsibility to free DevicePath when the caller
+                     is finished with DevicePath.
+
+  @retval EFI_SUCCESS           The device path node that describes the SCSI device
+                                specified by Target and Lun was allocated and
+                                returned in DevicePath.
+  @retval EFI_NOT_FOUND         The SCSI devices specified by Target and Lun does
+                                not exist on the SCSI channel.
+  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate
+                                DevicePath.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_BUILD_DEVICE_PATH)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL            *This,
+  IN     UINT32                             Target,
+  IN     UINT64                             Lun,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL           **DevicePath
+  );
+
+/**
+  Used to translate a device path node to a Target ID and LUN.
+
+  @param  This       Protocol instance pointer.
+  @param  DevicePath A pointer to the device path node that
+                     describes a SCSI device on the SCSI channel.
+  @param  Target     A pointer to the Target ID of a SCSI device
+                     on the SCSI channel.
+  @param  Lun        A pointer to the LUN of a SCSI device on
+                     the SCSI channel.
+
+  @retval EFI_SUCCESS           DevicePath was successfully translated to a
+                                Target ID and LUN, and they were returned
+                                in Target and Lun.
+  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
+  @retval EFI_INVALID_PARAMETER Target is NULL.
+  @retval EFI_INVALID_PARAMETER Lun is NULL.
+  @retval EFI_UNSUPPORTED       This driver does not support the device path
+                                node type in DevicePath.
+  @retval EFI_NOT_FOUND         A valid translation from DevicePath to a
+                                Target ID and LUN does not exist.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_GET_TARGET_LUN)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL            *This,
+  IN  EFI_DEVICE_PATH_PROTOCOL              *DevicePath,
+  OUT UINT32                                *Target,
+  OUT UINT64                                *Lun
+  );
+
+/**
+  Resets a SCSI channel.This operation resets all the 
+  SCSI devices connected to the SCSI channel.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS      The SCSI channel was reset.
+  @retval EFI_UNSUPPORTED  The SCSI channel does not support
+                           a channel reset operation.
+  @retval EFI_DEVICE_ERROR A device error occurred while
+                           attempting to reset the SCSI channel.
+  @retval EFI_TIMEOUT      A timeout occurred while attempting
+                           to reset the SCSI channel.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_RESET_CHANNEL)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL             *This
+  );
+
+/**
+  Resets a SCSI device that is connected to a SCSI channel.
+
+  @param  This   Protocol instance pointer.
+  @param  Target The Target ID of the SCSI device to reset.
+  @param  Lun    The LUN of the SCSI device to reset.
+
+  @retval EFI_SUCCESS           The SCSI device specified by Target and
+                                Lun was reset.
+  @retval EFI_UNSUPPORTED       The SCSI channel does not support a target
+                                reset operation.
+  @retval EFI_INVALID_PARAMETER Target or Lun are invalid.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting
+                                to reset the SCSI device specified by Target
+                                and Lun.
+  @retval EFI_TIMEOUT           A timeout occurred while attempting to reset
+                                the SCSI device specified by Target and Lun.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SCSI_PASS_THRU_RESET_TARGET)(
+  IN EFI_SCSI_PASS_THRU_PROTOCOL             *This,
+  IN UINT32                                  Target,
+  IN UINT64                                  Lun
+  );
+
+///
+/// The EFI_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel and
+/// the ability to send SCSI Request Packets to any SCSI device attached to that SCSI channel. The
+/// information includes the Target ID of the host controller on the SCSI channel, the attributes of
+/// the SCSI channel, the printable name for the SCSI controller, and the printable name of the
+/// SCSI channel.
+///
+struct _EFI_SCSI_PASS_THRU_PROTOCOL {
+  ///
+  /// A pointer to the EFI_SCSI_PASS_THRU_MODE data for this SCSI channel.
+  ///
+  EFI_SCSI_PASS_THRU_MODE               *Mode;
+  EFI_SCSI_PASS_THRU_PASSTHRU           PassThru;
+  EFI_SCSI_PASS_THRU_GET_NEXT_DEVICE    GetNextDevice;
+  EFI_SCSI_PASS_THRU_BUILD_DEVICE_PATH  BuildDevicePath;
+  EFI_SCSI_PASS_THRU_GET_TARGET_LUN     GetTargetLun;
+  EFI_SCSI_PASS_THRU_RESET_CHANNEL      ResetChannel;
+  EFI_SCSI_PASS_THRU_RESET_TARGET       ResetTarget;
+};
+
+extern EFI_GUID gEfiScsiPassThruProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ScsiPassThruExt.h b/MdePkg/Include/Protocol/ScsiPassThruExt.h
new file mode 100644
index 000000000000..a9d4047e0e7a
--- /dev/null
+++ b/MdePkg/Include/Protocol/ScsiPassThruExt.h
@@ -0,0 +1,394 @@
+/** @file
+  EFI_EXT_SCSI_PASS_THRU_PROTOCOL as defined in UEFI 2.0.
+  This protocol provides services that allow SCSI Pass Thru commands 
+  to be sent to SCSI devices attached to a SCSI channel.
+
+  Copyright (c) 2006 - 2008, 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 __EXT_SCSI_PASS_THROUGH_PROTOCOL_H__
+#define __EXT_SCSI_PASS_THROUGH_PROTOCOL_H__
+
+#define EFI_EXT_SCSI_PASS_THRU_PROTOCOL_GUID \
+  { \
+    0x143b7632, 0xb81b, 0x4cb7, {0xab, 0xd3, 0xb6, 0x25, 0xa5, 0xb9, 0xbf, 0xfe } \
+  }
+
+typedef struct _EFI_EXT_SCSI_PASS_THRU_PROTOCOL EFI_EXT_SCSI_PASS_THRU_PROTOCOL;
+
+#define TARGET_MAX_BYTES                             0x10
+
+#define EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL   0x0001
+#define EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL    0x0002
+#define EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_NONBLOCKIO 0x0004
+
+//
+// DataDirection
+//
+#define EFI_EXT_SCSI_DATA_DIRECTION_READ             0
+#define EFI_EXT_SCSI_DATA_DIRECTION_WRITE            1
+#define EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL    2
+//
+// HostAdapterStatus
+//
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK                    0x00
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND       0x09
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT               0x0b
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT        0x0d
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET             0x0e
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR          0x0f
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED  0x10
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT     0x11
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN 0x12
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_FREE              0x13
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR           0x14
+#define EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER                 0x7f
+//
+// TargetStatus
+//
+#define EFI_EXT_SCSI_STATUS_TARGET_GOOD                        0x00
+#define EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION             0x02
+#define EFI_EXT_SCSI_STATUS_TARGET_CONDITION_MET               0x04
+#define EFI_EXT_SCSI_STATUS_TARGET_BUSY                        0x08
+#define EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE                0x10
+#define EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE_CONDITION_MET  0x14
+#define EFI_EXT_SCSI_STATUS_TARGET_RESERVATION_CONFLICT        0x18
+#define EFI_EXT_SCSI_STATUS_TARGET_TASK_SET_FULL               0x28
+#define EFI_EXT_SCSI_STATUS_TARGET_ACA_ACTIVE                  0x30
+#define EFI_EXT_SCSI_STATUS_TARGET_TASK_ABORTED                0x40
+
+typedef struct {
+  ///
+  /// The Target ID of the host adapter on the SCSI channel.
+  ///
+  UINT32 AdapterId;
+  ///
+  /// Additional information on the attributes of the SCSI channel.
+  ///
+  UINT32 Attributes;
+  ///
+  /// Supplies the alignment requirement for any buffer used in a data transfer.
+  ///
+  UINT32 IoAlign;
+} EFI_EXT_SCSI_PASS_THRU_MODE;
+
+typedef struct {
+  ///
+  /// The timeout, in 100 ns units, to use for the execution of this SCSI
+  /// Request Packet. A Timeout value of 0 means that this function
+  /// will wait indefinitely for the SCSI Request Packet to execute. If
+  /// Timeout is greater than zero, then this function will return
+  /// EFI_TIMEOUT if the time required to execute the SCSI
+  /// Request Packet is greater than Timeout.
+  ///
+  UINT64 Timeout;
+  ///
+  /// A pointer to the data buffer to transfer between the SCSI
+  /// controller and the SCSI device for read and bidirectional commands.
+  ///
+  VOID   *InDataBuffer;
+  ///
+  /// A pointer to the data buffer to transfer between the SCSI
+  /// controller and the SCSI device for write or bidirectional commands.
+  ///
+  VOID   *OutDataBuffer;
+  ///
+  /// A pointer to the sense data that was generated by the execution of
+  /// the SCSI Request Packet.
+  ///
+  VOID   *SenseData;
+  ///
+  /// A pointer to buffer that contains the Command Data Block to
+  /// send to the SCSI device specified by Target and Lun.
+  ///
+  VOID   *Cdb;
+  ///
+  /// On Input, the size, in bytes, of InDataBuffer. On output, the
+  /// number of bytes transferred between the SCSI controller and the SCSI device.
+  ///
+  UINT32 InTransferLength;
+  ///
+  /// On Input, the size, in bytes of OutDataBuffer. On Output, the
+  /// Number of bytes transferred between SCSI Controller and the SCSI device.
+  ///
+  UINT32 OutTransferLength;
+  ///
+  /// The length, in bytes, of the buffer Cdb. The standard values are 6,
+  /// 10, 12, and 16, but other values are possible if a variable length CDB is used.
+  ///
+  UINT8  CdbLength;
+  ///
+  /// The direction of the data transfer. 0 for reads, 1 for writes. A
+  /// value of 2 is Reserved for Bi-Directional SCSI commands.
+  ///
+  UINT8  DataDirection;
+  ///
+  /// The status of the host adapter specified by This when the SCSI
+  /// Request Packet was executed on the target device.
+  ///
+  UINT8  HostAdapterStatus;
+  ///
+  /// The status returned by the device specified by Target and Lun
+  /// when the SCSI Request Packet was executed.
+  ///
+  UINT8  TargetStatus;
+  ///
+  /// On input, the length in bytes of the SenseData buffer. On
+  /// output, the number of bytes written to the SenseData buffer.
+  ///
+  UINT8  SenseDataLength;
+} EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET;
+
+/**
+  Sends a SCSI Request Packet to a SCSI device that is attached to the SCSI channel. This function   
+  supports both blocking I/O and nonblocking I/O. The blocking I/O functionality is required, and the
+  nonblocking I/O functionality is optional.                                                             
+
+  @param  This    A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  Target  The Target is an array of size TARGET_MAX_BYTES and it represents
+                  the id of the SCSI device to send the SCSI Request Packet. Each
+                  transport driver may choose to utilize a subset of this size to suit the needs
+                  of transport target representation. For example, a Fibre Channel driver
+                  may use only 8 bytes (WWN) to represent an FC target.
+  @param  Lun     The LUN of the SCSI device to send the SCSI Request Packet.
+  @param  Packet  A pointer to the SCSI Request Packet to send to the SCSI device
+                  specified by Target and Lun.
+  @param  Event   If nonblocking I/O is not supported then Event is ignored, and blocking
+                  I/O is performed. If Event is NULL, then blocking I/O is performed. If
+                  Event is not NULL and non blocking I/O is supported, then
+                  nonblocking I/O is performed, and Event will be signaled when the
+                  SCSI Request Packet completes.
+
+  @retval EFI_SUCCESS           The SCSI Request Packet was sent by the host. For bi-directional
+                                commands, InTransferLength bytes were transferred from
+                                InDataBuffer. For write and bi-directional commands,
+                                OutTransferLength bytes were transferred by
+                                OutDataBuffer.
+  @retval EFI_BAD_BUFFER_SIZE   The SCSI Request Packet was not executed. The number of bytes that
+                                could be transferred is returned in InTransferLength. For write
+                                and bi-directional commands, OutTransferLength bytes were
+                                transferred by OutDataBuffer.
+  @retval EFI_NOT_READY         The SCSI Request Packet could not be sent because there are too many
+                                SCSI Request Packets already queued. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to send the SCSI Request
+                                Packet.
+  @retval EFI_INVALID_PARAMETER Target, Lun, or the contents of ScsiRequestPacket are invalid.
+  @retval EFI_UNSUPPORTED       The command described by the SCSI Request Packet is not supported
+                                by the host adapter. This includes the case of Bi-directional SCSI
+                                commands not supported by the implementation. The SCSI Request
+                                Packet was not sent, so no additional status information is available.
+  @retval EFI_TIMEOUT           A timeout occurred while waiting for the SCSI Request Packet to execute.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_PASSTHRU)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL                *This,
+  IN UINT8                                          *Target,
+  IN UINT64                                         Lun,
+  IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
+  IN EFI_EVENT                                      Event     OPTIONAL
+  );      
+
+/**
+  Used to retrieve the list of legal Target IDs and LUNs for SCSI devices on a SCSI channel. These       
+  can either be the list SCSI devices that are actually present on the SCSI channel, or the list of legal
+  Target Ids and LUNs for the SCSI channel. Regardless, the caller of this function must probe the       
+  Target ID and LUN returned to see if a SCSI device is actually present at that location on the SCSI    
+  channel.                                                                                               
+
+  @param  This   A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  Target On input, a pointer to the Target ID (an array of size
+                 TARGET_MAX_BYTES) of a SCSI device present on the SCSI channel.
+                 On output, a pointer to the Target ID (an array of
+                 TARGET_MAX_BYTES) of the next SCSI device present on a SCSI
+                 channel. An input value of 0xF(all bytes in the array are 0xF) in the
+                 Target array retrieves the Target ID of the first SCSI device present on a
+                 SCSI channel.
+  @param  Lun    On input, a pointer to the LUN of a SCSI device present on the SCSI
+                 channel. On output, a pointer to the LUN of the next SCSI device present
+                 on a SCSI channel.
+
+  @retval EFI_SUCCESS           The Target ID and LUN of the next SCSI device on the SCSI
+                                channel was returned in Target and Lun.
+  @retval EFI_INVALID_PARAMETER Target array is not all 0xF, and Target and Lun were
+                                not returned on a previous call to GetNextTargetLun().
+  @retval EFI_NOT_FOUND         There are no more SCSI devices on this SCSI channel.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_GET_NEXT_TARGET_LUN)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL                *This,
+  IN OUT UINT8                                      **Target,
+  IN OUT UINT64                                     *Lun
+  );   
+
+/**
+  Used to allocate and build a device path node for a SCSI device on a SCSI channel.
+
+  @param  This       A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  Target     The Target is an array of size TARGET_MAX_BYTES and it specifies the
+                     Target ID of the SCSI device for which a device path node is to be
+                     allocated and built. Transport drivers may chose to utilize a subset of
+                     this size to suit the representation of targets. For example, a Fibre
+                     Channel driver may use only 8 bytes (WWN) in the array to represent a
+                     FC target.
+  @param  Lun        The LUN of the SCSI device for which a device path node is to be
+                     allocated and built.
+  @param  DevicePath A pointer to a single device path node that describes the SCSI device
+                     specified by Target and Lun. This function is responsible for
+                     allocating the buffer DevicePath with the boot service
+                     AllocatePool(). It is the caller's responsibility to free
+                     DevicePath when the caller is finished with DevicePath.
+
+  @retval EFI_SUCCESS           The device path node that describes the SCSI device specified by
+                                Target and Lun was allocated and returned in
+                                DevicePath.
+  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
+  @retval EFI_NOT_FOUND         The SCSI devices specified by Target and Lun does not exist
+                                on the SCSI channel.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate DevicePath.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_BUILD_DEVICE_PATH)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL               *This,
+  IN UINT8                                         *Target,
+  IN UINT64                                        Lun,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL                  **DevicePath
+  );
+
+/**
+  Used to translate a device path node to a Target ID and LUN.
+
+  @param  This       A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  DevicePath A pointer to a single device path node that describes the SCSI device
+                     on the SCSI channel.
+  @param  Target     A pointer to the Target Array which represents the ID of a SCSI device
+                     on the SCSI channel.
+  @param  Lun        A pointer to the LUN of a SCSI device on the SCSI channel.
+
+  @retval EFI_SUCCESS           DevicePath was successfully translated to a Target ID and
+                                LUN, and they were returned in Target and Lun.
+  @retval EFI_INVALID_PARAMETER DevicePath or Target or Lun is NULL.
+  @retval EFI_NOT_FOUND         A valid translation from DevicePath to a Target ID and LUN
+                                does not exist.
+  @retval EFI_UNSUPPORTED       This driver does not support the device path node type in
+                                 DevicePath.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_GET_TARGET_LUN)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL               *This,
+  IN EFI_DEVICE_PATH_PROTOCOL                      *DevicePath,
+  OUT UINT8                                        **Target,
+  OUT UINT64                                       *Lun
+  );       
+
+/**
+  Resets a SCSI channel. This operation resets all the SCSI devices connected to the SCSI channel.
+
+  @param  This A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+
+  @retval EFI_SUCCESS      The SCSI channel was reset.
+  @retval EFI_DEVICE_ERROR A device error occurred while attempting to reset the SCSI channel.
+  @retval EFI_TIMEOUT      A timeout occurred while attempting to reset the SCSI channel.
+  @retval EFI_UNSUPPORTED  The SCSI channel does not support a channel reset operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_RESET_CHANNEL)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL               *This
+  );    
+  
+/**
+  Resets a SCSI logical unit that is connected to a SCSI channel.
+
+  @param  This   A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  Target The Target is an array of size TARGET_MAX_BYTE and it represents the
+                 target port ID of the SCSI device containing the SCSI logical unit to
+                 reset. Transport drivers may chose to utilize a subset of this array to suit
+                 the representation of their targets.
+  @param  Lun    The LUN of the SCSI device to reset.
+
+  @retval EFI_SUCCESS           The SCSI device specified by Target and Lun was reset.
+  @retval EFI_INVALID_PARAMETER Target or Lun is NULL.
+  @retval EFI_TIMEOUT           A timeout occurred while attempting to reset the SCSI device
+                                specified by Target and Lun.
+  @retval EFI_UNSUPPORTED       The SCSI channel does not support a target reset operation.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to reset the SCSI device
+                                 specified by Target and Lun.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_RESET_TARGET_LUN)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL               *This,
+  IN UINT8                                         *Target,
+  IN UINT64                                        Lun
+  );         
+
+/**
+  Used to retrieve the list of legal Target IDs for SCSI devices on a SCSI channel. These can either     
+  be the list SCSI devices that are actually present on the SCSI channel, or the list of legal Target IDs
+  for the SCSI channel. Regardless, the caller of this function must probe the Target ID returned to     
+  see if a SCSI device is actually present at that location on the SCSI channel.                         
+
+  @param  This   A pointer to the EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
+  @param  Target (TARGET_MAX_BYTES) of a SCSI device present on the SCSI channel.
+                 On output, a pointer to the Target ID (an array of
+                 TARGET_MAX_BYTES) of the next SCSI device present on a SCSI
+                 channel. An input value of 0xF(all bytes in the array are 0xF) in the
+                 Target array retrieves the Target ID of the first SCSI device present on a
+                 SCSI channel.
+
+  @retval EFI_SUCCESS           The Target ID of the next SCSI device on the SCSI
+                                channel was returned in Target.
+  @retval EFI_INVALID_PARAMETER Target or Lun is NULL.
+  @retval EFI_TIMEOUT           Target array is not all 0xF, and Target was not
+                                returned on a previous call to GetNextTarget().
+  @retval EFI_NOT_FOUND         There are no more SCSI devices on this SCSI channel.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXT_SCSI_PASS_THRU_GET_NEXT_TARGET)(
+  IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL               *This,
+  IN OUT UINT8                                     **Target
+  );          
+
+///
+/// The EFI_EXT_SCSI_PASS_THRU_PROTOCOL provides information about a SCSI channel 
+/// and the ability to send SCI Request Packets to any SCSI device attached to 
+/// that SCSI channel. The information includes the Target ID of the host controller 
+/// on the SCSI channel and the attributes of the SCSI channel.
+///
+struct _EFI_EXT_SCSI_PASS_THRU_PROTOCOL {
+  ///
+  /// A pointer to the EFI_EXT_SCSI_PASS_THRU_MODE data for this SCSI channel.
+  ///
+  EFI_EXT_SCSI_PASS_THRU_MODE                *Mode;
+  EFI_EXT_SCSI_PASS_THRU_PASSTHRU            PassThru;
+  EFI_EXT_SCSI_PASS_THRU_GET_NEXT_TARGET_LUN GetNextTargetLun;
+  EFI_EXT_SCSI_PASS_THRU_BUILD_DEVICE_PATH   BuildDevicePath;
+  EFI_EXT_SCSI_PASS_THRU_GET_TARGET_LUN      GetTargetLun;
+  EFI_EXT_SCSI_PASS_THRU_RESET_CHANNEL       ResetChannel;
+  EFI_EXT_SCSI_PASS_THRU_RESET_TARGET_LUN    ResetTargetLun;
+  EFI_EXT_SCSI_PASS_THRU_GET_NEXT_TARGET     GetNextTarget;
+};
+
+extern EFI_GUID gEfiExtScsiPassThruProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SdMmcPassThru.h b/MdePkg/Include/Protocol/SdMmcPassThru.h
new file mode 100644
index 000000000000..ddbf45632cc5
--- /dev/null
+++ b/MdePkg/Include/Protocol/SdMmcPassThru.h
@@ -0,0 +1,264 @@
+/** @file
+  The EFI_SD_MMC_PASS_THRU_PROTOCOL provides the ability to send SD/MMC Commands
+  to any SD/MMC device attached to the SD compatible pci host controller.
+
+  Copyright (c) 2015, 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 __SD_MMC_PASS_THRU_H__
+#define __SD_MMC_PASS_THRU_H__
+
+#define EFI_SD_MMC_PASS_THRU_PROTOCOL_GUID \
+  { \
+    0x716ef0d9, 0xff83, 0x4f69, {0x81, 0xe9, 0x51, 0x8b, 0xd3, 0x9a, 0x8e, 0x70 } \
+  }
+
+typedef struct _EFI_SD_MMC_PASS_THRU_PROTOCOL EFI_SD_MMC_PASS_THRU_PROTOCOL;
+
+typedef enum {
+  SdMmcCommandTypeBc,  // Broadcast commands, no response
+  SdMmcCommandTypeBcr, // Broadcast commands with response
+  SdMmcCommandTypeAc,  // Addressed(point-to-point) commands
+  SdMmcCommandTypeAdtc // Addressed(point-to-point) data transfer commands
+} EFI_SD_MMC_COMMAND_TYPE;
+
+typedef enum {
+  SdMmcResponseTypeR1,
+  SdMmcResponseTypeR1b,
+  SdMmcResponseTypeR2,
+  SdMmcResponseTypeR3,
+  SdMmcResponseTypeR4,
+  SdMmcResponseTypeR5,
+  SdMmcResponseTypeR5b,
+  SdMmcResponseTypeR6,
+  SdMmcResponseTypeR7
+} EFI_SD_MMC_RESPONSE_TYPE;
+
+typedef struct _EFI_SD_MMC_COMMAND_BLOCK {
+  UINT16                            CommandIndex;
+  UINT32                            CommandArgument;
+  UINT32                            CommandType;      // One of the EFI_SD_MMC_COMMAND_TYPE values
+  UINT32                            ResponseType;     // One of the EFI_SD_MMC_RESPONSE_TYPE values
+} EFI_SD_MMC_COMMAND_BLOCK;
+
+typedef struct _EFI_SD_MMC_STATUS_BLOCK {
+  UINT32                            Resp0;
+  UINT32                            Resp1;
+  UINT32                            Resp2;
+  UINT32                            Resp3;
+} EFI_SD_MMC_STATUS_BLOCK;
+
+typedef struct _EFI_SD_MMC_PASS_THRU_COMMAND_PACKET {
+  UINT64                            Timeout;
+  EFI_SD_MMC_COMMAND_BLOCK          *SdMmcCmdBlk;
+  EFI_SD_MMC_STATUS_BLOCK           *SdMmcStatusBlk;
+  VOID                              *InDataBuffer;
+  VOID                              *OutDataBuffer;
+  UINT32                            InTransferLength;
+  UINT32                            OutTransferLength;
+  EFI_STATUS                        TransactionStatus;
+} EFI_SD_MMC_PASS_THRU_COMMAND_PACKET;
+
+/**
+  Sends SD command to an SD card that is attached to the SD controller.
+
+  The PassThru() function sends the SD command specified by Packet to the SD card
+  specified by Slot.
+
+  If Packet is successfully sent to the SD card, then EFI_SUCCESS is returned.
+
+  If a device error occurs while sending the Packet, then EFI_DEVICE_ERROR is returned.
+
+  If Slot is not in a valid range for the SD controller, then EFI_INVALID_PARAMETER
+  is returned.
+
+  If Packet defines a data command but both InDataBuffer and OutDataBuffer are NULL,
+  EFI_INVALID_PARAMETER is returned.
+
+  @param[in]     This           A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
+  @param[in]     Slot           The slot number of the SD card to send the command to.
+  @param[in,out] Packet         A pointer to the SD command data structure.
+  @param[in]     Event          If Event is NULL, blocking I/O is performed. If Event is
+                                not NULL, then nonblocking I/O is performed, and Event
+                                will be signaled when the Packet completes.
+
+  @retval EFI_SUCCESS           The SD Command Packet was sent by the host.
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to send the SD
+                                command Packet.
+  @retval EFI_INVALID_PARAMETER Packet, Slot, or the contents of the Packet is invalid.
+  @retval EFI_INVALID_PARAMETER Packet defines a data command but both InDataBuffer and
+                                OutDataBuffer are NULL.
+  @retval EFI_NO_MEDIA          SD Device not present in the Slot.
+  @retval EFI_UNSUPPORTED       The command described by the SD Command Packet is not
+                                supported by the host controller.
+  @retval EFI_BAD_BUFFER_SIZE   The InTransferLength or OutTransferLength exceeds the
+                                limit supported by SD card ( i.e. if the number of bytes
+                                exceed the Last LBA).
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SD_MMC_PASS_THRU_PASSTHRU) (
+  IN     EFI_SD_MMC_PASS_THRU_PROTOCOL         *This,
+  IN     UINT8                                 Slot,
+  IN OUT EFI_SD_MMC_PASS_THRU_COMMAND_PACKET   *Packet,
+  IN     EFI_EVENT                             Event    OPTIONAL
+);
+
+/**
+  Used to retrieve next slot numbers supported by the SD controller. The function
+  returns information about all available slots (populated or not-populated).
+
+  The GetNextSlot() function retrieves the next slot number on an SD controller.
+  If on input Slot is 0xFF, then the slot number of the first slot on the SD controller
+  is returned.
+
+  If Slot is a slot number that was returned on a previous call to GetNextSlot(), then
+  the slot number of the next slot on the SD controller is returned.
+
+  If Slot is not 0xFF and Slot was not returned on a previous call to GetNextSlot(),
+  EFI_INVALID_PARAMETER is returned.
+
+  If Slot is the slot number of the last slot on the SD controller, then EFI_NOT_FOUND
+  is returned.
+
+  @param[in]     This           A pointer to the EFI_SD_MMMC_PASS_THRU_PROTOCOL instance.
+  @param[in,out] Slot           On input, a pointer to a slot number on the SD controller.
+                                On output, a pointer to the next slot number on the SD controller.
+                                An input value of 0xFF retrieves the first slot number on the SD
+                                controller.
+
+  @retval EFI_SUCCESS           The next slot number on the SD controller was returned in Slot.
+  @retval EFI_NOT_FOUND         There are no more slots on this SD controller.
+  @retval EFI_INVALID_PARAMETER Slot is not 0xFF and Slot was not returned on a previous call
+                                to GetNextSlot().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SD_MMC_PASS_THRU_GET_NEXT_SLOT) (
+  IN     EFI_SD_MMC_PASS_THRU_PROTOCOL        *This,
+  IN OUT UINT8                                *Slot
+);
+
+/**
+  Used to allocate and build a device path node for an SD card on the SD controller.
+
+  The BuildDevicePath() function allocates and builds a single device node for the SD
+  card specified by Slot.
+
+  If the SD card specified by Slot is not present on the SD controller, then EFI_NOT_FOUND
+  is returned.
+
+  If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  If there are not enough resources to allocate the device path node, then EFI_OUT_OF_RESOURCES
+  is returned.
+
+  Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of
+  DevicePath are initialized to describe the SD card specified by Slot, and EFI_SUCCESS is
+  returned.
+
+  @param[in]     This           A pointer to the EFI_SD_MMMC_PASS_THRU_PROTOCOL instance.
+  @param[in]     Slot           Specifies the slot number of the SD card for which a device
+                                path node is to be allocated and built.
+  @param[in,out] DevicePath     A pointer to a single device path node that describes the SD
+                                card specified by Slot. This function is responsible for
+                                allocating the buffer DevicePath with the boot service
+                                AllocatePool(). It is the caller's responsibility to free
+                                DevicePath when the caller is finished with DevicePath.
+
+  @retval EFI_SUCCESS           The device path node that describes the SD card specified by
+                                Slot was allocated and returned in DevicePath.
+  @retval EFI_NOT_FOUND         The SD card specified by Slot does not exist on the SD controller.
+  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate DevicePath.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SD_MMC_PASS_THRU_BUILD_DEVICE_PATH) (
+  IN     EFI_SD_MMC_PASS_THRU_PROTOCOL       *This,
+  IN     UINT8                               Slot,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL            **DevicePath
+);
+
+/**
+  This function retrieves an SD card slot number based on the input device path.
+
+  The GetSlotNumber() function retrieves slot number for the SD card specified by
+  the DevicePath node. If DevicePath is NULL, EFI_INVALID_PARAMETER is returned.
+
+  If DevicePath is not a device path node type that the SD Pass Thru driver supports,
+  EFI_UNSUPPORTED is returned.
+
+  @param[in]  This              A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
+  @param[in]  DevicePath        A pointer to the device path node that describes a SD
+                                card on the SD controller.
+  @param[out] Slot              On return, points to the slot number of an SD card on
+                                the SD controller.
+
+  @retval EFI_SUCCESS           SD card slot number is returned in Slot.
+  @retval EFI_INVALID_PARAMETER Slot or DevicePath is NULL.
+  @retval EFI_UNSUPPORTED       DevicePath is not a device path node type that the SD
+                                Pass Thru driver supports.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SD_MMC_PASS_THRU_GET_SLOT_NUMBER) (
+  IN  EFI_SD_MMC_PASS_THRU_PROTOCOL          *This,
+  IN  EFI_DEVICE_PATH_PROTOCOL               *DevicePath,
+  OUT UINT8                                  *Slot
+);
+
+/**
+  Resets an SD card that is connected to the SD controller.
+
+  The ResetDevice() function resets the SD card specified by Slot.
+
+  If this SD controller does not support a device reset operation, EFI_UNSUPPORTED is
+  returned.
+
+  If Slot is not in a valid slot number for this SD controller, EFI_INVALID_PARAMETER
+  is returned.
+
+  If the device reset operation is completed, EFI_SUCCESS is returned.
+
+  @param[in]  This              A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
+  @param[in]  Slot              Specifies the slot number of the SD card to be reset.
+
+  @retval EFI_SUCCESS           The SD card specified by Slot was reset.
+  @retval EFI_UNSUPPORTED       The SD controller does not support a device reset operation.
+  @retval EFI_INVALID_PARAMETER Slot number is invalid.
+  @retval EFI_NO_MEDIA          SD Device not present in the Slot.
+  @retval EFI_DEVICE_ERROR      The reset command failed due to a device error
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SD_MMC_PASS_THRU_RESET_DEVICE) (
+  IN EFI_SD_MMC_PASS_THRU_PROTOCOL           *This,
+  IN UINT8                                   Slot
+);
+
+struct _EFI_SD_MMC_PASS_THRU_PROTOCOL {
+  UINT32                                     IoAlign;
+  EFI_SD_MMC_PASS_THRU_PASSTHRU              PassThru;
+  EFI_SD_MMC_PASS_THRU_GET_NEXT_SLOT         GetNextSlot;
+  EFI_SD_MMC_PASS_THRU_BUILD_DEVICE_PATH     BuildDevicePath;
+  EFI_SD_MMC_PASS_THRU_GET_SLOT_NUMBER       GetSlotNumber;
+  EFI_SD_MMC_PASS_THRU_RESET_DEVICE          ResetDevice;
+};
+
+extern EFI_GUID gEfiSdMmcPassThruProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Security.h b/MdePkg/Include/Protocol/Security.h
new file mode 100644
index 000000000000..54c51fa43209
--- /dev/null
+++ b/MdePkg/Include/Protocol/Security.h
@@ -0,0 +1,103 @@
+/** @file
+  Security Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  Used to provide Security services.  Specifically, dependening upon the 
+  authentication state of a discovered driver in a Firmware Volume, the 
+  portable DXE Core Dispatcher will call into the Security Architectural 
+  Protocol (SAP) with the authentication state of the driver.
+
+  This call-out allows for OEM-specific policy decisions to be made, such
+  as event logging for attested boots, locking flash in response to discovering
+  an unsigned driver or failed signature check, or other exception response.
+
+  The SAP can also change system behavior by having the DXE core put a driver
+  in the Schedule-On-Request (SOR) state.  This will allow for later disposition 
+  of the driver by platform agent, such as Platform BDS.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_SECURITY_H__
+#define __ARCH_PROTOCOL_SECURITY_H__
+
+///
+/// Global ID for the Security Code Architectural Protocol
+///
+#define EFI_SECURITY_ARCH_PROTOCOL_GUID  \
+  { 0xA46423E3, 0x4617, 0x49f1, {0xB9, 0xFF, 0xD1, 0xBF, 0xA9, 0x11, 0x58, 0x39 } }
+
+typedef struct _EFI_SECURITY_ARCH_PROTOCOL    EFI_SECURITY_ARCH_PROTOCOL;
+
+/**
+  The EFI_SECURITY_ARCH_PROTOCOL (SAP) is used to abstract platform-specific 
+  policy from the DXE core response to an attempt to use a file that returns a 
+  given status for the authentication check from the section extraction protocol.  
+
+  The possible responses in a given SAP implementation may include locking 
+  flash upon failure to authenticate, attestation logging for all signed drivers, 
+  and other exception operations.  The File parameter allows for possible logging 
+  within the SAP of the driver.
+
+  If File is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  If the file specified by File with an authentication status specified by 
+  AuthenticationStatus is safe for the DXE Core to use, then EFI_SUCCESS is returned.
+
+  If the file specified by File with an authentication status specified by 
+  AuthenticationStatus is not safe for the DXE Core to use under any circumstances, 
+  then EFI_ACCESS_DENIED is returned.
+
+  If the file specified by File with an authentication status specified by 
+  AuthenticationStatus is not safe for the DXE Core to use right now, but it 
+  might be possible to use it at a future time, then EFI_SECURITY_VIOLATION is 
+  returned.
+
+  @param  This             The EFI_SECURITY_ARCH_PROTOCOL instance.
+  @param  AuthenticationStatus 
+                           This is the authentication type returned from the Section
+                           Extraction protocol. See the Section Extraction Protocol
+                           Specification for details on this type.
+  @param  File             This is a pointer to the device path of the file that is
+                           being dispatched. This will optionally be used for logging.
+
+  @retval EFI_SUCCESS           The file specified by File did authenticate, and the
+                                platform policy dictates that the DXE Core may use File.
+  @retval EFI_INVALID_PARAMETER Driver is NULL.
+  @retval EFI_SECURITY_VIOLATION The file specified by File did not authenticate, and
+                                the platform policy dictates that File should be placed
+                                in the untrusted state. A file may be promoted from
+                                the untrusted to the trusted state at a future time
+                                with a call to the Trust() DXE Service.
+  @retval EFI_ACCESS_DENIED     The file specified by File did not authenticate, and
+                                the platform policy dictates that File should not be
+                                used for any purpose.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_SECURITY_FILE_AUTHENTICATION_STATE)(
+  IN  CONST EFI_SECURITY_ARCH_PROTOCOL *This,
+  IN  UINT32                           AuthenticationStatus,
+  IN  CONST EFI_DEVICE_PATH_PROTOCOL   *File
+  );
+
+///
+/// The EFI_SECURITY_ARCH_PROTOCOL is used to abstract platform-specific policy
+/// from the DXE core.  This includes locking flash upon failure to authenticate, 
+/// attestation logging, and other exception operations.
+///
+struct _EFI_SECURITY_ARCH_PROTOCOL {
+  EFI_SECURITY_FILE_AUTHENTICATION_STATE  FileAuthenticationState;
+};
+
+extern EFI_GUID gEfiSecurityArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Security2.h b/MdePkg/Include/Protocol/Security2.h
new file mode 100644
index 000000000000..a8d79156907c
--- /dev/null
+++ b/MdePkg/Include/Protocol/Security2.h
@@ -0,0 +1,107 @@
+/** @file
+  Security2 Architectural Protocol as defined in PI Specification1.2.1 VOLUME 2 DXE
+
+  Abstracts security-specific functions from the DXE Foundation of UEFI Image Verification,
+  Trusted Computing Group (TCG) measured boot, and User Identity policy for image loading and
+  consoles. This protocol must be produced by a boot service or runtime DXE driver.
+  
+  This protocol is optional and must be published prior to the EFI_SECURITY_ARCH_PROTOCOL.
+  As a result, the same driver must publish both of these interfaces.
+  
+  When both Security and Security2 Architectural Protocols are published, LoadImage must use
+  them in accordance with the following rules:
+    The Security2 protocol must be used on every image being loaded.
+    The Security protocol must be used after the Securiy2 protocol and only on images that 
+    have been read using Firmware Volume protocol.
+
+  When only Security architectural protocol is published, LoadImage must use it on every image
+  being loaded.
+
+  Copyright (c) 2012, 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 __ARCH_PROTOCOL_SECURITY2_H__
+#define __ARCH_PROTOCOL_SECURITY2_H__
+
+///
+/// Global ID for the Security2 Code Architectural Protocol
+///
+#define EFI_SECURITY2_ARCH_PROTOCOL_GUID \
+  { 0x94ab2f58, 0x1438, 0x4ef1, {0x91, 0x52, 0x18, 0x94, 0x1a, 0x3a, 0x0e, 0x68 } }
+  
+typedef struct _EFI_SECURITY2_ARCH_PROTOCOL    EFI_SECURITY2_ARCH_PROTOCOL;
+
+/**
+  The DXE Foundation uses this service to measure and/or verify a UEFI image.
+
+  This service abstracts the invocation of Trusted Computing Group (TCG) measured boot, UEFI
+  Secure boot, and UEFI User Identity infrastructure. For the former two, the DXE Foundation
+  invokes the FileAuthentication() with a DevicePath and corresponding image in
+  FileBuffer memory. The TCG measurement code will record the FileBuffer contents into the
+  appropriate PCR. The image verification logic will confirm the integrity and provenance of the
+  image in FileBuffer of length FileSize . The origin of the image will be DevicePath in
+  these cases.
+  If the FileBuffer is NULL, the interface will determine if the DevicePath can be connected
+  in order to support the User Identification policy.
+  
+  @param  This             The EFI_SECURITY2_ARCH_PROTOCOL instance.
+  @param  File             A pointer to the device path of the file that is
+                           being dispatched. This will optionally be used for logging.
+  @param  FileBuffer       A pointer to the buffer with the UEFI file image.
+  @param  FileSize         The size of the file.
+  @param  BootPolicy       A boot policy that was used to call LoadImage() UEFI service. If
+                           FileAuthentication() is invoked not from the LoadImage(),
+                           BootPolicy must be set to FALSE.
+  
+  @retval EFI_SUCCESS             The file specified by DevicePath and non-NULL
+                                  FileBuffer did authenticate, and the platform policy dictates
+                                  that the DXE Foundation may use the file.
+  @retval EFI_SUCCESS             The device path specified by NULL device path DevicePath
+                                  and non-NULL FileBuffer did authenticate, and the platform
+                                  policy dictates that the DXE Foundation may execute the image in
+                                  FileBuffer.
+  @retval EFI_SUCCESS             FileBuffer is NULL and current user has permission to start
+                                  UEFI device drivers on the device path specified by DevicePath.
+  @retval EFI_SECURITY_VIOLATION  The file specified by DevicePath and FileBuffer did not
+                                  authenticate, and the platform policy dictates that the file should be
+                                  placed in the untrusted state. The image has been added to the file
+                                  execution table.
+  @retval EFI_ACCESS_DENIED       The file specified by File and FileBuffer did not
+                                  authenticate, and the platform policy dictates that the DXE
+                                  Foundation may not use File.
+  @retval EFI_SECURITY_VIOLATION  FileBuffer is NULL and the user has no
+                                  permission to start UEFI device drivers on the device path specified
+                                  by DevicePath.
+  @retval EFI_SECURITY_VIOLATION  FileBuffer is not NULL and the user has no permission to load
+                                  drivers from the device path specified by DevicePath. The
+                                  image has been added into the list of the deferred images.
+**/
+typedef EFI_STATUS (EFIAPI *EFI_SECURITY2_FILE_AUTHENTICATION) (  
+  IN CONST EFI_SECURITY2_ARCH_PROTOCOL *This,
+  IN CONST EFI_DEVICE_PATH_PROTOCOL    *DevicePath,
+  IN VOID                              *FileBuffer,
+  IN UINTN                             FileSize,
+  IN BOOLEAN                           BootPolicy
+);
+
+///
+/// The EFI_SECURITY2_ARCH_PROTOCOL is used to abstract platform-specific policy from the
+/// DXE Foundation. This includes measuring the PE/COFF image prior to invoking, comparing the
+/// image against a policy (whether a white-list/black-list of public image verification keys
+/// or registered hashes).
+///
+struct _EFI_SECURITY2_ARCH_PROTOCOL {
+  EFI_SECURITY2_FILE_AUTHENTICATION FileAuthentication;
+};
+
+extern EFI_GUID gEfiSecurity2ArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SecurityPolicy.h b/MdePkg/Include/Protocol/SecurityPolicy.h
new file mode 100644
index 000000000000..ceff5ac22752
--- /dev/null
+++ b/MdePkg/Include/Protocol/SecurityPolicy.h
@@ -0,0 +1,26 @@
+/** @file
+  Security Policy protocol as defined in PI Specification VOLUME 2 DXE
+
+  Copyright (c) 2006 - 2008, 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 _SECURITY_POLICY_H_
+#define _SECURITY_POLICY_H_
+
+///
+/// Security policy protocol GUID definition
+///
+#define EFI_SECURITY_POLICY_PROTOCOL_GUID  \
+  {0x78E4D245, 0xCD4D, 0x4a05, {0xA2, 0xBA, 0x47, 0x43, 0xE8, 0x6C, 0xFC, 0xAB} }
+
+extern EFI_GUID gEfiSecurityPolicyProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SerialIo.h b/MdePkg/Include/Protocol/SerialIo.h
new file mode 100644
index 000000000000..8371f42b2ec9
--- /dev/null
+++ b/MdePkg/Include/Protocol/SerialIo.h
@@ -0,0 +1,299 @@
+/** @file
+  Serial IO protocol as defined in the UEFI 2.0 specification.
+
+  Abstraction of a basic serial device. Targeted at 16550 UART, but
+  could be much more generic.
+
+  Copyright (c) 2006 - 2015, 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 __SERIAL_IO_PROTOCOL_H__
+#define __SERIAL_IO_PROTOCOL_H__
+
+#define EFI_SERIAL_IO_PROTOCOL_GUID \
+  { \
+    0xBB25CF6F, 0xF1D4, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD } \
+  }
+
+///
+/// Protocol GUID defined in EFI1.1.
+/// 
+#define SERIAL_IO_PROTOCOL  EFI_SERIAL_IO_PROTOCOL_GUID
+
+typedef struct _EFI_SERIAL_IO_PROTOCOL EFI_SERIAL_IO_PROTOCOL;
+
+
+///
+/// Backward-compatible with EFI1.1.
+/// 
+typedef EFI_SERIAL_IO_PROTOCOL  SERIAL_IO_INTERFACE;
+
+///
+/// Parity type that is computed or checked as each character is transmitted or received. If the
+/// device does not support parity, the value is the default parity value.
+///
+typedef enum {
+  DefaultParity,
+  NoParity,
+  EvenParity,
+  OddParity,
+  MarkParity,
+  SpaceParity
+} EFI_PARITY_TYPE;
+
+///
+/// Stop bits type
+///
+typedef enum {
+  DefaultStopBits,
+  OneStopBit,
+  OneFiveStopBits,
+  TwoStopBits
+} EFI_STOP_BITS_TYPE;
+
+//
+// define for Control bits, grouped by read only, write only, and read write
+//
+//
+// Read Only
+//
+#define EFI_SERIAL_CLEAR_TO_SEND        0x00000010
+#define EFI_SERIAL_DATA_SET_READY       0x00000020
+#define EFI_SERIAL_RING_INDICATE        0x00000040
+#define EFI_SERIAL_CARRIER_DETECT       0x00000080
+#define EFI_SERIAL_INPUT_BUFFER_EMPTY   0x00000100
+#define EFI_SERIAL_OUTPUT_BUFFER_EMPTY  0x00000200
+
+//
+// Write Only
+//
+#define EFI_SERIAL_REQUEST_TO_SEND      0x00000002
+#define EFI_SERIAL_DATA_TERMINAL_READY  0x00000001
+
+//
+// Read Write
+//
+#define EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE     0x00001000
+#define EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE     0x00002000
+#define EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE 0x00004000
+
+//
+// Serial IO Member Functions
+//
+/**
+  Reset the serial device.
+
+  @param  This              Protocol instance pointer.
+                            
+  @retval EFI_SUCCESS       The device was reset.
+  @retval EFI_DEVICE_ERROR  The serial device could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_RESET)(
+  IN EFI_SERIAL_IO_PROTOCOL *This
+  );
+
+/**
+  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity, 
+  data bits, and stop bits on a serial device.
+
+  @param  This             Protocol instance pointer.
+  @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the
+                           device's default interface speed.
+  @param  ReveiveFifoDepth The requested depth of the FIFO on the receive side of the
+                           serial interface. A ReceiveFifoDepth value of 0 will use
+                           the device's default FIFO depth.
+  @param  Timeout          The requested time out for a single character in microseconds.
+                           This timeout applies to both the transmit and receive side of the
+                           interface. A Timeout value of 0 will use the device's default time
+                           out value.
+  @param  Parity           The type of parity to use on this serial device. A Parity value of
+                           DefaultParity will use the device's default parity value.
+  @param  DataBits         The number of data bits to use on the serial device. A DataBits
+                           vaule of 0 will use the device's default data bit setting.
+  @param  StopBits         The number of stop bits to use on this serial device. A StopBits
+                           value of DefaultStopBits will use the device's default number of
+                           stop bits.
+
+  @retval EFI_SUCCESS      The device was reset.
+  @retval EFI_DEVICE_ERROR The serial device could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_SET_ATTRIBUTES)(
+  IN EFI_SERIAL_IO_PROTOCOL         *This,
+  IN UINT64                         BaudRate,
+  IN UINT32                         ReceiveFifoDepth,
+  IN UINT32                         Timeout,
+  IN EFI_PARITY_TYPE                Parity,
+  IN UINT8                          DataBits,
+  IN EFI_STOP_BITS_TYPE             StopBits
+  );
+
+/**
+  Set the control bits on a serial device
+
+  @param  This             Protocol instance pointer.
+  @param  Control          Set the bits of Control that are settable.
+
+  @retval EFI_SUCCESS      The new control bits were set on the serial device.
+  @retval EFI_UNSUPPORTED  The serial device does not support this operation.
+  @retval EFI_DEVICE_ERROR The serial device is not functioning correctly.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_SET_CONTROL_BITS)(
+  IN EFI_SERIAL_IO_PROTOCOL         *This,
+  IN UINT32                         Control
+  );
+
+/**
+  Retrieves the status of thecontrol bits on a serial device
+
+  @param  This              Protocol instance pointer.
+  @param  Control           A pointer to return the current Control signals from the serial device.
+                            
+  @retval EFI_SUCCESS       The control bits were read from the serial device.
+  @retval EFI_DEVICE_ERROR  The serial device is not functioning correctly.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_GET_CONTROL_BITS)(
+  IN EFI_SERIAL_IO_PROTOCOL         *This,
+  OUT UINT32                        *Control
+  );
+
+/**
+  Writes data to a serial device.
+
+  @param  This              Protocol instance pointer.
+  @param  BufferSize        On input, the size of the Buffer. On output, the amount of
+                            data actually written.
+  @param  Buffer            The buffer of data to write
+
+  @retval EFI_SUCCESS       The data was written.
+  @retval EFI_DEVICE_ERROR  The device reported an error.
+  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_WRITE)(
+  IN EFI_SERIAL_IO_PROTOCOL         *This,
+  IN OUT UINTN                      *BufferSize,
+  IN VOID                           *Buffer
+  );
+
+/**
+  Writes data to a serial device.
+
+  @param  This              Protocol instance pointer.
+  @param  BufferSize        On input, the size of the Buffer. On output, the amount of
+                            data returned in Buffer.
+  @param  Buffer            The buffer to return the data into.
+
+  @retval EFI_SUCCESS       The data was read.
+  @retval EFI_DEVICE_ERROR  The device reported an error.
+  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_READ)(
+  IN EFI_SERIAL_IO_PROTOCOL         *This,
+  IN OUT UINTN                      *BufferSize,
+  OUT VOID                          *Buffer
+  );
+
+/**
+  @par Data Structure Description:
+  The data values in SERIAL_IO_MODE are read-only and are updated by the code 
+  that produces the SERIAL_IO_PROTOCOL member functions.
+
+  @param ControlMask
+  A mask for the Control bits that the device supports. The device
+  must always support the Input Buffer Empty control bit.
+  
+  @param TimeOut
+  If applicable, the number of microseconds to wait before timing out
+  a Read or Write operation.
+  
+  @param BaudRate
+  If applicable, the current baud rate setting of the device; otherwise,
+  baud rate has the value of zero to indicate that device runs at the
+  device's designed speed.
+  
+  @param ReceiveFifoDepth
+  The number of characters the device will buffer on input
+  
+  @param DataBits
+  The number of characters the device will buffer on input
+  
+  @param Parity
+  If applicable, this is the EFI_PARITY_TYPE that is computed or 
+  checked as each character is transmitted or reveived. If the device
+  does not support parity the value is the default parity value.
+  
+  @param StopBits
+  If applicable, the EFI_STOP_BITS_TYPE number of stop bits per
+  character. If the device does not support stop bits the value is
+  the default stop bit values.
+
+**/
+typedef struct {
+  UINT32  ControlMask;
+
+  //
+  // current Attributes
+  //
+  UINT32  Timeout;
+  UINT64  BaudRate;
+  UINT32  ReceiveFifoDepth;
+  UINT32  DataBits;
+  UINT32  Parity;
+  UINT32  StopBits;
+} EFI_SERIAL_IO_MODE;
+
+#define EFI_SERIAL_IO_PROTOCOL_REVISION    0x00010000
+#define SERIAL_IO_INTERFACE_REVISION  EFI_SERIAL_IO_PROTOCOL_REVISION
+
+///
+/// The Serial I/O protocol is used to communicate with UART-style serial devices. 
+/// These can be standard UART serial ports in PC-AT systems, serial ports attached 
+/// to a USB interface, or potentially any character-based I/O device.
+///
+struct _EFI_SERIAL_IO_PROTOCOL {
+  ///
+  /// The revision to which the EFI_SERIAL_IO_PROTOCOL adheres. All future revisions 
+  /// must be backwards compatible. If a future version is not backwards compatible, 
+  /// it is not the same GUID.
+  ///
+  UINT32                      Revision;
+  EFI_SERIAL_RESET            Reset;
+  EFI_SERIAL_SET_ATTRIBUTES   SetAttributes;
+  EFI_SERIAL_SET_CONTROL_BITS SetControl;
+  EFI_SERIAL_GET_CONTROL_BITS GetControl;
+  EFI_SERIAL_WRITE            Write;
+  EFI_SERIAL_READ             Read;
+  ///
+  /// Pointer to SERIAL_IO_MODE data.
+  ///
+  EFI_SERIAL_IO_MODE          *Mode;
+};
+
+extern EFI_GUID gEfiSerialIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ServiceBinding.h b/MdePkg/Include/Protocol/ServiceBinding.h
new file mode 100644
index 000000000000..546a0d0973d2
--- /dev/null
+++ b/MdePkg/Include/Protocol/ServiceBinding.h
@@ -0,0 +1,94 @@
+/** @file  
+  UEFI Service Binding Protocol is defined in UEFI specification.
+
+  The file defines the generic Service Binding Protocol functions.
+  It provides services that are required to create and destroy child 
+  handles that support a given set of protocols.
+
+  Copyright (c) 2006 - 2016, 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 __EFI_SERVICE_BINDING_H__
+#define __EFI_SERVICE_BINDING_H__
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_SERVICE_BINDING_PROTOCOL EFI_SERVICE_BINDING_PROTOCOL;
+
+/**
+  Creates a child handle and installs a protocol.
+  
+  The CreateChild() function installs a protocol on ChildHandle. 
+  If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle. 
+  If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
+
+  @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
+  @param  ChildHandle Pointer to the handle of the child to create. If it is NULL,
+                      then a new handle is created. If it is a pointer to an existing UEFI handle, 
+                      then the protocol is added to the existing UEFI handle.
+
+  @retval EFI_SUCCES            The protocol was added to ChildHandle.
+  @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to create
+                                the child
+  @retval other                 The child handle was not created
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERVICE_BINDING_CREATE_CHILD)(
+  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
+  IN OUT EFI_HANDLE                    *ChildHandle
+  );
+
+/**
+  Destroys a child handle with a protocol installed on it.
+  
+  The DestroyChild() function does the opposite of CreateChild(). It removes a protocol 
+  that was installed by CreateChild() from ChildHandle. If the removed protocol is the 
+  last protocol on ChildHandle, then ChildHandle is destroyed.
+
+  @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
+  @param  ChildHandle Handle of the child to destroy
+
+  @retval EFI_SUCCES            The protocol was removed from ChildHandle.
+  @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.
+  @retval EFI_INVALID_PARAMETER Child handle is NULL.
+  @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle
+                                because its services are being used.
+  @retval other                 The child handle was not destroyed
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERVICE_BINDING_DESTROY_CHILD)(
+  IN EFI_SERVICE_BINDING_PROTOCOL          *This,
+  IN EFI_HANDLE                            ChildHandle
+  );
+
+///
+/// The EFI_SERVICE_BINDING_PROTOCOL provides member functions to create and destroy 
+/// child handles. A driver is responsible for adding protocols to the child handle 
+/// in CreateChild() and removing protocols in DestroyChild(). It is also required 
+/// that the CreateChild() function opens the parent protocol BY_CHILD_CONTROLLER 
+/// to establish the parent-child relationship, and closes the protocol in DestroyChild().
+/// The pseudo code for CreateChild() and DestroyChild() is provided to specify the 
+/// required behavior, not to specify the required implementation. Each consumer of 
+/// a software protocol is responsible for calling CreateChild() when it requires the 
+/// protocol and calling DestroyChild() when it is finished with that protocol.
+///
+struct _EFI_SERVICE_BINDING_PROTOCOL {
+  EFI_SERVICE_BINDING_CREATE_CHILD         CreateChild;
+  EFI_SERVICE_BINDING_DESTROY_CHILD        DestroyChild;
+};
+
+#endif
diff --git a/MdePkg/Include/Protocol/Shell.h b/MdePkg/Include/Protocol/Shell.h
new file mode 100644
index 000000000000..c16da382b2a6
--- /dev/null
+++ b/MdePkg/Include/Protocol/Shell.h
@@ -0,0 +1,1268 @@
+/** @file
+  EFI Shell protocol as defined in the UEFI Shell 2.0 specification including errata.
+
+  (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2006 - 2016, 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 __EFI_SHELL_PROTOCOL_H__
+#define __EFI_SHELL_PROTOCOL_H__
+
+#include <Guid/FileInfo.h>
+
+#define EFI_SHELL_PROTOCOL_GUID \
+  { \
+  0x6302d008, 0x7f9b, 0x4f30, { 0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e } \
+  }
+typedef VOID *SHELL_FILE_HANDLE;
+
+typedef enum {
+  ///
+  /// The operation completed successfully.
+  ///
+  SHELL_SUCCESS               = 0,
+
+  ///
+  /// The image failed to load.
+  ///
+  SHELL_LOAD_ERROR            = 1,
+
+  ///
+  /// The parameter was incorrect.
+  ///
+  SHELL_INVALID_PARAMETER     = 2,
+
+  ///
+  /// The operation is not supported.
+  ///
+  SHELL_UNSUPPORTED           = 3,
+
+  ///
+  /// The buffer was not the proper size for the request.
+  ///
+  SHELL_BAD_BUFFER_SIZE       = 4,
+
+  ///
+  /// The buffer was not large enough to hold the requested data.
+  /// The required buffer size is returned in the appropriate
+  /// parameter when this error occurs.
+  ///
+  SHELL_BUFFER_TOO_SMALL      = 5,
+
+  ///
+  /// There is no data pending upon return.
+  ///
+  SHELL_NOT_READY             = 6,
+
+  ///
+  /// The physical device reported an error while attempting the
+  /// operation.
+  ///
+  SHELL_DEVICE_ERROR          = 7,
+
+  ///
+  /// The device cannot be written to.
+  ///
+  SHELL_WRITE_PROTECTED       = 8,
+
+  ///
+  /// The resource has run out.
+  ///
+  SHELL_OUT_OF_RESOURCES      = 9,
+
+  ///
+  /// An inconsistency was detected on the file system causing the
+  /// operation to fail.
+  ///
+  SHELL_VOLUME_CORRUPTED      = 10,
+
+  ///
+  /// There is no more space on the file system.
+  ///
+  SHELL_VOLUME_FULL           = 11,
+
+  ///
+  /// The device does not contain any medium to perform the
+  /// operation.
+  ///
+  SHELL_NO_MEDIA              = 12,
+
+  ///
+  /// The medium in the device has changed since the last
+  /// access.
+  ///
+  SHELL_MEDIA_CHANGED         = 13,
+
+  ///
+  /// The item was not found.
+  ///
+  SHELL_NOT_FOUND             = 14,
+
+  ///
+  /// Access was denied.
+  ///
+  SHELL_ACCESS_DENIED         = 15,
+
+  // note the skipping of 16 and 17
+
+  ///
+  /// A timeout time expired.
+  ///
+  SHELL_TIMEOUT               = 18,
+
+  ///
+  /// The protocol has not been started.
+  ///
+  SHELL_NOT_STARTED           = 19,
+
+  ///
+  /// The protocol has already been started.
+  ///
+  SHELL_ALREADY_STARTED       = 20,
+
+  ///
+  /// The operation was aborted.
+  ///
+  SHELL_ABORTED               = 21,
+
+  // note the skipping of 22, 23, and 24
+
+  ///
+  /// A function encountered an internal version that was
+  /// incompatible with a version requested by the caller.
+  ///
+  SHELL_INCOMPATIBLE_VERSION  = 25,
+
+  ///
+  /// The function was not performed due to a security violation.
+  ///
+  SHELL_SECURITY_VIOLATION    = 26,
+
+  ///
+  /// The function was performed and resulted in an unequal
+  /// comparison..
+  ///
+  SHELL_NOT_EQUAL             = 27
+} SHELL_STATUS;
+
+
+// replaced EFI_LIST_ENTRY with LIST_ENTRY for simplicity.
+// they are identical outside of the name.
+typedef struct {
+  LIST_ENTRY        Link;       ///< Linked list members.
+  EFI_STATUS        Status;     ///< Status of opening the file.  Valid only if Handle != NULL.
+  CONST CHAR16      *FullName;  ///< Fully qualified filename.
+  CONST CHAR16      *FileName;  ///< name of this file.
+  SHELL_FILE_HANDLE Handle;     ///< Handle for interacting with the opened file or NULL if closed.
+  EFI_FILE_INFO     *Info;      ///< Pointer to the FileInfo struct for this file or NULL.
+} EFI_SHELL_FILE_INFO;
+
+/**
+  Returns whether any script files are currently being processed.
+
+  @retval TRUE                 There is at least one script file active.
+  @retval FALSE                No script files are active now.
+
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_SHELL_BATCH_IS_ACTIVE) (
+  VOID
+  );
+
+/**
+  Closes the file handle.
+
+  This function closes a specified file handle. All 'dirty' cached file data is
+  flushed to the device, and the file is closed. In all cases, the handle is
+  closed.
+
+  @param[in] FileHandle         The file handle to be closed.
+
+  @retval EFI_SUCCESS           The file closed sucessfully.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_CLOSE_FILE)(
+  IN SHELL_FILE_HANDLE FileHandle
+  );
+
+/**
+  Creates a file or directory by name.
+
+  This function creates an empty new file or directory with the specified attributes and
+  returns the new file's handle. If the file already exists and is read-only, then
+  EFI_INVALID_PARAMETER will be returned.
+
+  If the file already existed, it is truncated and its attributes updated. If the file is
+  created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
+
+  If the file name begins with >v, then the file handle which is returned refers to the
+  shell environment variable with the specified name. If the shell environment variable
+  already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
+
+  @param[in] FileName           Pointer to NULL-terminated file path.
+  @param[in] FileAttribs        The new file's attrbiutes.  The different attributes are
+                                described in EFI_FILE_PROTOCOL.Open().
+  @param[out] FileHandle        On return, points to the created file handle or directory's handle.
+
+  @retval EFI_SUCCESS           The file was opened.  FileHandle points to the new file's handle.
+  @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
+  @retval EFI_UNSUPPORTED       The file path could not be opened.
+  @retval EFI_NOT_FOUND         The specified file could not be found on the device, or could not
+                                file the file system on the device.
+  @retval EFI_NO_MEDIA          The device has no medium.
+  @retval EFI_MEDIA_CHANGED     The device has a different medium in it or the medium is no
+                                longer supported.
+  @retval EFI_DEVICE_ERROR      The device reported an error or can't get the file path according
+                                the DirName.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   An attempt was made to create a file, or open a file for write
+                                when the media is write-protected.
+  @retval EFI_ACCESS_DENIED     The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES  Not enough resources were available to open the file.
+  @retval EFI_VOLUME_FULL       The volume is full.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_CREATE_FILE)(
+  IN CONST CHAR16               *FileName,
+  IN UINT64                     FileAttribs,
+  OUT SHELL_FILE_HANDLE         *FileHandle
+  );
+
+/**
+  Deletes the file specified by the file handle.
+
+  This function closes and deletes a file. In all cases, the file handle is closed. If the file
+  cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is returned, but the
+  handle is still closed.
+
+  @param[in] FileHandle           The file handle to delete.
+
+  @retval EFI_SUCCESS             The file was closed and deleted and the handle was closed.
+  @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_DELETE_FILE)(
+  IN SHELL_FILE_HANDLE FileHandle
+  );
+
+/**
+  Deletes the file specified by the file name.
+
+  This function deletes a file.
+
+  @param[in] FileName             Points to the NULL-terminated file name.
+
+  @retval EFI_SUCCESS             The file was deleted.
+  @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_DELETE_FILE_BY_NAME)(
+  IN CONST CHAR16 *FileName
+  );
+
+/**
+  Disables the page break output mode.
+**/
+typedef
+VOID
+(EFIAPI *EFI_SHELL_DISABLE_PAGE_BREAK) (
+  VOID
+  );
+
+/**
+  Enables the page break output mode.
+**/
+typedef
+VOID
+(EFIAPI *EFI_SHELL_ENABLE_PAGE_BREAK) (
+  VOID
+  );
+
+/**
+  Execute the command line.
+
+  This function creates a nested instance of the shell and executes the specified
+  command (CommandLine) with the specified environment (Environment). Upon return,
+  the status code returned by the specified command is placed in StatusCode.
+
+  If Environment is NULL, then the current environment is used and all changes made
+  by the commands executed will be reflected in the current environment. If the
+  Environment is non-NULL, then the changes made will be discarded.
+
+  The CommandLine is executed from the current working directory on the current
+  device.
+
+  @param[in] ParentImageHandle  A handle of the image that is executing the specified
+                                command line.
+  @param[in] CommandLine        Points to the NULL-terminated UCS-2 encoded string
+                                containing the command line. If NULL then the command-
+                                line will be empty.
+  @param[in] Environment        Points to a NULL-terminated array of environment
+                                variables with the format 'x=y', where x is the
+                                environment variable name and y is the value. If this
+                                is NULL, then the current shell environment is used.
+  @param[out] ErrorCode         Points to the status code returned by the command.
+
+  @retval EFI_SUCCESS           The command executed successfully. The  status code
+                                returned by the command is pointed to by StatusCode.
+  @retval EFI_INVALID_PARAMETER The parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  Out of resources.
+  @retval EFI_UNSUPPORTED       Nested shell invocations are not allowed.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_EXECUTE) (
+  IN EFI_HANDLE                 *ParentImageHandle,
+  IN CHAR16                     *CommandLine OPTIONAL,
+  IN CHAR16                     **Environment OPTIONAL,
+  OUT EFI_STATUS                *StatusCode OPTIONAL
+  );
+
+/**
+  Find files that match a specified pattern.
+
+  This function searches for all files and directories that match the specified
+  FilePattern. The FilePattern can contain wild-card characters. The resulting file
+  information is placed in the file list FileList.
+
+  The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
+  field is set to NULL.
+
+  @param[in] FilePattern        Points to a NULL-terminated shell file path, including wildcards.
+  @param[out] FileList          On return, points to the start of a file list containing the names
+                                of all matching files or else points to NULL if no matching files
+                                were found.
+
+  @retval EFI_SUCCESS           Files found.
+  @retval EFI_NOT_FOUND         No files found.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_FIND_FILES)(
+  IN CONST CHAR16               *FilePattern,
+  OUT EFI_SHELL_FILE_INFO       **FileList
+  );
+
+/**
+  Find all files in a specified directory.
+
+  @param[in] FileDirHandle      Handle of the directory to search.
+  @param[out] FileList          On return, points to the list of files in the directory
+                                or NULL if there are no files in the directory.
+
+  @retval EFI_SUCCESS           File information was returned successfully.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures have been corrupted.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_NO_MEDIA          The device media is not present.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_FIND_FILES_IN_DIR)(
+IN SHELL_FILE_HANDLE            FileDirHandle,
+OUT EFI_SHELL_FILE_INFO         **FileList
+);
+
+/**
+  Flushes data back to a device.
+
+  This function flushes all modified data associated with a file to a device.
+
+  @param[in] FileHandle         The handle of the file to flush.
+
+  @retval EFI_SUCCESS           The data was flushed.
+  @retval EFI_NO_MEDIA          The device has no medium.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED     The file was opened read-only.
+  @retval EFI_VOLUME_FULL       The volume is full.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_FLUSH_FILE)(
+  IN SHELL_FILE_HANDLE FileHandle
+  );
+
+/**
+  Frees the file list.
+
+  This function cleans up the file list and any related data structures. It has no
+  impact on the files themselves.
+
+  @param[in] FileList           The file list to free. Type EFI_SHELL_FILE_INFO is
+                                defined in OpenFileList().
+
+  @retval EFI_SUCCESS           Free the file list successfully.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_FREE_FILE_LIST) (
+  IN EFI_SHELL_FILE_INFO **FileList
+  );
+
+/**
+  Returns the current directory on the specified device.
+
+  If FileSystemMapping is NULL, it returns the current working directory. If the
+  FileSystemMapping is not NULL, it returns the current directory associated with the
+  FileSystemMapping. In both cases, the returned name includes the file system
+  mapping (i.e. fs0:\current-dir).
+
+  Note that the current directory string should exclude the tailing backslash character.
+
+  @param[in] FileSystemMapping  A pointer to the file system mapping. If NULL,
+                                then the current working directory is returned.
+
+  @retval !=NULL                The current directory.
+  @retval NULL                  Current directory does not exist.
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_CUR_DIR) (
+  IN CONST CHAR16 *FileSystemMapping OPTIONAL
+  );
+
+typedef UINT32 EFI_SHELL_DEVICE_NAME_FLAGS;
+#define EFI_DEVICE_NAME_USE_COMPONENT_NAME  0x00000001
+#define EFI_DEVICE_NAME_USE_DEVICE_PATH     0x00000002
+
+/**
+  Gets the name of the device specified by the device handle.
+
+  This function gets the user-readable name of the device specified by the device
+  handle. If no user-readable name could be generated, then *BestDeviceName will be
+  NULL and EFI_NOT_FOUND will be returned.
+
+  If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
+  device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
+  DeviceHandle.
+
+  If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
+  device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
+  If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
+  EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
+  EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
+
+  @param[in] DeviceHandle       The handle of the device.
+  @param[in] Flags              Determines the possible sources of component names.
+  @param[in] Language           A pointer to the language specified for the device
+                                name, in the same format as described in the UEFI
+                                specification, Appendix M.
+  @param[out] BestDeviceName    On return, points to the callee-allocated NULL-
+                                terminated name of the device. If no device name
+                                could be found, points to NULL. The name must be
+                                freed by the caller...
+
+  @retval EFI_SUCCESS           Get the name successfully.
+  @retval EFI_NOT_FOUND         Fail to get the device name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_DEVICE_NAME) (
+  IN EFI_HANDLE                   DeviceHandle,
+  IN EFI_SHELL_DEVICE_NAME_FLAGS  Flags,
+  IN CHAR8                        *Language,
+  OUT CHAR16                      **BestDeviceName
+  );
+
+/**
+  Gets the device path from the mapping.
+
+  This function gets the device path associated with a mapping.
+
+  @param[in] Mapping                A pointer to the mapping
+
+  @retval !=NULL                Pointer to the device path that corresponds to the
+                                device mapping. The returned pointer does not need
+                                to be freed.
+  @retval NULL                  There is no device path associated with the
+                                specified mapping.
+**/
+typedef
+CONST EFI_DEVICE_PATH_PROTOCOL *
+(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_MAP) (
+  IN CONST CHAR16 *Mapping
+  );
+
+/**
+  Converts a file system style name to a device path.
+
+  This function converts a file system style name to a device path, by replacing any
+  mapping references to the associated device path.
+
+  @param[in] Path               The pointer to the path.
+
+  @return                       The pointer of the file path. The file path is callee
+                                allocated and should be freed by the caller.
+**/
+typedef
+EFI_DEVICE_PATH_PROTOCOL *
+(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH) (
+  IN CONST CHAR16 *Path
+  );
+
+/**
+  Gets either a single or list of environment variables.
+
+  If name is not NULL then this function returns the current value of the specified
+  environment variable.
+
+  If Name is NULL than a list of all environment variable names is returned.  Each a
+  NULL terminated string with a double NULL terminating the list.
+
+  @param[in] Name               A pointer to the environment variable name.  If
+                                Name is NULL, then the function will return all
+                                of the defined shell environment variables.  In
+                                the case where multiple environment variables are
+                                being returned, each variable will be terminated by
+                                a NULL, and the list will be terminated by a double
+                                NULL.
+
+  @return                       A pointer to the returned string.
+                                The returned pointer does not need to be freed by the caller.
+
+  @retval NULL                  The environment variable doesn't exist or there are
+                                no environment variables.
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_ENV) (
+  IN CONST CHAR16 *Name OPTIONAL
+  );
+
+/**
+  Gets the environment variable and Attributes, or list of environment variables.  Can be 
+  used instead of GetEnv().
+
+  This function returns the current value of the specified environment variable and
+  the Attributes. If no variable name was specified, then all of the known
+  variables will be returned.
+
+  @param[in] Name               A pointer to the environment variable name. If Name is NULL,
+                                then the function will return all of the defined shell 
+                                environment variables. In the case where multiple environment
+                                variables are being returned, each variable will be terminated 
+                                by a NULL, and the list will be terminated by a double NULL.
+  @param[out] Attributes        If not NULL, a pointer to the returned attributes bitmask for
+                                the environment variable. In the case where Name is NULL, and
+                                multiple environment variables are being returned, Attributes
+                                is undefined.
+
+  @retval NULL                  The environment variable doesn't exist.  
+  @return                       The environment variable's value. The returned pointer does not 
+                                need to be freed by the caller.  
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_ENV_EX) (
+  IN  CONST CHAR16 *Name,
+  OUT       UINT32 *Attributes OPTIONAL
+  );
+
+/**
+  Gets the file information from an open file handle.
+
+  This function allocates a buffer to store the file's information. It's the caller's
+  responsibility to free the buffer.
+
+  @param[in] FileHandle         A File Handle.
+
+  @retval NULL                  Cannot get the file info.
+  @return                       A pointer to a buffer with file information.
+**/
+typedef
+EFI_FILE_INFO *
+(EFIAPI *EFI_SHELL_GET_FILE_INFO)(
+  IN SHELL_FILE_HANDLE FileHandle
+  );
+
+/**
+  Converts a device path to a file system-style path.
+
+  This function converts a device path to a file system path by replacing part, or all, of
+  the device path with the file-system mapping. If there are more than one application
+  file system mappings, the one that most closely matches Path will be used.
+
+  @param[in] Path               The pointer to the device path.
+
+  @return                       The pointer of the NULL-terminated file path. The path
+                                is callee-allocated and should be freed by the caller.
+**/
+typedef
+CHAR16 *
+(EFIAPI *EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH) (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *Path
+  );
+
+/**
+  Gets a file's current position.
+
+  This function returns the current file position for the file handle. For directories, the
+  current file position has no meaning outside of the file system driver and as such, the
+  operation is not supported.
+
+  @param[in] FileHandle         The file handle on which to get the current position.
+  @param[out] Position          Byte position from the start of the file.
+
+  @retval EFI_SUCCESS           Data was accessed.
+  @retval EFI_UNSUPPORTED       The request is not valid on open directories.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_FILE_POSITION)(
+  IN SHELL_FILE_HANDLE FileHandle,
+  OUT UINT64 *Position
+  );
+
+/**
+  Gets the size of a file.
+
+  This function returns the size of the file specified by FileHandle.
+
+  @param[in] FileHandle         The handle of the file.
+  @param[out] Size              The size of this file.
+
+  @retval EFI_SUCCESS           Get the file's size.
+  @retval EFI_DEVICE_ERROR      Can't access the file.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_FILE_SIZE)(
+  IN SHELL_FILE_HANDLE FileHandle,
+  OUT UINT64 *Size
+  );
+
+/**
+  Get the GUID value from a human readable name.
+
+  If GuidName is a known GUID name, then update Guid to have the correct value for
+  that GUID.
+
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+
+  @param[in]  GuidName   A pointer to the localized name for the GUID being queried.
+  @param[out] Guid       A pointer to the GUID structure to be filled in.
+
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           GuidName is not a known GUID Name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_GUID_FROM_NAME)(
+  IN  CONST CHAR16   *GuidName,
+  OUT       EFI_GUID *Guid
+  );
+
+/**
+  Get the human readable name for a GUID from the value.
+
+  If Guid is assigned a name, then update *GuidName to point to the name. The callee
+  should not modify the value.
+
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+
+  @param[in]  Guid       A pointer to the GUID being queried.
+  @param[out] GuidName   A pointer to a pointer the localized to name for the GUID being requested
+
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           Guid is not assigned a name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_GUID_NAME)(
+  IN  CONST EFI_GUID *Guid,
+  OUT CONST CHAR16   **GuidName
+  );
+
+/**
+  Return help information about a specific command.
+
+  This function returns the help information for the specified command. The help text
+  can be internal to the shell or can be from a UEFI Shell manual page.
+
+  If Sections is specified, then each section name listed will be compared in a casesensitive
+  manner, to the section names described in Appendix B. If the section exists,
+  it will be appended to the returned help text. If the section does not exist, no
+  information will be returned. If Sections is NULL, then all help text information
+  available will be returned.
+
+  @param[in] Command            Points to the NULL-terminated UEFI Shell command name.
+  @param[in] Sections           Points to the NULL-terminated comma-delimited
+                                section names to return. If NULL, then all
+                                sections will be returned.
+  @param[out] HelpText          On return, points to a callee-allocated buffer
+                                containing all specified help text.
+
+  @retval EFI_SUCCESS           The help text was returned.
+  @retval EFI_OUT_OF_RESOURCES  The necessary buffer could not be allocated to hold the
+                                returned help text.
+  @retval EFI_INVALID_PARAMETER HelpText is NULL.
+  @retval EFI_NOT_FOUND         There is no help text available for Command.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_HELP_TEXT) (
+  IN CONST CHAR16 *Command,
+  IN CONST CHAR16 *Sections OPTIONAL,
+  OUT CHAR16 **HelpText
+  );
+
+/**
+  Gets the mapping(s) that most closely matches the device path.
+
+  This function gets the mapping which corresponds to the device path *DevicePath. If
+  there is no exact match, then the mapping which most closely matches *DevicePath
+  is returned, and *DevicePath is updated to point to the remaining portion of the
+  device path. If there is an exact match, the mapping is returned and *DevicePath
+  points to the end-of-device-path node.
+
+  If there are multiple map names they will be semi-colon seperated in the
+  NULL-terminated string.
+
+  @param[in, out] DevicePath     On entry, points to a device path pointer. On
+                                 exit, updates the pointer to point to the
+                                 portion of the device path after the mapping.
+
+  @retval NULL                  No mapping was found.
+  @retval !=NULL                Pointer to NULL-terminated mapping. The buffer
+                                is callee allocated and should be freed by the caller.
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_MAP_FROM_DEVICE_PATH) (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
+  );
+
+/**
+  Gets the enable status of the page break output mode.
+
+  User can use this function to determine current page break mode.
+
+  @retval TRUE                  The page break output mode is enabled.
+  @retval FALSE                 The page break output mode is disabled.
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_SHELL_GET_PAGE_BREAK) (
+  VOID
+  );
+
+/**
+  Judges whether the active shell is the root shell.
+
+  This function makes the user to know that whether the active Shell is the root shell.
+
+  @retval TRUE                  The active Shell is the root Shell.
+  @retval FALSE                 The active Shell is NOT the root Shell.
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_SHELL_IS_ROOT_SHELL) (
+VOID
+);
+
+/**
+  Opens a file or a directory by file name.
+
+  This function opens the specified file in the specified OpenMode and returns a file
+  handle.
+  If the file name begins with '>v', then the file handle which is returned refers to the
+  shell environment variable with the specified name. If the shell environment variable
+  exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
+  EFI_INVALID_PARAMETER is returned.
+
+  If the file name is '>i', then the file handle which is returned refers to the standard
+  input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
+  is returned.
+
+  If the file name is '>o', then the file handle which is returned refers to the standard
+  output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
+  is returned.
+
+  If the file name is '>e', then the file handle which is returned refers to the standard
+  error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
+  is returned.
+
+  If the file name is 'NUL', then the file handle that is returned refers to the standard NUL
+  file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
+  returned.
+
+  If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
+  FileHandle is NULL.
+
+  @param[in] FileName           Points to the NULL-terminated UCS-2 encoded file name.
+  @param[out] FileHandle        On return, points to the file handle.
+  @param[in] OpenMode           File open mode. Either EFI_FILE_MODE_READ or
+                                EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
+                                Specification.
+  @retval EFI_SUCCESS           The file was opened. FileHandle has the opened file's handle.
+  @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
+  @retval EFI_UNSUPPORTED       Could not open the file path. FileHandle is NULL.
+  @retval EFI_NOT_FOUND         The specified file could not be found on the device or the file
+                                system could not be found on the device. FileHandle is NULL.
+  @retval EFI_NO_MEDIA          The device has no medium. FileHandle is NULL.
+  @retval EFI_MEDIA_CHANGED     The device has a different medium in it or the medium is no
+                                longer supported. FileHandle is NULL.
+  @retval EFI_DEVICE_ERROR      The device reported an error or can't get the file path according
+                                the FileName. FileHandle is NULL.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted. FileHandle is NULL.
+  @retval EFI_WRITE_PROTECTED   An attempt was made to create a file, or open a file for write
+                                when the media is write-protected. FileHandle is NULL.
+  @retval EFI_ACCESS_DENIED     The service denied access to the file. FileHandle is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Not enough resources were available to open the file. FileHandle
+                                is NULL.
+  @retval EFI_VOLUME_FULL       The volume is full. FileHandle is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_OPEN_FILE_BY_NAME) (
+  IN CONST CHAR16 *FileName,
+  OUT SHELL_FILE_HANDLE *FileHandle,
+  IN UINT64 OpenMode
+  );
+
+/**
+  Opens the files that match the path specified.
+
+  This function opens all of the files specified by Path. Wildcards are processed
+  according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
+  matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
+
+  @param[in] Path                A pointer to the path string.
+  @param[in] OpenMode            Specifies the mode used to open each file, EFI_FILE_MODE_READ or
+                                 EFI_FILE_MODE_WRITE.
+  @param[in, out] FileList       Points to the start of a list of files opened.
+
+  @retval EFI_SUCCESS           Create the file list successfully.
+  @return                       Can't create the file list.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_OPEN_FILE_LIST) (
+  IN CHAR16 *Path,
+  IN UINT64 OpenMode,
+  IN OUT EFI_SHELL_FILE_INFO **FileList
+  );
+
+/**
+  Opens the root directory of a device.
+
+  This function opens the root directory of a device and returns a file handle to it.
+
+  @param[in] DevicePath         Points to the device path corresponding to the device where the
+                                EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
+  @param[out] FileHandle        On exit, points to the file handle corresponding to the root directory on the
+                                device.
+
+  @retval EFI_SUCCESS           Root opened successfully.
+  @retval EFI_NOT_FOUND         EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
+                                could not be opened.
+  @retval EFI_VOLUME_CORRUPTED  The data structures in the volume were corrupted.
+  @retval EFI_DEVICE_ERROR      The device had an error.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_OPEN_ROOT)(
+  IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  OUT SHELL_FILE_HANDLE *FileHandle
+  );
+
+/**
+  Opens the root directory of a device on a handle.
+
+  This function opens the root directory of a device and returns a file handle to it.
+
+  @param[in] DeviceHandle       The handle of the device that contains the volume.
+  @param[out] FileHandle        On exit, points to the file handle corresponding to the root directory on the
+                                device.
+
+  @retval EFI_SUCCESS           Root opened successfully.
+  @retval EFI_NOT_FOUND         EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
+                                could not be opened.
+  @retval EFI_VOLUME_CORRUPTED  The data structures in the volume were corrupted.
+  @retval EFI_DEVICE_ERROR      The device had an error.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_OPEN_ROOT_BY_HANDLE)(
+  IN EFI_HANDLE DeviceHandle,
+  OUT SHELL_FILE_HANDLE *FileHandle
+  );
+
+/**
+  Reads data from the file.
+
+  If FileHandle is not a directory, the function reads the requested number of bytes
+  from the file at the file's current position and returns them in Buffer. If the read goes
+  beyond the end of the file, the read length is truncated to the end of the file. The file's
+  current position is increased by the number of bytes returned.
+  If FileHandle is a directory, then an error is returned.
+
+  @param[in] FileHandle          The opened file handle for read.
+  @param[in] ReadSize            On input, the size of Buffer, in bytes. On output, the amount of data read.
+  @param[in, out] Buffer         The buffer in which data is read.
+
+  @retval EFI_SUCCESS           Data was read.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_BUFFER_TO_SMALL   Buffer is too small. ReadSize contains required size.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_READ_FILE) (
+  IN SHELL_FILE_HANDLE FileHandle,
+  IN OUT UINTN *ReadSize,
+  IN OUT VOID *Buffer
+  );
+
+/**
+  Register a GUID and a localized human readable name for it.
+
+  If Guid is not assigned a name, then assign GuidName to Guid.  This list of GUID
+  names must be used whenever a shell command outputs GUID information.
+
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+
+  @param[in] Guid       A pointer to the GUID being registered.
+  @param[in] GuidName   A pointer to the localized name for the GUID being registered.
+
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_ACCESS_DENIED       Guid already is assigned a name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_REGISTER_GUID_NAME)(
+  IN CONST EFI_GUID *Guid,
+  IN CONST CHAR16   *GuidName
+  );
+
+/**
+  Deletes the duplicate file names files in the given file list.
+
+  @param[in] FileList           A pointer to the first entry in the file list.
+
+  @retval EFI_SUCCESS           Always success.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_REMOVE_DUP_IN_FILE_LIST) (
+  IN EFI_SHELL_FILE_INFO **FileList
+  );
+
+/**
+  Changes a shell command alias.
+
+  This function creates an alias for a shell command.
+
+  @param[in] Command            Points to the NULL-terminated shell command or existing alias.
+  @param[in] Alias              Points to the NULL-terminated alias for the shell command. If this is NULL, and
+                                Command refers to an alias, that alias will be deleted.
+  @param[in] Replace            If TRUE and the alias already exists, then the existing alias will be replaced. If
+                                FALSE and the alias already exists, then the existing alias is unchanged and
+                                EFI_ACCESS_DENIED is returned.
+  @param[in] Volatile           if TRUE the Alias being set will be stored in a volatile fashion.  if FALSE the
+                                Alias being set will be stored in a non-volatile fashion.
+
+  @retval EFI_SUCCESS           Alias created or deleted successfully.
+  @retval EFI_ACCESS_DENIED     The alias is a built-in alias or already existed and Replace was set to
+                                FALSE.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_ALIAS)(
+  IN CONST CHAR16 *Command,
+  IN CONST CHAR16 *Alias,
+  IN BOOLEAN Replace,
+  IN BOOLEAN Volatile
+  );
+
+/**
+  This function returns the command associated with a alias or a list of all
+  alias'.
+
+  @param[in] Alias              Points to the NULL-terminated shell alias.
+                                If this parameter is NULL, then all
+                                aliases will be returned in ReturnedData.
+  @param[out] Volatile          Upon return of a single command if TRUE indicates
+                                this is stored in a volatile fashion.  FALSE otherwise.
+  @return                      	If Alias is not NULL, it will return a pointer to
+                                the NULL-terminated command for that alias.
+                                If Alias is NULL, ReturnedData points to a ';'
+                                delimited list of alias (e.g.
+                                ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
+  @retval NULL                  An error ocurred.
+  @retval NULL                  Alias was not a valid Alias.
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_ALIAS)(
+  IN  CONST CHAR16 *Alias,
+  OUT BOOLEAN      *Volatile OPTIONAL
+  );
+
+/**
+  Changes the current directory on the specified device.
+
+  If the FileSystem is NULL, and the directory Dir does not contain a file system's
+  mapped name, this function changes the current working directory. If FileSystem is
+  NULL and the directory Dir contains a mapped name, then the current file system and
+  the current directory on that file system are changed.
+
+  If FileSystem is not NULL, and Dir is NULL, then this changes the current working file
+  system.
+
+  If FileSystem is not NULL and Dir is not NULL, then this function changes the current
+  directory on the specified file system.
+
+  If the current working directory or the current working file system is changed then the
+  %cwd% environment variable will be updated.
+
+  @param[in] FileSystem         A pointer to the file system's mapped name. If NULL, then the current working
+                                directory is changed.
+  @param[in] Dir                Points to the NULL-terminated directory on the device specified by FileSystem.
+
+  @retval NULL                  Current directory does not exist.
+  @return                       The current directory.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_CUR_DIR) (
+  IN CONST CHAR16 *FileSystem OPTIONAL,
+  IN CONST CHAR16 *Dir
+  );
+
+/**
+  Sets the environment variable.
+
+  This function changes the current value of the specified environment variable. If the
+  environment variable exists and the Value is an empty string, then the environment
+  variable is deleted. If the environment variable exists and the Value is not an empty
+  string, then the value of the environment variable is changed. If the environment
+  variable does not exist and the Value is an empty string, there is no action. If the
+  environment variable does not exist and the Value is a non-empty string, then the
+  environment variable is created and assigned the specified value.
+
+  For a description of volatile and non-volatile environment variables, see UEFI Shell
+  2.0 specification section 3.6.1.
+
+  @param[in] Name               Points to the NULL-terminated environment variable name.
+  @param[in] Value              Points to the NULL-terminated environment variable value. If the value is an
+                                empty string then the environment variable is deleted.
+  @param[in] Volatile           Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
+
+  @retval EFI_SUCCESS           The environment variable was successfully updated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_ENV) (
+  IN CONST CHAR16 *Name,
+  IN CONST CHAR16 *Value,
+  IN BOOLEAN Volatile
+  );
+
+/**
+  Sets the file information to an opened file handle.
+
+  This function changes file information.  All file information in the EFI_FILE_INFO
+  struct will be updated to the passed in data.
+
+  @param[in] FileHandle         A file handle.
+  @param[in] FileInfo           Points to new file information.
+
+  @retval EFI_SUCCESS           The information was set.
+  @retval EFI_NO_MEDIA          The device has no medium.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED     The file was opened read-only.
+  @retval EFI_VOLUME_FULL       The volume is full.
+  @retval EFI_BAD_BUFFER_SIZE   BufferSize is smaller than the size of EFI_FILE_INFO.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_FILE_INFO)(
+  IN SHELL_FILE_HANDLE FileHandle,
+  IN CONST EFI_FILE_INFO *FileInfo
+  );
+
+/**
+  Sets a file's current position.
+
+  This function sets the current file position for the handle to the position supplied. With
+  the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only absolute positioning is
+  supported, and seeking past the end of the file is allowed (a subsequent write would
+  grow the file). Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position
+  to be set to the end of the file.
+
+  @param[in] FileHandle         The file handle on which requested position will be set.
+  @param[in] Position           Byte position from the start of the file.
+
+  @retval EFI_SUCCESS           Data was written.
+  @retval EFI_UNSUPPORTED       The seek request for nonzero is not valid on open directories.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_FILE_POSITION)(
+  IN SHELL_FILE_HANDLE FileHandle,
+  IN UINT64 Position
+  );
+
+/**
+  This function creates a mapping for a device path.
+
+  @param[in] DevicePath         Points to the device path. If this is NULL and Mapping points to a valid mapping,
+                                then the mapping will be deleted.
+  @param[in] Mapping            Points to the NULL-terminated mapping for the device path.
+
+  @retval EFI_SUCCESS           Mapping created or deleted successfully.
+  @retval EFI_NO_MAPPING        There is no handle that corresponds exactly to DevicePath. See the
+                                boot service function LocateDevicePath().
+  @retval EFI_ACCESS_DENIED     The mapping is a built-in alias.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_SET_MAP)(
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN CONST CHAR16 *Mapping
+  );
+
+/**
+  Writes data to the file.
+
+  This function writes the specified number of bytes to the file at the current file position.
+  The current file position is advanced the actual number of bytes written, which is
+  returned in BufferSize. Partial writes only occur when there has been a data error
+  during the write attempt (such as "volume space full"). The file automatically grows to
+  hold the data, if required.
+
+  Direct writes to opened directories are not supported.
+
+  @param[in] FileHandle              The opened file handle for writing.
+  @param[in, out] BufferSize         On input, size of Buffer.
+  @param[in] Buffer                  The buffer in which data to write.
+
+  @retval EFI_SUCCESS               Data was written.
+  @retval EFI_UNSUPPORTED           Writes to open directory are not supported.
+  @retval EFI_NO_MEDIA              The device has no media.
+  @retval EFI_DEVICE_ERROR          The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED      The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED       The device is write-protected.
+  @retval EFI_ACCESS_DENIED         The file was open for read only.
+  @retval EFI_VOLUME_FULL           The volume is full.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_WRITE_FILE)(
+  IN SHELL_FILE_HANDLE          FileHandle,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer
+  );
+
+//
+// EFI_SHELL_PROTOCOL has been updated since UEFI Shell Spec 2.0
+// Usage of this protocol will require version checking before attempting
+// to use any new members.  There is no need to check the version for
+// members that existed in UEFI Shell Spec 2.0.
+//
+// Update below for any future UEFI Shell spec changes to this protocol.
+//
+// Check EFI_SHELL_PROTOCOL MajorVersion and MinorVersion:
+// if ((2 == gEfiShellProtocol->MajorVersion) &&
+//     (0 == gEfiShellProtocol->MinorVersion)) {
+//   //
+//   // Cannot call:
+//   // RegisterGuidName - UEFI Shell 2.1
+//   // GetGuidName      - UEFI Shell 2.1
+//   // GetGuidFromName  - UEFI Shell 2.1
+//   // GetEnvEx         - UEFI Shell 2.1
+//   //
+// } else {
+//   //
+//   // Can use all members
+//   //
+// }
+//
+typedef struct _EFI_SHELL_PROTOCOL {
+  EFI_SHELL_EXECUTE                         Execute;
+  EFI_SHELL_GET_ENV                         GetEnv;
+  EFI_SHELL_SET_ENV                         SetEnv;
+  EFI_SHELL_GET_ALIAS                       GetAlias;
+  EFI_SHELL_SET_ALIAS                       SetAlias;
+  EFI_SHELL_GET_HELP_TEXT                   GetHelpText;
+  EFI_SHELL_GET_DEVICE_PATH_FROM_MAP        GetDevicePathFromMap;
+  EFI_SHELL_GET_MAP_FROM_DEVICE_PATH        GetMapFromDevicePath;
+  EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH  GetDevicePathFromFilePath;
+  EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH  GetFilePathFromDevicePath;
+  EFI_SHELL_SET_MAP                         SetMap;
+  EFI_SHELL_GET_CUR_DIR                     GetCurDir;
+  EFI_SHELL_SET_CUR_DIR                     SetCurDir;
+  EFI_SHELL_OPEN_FILE_LIST                  OpenFileList;
+  EFI_SHELL_FREE_FILE_LIST                  FreeFileList;
+  EFI_SHELL_REMOVE_DUP_IN_FILE_LIST         RemoveDupInFileList;
+  EFI_SHELL_BATCH_IS_ACTIVE                 BatchIsActive;
+  EFI_SHELL_IS_ROOT_SHELL                   IsRootShell;
+  EFI_SHELL_ENABLE_PAGE_BREAK               EnablePageBreak;
+  EFI_SHELL_DISABLE_PAGE_BREAK              DisablePageBreak;
+  EFI_SHELL_GET_PAGE_BREAK                  GetPageBreak;
+  EFI_SHELL_GET_DEVICE_NAME                 GetDeviceName;
+  EFI_SHELL_GET_FILE_INFO                   GetFileInfo;
+  EFI_SHELL_SET_FILE_INFO                   SetFileInfo;
+  EFI_SHELL_OPEN_FILE_BY_NAME               OpenFileByName;
+  EFI_SHELL_CLOSE_FILE                      CloseFile;
+  EFI_SHELL_CREATE_FILE                     CreateFile;
+  EFI_SHELL_READ_FILE                       ReadFile;
+  EFI_SHELL_WRITE_FILE                      WriteFile;
+  EFI_SHELL_DELETE_FILE                     DeleteFile;
+  EFI_SHELL_DELETE_FILE_BY_NAME             DeleteFileByName;
+  EFI_SHELL_GET_FILE_POSITION               GetFilePosition;
+  EFI_SHELL_SET_FILE_POSITION               SetFilePosition;
+  EFI_SHELL_FLUSH_FILE                      FlushFile;
+  EFI_SHELL_FIND_FILES                      FindFiles;
+  EFI_SHELL_FIND_FILES_IN_DIR               FindFilesInDir;
+  EFI_SHELL_GET_FILE_SIZE                   GetFileSize;
+  EFI_SHELL_OPEN_ROOT                       OpenRoot;
+  EFI_SHELL_OPEN_ROOT_BY_HANDLE             OpenRootByHandle;
+  EFI_EVENT                                 ExecutionBreak;
+  UINT32                                    MajorVersion;
+  UINT32                                    MinorVersion;
+  // Added for Shell 2.1
+  EFI_SHELL_REGISTER_GUID_NAME              RegisterGuidName;
+  EFI_SHELL_GET_GUID_NAME                   GetGuidName;
+  EFI_SHELL_GET_GUID_FROM_NAME              GetGuidFromName;
+  EFI_SHELL_GET_ENV_EX                      GetEnvEx;
+} EFI_SHELL_PROTOCOL;
+
+extern EFI_GUID gEfiShellProtocolGuid;
+
+enum ShellVersion {
+  SHELL_MAJOR_VERSION = 2,
+  SHELL_MINOR_VERSION = 1
+};
+
+#endif
diff --git a/MdePkg/Include/Protocol/ShellDynamicCommand.h b/MdePkg/Include/Protocol/ShellDynamicCommand.h
new file mode 100644
index 000000000000..da2055d2d506
--- /dev/null
+++ b/MdePkg/Include/Protocol/ShellDynamicCommand.h
@@ -0,0 +1,85 @@
+/** @file
+  EFI Shell Dynamic Command registration protocol
+
+  (C) Copyright 2012-2014 Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2016, 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 __EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL_H__
+#define __EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL_H__
+
+#include <Protocol/Shell.h>
+#include <Protocol/ShellParameters.h>
+
+// {3C7200E9-005F-4EA4-87DE-A3DFAC8A27C3}
+#define EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL_GUID \
+  { \
+  0x3c7200e9, 0x005f, 0x4ea4, { 0x87, 0xde, 0xa3, 0xdf, 0xac, 0x8a, 0x27, 0xc3 } \
+  }
+
+
+//
+// Define for forward reference.
+//
+typedef struct _EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL;
+
+
+/**
+  This is the shell command handler function pointer callback type.  This
+  function handles the command when it is invoked in the shell.
+
+  @param[in] This                   The instance of the EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.
+  @param[in] SystemTable            The pointer to the system table.
+  @param[in] ShellParameters        The parameters associated with the command.
+  @param[in] Shell                  The instance of the shell protocol used in the context
+                                    of processing this command.
+
+  @return EFI_SUCCESS               the operation was sucessful
+  @return other                     the operation failed.
+**/
+typedef
+SHELL_STATUS
+(EFIAPI * SHELL_COMMAND_HANDLER)(
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,
+  IN EFI_SYSTEM_TABLE                      *SystemTable,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL         *ShellParameters,
+  IN EFI_SHELL_PROTOCOL                    *Shell
+  );
+
+/**
+  This is the command help handler function pointer callback type.  This
+  function is responsible for displaying help information for the associated
+  command.
+
+  @param[in] This                   The instance of the EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.
+  @param[in] Language               The pointer to the language string to use.
+
+  @return string                    Pool allocated help string, must be freed by caller
+**/
+typedef
+CHAR16*
+(EFIAPI * SHELL_COMMAND_GETHELP)(
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,
+  IN CONST CHAR8                           *Language
+  );
+
+/// EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL protocol structure.
+struct _EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL {
+  
+  CONST CHAR16           *CommandName;
+  SHELL_COMMAND_HANDLER  Handler;
+  SHELL_COMMAND_GETHELP  GetHelp;
+
+};
+
+extern EFI_GUID gEfiShellDynamicCommandProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/ShellParameters.h b/MdePkg/Include/Protocol/ShellParameters.h
new file mode 100644
index 000000000000..e9c0ee5f634e
--- /dev/null
+++ b/MdePkg/Include/Protocol/ShellParameters.h
@@ -0,0 +1,60 @@
+/** @file
+  EFI Shell protocol as defined in the UEFI Shell 2.0 specification.
+
+  Copyright (c) 2006 - 2016, 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 __EFI_SHELL_PARAMETERS_PROTOCOL_H__
+#define __EFI_SHELL_PARAMETERS_PROTOCOL_H__
+
+#include <Protocol/Shell.h>
+
+#define EFI_SHELL_PARAMETERS_PROTOCOL_GUID \
+  { \
+  0x752f3136, 0x4e16, 0x4fdc, { 0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca } \
+  }
+
+typedef struct _EFI_SHELL_PARAMETERS_PROTOCOL {
+  ///
+  /// Points to an Argc-element array of points to NULL-terminated strings containing
+  /// the command-line parameters. The first entry in the array is always the full file
+  /// path of the executable. Any quotation marks that were used to preserve
+  /// whitespace have been removed.
+  ///
+  CHAR16 **Argv;
+
+  ///
+  /// The number of elements in the Argv array.
+  ///
+  UINTN Argc;
+
+  ///
+  /// The file handle for the standard input for this executable. This may be different
+  /// from the ConInHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdIn;
+
+  ///
+  /// The file handle for the standard output for this executable. This may be different
+  /// from the ConOutHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdOut;
+
+  ///
+  /// The file handle for the standard error output for this executable. This may be
+  /// different from the StdErrHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdErr;
+} EFI_SHELL_PARAMETERS_PROTOCOL;
+
+extern EFI_GUID gEfiShellParametersProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SimpleFileSystem.h b/MdePkg/Include/Protocol/SimpleFileSystem.h
new file mode 100644
index 000000000000..cf39e83c2c33
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimpleFileSystem.h
@@ -0,0 +1,562 @@
+/** @file
+  SimpleFileSystem protocol as defined in the UEFI 2.0 specification.
+
+  The SimpleFileSystem protocol is the programmatic access to the FAT (12,16,32) 
+  file system specified in UEFI 2.0. It can also be used to abstract a file  
+  system other than FAT.
+
+  UEFI 2.0 can boot from any valid EFI image contained in a SimpleFileSystem.
+
+Copyright (c) 2006 - 2014, 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 __SIMPLE_FILE_SYSTEM_H__
+#define __SIMPLE_FILE_SYSTEM_H__
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \
+  { \
+    0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL;
+
+typedef struct _EFI_FILE_PROTOCOL         EFI_FILE_PROTOCOL;
+typedef struct _EFI_FILE_PROTOCOL         *EFI_FILE_HANDLE;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+/// 
+#define SIMPLE_FILE_SYSTEM_PROTOCOL       EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID
+
+///
+/// Protocol name defined in EFI1.1.
+/// 
+typedef EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   EFI_FILE_IO_INTERFACE;
+typedef EFI_FILE_PROTOCOL                 EFI_FILE;
+
+/**
+  Open the root directory on a volume.
+
+  @param  This A pointer to the volume to open the root directory.
+  @param  Root A pointer to the location to return the opened file handle for the
+               root directory.
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_UNSUPPORTED      This volume does not support the requested file system type.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported. Any existing file handles for this volume are
+                               no longer valid. To access the files on the new medium, the
+                               volume must be reopened with OpenVolume().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME)(
+  IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL    *This,
+  OUT EFI_FILE_PROTOCOL                 **Root
+  );
+
+#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION  0x00010000
+
+///
+/// Revision defined in EFI1.1
+/// 
+#define EFI_FILE_IO_INTERFACE_REVISION  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION
+
+struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL {
+  ///
+  /// The version of the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL. The version
+  /// specified by this specification is 0x00010000. All future revisions
+  /// must be backwards compatible.
+  ///
+  UINT64                                      Revision;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME OpenVolume;
+};
+
+/**
+  Opens a new file relative to the source file's location.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to the source location. This would typically be an open
+                     handle to a directory.
+  @param  NewHandle  A pointer to the location to return the opened handle for the new
+                     file.
+  @param  FileName   The Null-terminated string of the name of the file to be opened.
+                     The file name may contain the following path modifiers: "\", ".",
+                     and "..".
+  @param  OpenMode   The mode to open the file. The only valid combinations that the
+                     file may be opened with are: Read, Read/Write, or Create/Read/Write.
+  @param  Attributes Only valid for EFI_FILE_MODE_CREATE, in which case these are the 
+                     attribute bits for the newly created file.
+
+  @retval EFI_SUCCESS          The file was opened.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the device.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  An attempt was made to create a file, or open a file for write
+                               when the media is write-protected.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_OPEN)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN CHAR16                   *FileName,
+  IN UINT64                   OpenMode,
+  IN UINT64                   Attributes
+  );
+
+//
+// Open modes
+//
+#define EFI_FILE_MODE_READ    0x0000000000000001ULL
+#define EFI_FILE_MODE_WRITE   0x0000000000000002ULL
+#define EFI_FILE_MODE_CREATE  0x8000000000000000ULL
+
+//
+// File attributes
+//
+#define EFI_FILE_READ_ONLY  0x0000000000000001ULL
+#define EFI_FILE_HIDDEN     0x0000000000000002ULL
+#define EFI_FILE_SYSTEM     0x0000000000000004ULL
+#define EFI_FILE_RESERVED   0x0000000000000008ULL
+#define EFI_FILE_DIRECTORY  0x0000000000000010ULL
+#define EFI_FILE_ARCHIVE    0x0000000000000020ULL
+#define EFI_FILE_VALID_ATTR 0x0000000000000037ULL
+
+/**
+  Closes a specified file handle.
+
+  @param  This          A pointer to the EFI_FILE_PROTOCOL instance that is the file 
+                        handle to close.
+
+  @retval EFI_SUCCESS   The file was closed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_CLOSE)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+/**
+  Close and delete the file handle.
+
+  @param  This                     A pointer to the EFI_FILE_PROTOCOL instance that is the
+                                   handle to the file to delete.
+
+  @retval EFI_SUCCESS              The file was closed and deleted, and the handle was closed.
+  @retval EFI_WARN_DELETE_FAILURE  The handle was closed, but the file was not deleted.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_DELETE)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+/**
+  Reads data from a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to read data from.
+  @param  BufferSize On input, the size of the Buffer. On output, the amount of data
+                     returned in Buffer. In both cases, the size is measured in bytes.
+  @param  Buffer     The buffer into which the data is read.
+
+  @retval EFI_SUCCESS          Data was read.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to read from a deleted file.
+  @retval EFI_DEVICE_ERROR     On entry, the current file position is beyond the end of the file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory
+                               entry. BufferSize has been updated with the size
+                               needed to complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_READ)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+
+/**
+  Writes data to a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to write data to.
+  @param  BufferSize On input, the size of the Buffer. On output, the amount of data
+                     actually written. In both cases, the size is measured in bytes.
+  @param  Buffer     The buffer of data to write.
+
+  @retval EFI_SUCCESS          Data was written.
+  @retval EFI_UNSUPPORTED      Writes to open directory files are not supported.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_WRITE)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  IN VOID                     *Buffer
+  );
+
+/**
+  Sets a file's current position.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the
+                          file handle to set the requested position on.
+  @param  Position        The byte position from the start of the file to set.
+
+  @retval EFI_SUCCESS      The position was set.
+  @retval EFI_UNSUPPORTED  The seek request for nonzero is not valid on open
+                           directories.
+  @retval EFI_DEVICE_ERROR An attempt was made to set the position of a deleted file.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_SET_POSITION)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN UINT64                   Position
+  );
+
+/**
+  Returns a file's current position.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle to get the current position on.
+  @param  Position        The address to return the file's current position value.
+
+  @retval EFI_SUCCESS      The position was returned.
+  @retval EFI_UNSUPPORTED  The request is not valid on open directories.
+  @retval EFI_DEVICE_ERROR An attempt was made to get the position from a deleted file.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_GET_POSITION)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT UINT64                  *Position
+  );
+
+/**
+  Returns information about a file.
+
+  @param  This            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle the requested information is for.
+  @param  InformationType The type identifier for the information being requested.
+  @param  BufferSize      On input, the size of Buffer. On output, the amount of data
+                          returned in Buffer. In both cases, the size is measured in bytes.
+  @param  Buffer          A pointer to the data buffer to return. The buffer's type is
+                          indicated by InformationType.
+
+  @retval EFI_SUCCESS          The information was returned.
+  @retval EFI_UNSUPPORTED      The InformationType is not known.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory entry.
+                               BufferSize has been updated with the size needed to complete
+                               the request.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_GET_INFO)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+
+/**
+  Sets information about a file.
+
+  @param  File            A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                          handle the information is for.
+  @param  InformationType The type identifier for the information being set.
+  @param  BufferSize      The size, in bytes, of Buffer.
+  @param  Buffer          A pointer to the data buffer to write. The buffer's type is
+                          indicated by InformationType.
+
+  @retval EFI_SUCCESS          The information was set.
+  @retval EFI_UNSUPPORTED      The InformationType is not known.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_INFO_ID and the media is
+                               read-only.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_PROTOCOL_SYSTEM_INFO_ID
+                               and the media is read only.
+  @retval EFI_WRITE_PROTECTED  InformationType is EFI_FILE_SYSTEM_VOLUME_LABEL_ID
+                               and the media is read-only.
+  @retval EFI_ACCESS_DENIED    An attempt is made to change the name of a file to a
+                               file that is already present.
+  @retval EFI_ACCESS_DENIED    An attempt is being made to change the EFI_FILE_DIRECTORY
+                               Attribute.
+  @retval EFI_ACCESS_DENIED    An attempt is being made to change the size of a directory.
+  @retval EFI_ACCESS_DENIED    InformationType is EFI_FILE_INFO_ID and the file was opened
+                               read-only and an attempt is being made to modify a field
+                               other than Attribute.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_BAD_BUFFER_SIZE  BufferSize is smaller than the size of the type indicated
+                               by InformationType.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_SET_INFO)(
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN UINTN                    BufferSize,
+  IN VOID                     *Buffer
+  );
+
+/**
+  Flushes all modified data associated with a file to a device.
+
+  @param  This A pointer to the EFI_FILE_PROTOCOL instance that is the file 
+               handle to flush.
+
+  @retval EFI_SUCCESS          The data was flushed.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read-only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_FLUSH)(
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+typedef struct {
+  //
+  // If Event is NULL, then blocking I/O is performed.
+  // If Event is not NULL and non-blocking I/O is supported, then non-blocking I/O is performed,
+  // and Event will be signaled when the read request is completed.
+  // The caller must be prepared to handle the case where the callback associated with Event
+  // occurs before the original asynchronous I/O request call returns.
+  //
+  EFI_EVENT                   Event;
+
+  //
+  // Defines whether or not the signaled event encountered an error.
+  //
+  EFI_STATUS                  Status;
+
+  //
+  // For OpenEx():  Not Used, ignored.
+  // For ReadEx():  On input, the size of the Buffer. On output, the amount of data returned in Buffer.
+  //                In both cases, the size is measured in bytes.
+  // For WriteEx(): On input, the size of the Buffer. On output, the amount of data actually written.
+  //                In both cases, the size is measured in bytes.
+  // For FlushEx(): Not used, ignored.
+  //
+  UINTN                       BufferSize;
+
+  //
+  // For OpenEx():  Not Used, ignored.
+  // For ReadEx():  The buffer into which the data is read.
+  // For WriteEx(): The buffer of data to write.
+  // For FlushEx(): Not Used, ignored.
+  //
+  VOID                        *Buffer;
+} EFI_FILE_IO_TOKEN;
+
+/**
+  Opens a new file relative to the source directory's location.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file
+                     handle to the source location.
+  @param  NewHandle  A pointer to the location to return the opened handle for the new
+                     file.
+  @param  FileName   The Null-terminated string of the name of the file to be opened.
+                     The file name may contain the following path modifiers: "\", ".",
+                     and "..".
+  @param  OpenMode   The mode to open the file. The only valid combinations that the
+                     file may be opened with are: Read, Read/Write, or Create/Read/Write.
+  @param  Attributes Only valid for EFI_FILE_MODE_CREATE, in which case these are the 
+                     attribute bits for the newly created file.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the device.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the medium is no
+                               longer supported.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  An attempt was made to create a file, or open a file for write
+                               when the media is write-protected.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_OPEN_EX)(
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN CHAR16                   *FileName,
+  IN UINT64                   OpenMode,
+  IN UINT64                   Attributes,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  );
+
+
+/**
+  Reads data from a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file handle to read data from.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to read from a deleted file.
+  @retval EFI_DEVICE_ERROR     On entry, the current file position is beyond the end of the file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_READ_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+);
+
+
+/**
+  Writes data to a file.
+
+  @param  This       A pointer to the EFI_FILE_PROTOCOL instance that is the file handle to write data to.
+  @param  Token      A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_UNSUPPORTED      Writes to open directory files are not supported.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_WRITE_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token 
+);
+
+/**
+  Flushes all modified data associated with a file to a device.
+
+  @param  This  A pointer to the EFI_FILE_PROTOCOL instance that is the file 
+                handle to flush.
+  @param  Token A pointer to the token associated with the transaction.
+
+  @retval EFI_SUCCESS          If Event is NULL (blocking I/O): The data was read successfully.
+                               If Event is not NULL (asynchronous I/O): The request was successfully
+                                                                        queued for processing.
+  @retval EFI_NO_MEDIA         The device has no medium.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The file or medium is write-protected.
+  @retval EFI_ACCESS_DENIED    The file was opened read-only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+  @retval EFI_OUT_OF_RESOURCES Unable to queue the request due to lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FILE_FLUSH_EX) (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT EFI_FILE_IO_TOKEN    *Token
+  );
+
+#define EFI_FILE_PROTOCOL_REVISION        0x00010000
+#define EFI_FILE_PROTOCOL_REVISION2       0x00020000
+#define EFI_FILE_PROTOCOL_LATEST_REVISION EFI_FILE_PROTOCOL_REVISION2
+
+//
+// Revision defined in EFI1.1.
+// 
+#define EFI_FILE_REVISION   EFI_FILE_PROTOCOL_REVISION
+
+///
+/// The EFI_FILE_PROTOCOL provides file IO access to supported file systems.
+/// An EFI_FILE_PROTOCOL provides access to a file's or directory's contents, 
+/// and is also a reference to a location in the directory tree of the file system 
+/// in which the file resides. With any given file handle, other files may be opened 
+/// relative to this file's location, yielding new file handles.
+///
+struct _EFI_FILE_PROTOCOL {
+  ///
+  /// The version of the EFI_FILE_PROTOCOL interface. The version specified 
+  /// by this specification is EFI_FILE_PROTOCOL_LATEST_REVISION.
+  /// Future versions are required to be backward compatible to version 1.0.
+  ///
+  UINT64                Revision;
+  EFI_FILE_OPEN         Open;
+  EFI_FILE_CLOSE        Close;
+  EFI_FILE_DELETE       Delete;
+  EFI_FILE_READ         Read;
+  EFI_FILE_WRITE        Write;
+  EFI_FILE_GET_POSITION GetPosition;
+  EFI_FILE_SET_POSITION SetPosition;
+  EFI_FILE_GET_INFO     GetInfo;
+  EFI_FILE_SET_INFO     SetInfo;
+  EFI_FILE_FLUSH        Flush;
+  EFI_FILE_OPEN_EX      OpenEx;
+  EFI_FILE_READ_EX      ReadEx;
+  EFI_FILE_WRITE_EX     WriteEx;
+  EFI_FILE_FLUSH_EX     FlushEx;
+};
+
+
+extern EFI_GUID gEfiSimpleFileSystemProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SimpleNetwork.h b/MdePkg/Include/Protocol/SimpleNetwork.h
new file mode 100644
index 000000000000..0dda83aaafd9
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimpleNetwork.h
@@ -0,0 +1,681 @@
+/** @file
+  The EFI_SIMPLE_NETWORK_PROTOCOL provides services to initialize a network interface, 
+  transmit packets, receive packets, and close a network interface.
+
+  Basic network device abstraction.
+
+  Rx    - Received
+  Tx    - Transmit
+  MCast - MultiCast
+  ...
+
+Copyright (c) 2006 - 2016, 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.   
+
+  @par Revision Reference:          
+  This Protocol is introduced in EFI Specification 1.10.          
+
+**/
+
+#ifndef __SIMPLE_NETWORK_H__
+#define __SIMPLE_NETWORK_H__
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_GUID \
+  { \
+    0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } \
+  }
+
+typedef struct _EFI_SIMPLE_NETWORK_PROTOCOL  EFI_SIMPLE_NETWORK_PROTOCOL;
+
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_SIMPLE_NETWORK_PROTOCOL   EFI_SIMPLE_NETWORK;
+
+///
+/// Simple Network Protocol data structures.
+///
+typedef struct {
+  ///
+  /// Total number of frames received.  Includes frames with errors and
+  /// dropped frames.
+  ///
+  UINT64  RxTotalFrames;
+
+  ///
+  /// Number of valid frames received and copied into receive buffers.
+  ///
+  UINT64  RxGoodFrames;
+
+  ///
+  /// Number of frames below the minimum length for the media.
+  /// This would be <64 for ethernet.
+  ///
+  UINT64  RxUndersizeFrames;
+
+  ///
+  /// Number of frames longer than the maxminum length for the
+  /// media.  This would be >1500 for ethernet.
+  ///
+  UINT64  RxOversizeFrames;
+
+  ///
+  /// Valid frames that were dropped because receive buffers were full.
+  ///
+  UINT64  RxDroppedFrames;
+
+  ///
+  /// Number of valid unicast frames received and not dropped.
+  ///
+  UINT64  RxUnicastFrames;
+
+  ///
+  /// Number of valid broadcast frames received and not dropped.
+  ///
+  UINT64  RxBroadcastFrames;
+
+  ///
+  /// Number of valid mutlicast frames received and not dropped.
+  ///
+  UINT64  RxMulticastFrames;
+
+  ///
+  /// Number of frames w/ CRC or alignment errors.
+  ///
+  UINT64  RxCrcErrorFrames;
+
+  ///
+  /// Total number of bytes received.  Includes frames with errors
+  /// and dropped frames.
+  //
+  UINT64  RxTotalBytes;
+
+  ///
+  /// Transmit statistics.
+  ///
+  UINT64  TxTotalFrames;
+  UINT64  TxGoodFrames;
+  UINT64  TxUndersizeFrames;
+  UINT64  TxOversizeFrames;
+  UINT64  TxDroppedFrames;
+  UINT64  TxUnicastFrames;
+  UINT64  TxBroadcastFrames;
+  UINT64  TxMulticastFrames;
+  UINT64  TxCrcErrorFrames;
+  UINT64  TxTotalBytes;
+
+  ///
+  /// Number of collisions detection on this subnet.
+  ///
+  UINT64  Collisions;
+
+  ///
+  /// Number of frames destined for unsupported protocol.
+  ///
+  UINT64  UnsupportedProtocol;
+
+  ///
+  /// Number of valid frames received that were duplicated.
+  ///
+  UINT64  RxDuplicatedFrames;
+
+  ///
+  /// Number of encrypted frames received that failed to decrypt.
+  ///
+  UINT64  RxDecryptErrorFrames;
+
+  ///
+  /// Number of frames that failed to transmit after exceeding the retry limit.
+  ///
+  UINT64  TxErrorFrames;
+
+  ///
+  /// Number of frames transmitted successfully after more than one attempt.
+  ///
+  UINT64  TxRetryFrames;
+} EFI_NETWORK_STATISTICS;
+
+///
+/// The state of the network interface.
+/// When an EFI_SIMPLE_NETWORK_PROTOCOL driver initializes a
+/// network interface, the network interface is left in the EfiSimpleNetworkStopped state.
+///
+typedef enum {
+  EfiSimpleNetworkStopped,
+  EfiSimpleNetworkStarted,
+  EfiSimpleNetworkInitialized,
+  EfiSimpleNetworkMaxState
+} EFI_SIMPLE_NETWORK_STATE;
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST                0x01
+#define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST              0x02
+#define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST              0x04
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS            0x08
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST  0x10
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT              0x01
+#define EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT             0x02
+#define EFI_SIMPLE_NETWORK_COMMAND_INTERRUPT              0x04
+#define EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT             0x08
+
+#define MAX_MCAST_FILTER_CNT                              16
+typedef struct {
+  ///
+  /// Reports the current state of the network interface.
+  ///
+  UINT32          State;
+  ///
+  /// The size, in bytes, of the network interface's HW address.
+  ///
+  UINT32          HwAddressSize;
+  ///
+  /// The size, in bytes, of the network interface's media header.
+  ///
+  UINT32          MediaHeaderSize;
+  ///
+  /// The maximum size, in bytes, of the packets supported by the network interface.
+  ///
+  UINT32          MaxPacketSize;
+  ///
+  /// The size, in bytes, of the NVRAM device attached to the network interface.
+  ///
+  UINT32          NvRamSize;
+  ///
+  /// The size that must be used for all NVRAM reads and writes. The
+  /// start address for NVRAM read and write operations and the total
+  /// length of those operations, must be a multiple of this value. The
+  /// legal values for this field are 0, 1, 2, 4, and 8.
+  ///
+  UINT32          NvRamAccessSize;
+  ///
+  /// The multicast receive filter settings supported by the network interface.
+  ///
+  UINT32          ReceiveFilterMask;
+  ///
+  /// The current multicast receive filter settings.
+  ///
+  UINT32          ReceiveFilterSetting;
+  ///
+  /// The maximum number of multicast address receive filters supported by the driver.
+  ///
+  UINT32          MaxMCastFilterCount;
+  ///
+  /// The current number of multicast address receive filters.
+  ///
+  UINT32          MCastFilterCount;
+  ///
+  /// Array containing the addresses of the current multicast address receive filters.
+  ///
+  EFI_MAC_ADDRESS MCastFilter[MAX_MCAST_FILTER_CNT];
+  ///
+  /// The current HW MAC address for the network interface.
+  ///
+  EFI_MAC_ADDRESS CurrentAddress;
+  ///
+  /// The current HW MAC address for broadcast packets.
+  ///
+  EFI_MAC_ADDRESS BroadcastAddress;
+  ///
+  /// The permanent HW MAC address for the network interface.
+  ///
+  EFI_MAC_ADDRESS PermanentAddress;
+  ///
+  /// The interface type of the network interface.
+  ///
+  UINT8           IfType;
+  ///
+  /// TRUE if the HW MAC address can be changed.
+  ///
+  BOOLEAN         MacAddressChangeable;
+  ///
+  /// TRUE if the network interface can transmit more than one packet at a time.
+  ///
+  BOOLEAN         MultipleTxSupported;
+  ///
+  /// TRUE if the presence of media can be determined; otherwise FALSE.
+  ///
+  BOOLEAN         MediaPresentSupported;
+  ///
+  /// TRUE if media are connected to the network interface; otherwise FALSE.
+  ///
+  BOOLEAN         MediaPresent;
+} EFI_SIMPLE_NETWORK_MODE;
+
+//
+// Protocol Member Functions
+//
+/**
+  Changes the state of a network interface from "stopped" to "started".
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS           The network interface was started.
+  @retval EFI_ALREADY_STARTED   The network interface is already in the started state.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_START)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
+  );
+
+/**
+  Changes the state of a network interface from "started" to "stopped".
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS           The network interface was stopped.
+  @retval EFI_ALREADY_STARTED   The network interface is already in the stopped state.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STOP)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
+  );
+
+/**
+  Resets a network adapter and allocates the transmit and receive buffers 
+  required by the network interface; optionally, also requests allocation 
+  of additional transmit and receive buffers.
+
+  @param  This              The protocol instance pointer.
+  @param  ExtraRxBufferSize The size, in bytes, of the extra receive buffer space
+                            that the driver should allocate for the network interface.
+                            Some network interfaces will not be able to use the extra
+                            buffer, and the caller will not know if it is actually
+                            being used.
+  @param  ExtraTxBufferSize The size, in bytes, of the extra transmit buffer space
+                            that the driver should allocate for the network interface.
+                            Some network interfaces will not be able to use the extra
+                            buffer, and the caller will not know if it is actually
+                            being used.
+
+  @retval EFI_SUCCESS           The network interface was initialized.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory for the transmit and
+                                receive buffers.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_INITIALIZE)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL                    *This,
+  IN UINTN                                          ExtraRxBufferSize  OPTIONAL,
+  IN UINTN                                          ExtraTxBufferSize  OPTIONAL
+  );
+
+/**
+  Resets a network adapter and re-initializes it with the parameters that were 
+  provided in the previous call to Initialize().  
+
+  @param  This                 The protocol instance pointer.
+  @param  ExtendedVerification Indicates that the driver may perform a more
+                               exhaustive verification operation of the device
+                               during reset.
+
+  @retval EFI_SUCCESS           The network interface was reset.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RESET)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL   *This,
+  IN BOOLEAN                       ExtendedVerification
+  );
+
+/**
+  Resets a network adapter and leaves it in a state that is safe for 
+  another driver to initialize.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS           The network interface was shutdown.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_SHUTDOWN)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL  *This
+  );
+
+/**
+  Manages the multicast receive filters of a network interface.
+
+  @param  This             The protocol instance pointer.
+  @param  Enable           A bit mask of receive filters to enable on the network interface.
+  @param  Disable          A bit mask of receive filters to disable on the network interface.
+  @param  ResetMCastFilter Set to TRUE to reset the contents of the multicast receive
+                           filters on the network interface to their default values.
+  @param  McastFilterCnt   Number of multicast HW MAC addresses in the new
+                           MCastFilter list. This value must be less than or equal to
+                           the MCastFilterCnt field of EFI_SIMPLE_NETWORK_MODE. This
+                           field is optional if ResetMCastFilter is TRUE.
+  @param  MCastFilter      A pointer to a list of new multicast receive filter HW MAC
+                           addresses. This list will replace any existing multicast
+                           HW MAC address list. This field is optional if
+                           ResetMCastFilter is TRUE.
+
+  @retval EFI_SUCCESS           The multicast receive filter list was updated.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE_FILTERS)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL                             *This,
+  IN UINT32                                                  Enable,
+  IN UINT32                                                  Disable,
+  IN BOOLEAN                                                 ResetMCastFilter,
+  IN UINTN                                                   MCastFilterCnt     OPTIONAL,
+  IN EFI_MAC_ADDRESS                                         *MCastFilter OPTIONAL
+  );
+
+/**
+  Modifies or resets the current station address, if supported.
+
+  @param  This  The protocol instance pointer.
+  @param  Reset Flag used to reset the station address to the network interfaces
+                permanent address.
+  @param  New   The new station address to be used for the network interface.
+
+  @retval EFI_SUCCESS           The network interfaces station address was updated.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STATION_ADDRESS)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL            *This,
+  IN BOOLEAN                                Reset,
+  IN EFI_MAC_ADDRESS                        *New OPTIONAL
+  );
+
+/**
+  Resets or collects the statistics on a network interface.
+
+  @param  This            Protocol instance pointer.
+  @param  Reset           Set to TRUE to reset the statistics for the network interface.
+  @param  StatisticsSize  On input the size, in bytes, of StatisticsTable. On
+                          output the size, in bytes, of the resulting table of
+                          statistics.
+  @param  StatisticsTable A pointer to the EFI_NETWORK_STATISTICS structure that
+                          contains the statistics.
+
+  @retval EFI_SUCCESS           The statistics were collected from the network interface.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_BUFFER_TOO_SMALL  The Statistics buffer was too small. The current buffer
+                                size needed to hold the statistics is returned in
+                                StatisticsSize.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STATISTICS)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  IN BOOLEAN                              Reset,
+  IN OUT UINTN                            *StatisticsSize   OPTIONAL,
+  OUT EFI_NETWORK_STATISTICS              *StatisticsTable  OPTIONAL
+  );
+
+/**
+  Converts a multicast IP address to a multicast HW MAC address.
+
+  @param  This The protocol instance pointer.
+  @param  IPv6 Set to TRUE if the multicast IP address is IPv6 [RFC 2460]. Set
+               to FALSE if the multicast IP address is IPv4 [RFC 791].
+  @param  IP   The multicast IP address that is to be converted to a multicast
+               HW MAC address.
+  @param  MAC  The multicast HW MAC address that is to be generated from IP.
+
+  @retval EFI_SUCCESS           The multicast IP address was mapped to the multicast
+                                HW MAC address.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_BUFFER_TOO_SMALL  The Statistics buffer was too small. The current buffer
+                                size needed to hold the statistics is returned in
+                                StatisticsSize.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  IN BOOLEAN                              IPv6,
+  IN EFI_IP_ADDRESS                       *IP,
+  OUT EFI_MAC_ADDRESS                     *MAC
+  );
+
+/**
+  Performs read and write operations on the NVRAM device attached to a 
+  network interface.
+
+  @param  This       The protocol instance pointer.
+  @param  ReadWrite  TRUE for read operations, FALSE for write operations.
+  @param  Offset     Byte offset in the NVRAM device at which to start the read or
+                     write operation. This must be a multiple of NvRamAccessSize and
+                     less than NvRamSize.
+  @param  BufferSize The number of bytes to read or write from the NVRAM device.
+                     This must also be a multiple of NvramAccessSize.
+  @param  Buffer     A pointer to the data buffer.
+
+  @retval EFI_SUCCESS           The NVRAM access was performed.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_NVDATA)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  IN BOOLEAN                              ReadWrite,
+  IN UINTN                                Offset,
+  IN UINTN                                BufferSize,
+  IN OUT VOID                             *Buffer
+  );
+
+/**
+  Reads the current interrupt status and recycled transmit buffer status from 
+  a network interface.
+
+  @param  This            The protocol instance pointer.
+  @param  InterruptStatus A pointer to the bit mask of the currently active interrupts
+                          If this is NULL, the interrupt status will not be read from
+                          the device. If this is not NULL, the interrupt status will
+                          be read from the device. When the  interrupt status is read,
+                          it will also be cleared. Clearing the transmit  interrupt
+                          does not empty the recycled transmit buffer array.
+  @param  TxBuf           Recycled transmit buffer address. The network interface will
+                          not transmit if its internal recycled transmit buffer array
+                          is full. Reading the transmit buffer does not clear the
+                          transmit interrupt. If this is NULL, then the transmit buffer
+                          status will not be read. If there are no transmit buffers to
+                          recycle and TxBuf is not NULL, * TxBuf will be set to NULL.
+
+  @retval EFI_SUCCESS           The status of the network interface was retrieved.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_GET_STATUS)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  OUT UINT32                              *InterruptStatus OPTIONAL,
+  OUT VOID                                **TxBuf OPTIONAL
+  );
+
+/**
+  Places a packet in the transmit queue of a network interface.
+
+  @param  This       The protocol instance pointer.
+  @param  HeaderSize The size, in bytes, of the media header to be filled in by
+                     the Transmit() function. If HeaderSize is non-zero, then it
+                     must be equal to This->Mode->MediaHeaderSize and the DestAddr
+                     and Protocol parameters must not be NULL.
+  @param  BufferSize The size, in bytes, of the entire packet (media header and
+                     data) to be transmitted through the network interface.
+  @param  Buffer     A pointer to the packet (media header followed by data) to be
+                     transmitted. This parameter cannot be NULL. If HeaderSize is zero,
+                     then the media header in Buffer must already be filled in by the
+                     caller. If HeaderSize is non-zero, then the media header will be
+                     filled in by the Transmit() function.
+  @param  SrcAddr    The source HW MAC address. If HeaderSize is zero, then this parameter
+                     is ignored. If HeaderSize is non-zero and SrcAddr is NULL, then
+                     This->Mode->CurrentAddress is used for the source HW MAC address.
+  @param  DestAddr   The destination HW MAC address. If HeaderSize is zero, then this
+                     parameter is ignored.
+  @param  Protocol   The type of header to build. If HeaderSize is zero, then this
+                     parameter is ignored. See RFC 1700, section "Ether Types", for
+                     examples.
+
+  @retval EFI_SUCCESS           The packet was placed on the transmit queue.
+  @retval EFI_NOT_STARTED       The network interface has not been started.
+  @retval EFI_NOT_READY         The network interface is too busy to accept this transmit request.                      
+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize parameter is too small.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_TRANSMIT)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  IN UINTN                                HeaderSize,
+  IN UINTN                                BufferSize,
+  IN VOID                                 *Buffer,
+  IN EFI_MAC_ADDRESS                      *SrcAddr  OPTIONAL,
+  IN EFI_MAC_ADDRESS                      *DestAddr OPTIONAL,
+  IN UINT16                               *Protocol OPTIONAL
+  );
+
+/**
+  Receives a packet from a network interface.
+
+  @param  This       The protocol instance pointer.
+  @param  HeaderSize The size, in bytes, of the media header received on the network
+                     interface. If this parameter is NULL, then the media header size
+                     will not be returned.
+  @param  BufferSize On entry, the size, in bytes, of Buffer. On exit, the size, in
+                     bytes, of the packet that was received on the network interface.
+  @param  Buffer     A pointer to the data buffer to receive both the media header and
+                     the data.
+  @param  SrcAddr    The source HW MAC address. If this parameter is NULL, the
+                     HW MAC source address will not be extracted from the media
+                     header.
+  @param  DestAddr   The destination HW MAC address. If this parameter is NULL,
+                     the HW MAC destination address will not be extracted from the
+                     media header.
+  @param  Protocol   The media header type. If this parameter is NULL, then the
+                     protocol will not be extracted from the media header. See
+                     RFC 1700 section "Ether Types" for examples.
+
+  @retval  EFI_SUCCESS           The received data was stored in Buffer, and BufferSize has
+                                 been updated to the number of bytes received.
+  @retval  EFI_NOT_STARTED       The network interface has not been started.
+  @retval  EFI_NOT_READY         The network interface is too busy to accept this transmit
+                                 request.
+  @retval  EFI_BUFFER_TOO_SMALL  The BufferSize parameter is too small.
+  @retval  EFI_INVALID_PARAMETER One or more of the parameters has an unsupported value.
+  @retval  EFI_DEVICE_ERROR      The command could not be sent to the network interface.
+  @retval  EFI_UNSUPPORTED       This function is not supported by the network interface.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE)(
+  IN EFI_SIMPLE_NETWORK_PROTOCOL          *This,
+  OUT UINTN                               *HeaderSize OPTIONAL,
+  IN OUT UINTN                            *BufferSize,
+  OUT VOID                                *Buffer,
+  OUT EFI_MAC_ADDRESS                     *SrcAddr    OPTIONAL,
+  OUT EFI_MAC_ADDRESS                     *DestAddr   OPTIONAL,
+  OUT UINT16                              *Protocol   OPTIONAL
+  );
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_REVISION  0x00010000
+
+//
+// Revision defined in EFI1.1
+// 
+#define EFI_SIMPLE_NETWORK_INTERFACE_REVISION   EFI_SIMPLE_NETWORK_PROTOCOL_REVISION
+
+///
+/// The EFI_SIMPLE_NETWORK_PROTOCOL protocol is used to initialize access 
+/// to a network adapter. Once the network adapter initializes, 
+/// the EFI_SIMPLE_NETWORK_PROTOCOL protocol provides services that 
+/// allow packets to be transmitted and received.
+///
+struct _EFI_SIMPLE_NETWORK_PROTOCOL {
+  ///
+  /// Revision of the EFI_SIMPLE_NETWORK_PROTOCOL. All future revisions must 
+  /// be backwards compatible. If a future version is not backwards compatible 
+  /// it is not the same GUID.
+  ///
+  UINT64                              Revision;
+  EFI_SIMPLE_NETWORK_START            Start;
+  EFI_SIMPLE_NETWORK_STOP             Stop;
+  EFI_SIMPLE_NETWORK_INITIALIZE       Initialize;
+  EFI_SIMPLE_NETWORK_RESET            Reset;
+  EFI_SIMPLE_NETWORK_SHUTDOWN         Shutdown;
+  EFI_SIMPLE_NETWORK_RECEIVE_FILTERS  ReceiveFilters;
+  EFI_SIMPLE_NETWORK_STATION_ADDRESS  StationAddress;
+  EFI_SIMPLE_NETWORK_STATISTICS       Statistics;
+  EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC  MCastIpToMac;
+  EFI_SIMPLE_NETWORK_NVDATA           NvData;
+  EFI_SIMPLE_NETWORK_GET_STATUS       GetStatus;
+  EFI_SIMPLE_NETWORK_TRANSMIT         Transmit;
+  EFI_SIMPLE_NETWORK_RECEIVE          Receive;
+  ///
+  /// Event used with WaitForEvent() to wait for a packet to be received.
+  ///
+  EFI_EVENT                           WaitForPacket;
+  ///
+  /// Pointer to the EFI_SIMPLE_NETWORK_MODE data for the device.
+  ///
+  EFI_SIMPLE_NETWORK_MODE             *Mode;
+};
+
+extern EFI_GUID gEfiSimpleNetworkProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SimplePointer.h b/MdePkg/Include/Protocol/SimplePointer.h
new file mode 100644
index 000000000000..d8c0757f6243
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimplePointer.h
@@ -0,0 +1,143 @@
+/** @file
+  Simple Pointer protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple pointer device like a mouse or trackball.
+
+  Copyright (c) 2006 - 2008, 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 __SIMPLE_POINTER_H__
+#define __SIMPLE_POINTER_H__
+
+#define EFI_SIMPLE_POINTER_PROTOCOL_GUID \
+  { \
+    0x31878c87, 0xb75, 0x11d5, {0x9a, 0x4f, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+typedef struct _EFI_SIMPLE_POINTER_PROTOCOL  EFI_SIMPLE_POINTER_PROTOCOL;
+
+//
+// Data structures
+//
+typedef struct {
+  ///
+  /// The signed distance in counts that the pointer device has been moved along the x-axis.
+  ///
+  INT32   RelativeMovementX;
+  ///
+  /// The signed distance in counts that the pointer device has been moved along the y-axis.
+  ///
+  INT32   RelativeMovementY;
+  ///
+  /// The signed distance in counts that the pointer device has been moved along the z-axis.
+  ///
+  INT32   RelativeMovementZ;
+  ///
+  /// If TRUE, then the left button of the pointer device is being
+  /// pressed. If FALSE, then the left button of the pointer device is not being pressed.
+  ///
+  BOOLEAN LeftButton;
+  ///
+  /// If TRUE, then the right button of the pointer device is being
+  /// pressed. If FALSE, then the right button of the pointer device is not being pressed.
+  ///
+  BOOLEAN RightButton;
+} EFI_SIMPLE_POINTER_STATE;
+
+typedef struct {
+  ///
+  /// The resolution of the pointer device on the x-axis in counts/mm.
+  /// If 0, then the pointer device does not support an x-axis.
+  ///
+  UINT64  ResolutionX;
+  ///
+  /// The resolution of the pointer device on the y-axis in counts/mm.
+  /// If 0, then the pointer device does not support an x-axis.
+  ///
+  UINT64  ResolutionY;
+  ///
+  /// The resolution of the pointer device on the z-axis in counts/mm.
+  /// If 0, then the pointer device does not support an x-axis.
+  ///
+  UINT64  ResolutionZ;
+  ///
+  /// TRUE if a left button is present on the pointer device. Otherwise FALSE.
+  ///
+  BOOLEAN LeftButton;
+  ///
+  /// TRUE if a right button is present on the pointer device. Otherwise FALSE.
+  ///
+  BOOLEAN RightButton;
+} EFI_SIMPLE_POINTER_MODE;
+
+/**                                                                 
+  Resets the pointer device hardware.
+    
+  @param  This                  A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
+                                instance.                                   
+  @param  ExtendedVerification  Indicates that the driver may perform a more exhaustive
+                                verification operation of the device during reset.                                       
+                                
+  @retval EFI_SUCCESS           The device was reset.
+  @retval EFI_DEVICE_ERROR      The device is not functioning correctly and could not be reset.  
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_POINTER_RESET)(
+  IN EFI_SIMPLE_POINTER_PROTOCOL            *This,
+  IN BOOLEAN                                ExtendedVerification
+  );
+
+/**                                                                 
+  Retrieves the current state of a pointer device.
+    
+  @param  This                  A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
+                                instance.                                   
+  @param  State                 A pointer to the state information on the pointer device.
+                                
+  @retval EFI_SUCCESS           The state of the pointer device was returned in State.
+  @retval EFI_NOT_READY         The state of the pointer device has not changed since the last call to
+                                GetState().                                                           
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to retrieve the pointer device's
+                                current state.                                                           
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_POINTER_GET_STATE)(
+  IN EFI_SIMPLE_POINTER_PROTOCOL          *This,
+  IN OUT EFI_SIMPLE_POINTER_STATE         *State
+  );
+
+///
+/// The EFI_SIMPLE_POINTER_PROTOCOL provides a set of services for a pointer 
+/// device that can use used as an input device from an application written 
+/// to this specification. The services include the ability to reset the 
+/// pointer device, retrieve get the state of the pointer device, and 
+/// retrieve the capabilities of the pointer device.
+///
+struct _EFI_SIMPLE_POINTER_PROTOCOL {
+  EFI_SIMPLE_POINTER_RESET      Reset;
+  EFI_SIMPLE_POINTER_GET_STATE  GetState;
+  ///
+  /// Event to use with WaitForEvent() to wait for input from the pointer device.
+  ///
+  EFI_EVENT                     WaitForInput;
+  ///
+  /// Pointer to EFI_SIMPLE_POINTER_MODE data.
+  ///
+  EFI_SIMPLE_POINTER_MODE       *Mode;
+};
+
+extern EFI_GUID gEfiSimplePointerProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SimpleTextIn.h b/MdePkg/Include/Protocol/SimpleTextIn.h
new file mode 100644
index 000000000000..d8df5537aa1e
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimpleTextIn.h
@@ -0,0 +1,133 @@
+/** @file
+  Simple Text Input protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple input device like a keyboard or serial
+  terminal.
+
+  Copyright (c) 2006 - 2011, 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 __SIMPLE_TEXT_IN_PROTOCOL_H__
+#define __SIMPLE_TEXT_IN_PROTOCOL_H__
+
+#define EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID \
+  { \
+    0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+typedef struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL  EFI_SIMPLE_TEXT_INPUT_PROTOCOL;
+
+///
+/// Protocol GUID name defined in EFI1.1.
+///
+#define SIMPLE_INPUT_PROTOCOL   EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID
+
+///
+/// Protocol name in EFI1.1 for backward-compatible.
+///
+typedef struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL  SIMPLE_INPUT_INTERFACE;
+
+///
+/// The keystroke information for the key that was pressed.
+///
+typedef struct {
+  UINT16  ScanCode;
+  CHAR16  UnicodeChar;
+} EFI_INPUT_KEY;
+
+//
+// Required unicode control chars
+//
+#define CHAR_BACKSPACE        0x0008
+#define CHAR_TAB              0x0009
+#define CHAR_LINEFEED         0x000A
+#define CHAR_CARRIAGE_RETURN  0x000D
+
+//
+// EFI Scan codes
+//
+#define SCAN_NULL       0x0000
+#define SCAN_UP         0x0001
+#define SCAN_DOWN       0x0002
+#define SCAN_RIGHT      0x0003
+#define SCAN_LEFT       0x0004
+#define SCAN_HOME       0x0005
+#define SCAN_END        0x0006
+#define SCAN_INSERT     0x0007
+#define SCAN_DELETE     0x0008
+#define SCAN_PAGE_UP    0x0009
+#define SCAN_PAGE_DOWN  0x000A
+#define SCAN_F1         0x000B
+#define SCAN_F2         0x000C
+#define SCAN_F3         0x000D
+#define SCAN_F4         0x000E
+#define SCAN_F5         0x000F
+#define SCAN_F6         0x0010
+#define SCAN_F7         0x0011
+#define SCAN_F8         0x0012
+#define SCAN_F9         0x0013
+#define SCAN_F10        0x0014
+#define SCAN_ESC        0x0017
+
+/**
+  Reset the input device and optionally run diagnostics
+
+  @param  This                 Protocol instance pointer.
+  @param  ExtendedVerification Driver may perform diagnostics on reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET)(
+  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL       *This,
+  IN BOOLEAN                              ExtendedVerification
+  );
+
+/**
+  Reads the next keystroke from the input device. The WaitForKey Event can
+  be used to test for existence of a keystroke via WaitForEvent () call.
+
+  @param  This  Protocol instance pointer.
+  @param  Key   A pointer to a buffer that is filled in with the keystroke
+                information for the key that was pressed.
+
+  @retval EFI_SUCCESS      The keystroke information was returned.
+  @retval EFI_NOT_READY    There was no keystroke data available.
+  @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
+                           hardware errors.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY)(
+  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL       *This,
+  OUT EFI_INPUT_KEY                       *Key
+  );
+
+///
+/// The EFI_SIMPLE_TEXT_INPUT_PROTOCOL is used on the ConsoleIn device.
+/// It is the minimum required protocol for ConsoleIn.
+///
+struct _EFI_SIMPLE_TEXT_INPUT_PROTOCOL {
+  EFI_INPUT_RESET     Reset;
+  EFI_INPUT_READ_KEY  ReadKeyStroke;
+  ///
+  /// Event to use with WaitForEvent() to wait for a key to be available
+  ///
+  EFI_EVENT           WaitForKey;
+};
+
+extern EFI_GUID gEfiSimpleTextInProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SimpleTextInEx.h b/MdePkg/Include/Protocol/SimpleTextInEx.h
new file mode 100644
index 000000000000..5524c720a713
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimpleTextInEx.h
@@ -0,0 +1,325 @@
+/** @file
+  Simple Text Input Ex protocol from the UEFI 2.0 specification.
+
+  This protocol defines an extension to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL
+  which exposes much more state and modifier information from the input device,
+  also allows one to register a notification for a particular keystroke.
+
+  Copyright (c) 2006 - 2012, 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 __SIMPLE_TEXT_IN_EX_H__
+#define __SIMPLE_TEXT_IN_EX_H__
+
+#include <Protocol/SimpleTextIn.h>
+
+#define EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID \
+  {0xdd9e7534, 0x7762, 0x4698, { 0x8c, 0x14, 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa } }
+
+
+typedef struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL;
+
+/**
+  The Reset() function resets the input device hardware. As part
+  of initialization process, the firmware/device will make a quick
+  but reasonable attempt to verify that the device is functioning.
+  If the ExtendedVerification flag is TRUE the firmware may take
+  an extended amount of time to verify the device is operating on
+  reset. Otherwise the reset operation is to occur as quickly as
+  possible. The hardware verification process is not defined by
+  this specification and is left up to the platform firmware or
+  driver to implement.
+
+  @param This                 A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param ExtendedVerification Indicates that the driver may
+                              perform a more exhaustive
+                              verification operation of the
+                              device during reset.
+
+
+  @retval EFI_SUCCESS       The device was reset.
+
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET_EX)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN BOOLEAN                           ExtendedVerification
+);
+
+
+///
+/// EFI_KEY_TOGGLE_STATE. The toggle states are defined.
+/// They are: EFI_TOGGLE_STATE_VALID, EFI_SCROLL_LOCK_ACTIVE
+/// EFI_NUM_LOCK_ACTIVE, EFI_CAPS_LOCK_ACTIVE
+///
+typedef UINT8 EFI_KEY_TOGGLE_STATE;
+
+typedef struct _EFI_KEY_STATE {
+  ///
+  /// Reflects the currently pressed shift
+  /// modifiers for the input device. The
+  /// returned value is valid only if the high
+  /// order bit has been set.
+  ///
+  UINT32                KeyShiftState;
+  ///
+  /// Reflects the current internal state of
+  /// various toggled attributes. The returned
+  /// value is valid only if the high order
+  /// bit has been set.
+  ///
+  EFI_KEY_TOGGLE_STATE  KeyToggleState;
+} EFI_KEY_STATE;
+
+typedef struct {
+  ///
+  /// The EFI scan code and Unicode value returned from the input device.
+  ///
+  EFI_INPUT_KEY   Key;
+  ///
+  /// The current state of various toggled attributes as well as input modifier values.
+  ///
+  EFI_KEY_STATE   KeyState;
+} EFI_KEY_DATA;
+
+//
+// Any Shift or Toggle State that is valid should have
+// high order bit set.
+//
+// Shift state
+//
+#define EFI_SHIFT_STATE_VALID     0x80000000
+#define EFI_RIGHT_SHIFT_PRESSED   0x00000001
+#define EFI_LEFT_SHIFT_PRESSED    0x00000002
+#define EFI_RIGHT_CONTROL_PRESSED 0x00000004
+#define EFI_LEFT_CONTROL_PRESSED  0x00000008
+#define EFI_RIGHT_ALT_PRESSED     0x00000010
+#define EFI_LEFT_ALT_PRESSED      0x00000020
+#define EFI_RIGHT_LOGO_PRESSED    0x00000040
+#define EFI_LEFT_LOGO_PRESSED     0x00000080
+#define EFI_MENU_KEY_PRESSED      0x00000100
+#define EFI_SYS_REQ_PRESSED       0x00000200
+
+//
+// Toggle state
+//
+#define EFI_TOGGLE_STATE_VALID    0x80
+#define EFI_KEY_STATE_EXPOSED     0x40
+#define EFI_SCROLL_LOCK_ACTIVE    0x01
+#define EFI_NUM_LOCK_ACTIVE       0x02
+#define EFI_CAPS_LOCK_ACTIVE      0x04
+
+//
+// EFI Scan codes
+//
+#define SCAN_F11                  0x0015
+#define SCAN_F12                  0x0016
+#define SCAN_PAUSE                0x0048
+#define SCAN_F13                  0x0068
+#define SCAN_F14                  0x0069
+#define SCAN_F15                  0x006A
+#define SCAN_F16                  0x006B
+#define SCAN_F17                  0x006C
+#define SCAN_F18                  0x006D
+#define SCAN_F19                  0x006E
+#define SCAN_F20                  0x006F
+#define SCAN_F21                  0x0070
+#define SCAN_F22                  0x0071
+#define SCAN_F23                  0x0072
+#define SCAN_F24                  0x0073
+#define SCAN_MUTE                 0x007F
+#define SCAN_VOLUME_UP            0x0080
+#define SCAN_VOLUME_DOWN          0x0081
+#define SCAN_BRIGHTNESS_UP        0x0100
+#define SCAN_BRIGHTNESS_DOWN      0x0101
+#define SCAN_SUSPEND              0x0102
+#define SCAN_HIBERNATE            0x0103
+#define SCAN_TOGGLE_DISPLAY       0x0104
+#define SCAN_RECOVERY             0x0105
+#define SCAN_EJECT                0x0106
+
+/**
+  The function reads the next keystroke from the input device. If
+  there is no pending keystroke the function returns
+  EFI_NOT_READY. If there is a pending keystroke, then
+  KeyData.Key.ScanCode is the EFI scan code defined in Error!
+  Reference source not found. The KeyData.Key.UnicodeChar is the
+  actual printable character or is zero if the key does not
+  represent a printable character (control key, function key,
+  etc.). The KeyData.KeyState is shift state for the character
+  reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
+  When interpreting the data from this function, it should be
+  noted that if a class of printable characters that are
+  normally adjusted by shift modifiers (e.g. Shift Key + "f"
+  key) would be presented solely as a KeyData.Key.UnicodeChar
+  without the associated shift state. So in the previous example
+  of a Shift Key + "f" key being pressed, the only pertinent
+  data returned would be KeyData.Key.UnicodeChar with the value
+  of "F". This of course would not typically be the case for
+  non-printable characters such as the pressing of the Right
+  Shift Key + F10 key since the corresponding returned data
+  would be reflected both in the KeyData.KeyState.KeyShiftState
+  and KeyData.Key.ScanCode values. UEFI drivers which implement
+  the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
+  KeyData.Key and KeyData.KeyState values. These drivers must
+  always return the most current state of
+  KeyData.KeyState.KeyShiftState and
+  KeyData.KeyState.KeyToggleState. It should also be noted that
+  certain input devices may not be able to produce shift or toggle
+  state information, and in those cases the high order bit in the
+  respective Toggle and Shift state fields should not be active.
+
+
+  @param This     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyData  A pointer to a buffer that is filled in with
+                  the keystroke state data for the key that was
+                  pressed.
+
+
+  @retval EFI_SUCCESS     The keystroke information was
+                          returned.
+
+  @retval EFI_NOT_READY   There was no keystroke data available.
+                          EFI_DEVICE_ERROR The keystroke
+                          information was not returned due to
+                          hardware errors.
+
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY_EX)(
+  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  OUT EFI_KEY_DATA                      *KeyData
+);
+
+/**
+  The SetState() function allows the input device hardware to
+  have state settings adjusted.
+
+  @param This           A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
+                        set the state for the input device.
+
+
+  @retval EFI_SUCCESS       The device state was set appropriately.
+
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not have the
+                            setting adjusted.
+
+  @retval EFI_UNSUPPORTED   The device does not support the
+                            ability to have its state set.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_STATE)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN EFI_KEY_TOGGLE_STATE              *KeyToggleState
+);
+
+///
+/// The function will be called when the key sequence is typed specified by KeyData.
+///
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KEY_NOTIFY_FUNCTION)(
+  IN EFI_KEY_DATA *KeyData
+);
+
+/**
+  The RegisterKeystrokeNotify() function registers a function
+  which will be called when a specified keystroke will occur.
+
+  @param This                     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyData                  A pointer to a buffer that is filled in with
+                                  the keystroke information for the key that was
+                                  pressed.
+
+  @param KeyNotificationFunction  Points to the function to be
+                                  called when the key sequence
+                                  is typed specified by KeyData.
+
+
+  @param NotifyHandle             Points to the unique handle assigned to
+                                  the registered notification.
+
+  @retval EFI_SUCCESS           The device state was set
+                                appropriately.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate necessary
+                                data structures.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_KEYSTROKE_NOTIFY)(
+  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  IN  EFI_KEY_DATA                      *KeyData,
+  IN  EFI_KEY_NOTIFY_FUNCTION           KeyNotificationFunction,
+  OUT VOID                              **NotifyHandle
+);
+
+/**
+  The UnregisterKeystrokeNotify() function removes the
+  notification which was previously registered.
+
+  @param This               A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param NotificationHandle The handle of the notification
+                            function being unregistered.
+
+  @retval EFI_SUCCESS The device state was set appropriately.
+
+  @retval EFI_INVALID_PARAMETER The NotificationHandle is
+                                invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNREGISTER_KEYSTROKE_NOTIFY)(
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN VOID                               *NotificationHandle
+);
+
+
+///
+/// The EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL is used on the ConsoleIn
+/// device. It is an extension to the Simple Text Input protocol
+/// which allows a variety of extended shift state information to be
+/// returned.
+///
+struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL{
+  EFI_INPUT_RESET_EX              Reset;
+  EFI_INPUT_READ_KEY_EX           ReadKeyStrokeEx;
+  ///
+  /// Event to use with WaitForEvent() to wait for a key to be available.
+  ///
+  EFI_EVENT                       WaitForKeyEx;
+  EFI_SET_STATE                   SetState;
+  EFI_REGISTER_KEYSTROKE_NOTIFY   RegisterKeyNotify;
+  EFI_UNREGISTER_KEYSTROKE_NOTIFY UnregisterKeyNotify;
+};
+
+
+extern EFI_GUID gEfiSimpleTextInputExProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SimpleTextOut.h b/MdePkg/Include/Protocol/SimpleTextOut.h
new file mode 100644
index 000000000000..4d2612c0a91d
--- /dev/null
+++ b/MdePkg/Include/Protocol/SimpleTextOut.h
@@ -0,0 +1,415 @@
+/** @file
+  Simple Text Out protocol from the UEFI 2.0 specification.
+
+  Abstraction of a very simple text based output device like VGA text mode or
+  a serial terminal. The Simple Text Out protocol instance can represent
+  a single hardware device or a virtual device that is an aggregation
+  of multiple physical devices.
+
+Copyright (c) 2006 - 2015, 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 __SIMPLE_TEXT_OUT_H__
+#define __SIMPLE_TEXT_OUT_H__
+
+#define EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID \
+  { \
+    0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
+  }
+
+///
+/// Protocol GUID defined in EFI1.1.
+/// 
+#define SIMPLE_TEXT_OUTPUT_PROTOCOL   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID
+
+typedef struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL;
+
+///
+/// Backward-compatible with EFI1.1.
+/// 
+typedef EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   SIMPLE_TEXT_OUTPUT_INTERFACE;
+
+//
+// Define's for required EFI Unicode Box Draw characters
+//
+#define BOXDRAW_HORIZONTAL                  0x2500
+#define BOXDRAW_VERTICAL                    0x2502
+#define BOXDRAW_DOWN_RIGHT                  0x250c
+#define BOXDRAW_DOWN_LEFT                   0x2510
+#define BOXDRAW_UP_RIGHT                    0x2514
+#define BOXDRAW_UP_LEFT                     0x2518
+#define BOXDRAW_VERTICAL_RIGHT              0x251c
+#define BOXDRAW_VERTICAL_LEFT               0x2524
+#define BOXDRAW_DOWN_HORIZONTAL             0x252c
+#define BOXDRAW_UP_HORIZONTAL               0x2534
+#define BOXDRAW_VERTICAL_HORIZONTAL         0x253c
+#define BOXDRAW_DOUBLE_HORIZONTAL           0x2550
+#define BOXDRAW_DOUBLE_VERTICAL             0x2551
+#define BOXDRAW_DOWN_RIGHT_DOUBLE           0x2552
+#define BOXDRAW_DOWN_DOUBLE_RIGHT           0x2553
+#define BOXDRAW_DOUBLE_DOWN_RIGHT           0x2554
+#define BOXDRAW_DOWN_LEFT_DOUBLE            0x2555
+#define BOXDRAW_DOWN_DOUBLE_LEFT            0x2556
+#define BOXDRAW_DOUBLE_DOWN_LEFT            0x2557
+#define BOXDRAW_UP_RIGHT_DOUBLE             0x2558
+#define BOXDRAW_UP_DOUBLE_RIGHT             0x2559
+#define BOXDRAW_DOUBLE_UP_RIGHT             0x255a
+#define BOXDRAW_UP_LEFT_DOUBLE              0x255b
+#define BOXDRAW_UP_DOUBLE_LEFT              0x255c
+#define BOXDRAW_DOUBLE_UP_LEFT              0x255d
+#define BOXDRAW_VERTICAL_RIGHT_DOUBLE       0x255e
+#define BOXDRAW_VERTICAL_DOUBLE_RIGHT       0x255f
+#define BOXDRAW_DOUBLE_VERTICAL_RIGHT       0x2560
+#define BOXDRAW_VERTICAL_LEFT_DOUBLE        0x2561
+#define BOXDRAW_VERTICAL_DOUBLE_LEFT        0x2562
+#define BOXDRAW_DOUBLE_VERTICAL_LEFT        0x2563
+#define BOXDRAW_DOWN_HORIZONTAL_DOUBLE      0x2564
+#define BOXDRAW_DOWN_DOUBLE_HORIZONTAL      0x2565
+#define BOXDRAW_DOUBLE_DOWN_HORIZONTAL      0x2566
+#define BOXDRAW_UP_HORIZONTAL_DOUBLE        0x2567
+#define BOXDRAW_UP_DOUBLE_HORIZONTAL        0x2568
+#define BOXDRAW_DOUBLE_UP_HORIZONTAL        0x2569
+#define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE  0x256a
+#define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL  0x256b
+#define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL  0x256c
+
+//
+// EFI Required Block Elements Code Chart
+//
+#define BLOCKELEMENT_FULL_BLOCK   0x2588
+#define BLOCKELEMENT_LIGHT_SHADE  0x2591
+
+//
+// EFI Required Geometric Shapes Code Chart
+//
+#define GEOMETRICSHAPE_UP_TRIANGLE    0x25b2
+#define GEOMETRICSHAPE_RIGHT_TRIANGLE 0x25ba
+#define GEOMETRICSHAPE_DOWN_TRIANGLE  0x25bc
+#define GEOMETRICSHAPE_LEFT_TRIANGLE  0x25c4
+
+//
+// EFI Required Arrow shapes
+//
+#define ARROW_LEFT  0x2190
+#define ARROW_UP    0x2191
+#define ARROW_RIGHT 0x2192
+#define ARROW_DOWN  0x2193
+
+//
+// EFI Console Colours
+//
+#define EFI_BLACK                 0x00
+#define EFI_BLUE                  0x01
+#define EFI_GREEN                 0x02
+#define EFI_CYAN                  (EFI_BLUE | EFI_GREEN)
+#define EFI_RED                   0x04
+#define EFI_MAGENTA               (EFI_BLUE | EFI_RED)
+#define EFI_BROWN                 (EFI_GREEN | EFI_RED)
+#define EFI_LIGHTGRAY             (EFI_BLUE | EFI_GREEN | EFI_RED)
+#define EFI_BRIGHT                0x08
+#define EFI_DARKGRAY              (EFI_BLACK | EFI_BRIGHT)
+#define EFI_LIGHTBLUE             (EFI_BLUE | EFI_BRIGHT)
+#define EFI_LIGHTGREEN            (EFI_GREEN | EFI_BRIGHT)
+#define EFI_LIGHTCYAN             (EFI_CYAN | EFI_BRIGHT)
+#define EFI_LIGHTRED              (EFI_RED | EFI_BRIGHT)
+#define EFI_LIGHTMAGENTA          (EFI_MAGENTA | EFI_BRIGHT)
+#define EFI_YELLOW                (EFI_BROWN | EFI_BRIGHT)
+#define EFI_WHITE                 (EFI_BLUE | EFI_GREEN | EFI_RED | EFI_BRIGHT)
+
+//
+// Macro to accept color values in their raw form to create 
+// a value that represents both a foreground and background 
+// color in a single byte.
+// For Foreground, and EFI_* value is valid from EFI_BLACK(0x00) to
+// EFI_WHITE (0x0F).
+// For Background, only EFI_BLACK, EFI_BLUE, EFI_GREEN, EFI_CYAN,
+// EFI_RED, EFI_MAGENTA, EFI_BROWN, and EFI_LIGHTGRAY are acceptable
+//
+// Do not use EFI_BACKGROUND_xxx values with this macro.
+//
+#define EFI_TEXT_ATTR(Foreground,Background) ((Foreground) | ((Background) << 4))
+
+#define EFI_BACKGROUND_BLACK      0x00
+#define EFI_BACKGROUND_BLUE       0x10
+#define EFI_BACKGROUND_GREEN      0x20
+#define EFI_BACKGROUND_CYAN       (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN)
+#define EFI_BACKGROUND_RED        0x40
+#define EFI_BACKGROUND_MAGENTA    (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_BROWN      (EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_LIGHTGRAY  (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+
+//
+// We currently define attributes from 0 - 7F for color manipulations
+// To internally handle the local display characteristics for a particular character, 
+// Bit 7 signifies the local glyph representation for a character.  If turned on, glyphs will be
+// pulled from the wide glyph database and will display locally as a wide character (16 X 19 versus 8 X 19)
+// If bit 7 is off, the narrow glyph database will be used.  This does NOT affect information that is sent to
+// non-local displays, such as serial or LAN consoles.
+//
+#define EFI_WIDE_ATTRIBUTE  0x80
+
+/**
+  Reset the text output device hardware and optionaly run diagnostics
+
+  @param  This                 The protocol instance pointer.
+  @param  ExtendedVerification Driver may perform more exhaustive verification
+                               operation of the device during reset.
+
+  @retval EFI_SUCCESS          The text output device was reset.
+  @retval EFI_DEVICE_ERROR     The text output device is not functioning correctly and
+                               could not be reset.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_RESET)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN BOOLEAN                                ExtendedVerification
+  );
+
+/**
+  Write a string to the output device.
+
+  @param  This   The protocol instance pointer.
+  @param  String The NULL-terminated string to be displayed on the output
+                 device(s). All output devices must also support the Unicode
+                 drawing character codes defined in this file.
+
+  @retval EFI_SUCCESS             The string was output to the device.
+  @retval EFI_DEVICE_ERROR        The device reported an error while attempting to output
+                                  the text.
+  @retval EFI_UNSUPPORTED         The output device's mode is not currently in a
+                                  defined text mode.
+  @retval EFI_WARN_UNKNOWN_GLYPH  This warning code indicates that some of the
+                                  characters in the string could not be
+                                  rendered and were skipped.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_STRING)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN CHAR16                                 *String
+  );
+
+/**
+  Verifies that all characters in a string can be output to the 
+  target device.
+
+  @param  This   The protocol instance pointer.
+  @param  String The NULL-terminated string to be examined for the output
+                 device(s).
+
+  @retval EFI_SUCCESS      The device(s) are capable of rendering the output string.
+  @retval EFI_UNSUPPORTED  Some of the characters in the string cannot be
+                           rendered by one or more of the output devices mapped
+                           by the EFI handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_TEST_STRING)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN CHAR16                                 *String
+  );
+
+/**
+  Returns information for an available text mode that the output device(s)
+  supports.
+
+  @param  This       The protocol instance pointer.
+  @param  ModeNumber The mode number to return information on.
+  @param  Columns    Returns the geometry of the text output device for the
+                     requested ModeNumber.
+  @param  Rows       Returns the geometry of the text output device for the
+                     requested ModeNumber.
+                                          
+  @retval EFI_SUCCESS      The requested mode information was returned.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The mode number was not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_QUERY_MODE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  ModeNumber,
+  OUT UINTN                                 *Columns,
+  OUT UINTN                                 *Rows
+  );
+
+/**
+  Sets the output device(s) to a specified mode.
+
+  @param  This       The protocol instance pointer.
+  @param  ModeNumber The mode number to set.
+
+  @retval EFI_SUCCESS      The requested text mode was set.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The mode number was not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_MODE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  ModeNumber
+  );
+
+/**
+  Sets the background and foreground colors for the OutputString () and
+  ClearScreen () functions.
+
+  @param  This      The protocol instance pointer.
+  @param  Attribute The attribute to set. Bits 0..3 are the foreground color, and
+                    bits 4..6 are the background color. All other bits are undefined
+                    and must be zero. The valid Attributes are defined in this file.
+
+  @retval EFI_SUCCESS       The attribute was set.
+  @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED   The attribute requested is not defined.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_ATTRIBUTE)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  Attribute
+  );
+
+/**
+  Clears the output device(s) display to the currently selected background 
+  color.
+
+  @param  This              The protocol instance pointer.
+                           
+  @retval  EFI_SUCCESS      The operation completed successfully.
+  @retval  EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval  EFI_UNSUPPORTED  The output device is not in a valid text mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_CLEAR_SCREEN)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   *This
+  );
+
+/**
+  Sets the current coordinates of the cursor position
+
+  @param  This        The protocol instance pointer.
+  @param  Column      The position to set the cursor to. Must be greater than or
+                      equal to zero and less than the number of columns and rows
+                      by QueryMode ().
+  @param  Row         The position to set the cursor to. Must be greater than or
+                      equal to zero and less than the number of columns and rows
+                      by QueryMode ().
+
+  @retval EFI_SUCCESS      The operation completed successfully.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED  The output device is not in a valid text mode, or the
+                           cursor position is invalid for the current mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_CURSOR_POSITION)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN UINTN                                  Column,
+  IN UINTN                                  Row
+  );
+
+/**
+  Makes the cursor visible or invisible
+
+  @param  This    The protocol instance pointer.
+  @param  Visible If TRUE, the cursor is set to be visible. If FALSE, the cursor is
+                  set to be invisible.
+
+  @retval EFI_SUCCESS      The operation completed successfully.
+  @retval EFI_DEVICE_ERROR The device had an error and could not complete the
+                           request, or the device does not support changing
+                           the cursor mode.
+  @retval EFI_UNSUPPORTED  The output device is not in a valid text mode.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_ENABLE_CURSOR)(
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL        *This,
+  IN BOOLEAN                                Visible
+  );
+
+/**
+  @par Data Structure Description:
+  Mode Structure pointed to by Simple Text Out protocol.
+**/
+typedef struct {
+  ///
+  /// The number of modes supported by QueryMode () and SetMode ().
+  ///
+  INT32   MaxMode;
+
+  //
+  // current settings
+  //
+
+  ///
+  /// The text mode of the output device(s).
+  ///
+  INT32   Mode;
+  ///
+  /// The current character output attribute.
+  ///
+  INT32   Attribute;
+  ///
+  /// The cursor's column.
+  ///
+  INT32   CursorColumn;
+  ///
+  /// The cursor's row.
+  ///
+  INT32   CursorRow;
+  ///
+  /// The cursor is currently visbile or not.
+  ///
+  BOOLEAN CursorVisible;
+} EFI_SIMPLE_TEXT_OUTPUT_MODE;
+
+///
+/// The SIMPLE_TEXT_OUTPUT protocol is used to control text-based output devices. 
+/// It is the minimum required protocol for any handle supplied as the ConsoleOut 
+/// or StandardError device. In addition, the minimum supported text mode of such 
+/// devices is at least 80 x 25 characters.
+///
+struct _EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL {
+  EFI_TEXT_RESET                Reset;
+
+  EFI_TEXT_STRING               OutputString;
+  EFI_TEXT_TEST_STRING          TestString;
+
+  EFI_TEXT_QUERY_MODE           QueryMode;
+  EFI_TEXT_SET_MODE             SetMode;
+  EFI_TEXT_SET_ATTRIBUTE        SetAttribute;
+
+  EFI_TEXT_CLEAR_SCREEN         ClearScreen;
+  EFI_TEXT_SET_CURSOR_POSITION  SetCursorPosition;
+  EFI_TEXT_ENABLE_CURSOR        EnableCursor;
+
+  ///
+  /// Pointer to SIMPLE_TEXT_OUTPUT_MODE data.
+  ///
+  EFI_SIMPLE_TEXT_OUTPUT_MODE   *Mode;
+};
+
+extern EFI_GUID gEfiSimpleTextOutProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmartCardEdge.h b/MdePkg/Include/Protocol/SmartCardEdge.h
new file mode 100644
index 000000000000..ac5095c375fc
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmartCardEdge.h
@@ -0,0 +1,739 @@
+/** @file
+  The Smart Card Edge Protocol provides an abstraction for device to provide Smart
+  Card support.
+
+  This protocol allows UEFI applications to interface with a Smart Card during
+  boot process for authentication or data signing/decryption, especially if the
+  application has to make use of PKI.
+
+  Copyright (c) 2015, 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 __SMART_CARD_EDGE_H__
+#define __SMART_CARD_EDGE_H__
+
+#define EFI_SMART_CARD_EDGE_PROTOCOL_GUID \
+    { \
+      0xd317f29b, 0xa325, 0x4712, {0x9b, 0xf1, 0xc6, 0x19, 0x54, 0xdc, 0x19, 0x8c} \
+    }
+
+typedef struct _EFI_SMART_CARD_EDGE_PROTOCOL  EFI_SMART_CARD_EDGE_PROTOCOL;
+
+//
+// Maximum size for a Smart Card AID (Application IDentifier)
+//
+#define SCARD_AID_MAXSIZE                        0x0010
+//
+// Size of CSN (Card Serial Number)
+//
+#define SCARD_CSN_SIZE                           0x0010
+//
+// Current specification version 1.00
+//
+#define SMART_CARD_EDGE_PROTOCOL_VERSION_1       0x00000100
+//
+// Parameters type definition
+//
+typedef UINT8 SMART_CARD_AID[SCARD_AID_MAXSIZE];
+typedef UINT8 SMART_CARD_CSN[SCARD_CSN_SIZE];
+
+//
+// Type of data elements in credentials list
+//
+// value of tag field for header, the number of containers
+//
+#define SC_EDGE_TAG_HEADER              0x0000
+//
+// value of tag field for certificate
+//
+#define SC_EDGE_TAG_CERT                0x0001
+//
+// value of tag field for key index associated with certificate
+//
+#define SC_EDGE_TAG_KEY_ID              0x0002
+//
+// value of tag field for key type
+//
+#define SC_EDGE_TAG_KEY_TYPE            0x0003
+//
+// value of tag field for key size
+//
+#define SC_EDGE_TAG_KEY_SIZE            0x0004
+
+//
+// Length of L fields of TLV items
+//
+//
+// size of L field for header
+//
+#define SC_EDGE_L_SIZE_HEADER           1
+//
+// size of L field for certificate (big endian)
+//
+#define SC_EDGE_L_SIZE_CERT             2
+//
+// size of L field for key index
+//
+#define SC_EDGE_L_SIZE_KEY_ID           1
+//
+// size of L field for key type
+//
+#define SC_EDGE_L_SIZE_KEY_TYPE         1
+//
+// size of L field for key size (big endian)
+//
+#define SC_EDGE_L_SIZE_KEY_SIZE         2
+
+//
+// Some TLV items have a fixed value for L field
+//
+// value of L field for header
+//
+#define SC_EDGE_L_VALUE_HEADER          1
+//
+// value of L field for key index
+//
+#define SC_EDGE_L_VALUE_KEY_ID          1
+//
+// value of L field for key type
+//
+#define SC_EDGE_L_VALUE_KEY_TYPE        1
+//
+// value of L field for key size
+//
+#define SC_EDGE_L_VALUE_KEY_SIZE        2
+
+//
+// Possible values for key type
+//
+//
+// RSA decryption
+//
+#define SC_EDGE_RSA_EXCHANGE            0x01
+//
+// RSA signature
+//
+#define SC_EDGE_RSA_SIGNATURE           0x02
+//
+// ECDSA signature
+//
+#define SC_EDGE_ECDSA_256               0x03
+//
+// ECDSA signature
+//
+#define SC_EDGE_ECDSA_384               0x04
+//
+// ECDSA signature
+//
+#define SC_EDGE_ECDSA_521               0x05
+//
+// ECDH agreement
+//
+#define SC_EDGE_ECDH_256                0x06
+//
+// ECDH agreement
+//
+#define SC_EDGE_ECDH_384                0x07
+//
+// ECDH agreement
+//
+#define SC_EDGE_ECDH_521                0x08
+
+//
+// Padding methods GUIDs for signature
+//
+//
+// RSASSA- PKCS#1-V1.5 padding method, for signature
+//
+#define EFI_PADDING_RSASSA_PKCS1V1P5_GUID \
+  { \
+    0x9317ec24, 0x7cb0, 0x4d0e, {0x8b, 0x32, 0x2e, 0xd9, 0x20, 0x9c, 0xd8, 0xaf} \
+  }
+
+extern EFI_GUID gEfiPaddingRsassaPkcs1V1P5Guid;
+
+//
+// RSASSA-PSS padding method, for signature
+//
+#define EFI_PADDING_RSASSA_PSS_GUID \
+  { \
+    0x7b2349e0, 0x522d, 0x4f8e, {0xb9, 0x27, 0x69, 0xd9, 0x7c, 0x9e, 0x79, 0x5f} \
+  }
+
+extern EFI_GUID gEfiPaddingRsassaPssGuid;
+
+//
+// Padding methods GUIDs for decryption
+//
+//
+// No padding, for decryption
+//
+#define EFI_PADDING_NONE_GUID \
+  { \
+    0x3629ddb1, 0x228c, 0x452e, {0xb6, 0x16, 0x09, 0xed, 0x31, 0x6a, 0x97, 0x00} \
+  }
+
+extern EFI_GUID gEfiPaddingNoneGuid;
+
+//
+// RSAES-PKCS#1-V1.5 padding, for decryption
+//
+#define EFI_PADDING_RSAES_PKCS1V1P5_GUID \
+  { \
+    0xe1c1d0a9, 0x40b1, 0x4632, {0xbd, 0xcc, 0xd9, 0xd6, 0xe5, 0x29, 0x56, 0x31} \
+  }
+
+extern EFI_GUID gEfiPaddingRsaesPkcs1V1P5Guid;
+
+//
+// RSAES-OAEP padding, for decryption
+//
+#define EFI_PADDING_RSAES_OAEP_GUID \
+  { \
+    0xc1e63ac4, 0xd0cf, 0x4ce6, {0x83, 0x5b, 0xee, 0xd0, 0xe6, 0xa8, 0xa4, 0x5b} \
+  }
+
+extern EFI_GUID gEfiPaddingRsaesOaepGuid;
+
+/**
+  This function retrieves the context driver.
+
+  The GetContextfunction returns the context of the protocol, the application
+  identifiers supported by the protocol and the number and the CSN unique identifier
+  of Smart Cards that are present and supported by protocol.
+
+  If AidTableSize, AidTable, CsnTableSize, CsnTable or VersionProtocol is NULL,
+  the function does not fail but does not fill in such variables.
+
+  In case AidTableSize indicates a buffer too small to hold all the protocol AID table,
+  only the first AidTableSize items of the table are returned in AidTable.
+
+  In case CsnTableSize indicates a buffer too small to hold the entire table of
+  Smart Card CSN present, only the first CsnTableSize items of the table are returned
+  in CsnTable.
+
+  VersionScEdgeProtocol returns the version of the EFI_SMART_CARD_EDGE_PROTOCOL this
+  driver uses. For this protocol specification value is SMART_CARD_EDGE_PROTOCOL_VERSION_1.
+
+  In case of Smart Card removal the internal CSN list is immediately updated, even if
+  a connection is opened with that Smart Card.
+
+  @param[in]      This                  Indicates a pointer to the calling context.
+  @param[out]     NumberAidSupported    Number of AIDs this protocol supports.
+  @param[in, out] AidTableSize          On input, number of items allocated for the
+                                        AID table. On output, number of items returned
+                                        by protocol.
+  @param[out]     AidTable              Table of the AIDs supported by the protocol.
+  @param[out]     NumberSCPresent       Number of currently present Smart Cards that
+                                        are supported by protocol.
+  @param[in, out] CsnTableSize          On input, the number of items the buffer CSN
+                                        table can contain. On output, the number of
+                                        items returned by the protocol.
+  @param[out]     CsnTable              Table of the CSN of the Smart Card present and
+                                        supported by protocol.
+  @param[out]     VersionScEdgeProtocol EFI_SMART_CARD_EDGE_PROTOCOL version.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  NumberSCPresent is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_CONTEXT) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+     OUT UINTN                             *NumberAidSupported,
+  IN OUT UINTN                             *AidTableSize OPTIONAL,
+     OUT SMART_CARD_AID                    *AidTable OPTIONAL,
+     OUT UINTN                             *NumberSCPresent,
+  IN OUT UINTN                             *CsnTableSize OPTIONAL,
+     OUT SMART_CARD_CSN                    *CsnTable OPTIONAL,
+     OUT UINT32                            *VersionScEdgeProtocol OPTIONAL
+  );
+
+/**
+  This function establish a connection with a Smart Card the protocol support.
+
+  In case of success the SCardHandle can be used.
+
+  If the ScardCsn is NULL the connection is established with the first Smart Card
+  the protocol finds in its table of Smart Card present and supported. Else it
+  establish context with the Smart Card whose CSN given by ScardCsn.
+
+  If ScardAid is not NULL the function returns the Smart Card AID the protocol supports.
+  After a successful connect the SCardHandle will remain existing even in case Smart Card
+  removed from Smart Card reader, but all function invoking this SCardHandle will fail.
+  SCardHandle is released only on Disconnect.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[out] SCardHandle        Handle on Smart Card connection.
+  @param[in]  ScardCsn           CSN of the Smart Card the connection has to be
+                                 established.
+  @param[out] ScardAid           AID of the Smart Card the connection has been
+                                 established.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  SCardHandle is NULL.
+  @retval EFI_NO_MEDIA           No Smart Card supported by protocol is present,
+                                 Smart Card with CSN ScardCsn or Reader has been
+                                 removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_CONNECT) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+     OUT EFI_HANDLE                        *SCardHandle,
+  IN     UINT8                             *ScardCsn OPTIONAL,
+     OUT UINT8                             *ScardAid OPTIONAL
+  );
+
+/**
+  This function releases a connection previously established by Connect.
+
+  The Disconnect function releases the connection previously established by
+  a Connect. In case the Smart Card or the Smart Card reader has been removed
+  before this call, this function returns EFI_SUCCESS.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection to release.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_DISCONNECT) (
+  IN  EFI_SMART_CARD_EDGE_PROTOCOL         *This,
+  IN  EFI_HANDLE                           SCardHandle
+  );
+
+/**
+  This function returns the Smart Card serial number.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection.
+  @param[out] Csn                The Card Serial number, 16 bytes array.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_CSN) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+     OUT UINT8                             Csn[SCARD_CSN_SIZE]
+  );
+
+/**
+  This function returns the name of the Smart Card reader used for this connection.
+
+  @param[in]      This              Indicates a pointer to the calling context.
+  @param[in]      SCardHandle       Handle on Smart Card connection.
+  @param[in, out] ReaderNameLength  On input, a pointer to the variable that holds
+                                    the maximal size, in bytes, of ReaderName.
+                                    On output, the required size, in bytes, for ReaderName.
+  @param[out]     ReaderName        A pointer to a NULL terminated string that will
+                                    contain the reader name.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  ReaderNameLength is NULL.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_READER_NAME) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN OUT UINTN                             *ReaderNameLength,
+     OUT CHAR16                            *ReaderName OPTIONAL
+  );
+
+/**
+  This function authenticates a Smart Card user by presenting a PIN code.
+
+  The VerifyPinfunction presents a PIN code to the Smart Card.
+
+  If Smart Card found the PIN code correct the user is considered authenticated
+  to current application, and the function returns TRUE.
+
+  Negative or null PinSize value rejected if PinCodeis not NULL.
+
+  A NULL PinCodebuffer means the application didn't know the PIN, in that case:
+    - If PinSize value is negative the caller only wants to know if the current
+      chain of the elements Smart Card Edge protocol, Smart Card Reader protocol
+      and Smart Card Reader supports the Secure Pin Entry PCSC V2 functionality.
+    - If PinSize value is positive or null the caller ask to perform the verify
+      PIN using the Secure PIN Entry functionality.
+
+  In PinCode buffer, the PIN value is always given in plaintext, in case of secure
+  messaging the SMART_CARD_EDGE_PROTOCOL will be in charge of all intermediate
+  treatments to build the correct Smart Card APDU.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection.
+  @param[in]  PinSize            PIN code buffer size.
+  @param[in]  PinCode            PIN code to present to the Smart Card.
+  @param[out] PinResult          Result of PIN code presentation to the Smart Card.
+                                 TRUE when Smard Card founds the PIN code correct.
+  @param[out] RemainingAttempts  Number of attempts still possible.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_UNSUPPORTED        Pinsize < 0 and Secure PIN Entry functionality not
+                                 supported.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  Bad value for PinSize: value not supported by Smart
+                                 Card or, negative with PinCode not null.
+  @retval EFI_INVALID_PARAMETER  PinResult is NULL.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_VERIFY_PIN) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN     INT32                             PinSize,
+  IN     UINT8                             *PinCode,
+     OUT BOOLEAN                           *PinResult,
+     OUT UINT32                            *RemainingAttempts OPTIONAL
+  );
+
+/**
+  This function gives the remaining number of attempts for PIN code presentation.
+
+  The number of attempts to present a correct PIN is limited and depends on Smart
+  Card and on PIN.
+
+  This function will retrieve the number of remaining possible attempts.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection.
+  @param[out] RemainingAttempts  Number of attempts still possible.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  RemainingAttempts is NULL.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_PIN_REMAINING) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+     OUT UINT32                            *RemainingAttempts
+  );
+
+/**
+  This function returns a specific data from Smart Card.
+
+  The function is generic for any kind of data, but driver and application must
+  share an EFI_GUID that identify the data.
+
+  @param[in]      This           Indicates a pointer to the calling context.
+  @param[in]      SCardHandle    Handle on Smart Card connection.
+  @param[in]      DataId         The type identifier of the data to get.
+  @param[in, out] DataSize       On input, in bytes, the size of Data. On output,
+                                 in bytes, the size of buffer required to store
+                                 the specified data.
+  @param[out]     Data           The data buffer in which the data is returned.
+                                 The type of the data buffer is associated with
+                                 the DataId. Ignored if *DataSize is 0.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  DataId is NULL.
+  @retval EFI_INVALID_PARAMETER  DataSize is NULL.
+  @retval EFI_INVALID_PARAMETER  Data is NULL, and *DataSize is not zero.
+  @retval EFI_NOT_FOUND          DataId unknown for this driver.
+  @retval EFI_BUFFER_TOO_SMALL   The size of Data is too small for the specified
+                                 data and the required size is returned in DataSize.
+  @retval EFI_ACCESS_DENIED      Operation not performed, conditions not fulfilled.
+                                 PIN not verified.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_DATA) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN     EFI_GUID                          *DataId,
+  IN OUT UINTN                             *DataSize,
+     OUT VOID                              *Data OPTIONAL
+  );
+
+/**
+  This function retrieve credentials store into the Smart Card.
+
+  The function returns a series of items in TLV (Tag Length Value) format.
+
+  First TLV item is the header item that gives the number of following
+  containers (0x00, 0x01, Nb containers).
+
+  All these containers are a series of 4 TLV items:
+    - The certificate item (0x01, certificate size, certificate)
+    - The Key identifier item (0x02, 0x01, key index)
+    - The key type item (0x03, 0x01, key type)
+    - The key size item (0x04, 0x02, key size), key size in number of bits.
+  Numeric multi-bytes values are on big endian format, most significant byte first:
+    - The L field value for certificate (2 bytes)
+    - The L field value for key size (2 bytes)
+    - The value field for key size (2 bytes)
+
+  @param[in]      This           Indicates a pointer to the calling context.
+  @param[in]      SCardHandle    Handle on Smart Card connection.
+  @param[in, out] CredentialSize On input, in bytes, the size of buffer to store
+                                 the list of credential.
+                                 On output, in bytes, the size of buffer required
+                                 to store the entire list of credentials.
+
+  @param[out]     CredentialList List of credentials stored into the Smart Card.
+                                 A list of TLV (Tag Length Value) elements organized
+                                 in containers array.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  CredentialSize is NULL.
+  @retval EFI_INVALID_PARAMETER  CredentialList is NULL, if CredentialSize is not zero.
+  @retval EFI_BUFFER_TOO_SMALL   The size of CredentialList is too small for the
+                                 specified data and the required size is returned in
+                                 CredentialSize.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_GET_CREDENTIAL) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN OUT UINTN                             *CredentialSize,
+     OUT UINT8                             *CredentialList OPTIONAL
+  );
+
+/**
+  This function signs an already hashed data with a Smart Card private key.
+
+  This function signs data, actually it is the hash of these data that is given
+  to the function.
+
+  SignatureData buffer shall be big enough for signature. Signature size is
+  function key size and key type.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection.
+  @param[in]  KeyId              Identifier of the key container, retrieved
+                                 in a key index item of credentials.
+  @param[in]  KeyType            The key type, retrieved in a key type item of
+                                 credentials.
+
+  @param[in]  HashAlgorithm      Hash algorithm used to hash the, one of:
+                                   - EFI_HASH_ALGORITHM_SHA1_GUID
+                                   - EFI_HASH_ALGORITHM_SHA256_GUID
+                                   - EFI_HASH_ALGORITHM_SHA384_GUID
+                                   - EFI_HASH_ALGORITHM_SHA512_GUID
+  @param[in]  PaddingMethod      Padding method used jointly with hash algorithm,
+                                 one of:
+                                   - EFI_PADDING_RSASSA_PKCS1V1P5_GUID
+                                   - EFI_PADDING_RSASSA_PSS_GUID
+  @param[in]  HashedData         Hash of the data to sign. Size is function of the
+                                 HashAlgorithm.
+
+  @param[out] SignatureData      Resulting signature with private key KeyId. Size
+                                 is function of the KeyType and key size retrieved
+                                 in the associated key size item of credentials.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  KeyId is not valid.
+  @retval EFI_INVALID_PARAMETER  KeyType is not valid or not corresponding to KeyId.
+  @retval EFI_INVALID_PARAMETER  HashAlgorithm is NULL.
+  @retval EFI_INVALID_PARAMETER  HashAlgorithm is not valid.
+  @retval EFI_INVALID_PARAMETER  PaddingMethod is NULL.
+  @retval EFI_INVALID_PARAMETER  PaddingMethod is not valid.
+  @retval EFI_INVALID_PARAMETER  HashedData is NULL.
+  @retval EFI_INVALID_PARAMETER  SignatureData is NULL.
+  @retval EFI_ACCESS_DENIED      Operation not performed, conditions not fulfilled.
+                                 PIN not verified.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_SIGN_DATA) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN     UINTN                             KeyId,
+  IN     UINTN                             KeyType,
+  IN     EFI_GUID                          *HashAlgorithm,
+  IN     EFI_GUID                          *PaddingMethod,
+  IN     UINT8                             *HashedData,
+     OUT UINT8                             *SignatureData
+  );
+
+/**
+  This function decrypts data with a PKI/RSA Smart Card private key.
+
+  The function decrypts some PKI/RSA encrypted data with private key securely
+  stored into the Smart Card.
+
+  The KeyId must reference a key of type SC_EDGE_RSA_EXCHANGE.
+
+  @param[in]      This           Indicates a pointer to the calling context.
+  @param[in]      SCardHandle    Handle on Smart Card connection.
+  @param[in]      KeyId          Identifier of the key container, retrieved
+                                 in a key index item of credentials.
+  @param[in]      HashAlgorithm  Hash algorithm used to hash the, one of:
+                                   - EFI_HASH_ALGORITHM_SHA1_GUID
+                                   - EFI_HASH_ALGORITHM_SHA256_GUID
+                                   - EFI_HASH_ALGORITHM_SHA384_GUID
+                                   - EFI_HASH_ALGORITHM_SHA512_GUID
+  @param[in]      PaddingMethod  Padding method used jointly with hash algorithm,
+                                 one of:
+                                   - EFI_PADDING_NONE_GUID
+                                   - EFI_PADDING_RSAES_PKCS1V1P5_GUID
+                                   - EFI_PADDING_RSAES_OAEP_GUID
+  @param[in]      EncryptedSize  Size of data to decrypt.
+  @param[in]      EncryptedData  Data to decrypt
+  @param[in, out] PlaintextSize  On input, in bytes, the size of buffer to store
+                                 the decrypted data.
+                                 On output, in bytes, the size of buffer required
+                                 to store the decrypted data.
+  @param[out]     PlaintextData  Buffer for decrypted data, padding removed.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  KeyId is not valid or associated key not of type
+                                 SC_EDGE_RSA_EXCHANGE.
+  @retval EFI_INVALID_PARAMETER  HashAlgorithm is NULL.
+  @retval EFI_INVALID_PARAMETER  HashAlgorithm is not valid.
+  @retval EFI_INVALID_PARAMETER  PaddingMethod is NULL.
+  @retval EFI_INVALID_PARAMETER  PaddingMethod is not valid.
+  @retval EFI_INVALID_PARAMETER  EncryptedSize is 0.
+  @retval EFI_INVALID_PARAMETER  EncryptedData is NULL.
+  @retval EFI_INVALID_PARAMETER  PlaintextSize is NULL.
+  @retval EFI_INVALID_PARAMETER  PlaintextData is NULL.
+  @retval EFI_ACCESS_DENIED      Operation not performed, conditions not fulfilled.
+                                 PIN not verified.
+  @retval EFI_BUFFER_TOO_SMALL   PlaintextSize is too small for the plaintext data
+                                 and the required size is returned in PlaintextSize.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_DECRYPT_DATA) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN     UINTN                             KeyId,
+  IN     EFI_GUID                          *HashAlgorithm,
+  IN     EFI_GUID                          *PaddingMethod,
+  IN     UINTN                             EncryptedSize,
+  IN     UINT8                             *EncryptedData,
+  IN OUT UINTN                             *PlaintextSize,
+     OUT UINT8                             *PlaintextData
+  );
+
+/**
+  This function performs a secret Diffie Hellman agreement calculation that would
+  be used to derive a symmetric encryption / decryption key.
+
+  The function compute a DH agreement that should be diversified togenerate a symmetric
+  key to proceed encryption or decryption.
+
+  The application and the Smart Card shall agree on the diversification process.
+
+  The KeyId must reference a key of one of the types: SC_EDGE_ECDH_256, SC_EDGE_ECDH_384
+  or SC_EDGE_ECDH_521.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  SCardHandle        Handle on Smart Card connection.
+  @param[in]  KeyId              Identifier of the key container, retrieved
+                                 in a key index item of credentials.
+  @param[in]  dataQx             Public key x coordinate. Size is the same as
+                                 key size for KeyId. Stored in big endian format.
+  @param[in]  dataQy             Public key y coordinate. Size is the same as
+                                 key size for KeyId. Stored in big endian format.
+  @param[out] DHAgreement        Buffer for DH agreement computed. Size must be
+                                 bigger or equal to key size for KeyId.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_INVALID_PARAMETER  No connection for SCardHandle value.
+  @retval EFI_INVALID_PARAMETER  KeyId is not valid.
+  @retval EFI_INVALID_PARAMETER  dataQx is NULL.
+  @retval EFI_INVALID_PARAMETER  dataQy is NULL.
+  @retval EFI_INVALID_PARAMETER  DHAgreement is NULL.
+  @retval EFI_ACCESS_DENIED      Operation not performed, conditions not fulfilled.
+                                 PIN not verified.
+  @retval EFI_NO_MEDIA           Smart Card or Reader of SCardHandle connection
+                                 has been removed. A Disconnect should be performed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_EDGE_BUILD_DH_AGREEMENT) (
+  IN     EFI_SMART_CARD_EDGE_PROTOCOL      *This,
+  IN     EFI_HANDLE                        SCardHandle,
+  IN     UINTN                             KeyId,
+  IN     UINT8                             *dataQx,
+  IN     UINT8                             *dataQy,
+     OUT UINT8                             *DHAgreement
+  );
+
+///
+/// Smart card aware application invokes this protocol to get access to an inserted
+/// smart card in the reader or to the reader itself.
+///
+struct _EFI_SMART_CARD_EDGE_PROTOCOL {
+  EFI_SMART_CARD_EDGE_GET_CONTEXT          GetContext;
+  EFI_SMART_CARD_EDGE_CONNECT              Connect;
+  EFI_SMART_CARD_EDGE_DISCONNECT           Disconnect;
+  EFI_SMART_CARD_EDGE_GET_CSN              GetCsn;
+  EFI_SMART_CARD_EDGE_GET_READER_NAME      GetReaderName;
+  EFI_SMART_CARD_EDGE_VERIFY_PIN           VerifyPin;
+  EFI_SMART_CARD_EDGE_GET_PIN_REMAINING    GetPinRemaining;
+  EFI_SMART_CARD_EDGE_GET_DATA             GetData;
+  EFI_SMART_CARD_EDGE_GET_CREDENTIAL       GetCredential;
+  EFI_SMART_CARD_EDGE_SIGN_DATA            SignData;
+  EFI_SMART_CARD_EDGE_DECRYPT_DATA         DecryptData;
+  EFI_SMART_CARD_EDGE_BUILD_DH_AGREEMENT   BuildDHAgreement;
+};
+
+extern EFI_GUID gEfiSmartCardEdgeProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmartCardReader.h b/MdePkg/Include/Protocol/SmartCardReader.h
new file mode 100644
index 000000000000..a39b379c5eaf
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmartCardReader.h
@@ -0,0 +1,325 @@
+/** @file
+  The UEFI Smart Card Reader Protocol provides an abstraction for device to provide
+  smart card reader support. This protocol is very close to Part 5 of PC/SC workgroup
+  specifications and provides an API to applications willing to communicate with a
+  smart card or a smart card reader.
+
+  Copyright (c) 2015, 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 __SMART_CARD_READER_H__
+#define __SMART_CARD_READER_H__
+
+#define EFI_SMART_CARD_READER_PROTOCOL_GUID \
+    { \
+      0x2a4d1adf, 0x21dc, 0x4b81, {0xa4, 0x2f, 0x8b, 0x8e, 0xe2, 0x38, 0x00, 0x60} \
+    }
+
+typedef struct _EFI_SMART_CARD_READER_PROTOCOL  EFI_SMART_CARD_READER_PROTOCOL;
+
+//
+// Codes for access mode
+//
+#define SCARD_AM_READER              0x0001 // Exclusive access to reader
+#define SCARD_AM_CARD                0x0002 // Exclusive access to card
+//
+// Codes for card action
+//
+#define SCARD_CA_NORESET             0x0000 // Don't reset card
+#define SCARD_CA_COLDRESET           0x0001 // Perform a cold reset
+#define SCARD_CA_WARMRESET           0x0002 // Perform a warm reset
+#define SCARD_CA_UNPOWER             0x0003 // Power off the card
+#define SCARD_CA_EJECT               0x0004 // Eject the card
+//
+// Protocol types
+//
+#define SCARD_PROTOCOL_UNDEFINED     0x0000
+#define SCARD_PROTOCOL_T0            0x0001
+#define SCARD_PROTOCOL_T1            0x0002
+#define SCARD_PROTOCOL_RAW           0x0004
+//
+// Codes for state type
+//
+#define SCARD_UNKNOWN                0x0000 /* state is unknown */
+#define SCARD_ABSENT                 0x0001 /* Card is absent */
+#define SCARD_INACTIVE               0x0002 /* Card is present and not powered*/
+#define SCARD_ACTIVE                 0x0003 /* Card is present and powered */
+//
+// Macro to generate a ControlCode & PC/SC part 10 control code
+//
+#define SCARD_CTL_CODE(code)         (0x42000000 + (code))
+#define CM_IOCTL_GET_FEATURE_REQUEST SCARD_CTL_CODE(3400)
+
+/**
+  This function requests connection to the smart card or the reader, using the
+  appropriate reset type and protocol.
+
+  The SCardConnectfunction requests access to the smart card or the reader. Upon
+  success, it is then possible to call SCardTransmit.
+
+  If AccessMode is set to SCARD_AM_READER, PreferredProtocols must be set to
+  SCARD_PROTOCOL_UNDEFINED and CardAction to SCARD_CA_NORESET else function
+  fails with EFI_INVALID_PARAMETER.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  AccessMode         Codes of access mode.
+  @param[in]  CardAction         SCARD_CA_NORESET, SCARD_CA_COLDRESET or
+                                 SCARD_CA_WARMRESET.
+  @param[in]  PreferredProtocols Bitmask of acceptable protocols.
+  @param[out] ActiveProtocol     A flag that indicates the active protocol.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL
+  @retval EFI_INVALID_PARAMETER  AccessMode is not valid.
+  @retval EFI_INVALID_PARAMETER  CardAction is not valid.
+  @retval EFI_INVALID_PARAMETER  Invalid combination of AccessMode/CardAction/
+                                 PreferredProtocols.
+  @retval EFI_NOT_READY          A smart card is inserted but failed to return an ATR.
+  @retval EFI_UNSUPPORTED        PreferredProtocols does not contain an available
+                                 protocol to use.
+  @retval EFI_NO_MEDIA           AccessMode is set to SCARD_AM_CARD but there is
+                                 no smart card inserted.
+  @retval EFI_ACCESS_DENIED      Access is already locked by a previous SCardConnectcall.
+  @retval EFI_DEVICE_ERROR       Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_CONNECT) (
+  IN     EFI_SMART_CARD_READER_PROTOCOL    *This,
+  IN     UINT32                            AccessMode,
+  IN     UINT32                            CardAction,
+  IN     UINT32                            PreferredProtocols,
+     OUT UINT32                            *ActiveProtocol
+  );
+
+/**
+  This function releases a connection previously taken by SCardConnect.
+
+  The SCardDisconnect function releases the lock previously taken by SCardConnect.
+  In case the smart card has been removed before this call, thisfunction
+  returns EFI_SUCCESS. If there is no previous call to SCardConnect, this
+  function returns EFI_SUCCESS.
+
+  @param[in]  This               Indicates a pointer to the calling context.
+  @param[in]  CardAction         Codes for card action.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL
+  @retval EFI_INVALID_PARAMETER  CardAction value is unknown.
+  @retval EFI_UNSUPPORTED        Reader does not support Eject card feature
+                                 (disconnect was not performed).
+  @retval EFI_DEVICE_ERROR       Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_DISCONNECT) (
+  IN  EFI_SMART_CARD_READER_PROTOCOL    *This,
+  IN  UINT32                            CardAction
+  );
+
+/**
+  This function retrieves some basic information about the smart card and reader.
+
+  The SCardStatusfunction retrieves basic reader and card information.
+
+  If ReaderName, State, CardProtocolor Atris NULL, the function does not fail but
+  does not fill in such variables.
+
+  If EFI_SUCCESS is not returned, ReaderName and Atr contents shall not be considered
+  as valid.
+
+  @param[in]      This             Indicates a pointer to the calling context.
+  @param[out]     ReaderName       A pointer to a NULL terminated string that will
+                                   contain the reader name.
+  @param[in, out] ReaderNameLength On input, a pointer to the variablethat holds the
+                                   maximal size, in bytes,of ReaderName.
+                                   On output, the required size, in bytes, for ReaderName.
+  @param[out]     State            Current state of the smart card reader.
+  @param[out]     CardProtocol     Current protocol used to communicate with the smart card.
+  @param[out]     Atr              A pointer to retrieve the ATR of the smart card.
+  @param[in, out] AtrLength        On input, a pointer to hold the maximum size, in bytes,
+                                   of Atr(usually 33).
+                                   On output, the required size, inbytes, for the smart
+                                   card ATR.
+
+  @retval EFI_SUCCESS            The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER  This is NULL
+  @retval EFI_INVALID_PARAMETER  ReaderName is not NULL but ReaderNameLength is NULL
+  @retval EFI_INVALID_PARAMETER  Atr is not NULL but AtrLength is NULL
+  @retval EFI_BUFFER_TOO_SMALL   ReaderNameLength is not big enough to hold the reader name.
+                                 ReaderNameLength has been updated to the required value.
+  @retval EFI_BUFFER_TOO_SMALL   AtrLength is not big enough to hold the ATR.
+                                 AtrLength has been updated to the required value.
+  @retval EFI_DEVICE_ERROR       Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_STATUS) (
+  IN     EFI_SMART_CARD_READER_PROTOCOL    *This,
+     OUT CHAR16                            *ReaderName OPTIONAL,
+  IN OUT UINTN                             *ReaderNameLength OPTIONAL,
+     OUT UINT32                            *State OPTIONAL,
+     OUT UINT32                            *CardProtocol OPTIONAL,
+     OUT UINT8                             *Atr OPTIONAL,
+  IN OUT UINTN                             *AtrLength OPTIONAL
+  );
+
+/**
+  This function sends a command to the card or reader and returns its response.
+
+  The protocol to use to communicate with the smart card has been selected through
+  SCardConnectcall.
+
+  In case RAPDULength indicates a buffer too small to holdthe response APDU, the
+  function fails with EFI_BUFFER_TOO_SMALL.
+
+  @param[in]      This          A pointer to the EFI_USBFN_IO_PROTOCOLinstance.
+  @param[in]      CAPDU         A pointer to a byte array thatcontains the Command
+                                APDU to send to the smart card or reader.
+  @param[in]      CAPDULength   Command APDU size, in bytes.
+  @param[out]     RAPDU         A pointer to a byte array that will contain the
+                                Response APDU.
+  @param[in, out] RAPDULength   On input, the maximum size, inbytes, of the Response
+                                APDU.
+                                On output, the size, in bytes, of the Response APDU.
+
+  @retval EFI_SUCCESS           The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER CAPDU is NULL or CAPDULength is 0.
+  @retval EFI_BUFFER_TOO_SMALL  RAPDULength is not big enough to hold the response APDU.
+                                RAPDULength has been updated to the required value.
+  @retval EFI_NO_MEDIA          There is no card in the reader.
+  @retval EFI_NOT_READY         Card is not powered.
+  @retval EFI_PROTOCOL_ERROR    A protocol error has occurred.
+  @retval EFI_TIMEOUT           The reader did not respond.
+  @retval EFI_ACCESS_DENIED     A communication with the reader/card is already pending.
+  @retval EFI_DEVICE_ERROR      Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_TRANSMIT) (
+  IN     EFI_SMART_CARD_READER_PROTOCOL    *This,
+  IN     UINT8                             *CAPDU,
+  IN     UINTN                             CAPDULength,
+     OUT UINT8                             *RAPDU,
+  IN OUT UINTN                             *RAPDULength
+  );
+
+/**
+  This function provides direct access to the reader.
+
+  This function gives direct control to send commands to the driver or the reader.
+  The ControlCode to use is vendor dependant; the only standard code defined is
+  the one to get PC/SC part 10 features.
+
+  InBuffer and Outbuffer may be NULL when ControlCode operation does not require
+  them.
+
+  @param[in]      This             Indicates a pointer to the calling context.
+  @param[in]      ControlCode      The control code for the operation to perform.
+  @param[in]      InBuffer         A pointer to the input parameters.
+  @param[in]      InBufferLength   Size, in bytes, of input parameters.
+  @param[out]     OutBuffer        A pointer to the output parameters.
+  @param[in, out] OutBufferLength  On input, maximal size, in bytes, to store output
+                                   parameters.
+                                   On output, the size, in bytes, of output parameters.
+
+  @retval EFI_SUCCESS           The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER ControlCode requires input parameters but:
+                                  InBuffer is NULL or InBufferLenth is NULL or
+                                  InBuffer is not NULL but InBufferLenth is less than
+                                  expected.
+  @retval EFI_INVALID_PARAMETER OutBuffer is not NULL but OutBufferLength is NULL.
+  @retval EFI_UNSUPPORTED       ControlCode is not supported.
+  @retval EFI_BUFFER_TOO_SMALL  OutBufferLength is not big enough to hold the output
+                                parameters.
+                                OutBufferLength has been updated to the required value.
+  @retval EFI_NO_MEDIA          There is no card in the reader and the control code
+                                specified requires one.
+  @retval EFI_NOT_READY         ControlCode requires a powered card to operate.
+  @retval EFI_PROTOCOL_ERROR    A protocol error has occurred.
+  @retval EFI_TIMEOUT           The reader did not respond.
+  @retval EFI_ACCESS_DENIED     A communication with the reader/card is already pending.
+  @retval EFI_DEVICE_ERROR      Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_CONTROL) (
+  IN     EFI_SMART_CARD_READER_PROTOCOL    *This,
+  IN     UINT32                            ControlCode,
+  IN     UINT8                             *InBuffer OPTIONAL,
+  IN     UINTN                             InBufferLength OPTIONAL,
+     OUT UINT8                             *OutBuffer OPTIONAL,
+  IN OUT UINTN                             *OutBufferLength OPTIONAL
+  );
+
+/**
+  This function retrieves a reader or smart card attribute.
+
+  Possibly supported attrib values are listed in "PC/SC specification, Part 3:
+  Requirements for PC-Connected Interface Devices".
+
+  @param[in]      This             Indicates a pointer to the calling context.
+  @param[in]      Attrib           Identifier for the attribute to retrieve.
+  @param[out]     OutBuffer        A pointer to a buffer that will contain
+                                   attribute data.
+  @param[in, out] OutBufferLength  On input, maximal size, in bytes, to store
+                                   attribute data.
+                                   On output, the size, in bytes, of attribute
+                                   data.
+
+  @retval EFI_SUCCESS           The requested command completed successfully.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER OutBuffer is NULL or OutBufferLength is 0.
+  @retval EFI_BUFFER_TOO_SMALL  OutBufferLength is not big enough to hold the output
+                                parameters.
+                                OutBufferLength has been updated to the required value.
+  @retval EFI_UNSUPPORTED       Attribis not supported
+  @retval EFI_NO_MEDIA          There is no card in the reader and Attrib value
+                                requires one.
+  @retval EFI_NOT_READY         Attrib requires a powered card to operate.
+  @retval EFI_PROTOCOL_ERROR    A protocol error has occurred.
+  @retval EFI_TIMEOUT           The reader did not respond.
+  @retval EFI_DEVICE_ERROR      Any other error condition, typically a reader removal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMART_CARD_READER_GET_ATTRIB) (
+  IN     EFI_SMART_CARD_READER_PROTOCOL    *This,
+  IN     UINT32                            Attrib,
+     OUT UINT8                             *OutBuffer,
+  IN OUT UINTN                             *OutBufferLength
+  );
+
+///
+/// Smart card aware application invokes this protocol to get access to an inserted
+/// smart card in the reader or to the reader itself.
+///
+struct _EFI_SMART_CARD_READER_PROTOCOL {
+  EFI_SMART_CARD_READER_CONNECT        SCardConnect;
+  EFI_SMART_CARD_READER_DISCONNECT     SCardDisconnect;
+  EFI_SMART_CARD_READER_STATUS         SCardStatus;
+  EFI_SMART_CARD_READER_TRANSMIT       SCardTransmit;
+  EFI_SMART_CARD_READER_CONTROL        SCardControl;
+  EFI_SMART_CARD_READER_GET_ATTRIB     SCardGetAttrib;
+};
+
+extern EFI_GUID gEfiSmartCardReaderProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Smbios.h b/MdePkg/Include/Protocol/Smbios.h
new file mode 100644
index 000000000000..1860ba50259e
--- /dev/null
+++ b/MdePkg/Include/Protocol/Smbios.h
@@ -0,0 +1,213 @@
+/** @file
+  SMBIOS Protocol as defined in PI1.2 Specification VOLUME 5 Standard.
+
+  SMBIOS protocol allows consumers to log SMBIOS data records, and enables the producer 
+  to create the SMBIOS tables for a platform.
+
+  This protocol provides an interface to add, remove or discover SMBIOS records. The driver which
+  produces this protocol is responsible for creating the SMBIOS data tables and installing the pointer
+  to the tables in the EFI System Configuration Table.
+  The caller is responsible for only adding SMBIOS records that are valid for the SMBIOS
+  MajorVersion and MinorVersion. When an enumerated SMBIOS field's values are
+  controlled by the DMTF, new values can be used as soon as they are defined by the DMTF without
+  requiring an update to MajorVersion and MinorVersion.
+  The SMBIOS protocol can only be called a TPL < TPL_NOTIFY.
+
+  Copyright (c) 2006 - 2011, 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 __SMBIOS_PROTOCOL_H__
+#define __SMBIOS_PROTOCOL_H__
+
+#include <IndustryStandard/SmBios.h>
+
+#define EFI_SMBIOS_PROTOCOL_GUID \
+    { 0x3583ff6, 0xcb36, 0x4940, { 0x94, 0x7e, 0xb9, 0xb3, 0x9f, 0x4a, 0xfa, 0xf7 }}
+
+#define EFI_SMBIOS_TYPE_BIOS_INFORMATION                     SMBIOS_TYPE_BIOS_INFORMATION
+#define EFI_SMBIOS_TYPE_SYSTEM_INFORMATION                   SMBIOS_TYPE_SYSTEM_INFORMATION
+#define EFI_SMBIOS_TYPE_BASEBOARD_INFORMATION                SMBIOS_TYPE_BASEBOARD_INFORMATION
+#define EFI_SMBIOS_TYPE_SYSTEM_ENCLOSURE                     SMBIOS_TYPE_SYSTEM_ENCLOSURE
+#define EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION                SMBIOS_TYPE_PROCESSOR_INFORMATION
+#define EFI_SMBIOS_TYPE_MEMORY_CONTROLLER_INFORMATION        SMBIOS_TYPE_MEMORY_CONTROLLER_INFORMATION
+#define EFI_SMBIOS_TYPE_MEMORY_MODULE_INFORMATON             SMBIOS_TYPE_MEMORY_MODULE_INFORMATON
+#define EFI_SMBIOS_TYPE_CACHE_INFORMATION                    SMBIOS_TYPE_CACHE_INFORMATION
+#define EFI_SMBIOS_TYPE_PORT_CONNECTOR_INFORMATION           SMBIOS_TYPE_PORT_CONNECTOR_INFORMATION
+#define EFI_SMBIOS_TYPE_SYSTEM_SLOTS                         SMBIOS_TYPE_SYSTEM_SLOTS
+#define EFI_SMBIOS_TYPE_ONBOARD_DEVICE_INFORMATION           SMBIOS_TYPE_ONBOARD_DEVICE_INFORMATION
+#define EFI_SMBIOS_TYPE_OEM_STRINGS                          SMBIOS_TYPE_OEM_STRINGS
+#define EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS         SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS
+#define EFI_SMBIOS_TYPE_BIOS_LANGUAGE_INFORMATION            SMBIOS_TYPE_BIOS_LANGUAGE_INFORMATION
+#define EFI_SMBIOS_TYPE_GROUP_ASSOCIATIONS                   SMBIOS_TYPE_GROUP_ASSOCIATIONS
+#define EFI_SMBIOS_TYPE_SYSTEM_EVENT_LOG                     SMBIOS_TYPE_SYSTEM_EVENT_LOG
+#define EFI_SMBIOS_TYPE_PHYSICAL_MEMORY_ARRAY                SMBIOS_TYPE_PHYSICAL_MEMORY_ARRAY
+#define EFI_SMBIOS_TYPE_MEMORY_DEVICE                        SMBIOS_TYPE_MEMORY_DEVICE
+#define EFI_SMBIOS_TYPE_32BIT_MEMORY_ERROR_INFORMATION       SMBIOS_TYPE_32BIT_MEMORY_ERROR_INFORMATION
+#define EFI_SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS          SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS
+#define EFI_SMBIOS_TYPE_MEMORY_DEVICE_MAPPED_ADDRESS         SMBIOS_TYPE_MEMORY_DEVICE_MAPPED_ADDRESS
+#define EFI_SMBIOS_TYPE_BUILT_IN_POINTING_DEVICE             SMBIOS_TYPE_BUILT_IN_POINTING_DEVICE
+#define EFI_SMBIOS_TYPE_PORTABLE_BATTERY                     SMBIOS_TYPE_PORTABLE_BATTERY
+#define EFI_SMBIOS_TYPE_SYSTEM_RESET                         SMBIOS_TYPE_SYSTEM_RESET
+#define EFI_SMBIOS_TYPE_HARDWARE_SECURITY                    SMBIOS_TYPE_HARDWARE_SECURITY
+#define EFI_SMBIOS_TYPE_SYSTEM_POWER_CONTROLS                SMBIOS_TYPE_SYSTEM_POWER_CONTROLS
+#define EFI_SMBIOS_TYPE_VOLTAGE_PROBE                        SMBIOS_TYPE_VOLTAGE_PROBE
+#define EFI_SMBIOS_TYPE_COOLING_DEVICE                       SMBIOS_TYPE_COOLING_DEVICE
+#define EFI_SMBIOS_TYPE_TEMPERATURE_PROBE                    SMBIOS_TYPE_TEMPERATURE_PROBE
+#define EFI_SMBIOS_TYPE_ELECTRICAL_CURRENT_PROBE             SMBIOS_TYPE_ELECTRICAL_CURRENT_PROBE
+#define EFI_SMBIOS_TYPE_OUT_OF_BAND_REMOTE_ACCESS            SMBIOS_TYPE_OUT_OF_BAND_REMOTE_ACCESS
+#define EFI_SMBIOS_TYPE_BOOT_INTEGRITY_SERVICE               SMBIOS_TYPE_BOOT_INTEGRITY_SERVICE
+#define EFI_SMBIOS_TYPE_SYSTEM_BOOT_INFORMATION              SMBIOS_TYPE_SYSTEM_BOOT_INFORMATION
+#define EFI_SMBIOS_TYPE_64BIT_MEMORY_ERROR_INFORMATION       SMBIOS_TYPE_64BIT_MEMORY_ERROR_INFORMATION
+#define EFI_SMBIOS_TYPE_MANAGEMENT_DEVICE                    SMBIOS_TYPE_MANAGEMENT_DEVICE
+#define EFI_SMBIOS_TYPE_MANAGEMENT_DEVICE_COMPONENT          SMBIOS_TYPE_MANAGEMENT_DEVICE_COMPONENT
+#define EFI_SMBIOS_TYPE_MANAGEMENT_DEVICE_THRESHOLD_DATA     SMBIOS_TYPE_MANAGEMENT_DEVICE_THRESHOLD_DATA
+#define EFI_SMBIOS_TYPE_MEMORY_CHANNEL                       SMBIOS_TYPE_MEMORY_CHANNEL
+#define EFI_SMBIOS_TYPE_IPMI_DEVICE_INFORMATION              SMBIOS_TYPE_IPMI_DEVICE_INFORMATION
+#define EFI_SMBIOS_TYPE_SYSTEM_POWER_SUPPLY                  SMBIOS_TYPE_SYSTEM_POWER_SUPPLY
+#define EFI_SMBIOS_TYPE_ADDITIONAL_INFORMATION               SMBIOS_TYPE_ADDITIONAL_INFORMATION
+#define EFI_SMBIOS_TYPE_ONBOARD_DEVICES_EXTENDED_INFORMATION SMBIOS_TYPE_ONBOARD_DEVICES_EXTENDED_INFORMATION
+#define EFI_SMBIOS_TYPE_MANAGEMENT_CONTROLLER_HOST_INTERFACE SMBIOS_TYPE_MANAGEMENT_CONTROLLER_HOST_INTERFACE
+#define EFI_SMBIOS_TYPE_INACTIVE                             SMBIOS_TYPE_INACTIVE
+#define EFI_SMBIOS_TYPE_END_OF_TABLE                         SMBIOS_TYPE_END_OF_TABLE
+#define EFI_SMBIOS_OEM_BEGIN                                 SMBIOS_OEM_BEGIN
+#define EFI_SMBIOS_OEM_END                                   SMBIOS_OEM_END
+
+typedef SMBIOS_TABLE_STRING EFI_SMBIOS_STRING;
+typedef SMBIOS_TYPE         EFI_SMBIOS_TYPE;
+typedef SMBIOS_HANDLE       EFI_SMBIOS_HANDLE;
+typedef SMBIOS_STRUCTURE    EFI_SMBIOS_TABLE_HEADER;
+    
+typedef struct _EFI_SMBIOS_PROTOCOL EFI_SMBIOS_PROTOCOL;
+
+/**
+  Add an SMBIOS record.
+  
+  This function allows any agent to add SMBIOS records. The caller is responsible for ensuring
+  Record is formatted in a way that matches the version of the SMBIOS specification as defined in
+  the MajorRevision and MinorRevision fields of the EFI_SMBIOS_PROTOCOL.
+  Record must follow the SMBIOS structure evolution and usage guidelines in the SMBIOS
+  specification. Record starts with the formatted area of the SMBIOS structure and the length is
+  defined by EFI_SMBIOS_TABLE_HEADER.Length. Each SMBIOS structure is terminated by a
+  double-null (0x0000), either directly following the formatted area (if no strings are present) or
+  directly following the last string. The number of optional strings is not defined by the formatted area,
+  but is fixed by the call to Add(). A string can be a place holder, but it must not be a NULL string as
+  two NULL strings look like the double-null that terminates the structure.
+  
+  @param[in]        This                The EFI_SMBIOS_PROTOCOL instance.
+  @param[in]        ProducerHandle      The handle of the controller or driver associated with the SMBIOS information. NULL means no handle.
+  @param[in, out]   SmbiosHandle        On entry, the handle of the SMBIOS record to add. If FFFEh, then a unique handle
+                                        will be assigned to the SMBIOS record. If the SMBIOS handle is already in use,
+                                        EFI_ALREADY_STARTED is returned and the SMBIOS record is not updated.
+  @param[in]        Record              The data for the fixed portion of the SMBIOS record. The format of the record is
+                                        determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted
+                                        area is defined by EFI_SMBIOS_TABLE_HEADER.Length and either followed
+                                        by a double-null (0x0000) or a set of null terminated strings and a null.
+  
+  @retval EFI_SUCCESS                   Record was added.
+  @retval EFI_OUT_OF_RESOURCES          Record was not added.
+  @retval EFI_ALREADY_STARTED           The SmbiosHandle passed in was already in use.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBIOS_ADD)(
+  IN CONST      EFI_SMBIOS_PROTOCOL     *This,
+  IN            EFI_HANDLE              ProducerHandle OPTIONAL,
+  IN OUT        EFI_SMBIOS_HANDLE       *SmbiosHandle,
+  IN            EFI_SMBIOS_TABLE_HEADER *Record
+);
+
+/**
+  Update the string associated with an existing SMBIOS record.
+  
+  This function allows the update of specific SMBIOS strings. The number of valid strings for any
+  SMBIOS record is defined by how many strings were present when Add() was called.
+  
+  @param[in]    This            The EFI_SMBIOS_PROTOCOL instance.
+  @param[in]    SmbiosHandle    SMBIOS Handle of structure that will have its string updated.
+  @param[in]    StringNumber    The non-zero string number of the string to update.
+  @param[in]    String          Update the StringNumber string with String.
+  
+  @retval EFI_SUCCESS           SmbiosHandle had its StringNumber String updated.
+  @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist.
+  @retval EFI_UNSUPPORTED       String was not added because it is longer than the SMBIOS Table supports.
+  @retval EFI_NOT_FOUND         The StringNumber.is not valid for this SMBIOS record.    
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBIOS_UPDATE_STRING)(
+   IN CONST EFI_SMBIOS_PROTOCOL *This,
+   IN       EFI_SMBIOS_HANDLE   *SmbiosHandle,
+   IN       UINTN               *StringNumber,
+   IN       CHAR8               *String
+);
+
+/**
+  Remove an SMBIOS record.
+  
+  This function removes an SMBIOS record using the handle specified by SmbiosHandle.
+  
+  @param[in]    This                The EFI_SMBIOS_PROTOCOL instance.
+  @param[in]    SmbiosHandle        The handle of the SMBIOS record to remove.
+  
+  @retval EFI_SUCCESS               SMBIOS record was removed.
+  @retval EFI_INVALID_PARAMETER     SmbiosHandle does not specify a valid SMBIOS record.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBIOS_REMOVE)(
+   IN CONST EFI_SMBIOS_PROTOCOL *This,
+   IN       EFI_SMBIOS_HANDLE   SmbiosHandle
+);
+
+/**
+  Allow the caller to discover all or some of the SMBIOS records.
+  
+  This function allows all of the SMBIOS records to be discovered. It's possible to find
+  only the SMBIOS records that match the optional Type argument.
+  
+  @param[in]        This            The EFI_SMBIOS_PROTOCOL instance.
+  @param[in, out]   SmbiosHandle    On entry, points to the previous handle of the SMBIOS record. On exit, points to the
+                                    next SMBIOS record handle. If it is FFFEh on entry, then the first SMBIOS record
+                                    handle will be returned. If it returns FFFEh on exit, then there are no more SMBIOS records.
+  @param[in]        Type            On entry, it points to the type of the next SMBIOS record to return. If NULL, it
+                                    indicates that the next record of any type will be returned. Type is not
+                                    modified by the this function.
+  @param[out]       Record          On exit, points to a pointer to the the SMBIOS Record consisting of the formatted area
+                                    followed by the unformatted area. The unformatted area optionally contains text strings.
+  @param[out]       ProducerHandle  On exit, points to the ProducerHandle registered by Add(). If no
+                                    ProducerHandle was passed into Add() NULL is returned. If a NULL pointer is
+                                    passed in no data will be returned.
+  @retval EFI_SUCCESS               SMBIOS record information was successfully returned in Record.
+                                    SmbiosHandle is the handle of the current SMBIOS record
+  @retval EFI_NOT_FOUND             The SMBIOS record with SmbiosHandle was the last available record.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBIOS_GET_NEXT)(
+   IN     CONST EFI_SMBIOS_PROTOCOL     *This,
+   IN OUT       EFI_SMBIOS_HANDLE       *SmbiosHandle,
+   IN           EFI_SMBIOS_TYPE         *Type              OPTIONAL,
+   OUT          EFI_SMBIOS_TABLE_HEADER **Record,
+   OUT          EFI_HANDLE              *ProducerHandle    OPTIONAL
+);
+
+struct _EFI_SMBIOS_PROTOCOL {
+  EFI_SMBIOS_ADD           Add;
+  EFI_SMBIOS_UPDATE_STRING UpdateString;
+  EFI_SMBIOS_REMOVE        Remove;
+  EFI_SMBIOS_GET_NEXT      GetNext;
+  UINT8                    MajorVersion;    ///< The major revision of the SMBIOS specification supported.
+  UINT8                    MinorVersion;    ///< The minor revision of the SMBIOS specification supported.
+};
+    
+extern EFI_GUID gEfiSmbiosProtocolGuid;
+    
+#endif // __SMBIOS_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/SmbusHc.h b/MdePkg/Include/Protocol/SmbusHc.h
new file mode 100644
index 000000000000..d5620d7a6c89
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmbusHc.h
@@ -0,0 +1,295 @@
+/** @file
+  The file provides basic SMBus host controller management 
+  and basic data transactions over the SMBus.
+
+  Copyright (c) 2006 - 2011, 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.             
+
+  @par Revision Reference: PI
+  Version 1.00.
+
+**/
+
+#ifndef __SMBUS_HC_H__
+#define __SMBUS_HC_H__
+
+#include <IndustryStandard/SmBus.h>
+
+#define EFI_SMBUS_HC_PROTOCOL_GUID \
+  {0xe49d33ed, 0x513d, 0x4634, { 0xb6, 0x98, 0x6f, 0x55, 0xaa, 0x75, 0x1c, 0x1b} }
+
+typedef struct _EFI_SMBUS_HC_PROTOCOL EFI_SMBUS_HC_PROTOCOL;
+
+/**
+     
+  The Execute() function provides a standard way to execute an
+  operation as defined in the System Management Bus (SMBus)
+  Specification. The resulting transaction will be either that
+  the SMBus slave devices accept this transaction or that this
+  function returns with error. 
+  
+  @param This     A pointer to the EFI_SMBUS_HC_PROTOCOL instance.
+                  SlaveAddress The SMBus slave address of the device
+                  with which to communicate. Type
+                  EFI_SMBUS_DEVICE_ADDRESS is defined in
+                  EFI_PEI_SMBUS_PPI.Execute() in the Platform
+                  Initialization SMBus PPI Specification.
+
+  @param Command  This command is transmitted by the SMBus host
+                  controller to the SMBus slave device and the
+                  interpretation is SMBus slave device specific.
+                  It can mean the offset to a list of functions
+                  inside an SMBus slave device. Not all
+                  operations or slave devices support this
+                  command's registers. Type
+                  EFI_SMBUS_DEVICE_COMMAND is defined in
+                  EFI_PEI_SMBUS_PPI.Execute() in the Platform
+                  Initialization SMBus PPI Specification.
+
+ @param Operation Signifies the particular SMBus
+                  hardware protocol instance it will use to
+                  execute the SMBus transactions. This SMBus
+                  hardware protocol is defined by the SMBus
+                  Specification and is not related to PI
+                  Architecture. Type EFI_SMBUS_OPERATION is
+                  defined in EFI_PEI_SMBUS_PPI.Execute() in the
+                  Platform Initialization SMBus PPI
+                  Specification.
+
+  @param PecCheck Defines if Packet Error Code (PEC) checking
+                  is required for this operation. SMBus Host
+                  Controller Code Definitions Version 1.0
+                  August 21, 2006 13 
+                  
+ @param Length    Signifies the number of bytes that this operation will do.
+                  The maximum number of bytes can be revision
+                  specific and operation specific. This field
+                  will contain the actual number of bytes that
+                  are executed for this operation. Not all
+                  operations require this argument.
+
+  @param Buffer   Contains the value of data to execute to the
+                  SMBus slave device. Not all operations require
+                  this argument. The length of this buffer is
+                  identified by Length.
+  
+  
+  @retval EFI_SUCCESS           The last data that was returned from the
+                                access matched the poll exit criteria.
+
+  @retval EFI_CRC_ERROR         Checksum is not correct (PEC is incorrect).
+
+  @retval EFI_TIMEOUT           Timeout expired before the operation was
+                                completed. Timeout is determined by the
+                                SMBus host controller device.
+
+  @retval EFI_OUT_OF_RESOURCES  The request could not be
+                                completed due to a lack of
+                                resources.
+
+  @retval EFI_DEVICE_ERROR      The request was not completed
+                                because a failure that was reflected
+                                in the Host Status Register bit.
+                                Device errors are a result of a
+                                transaction collision, illegal
+                                command field, unclaimed cycle (host
+                                initiated), or bus errors
+                                (collisions).
+
+  @retval EFI_INVALID_PARAMETER Operation is not defined in
+                                EFI_SMBUS_OPERATION.
+
+  @retval EFI_INVALID_PARAMETER Length/Buffer is NULL for
+                                operations except for
+                                EfiSmbusQuickRead and
+                                EfiSmbusQuickWrite. Length is
+                                outside the range of valid
+                                values.
+
+  @retval EFI_UNSUPPORTED       The SMBus operation or PEC is not
+                                supported. 
+
+  @retval EFI_BUFFER_TOO_SMALL  Buffer is not sufficient for
+                                this operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBUS_HC_EXECUTE_OPERATION)(
+  IN CONST  EFI_SMBUS_HC_PROTOCOL     *This,
+  IN        EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
+  IN        EFI_SMBUS_DEVICE_COMMAND  Command,
+  IN        EFI_SMBUS_OPERATION       Operation,
+  IN        BOOLEAN                   PecCheck,
+  IN OUT    UINTN                     *Length,
+  IN OUT    VOID                      *Buffer
+);
+
+
+
+/**
+   
+  The ArpDevice() function provides a standard way for a device driver to 
+  enumerate the entire SMBus or specific devices on the bus.
+  
+  @param This           A pointer to the EFI_SMBUS_HC_PROTOCOL instance.
+
+  @param ArpAll         A Boolean expression that indicates if the
+                        host drivers need to enumerate all the devices
+                        or enumerate only the device that is
+                        identified by SmbusUdid. If ArpAll is TRUE,
+                        SmbusUdid and SlaveAddress are optional. If
+                        ArpAll is FALSE, ArpDevice will enumerate
+                        SmbusUdid and the address will be at
+                        SlaveAddress.
+
+  @param SmbusUdid      The Unique Device Identifier (UDID) that is
+                        associated with this device. Type
+                        EFI_SMBUS_UDID is defined in
+                        EFI_PEI_SMBUS_PPI.ArpDevice() in the
+                        Platform Initialization SMBus PPI
+                        Specification.
+
+  @param SlaveAddress   The SMBus slave address that is
+                        associated with an SMBus UDID.
+
+  @retval EFI_SUCCESS           The last data that was returned from the
+                                access matched the poll exit criteria.
+
+  @retval EFI_CRC_ERROR         Checksum is not correct (PEC is
+                                incorrect).
+
+  @retval EFI_TIMEOUT           Timeout expired before the operation was
+                                completed. Timeout is determined by the
+                                SMBus host controller device.
+
+  @retval EFI_OUT_OF_RESOURCES  The request could not be
+                                completed due to a lack of
+                                resources.
+
+  @retval EFI_DEVICE_ERROR      The request was not completed
+                                because a failure was reflected in
+                                the Host Status Register bit. Device
+                                Errors are a result of a transaction
+                                collision, illegal command field,
+                                unclaimed cycle (host initiated), or
+                                bus errors (collisions).
+
+  @retval EFI_UNSUPPORTED       ArpDevice, GetArpMap, and Notify are
+                                not implemented by this driver.
+   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBUS_HC_PROTOCOL_ARP_DEVICE)(
+  IN CONST  EFI_SMBUS_HC_PROTOCOL     *This,
+  IN        BOOLEAN                   ArpAll,
+  IN        EFI_SMBUS_UDID            *SmbusUdid,   OPTIONAL
+  IN OUT    EFI_SMBUS_DEVICE_ADDRESS  *SlaveAddress OPTIONAL
+);
+
+
+/**
+  The GetArpMap() function returns the mapping of all the SMBus devices 
+  that were enumerated by the SMBus host driver.
+  
+  @param This           A pointer to the EFI_SMBUS_HC_PROTOCOL instance.
+  
+  @param Length         Size of the buffer that contains the SMBus
+                        device map.
+  
+  @param SmbusDeviceMap The pointer to the device map as
+                        enumerated by the SMBus controller
+                        driver.
+  
+  @retval EFI_SUCCESS       The SMBus returned the current device map.
+  
+  @retval EFI_UNSUPPORTED   ArpDevice, GetArpMap, and Notify are
+                            not implemented by this driver.
+  
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBUS_HC_PROTOCOL_GET_ARP_MAP)(
+  IN CONST  EFI_SMBUS_HC_PROTOCOL   *This,
+  IN OUT    UINTN                   *Length,
+  IN OUT    EFI_SMBUS_DEVICE_MAP    **SmbusDeviceMap
+);
+
+/**
+  The notify function does some actions.
+  
+  @param SlaveAddress
+  The SMBUS hardware address to which the SMBUS device is preassigned or allocated.
+
+  @param Data
+  Data of the SMBus host notify command that the caller wants to be called.
+  
+  @return EFI_STATUS
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBUS_NOTIFY_FUNCTION)(
+  IN        EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
+  IN        UINTN                     Data
+);
+
+
+/**
+   
+  The Notify() function registers all the callback functions to
+  allow the bus driver to call these functions when the 
+  SlaveAddress/Data pair happens.
+  
+  @param  This            A pointer to the EFI_SMBUS_HC_PROTOCOL instance.
+  
+  @param  SlaveAddress    Address that the host controller detects
+                          as sending a message and calls all the registered function.
+
+  @param  Data            Data that the host controller detects as sending
+                          message and calls all the registered function.
+
+
+  @param  NotifyFunction  The function to call when the bus
+                          driver detects the SlaveAddress and
+                          Data pair.
+
+  @retval EFI_SUCCESS       NotifyFunction was registered.
+  
+  @retval EFI_UNSUPPORTED   ArpDevice, GetArpMap, and Notify are
+                            not implemented by this driver.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMBUS_HC_PROTOCOL_NOTIFY)(
+  IN CONST  EFI_SMBUS_HC_PROTOCOL     *This,
+  IN        EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
+  IN        UINTN                     Data,
+  IN        EFI_SMBUS_NOTIFY_FUNCTION NotifyFunction
+);
+
+
+///
+/// The EFI_SMBUS_HC_PROTOCOL provides SMBus host controller management and basic data
+/// transactions over SMBus. There is one EFI_SMBUS_HC_PROTOCOL instance for each SMBus
+/// host controller.
+///
+struct _EFI_SMBUS_HC_PROTOCOL {
+  EFI_SMBUS_HC_EXECUTE_OPERATION    Execute;
+  EFI_SMBUS_HC_PROTOCOL_ARP_DEVICE  ArpDevice;
+  EFI_SMBUS_HC_PROTOCOL_GET_ARP_MAP GetArpMap;
+  EFI_SMBUS_HC_PROTOCOL_NOTIFY      Notify;
+};
+
+
+extern EFI_GUID gEfiSmbusHcProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmAccess2.h b/MdePkg/Include/Protocol/SmmAccess2.h
new file mode 100644
index 000000000000..66cdf0c50abd
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmAccess2.h
@@ -0,0 +1,132 @@
+/** @file
+  EFI SMM Access2 Protocol as defined in the PI 1.2 specification.
+
+  This protocol is used to control the visibility of the SMRAM on the platform.
+  It abstracts the location and characteristics of SMRAM.  The expectation is
+  that the north bridge or memory controller would publish this protocol.
+
+  The principal functionality found in the memory controller includes the following: 
+  - Exposing the SMRAM to all non-SMM agents, or the "open" state
+  - Shrouding the SMRAM to all but the SMM agents, or the "closed" state
+  - Preserving the system integrity, or "locking" the SMRAM, such that the settings cannot be 
+    perturbed by either boot service or runtime agents 
+
+  Copyright (c) 2009 - 2010, 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 _SMM_ACCESS2_H_
+#define _SMM_ACCESS2_H_
+
+#define EFI_SMM_ACCESS2_PROTOCOL_GUID \
+  { \
+     0xc2702b74, 0x800c, 0x4131, {0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac } \
+  }
+
+
+typedef struct _EFI_SMM_ACCESS2_PROTOCOL  EFI_SMM_ACCESS2_PROTOCOL;
+
+/**
+  Opens the SMRAM area to be accessible by a boot-service driver.
+
+  This function "opens" SMRAM so that it is visible while not inside of SMM. The function should 
+  return EFI_UNSUPPORTED if the hardware does not support hiding of SMRAM. The function 
+  should return EFI_DEVICE_ERROR if the SMRAM configuration is locked.
+
+  @param[in] This           The EFI_SMM_ACCESS2_PROTOCOL instance.
+
+  @retval EFI_SUCCESS       The operation was successful.
+  @retval EFI_UNSUPPORTED   The system does not support opening and closing of SMRAM.
+  @retval EFI_DEVICE_ERROR  SMRAM cannot be opened, perhaps because it is locked.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_OPEN2)(
+  IN EFI_SMM_ACCESS2_PROTOCOL  *This
+  );
+
+/**
+  Inhibits access to the SMRAM.
+
+  This function "closes" SMRAM so that it is not visible while outside of SMM. The function should 
+  return EFI_UNSUPPORTED if the hardware does not support hiding of SMRAM.
+
+  @param[in] This           The EFI_SMM_ACCESS2_PROTOCOL instance.
+
+  @retval EFI_SUCCESS       The operation was successful.
+  @retval EFI_UNSUPPORTED   The system does not support opening and closing of SMRAM.
+  @retval EFI_DEVICE_ERROR  SMRAM cannot be closed.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_CLOSE2)(
+  IN EFI_SMM_ACCESS2_PROTOCOL  *This
+  );
+
+/**
+  Inhibits access to the SMRAM.
+
+  This function prohibits access to the SMRAM region.  This function is usually implemented such 
+  that it is a write-once operation. 
+
+  @param[in] This          The EFI_SMM_ACCESS2_PROTOCOL instance.
+
+  @retval EFI_SUCCESS      The device was successfully locked.
+  @retval EFI_UNSUPPORTED  The system does not support locking of SMRAM.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_LOCK2)(
+  IN EFI_SMM_ACCESS2_PROTOCOL  *This
+  );
+
+/**
+  Queries the memory controller for the possible regions that will support SMRAM.
+
+  @param[in]     This           The EFI_SMM_ACCESS2_PROTOCOL instance.
+  @param[in,out] SmramMapSize   A pointer to the size, in bytes, of the SmramMemoryMap buffer.
+  @param[in,out] SmramMap       A pointer to the buffer in which firmware places the current memory map.
+
+  @retval EFI_SUCCESS           The chipset supported the given resource.
+  @retval EFI_BUFFER_TOO_SMALL  The SmramMap parameter was too small.  The current buffer size 
+                                needed to hold the memory map is returned in SmramMapSize.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_CAPABILITIES2)(
+  IN CONST EFI_SMM_ACCESS2_PROTOCOL  *This,
+  IN OUT UINTN                       *SmramMapSize,
+  IN OUT EFI_SMRAM_DESCRIPTOR        *SmramMap
+  );
+
+///
+///  EFI SMM Access2 Protocol is used to control the visibility of the SMRAM on the platform.
+///  It abstracts the location and characteristics of SMRAM.  The expectation is
+///  that the north bridge or memory controller would publish this protocol.
+/// 
+struct _EFI_SMM_ACCESS2_PROTOCOL {
+  EFI_SMM_OPEN2          Open;
+  EFI_SMM_CLOSE2         Close;
+  EFI_SMM_LOCK2          Lock;
+  EFI_SMM_CAPABILITIES2  GetCapabilities;
+  ///
+  /// Indicates the current state of the SMRAM. Set to TRUE if SMRAM is locked.
+  ///
+  BOOLEAN               LockState;
+  ///
+  /// Indicates the current state of the SMRAM. Set to TRUE if SMRAM is open.
+  ///
+  BOOLEAN               OpenState;
+};
+
+extern EFI_GUID gEfiSmmAccess2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmBase2.h b/MdePkg/Include/Protocol/SmmBase2.h
new file mode 100644
index 000000000000..3a1947c43870
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmBase2.h
@@ -0,0 +1,87 @@
+/** @file
+  EFI SMM Base2 Protocol as defined in the PI 1.2 specification.
+
+  This protocol is utilized by all SMM drivers to locate the SMM infrastructure services and determine
+  whether the driver is being invoked inside SMRAM or outside of SMRAM.
+
+  Copyright (c) 2009, 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 _SMM_BASE2_H_
+#define _SMM_BASE2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_BASE2_PROTOCOL_GUID \
+  { \
+    0xf4ccbfb7, 0xf6e0, 0x47fd, {0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }  \
+  }
+
+typedef struct _EFI_SMM_BASE2_PROTOCOL  EFI_SMM_BASE2_PROTOCOL;
+
+/**
+  Service to indicate whether the driver is currently executing in the SMM Initialization phase.
+  
+  This service is used to indicate whether the driver is currently executing in the SMM Initialization 
+  phase. For SMM drivers, this will return TRUE in InSmram while inside the driver's entry point and 
+  otherwise FALSE. For combination SMM/DXE drivers, this will return FALSE in the DXE launch. For the
+  SMM launch, it behaves as an SMM driver.
+
+  @param[in]  This               The EFI_SMM_BASE2_PROTOCOL instance. 
+  @param[out] InSmram            Pointer to a Boolean which, on return, indicates that the driver is
+                                 currently executing inside of SMRAM (TRUE) or outside of SMRAM (FALSE).
+
+  @retval EFI_SUCCESS            The call returned successfully.
+  @retval EFI_INVALID_PARAMETER  InSmram was NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_INSIDE_OUT2)(
+  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,
+  OUT BOOLEAN                      *InSmram
+  )
+;
+
+/**
+  Returns the location of the System Management Service Table (SMST).
+
+  This function returns the location of the System Management Service Table (SMST).  The use of the 
+  API is such that a driver can discover the location of the SMST in its entry point and then cache it in 
+  some driver global variable so that the SMST can be invoked in subsequent handlers.
+
+  @param[in]     This            The EFI_SMM_BASE2_PROTOCOL instance.
+  @param[in,out] Smst            On return, points to a pointer to the System Management Service Table (SMST).
+
+  @retval EFI_SUCCESS            The operation was successful.
+  @retval EFI_INVALID_PARAMETER  Smst was invalid.
+  @retval EFI_UNSUPPORTED        Not in SMM.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_GET_SMST_LOCATION2)(
+  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,
+  IN OUT EFI_SMM_SYSTEM_TABLE2     **Smst
+  )
+;
+
+///
+/// EFI SMM Base2 Protocol is utilized by all SMM drivers to locate the SMM infrastructure
+/// services and determine whether the driver is being invoked inside SMRAM or outside of SMRAM.
+///
+struct _EFI_SMM_BASE2_PROTOCOL {
+  EFI_SMM_INSIDE_OUT2         InSmm;
+  EFI_SMM_GET_SMST_LOCATION2  GetSmstLocation;
+};
+
+extern EFI_GUID gEfiSmmBase2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmCommunication.h b/MdePkg/Include/Protocol/SmmCommunication.h
new file mode 100644
index 000000000000..acd7a27d6ec5
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmCommunication.h
@@ -0,0 +1,65 @@
+/** @file
+  EFI SMM Communication Protocol as defined in the PI 1.2 specification.
+
+  This protocol provides a means of communicating between drivers outside of SMM and SMI 
+  handlers inside of SMM.  
+
+  Copyright (c) 2009 - 2011, 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 _SMM_COMMUNICATION_H_
+#define _SMM_COMMUNICATION_H_
+
+//
+// Need include this header file for EFI_SMM_COMMUNICATE_HEADER data structure.
+//
+#include <Uefi/UefiAcpiDataTable.h>
+
+#define EFI_SMM_COMMUNICATION_PROTOCOL_GUID \
+  { \
+    0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 } \
+  }
+
+typedef struct _EFI_SMM_COMMUNICATION_PROTOCOL  EFI_SMM_COMMUNICATION_PROTOCOL;
+
+/**
+  Communicates with a registered handler.
+  
+  This function provides a service to send and receive messages from a registered UEFI service.
+
+  @param[in] This                The EFI_SMM_COMMUNICATION_PROTOCOL instance.
+  @param[in] CommBuffer          A pointer to the buffer to convey into SMRAM.
+  @param[in] CommSize            The size of the data buffer being passed in.On exit, the size of data
+                                 being returned. Zero if the handler does not wish to reply with any data.
+
+  @retval EFI_SUCCESS            The message was successfully posted.
+  @retval EFI_INVALID_PARAMETER  The CommBuffer was NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_COMMUNICATE2)(
+  IN CONST EFI_SMM_COMMUNICATION_PROTOCOL  *This,
+  IN OUT VOID                              *CommBuffer,
+  IN OUT UINTN                             *CommSize
+  );
+
+///
+/// EFI SMM Communication Protocol provides runtime services for communicating
+/// between DXE drivers and a registered SMI handler.
+///
+struct _EFI_SMM_COMMUNICATION_PROTOCOL {
+  EFI_SMM_COMMUNICATE2  Communicate;
+};
+
+extern EFI_GUID gEfiSmmCommunicationProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmConfiguration.h b/MdePkg/Include/Protocol/SmmConfiguration.h
new file mode 100644
index 000000000000..f138fde877ee
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmConfiguration.h
@@ -0,0 +1,86 @@
+/** @file
+  EFI SMM Configuration Protocol as defined in the PI 1.2 specification.
+
+  This protocol is used to:
+  1) report the portions of SMRAM regions which cannot be used for the SMRAM heap.
+  2) register the SMM Foundation entry point with the processor code. The entry
+     point will be invoked by the SMM processor entry code.
+  
+  Copyright (c) 2009, 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 _SMM_CONFIGURATION_H_
+#define _SMM_CONFIGURATION_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_CONFIGURATION_PROTOCOL_GUID \
+  { \
+    0x26eeb3de, 0xb689, 0x492e, {0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }  \
+  }
+
+///
+/// Structure describing a SMRAM region which cannot be used for the SMRAM heap.
+///
+typedef struct _EFI_SMM_RESERVED_SMRAM_REGION {
+  ///
+  /// Starting address of the reserved SMRAM area, as it appears while SMRAM is open. 
+  /// Ignored if SmramReservedSize is 0.
+  ///
+  EFI_PHYSICAL_ADDRESS    SmramReservedStart;
+  ///
+  /// Number of bytes occupied by the reserved SMRAM area. A size of zero indicates the 
+  /// last SMRAM area.
+  ///
+  UINT64                  SmramReservedSize;
+} EFI_SMM_RESERVED_SMRAM_REGION;
+
+typedef struct _EFI_SMM_CONFIGURATION_PROTOCOL  EFI_SMM_CONFIGURATION_PROTOCOL;
+
+/**
+  Register the SMM Foundation entry point.
+  
+  This function registers the SMM Foundation entry point with the processor code. This entry point 
+  will be invoked by the SMM Processor entry code.
+
+  @param[in] This                The EFI_SMM_CONFIGURATION_PROTOCOL instance.
+  @param[in] SmmEntryPoint       SMM Foundation entry point.
+  
+  @retval EFI_SUCCESS            Success to register SMM Entry Point.
+  @retval EFI_INVALID_PARAMETER  SmmEntryPoint is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_REGISTER_SMM_ENTRY)(
+  IN CONST EFI_SMM_CONFIGURATION_PROTOCOL  *This,
+  IN EFI_SMM_ENTRY_POINT                   SmmEntryPoint
+  );
+
+///
+/// The EFI SMM Configuration Protocol is a mandatory protocol published by a DXE CPU driver to
+/// indicate which areas within SMRAM are reserved for use by the CPU for any purpose, 
+/// such as stack, save state or SMM entry point.
+///
+/// The RegisterSmmEntry() function allows the SMM IPL DXE driver to register the SMM 
+/// Foundation entry point with the SMM entry vector code.
+///
+struct _EFI_SMM_CONFIGURATION_PROTOCOL {
+  ///
+  /// A pointer to an array SMRAM ranges used by the initial SMM entry code.
+  ///
+  EFI_SMM_RESERVED_SMRAM_REGION  *SmramReservedRegions;
+  EFI_SMM_REGISTER_SMM_ENTRY     RegisterSmmEntry;
+};
+
+extern EFI_GUID gEfiSmmConfigurationProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmControl2.h b/MdePkg/Include/Protocol/SmmControl2.h
new file mode 100644
index 000000000000..5908fef945a4
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmControl2.h
@@ -0,0 +1,106 @@
+/** @file
+  EFI SMM Control2 Protocol as defined in the PI 1.2 specification.
+
+  This protocol is used initiate synchronous SMI activations. This protocol could be published by a
+  processor driver to abstract the SMI IPI or a driver which abstracts the ASIC that is supporting the
+  APM port. Because of the possibility of performing SMI IPI transactions, the ability to generate this 
+  event from a platform chipset agent is an optional capability for both IA-32 and x64-based systems.
+
+  The EFI_SMM_CONTROL2_PROTOCOL is produced by a runtime driver. It provides  an 
+  abstraction of the platform hardware that generates an SMI.  There are often I/O ports that, when 
+  accessed, will generate the SMI.  Also, the hardware optionally supports the periodic generation of 
+  these signals.
+
+  Copyright (c) 2009 - 2011, 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 _SMM_CONTROL2_H_
+#define _SMM_CONTROL2_H_
+
+#include <PiDxe.h>
+
+#define EFI_SMM_CONTROL2_PROTOCOL_GUID \
+  { \
+    0x843dc720, 0xab1e, 0x42cb, {0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}  \
+  }
+
+typedef struct _EFI_SMM_CONTROL2_PROTOCOL  EFI_SMM_CONTROL2_PROTOCOL;
+typedef UINTN  EFI_SMM_PERIOD;
+
+/**
+  Invokes SMI activation from either the preboot or runtime environment.
+
+  This function generates an SMI.
+
+  @param[in]     This                The EFI_SMM_CONTROL2_PROTOCOL instance.
+  @param[in,out] CommandPort         The value written to the command port.
+  @param[in,out] DataPort            The value written to the data port.
+  @param[in]     Periodic            Optional mechanism to engender a periodic stream.
+  @param[in]     ActivationInterval  Optional parameter to repeat at this period one
+                                     time or, if the Periodic Boolean is set, periodically.
+
+  @retval EFI_SUCCESS            The SMI/PMI has been engendered.
+  @retval EFI_DEVICE_ERROR       The timing is unsupported.
+  @retval EFI_INVALID_PARAMETER  The activation period is unsupported.
+  @retval EFI_INVALID_PARAMETER  The last periodic activation has not been cleared. 
+  @retval EFI_NOT_STARTED        The SMM base service has not been initialized.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_ACTIVATE2)(
+  IN CONST EFI_SMM_CONTROL2_PROTOCOL  *This,
+  IN OUT UINT8                        *CommandPort       OPTIONAL,
+  IN OUT UINT8                        *DataPort          OPTIONAL,
+  IN BOOLEAN                          Periodic           OPTIONAL,
+  IN UINTN                            ActivationInterval OPTIONAL
+  );
+
+/**
+  Clears any system state that was created in response to the Trigger() call.
+
+  This function acknowledges and causes the deassertion of the SMI activation source.
+
+  @param[in] This                The EFI_SMM_CONTROL2_PROTOCOL instance.
+  @param[in] Periodic            Optional parameter to repeat at this period one time
+
+  @retval EFI_SUCCESS            The SMI/PMI has been engendered.
+  @retval EFI_DEVICE_ERROR       The source could not be cleared.
+  @retval EFI_INVALID_PARAMETER  The service did not support the Periodic input argument.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_DEACTIVATE2)(
+  IN CONST EFI_SMM_CONTROL2_PROTOCOL  *This,
+  IN BOOLEAN                          Periodic OPTIONAL
+  );
+
+///
+/// The EFI_SMM_CONTROL2_PROTOCOL is produced by a runtime driver. It provides  an 
+/// abstraction of the platform hardware that generates an SMI.  There are often I/O ports that, when 
+/// accessed, will generate the SMI.  Also, the hardware optionally supports the periodic generation of 
+/// these signals.
+///
+struct _EFI_SMM_CONTROL2_PROTOCOL {
+  EFI_SMM_ACTIVATE2    Trigger;
+  EFI_SMM_DEACTIVATE2  Clear;
+  ///
+  /// Minimum interval at which the platform can set the period.  A maximum is not 
+  /// specified in that the SMM infrastructure code can emulate a maximum interval that is 
+  /// greater than the hardware capabilities by using software emulation in the SMM 
+  /// infrastructure code.
+  ///
+  EFI_SMM_PERIOD      MinimumTriggerPeriod;
+};
+
+extern EFI_GUID gEfiSmmControl2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmCpu.h b/MdePkg/Include/Protocol/SmmCpu.h
new file mode 100644
index 000000000000..9990dd25adfa
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmCpu.h
@@ -0,0 +1,247 @@
+/** @file
+  EFI SMM CPU Protocol as defined in the PI 1.2 specification.
+
+  This protocol allows SMM drivers to access architecture-standard registers from any of the CPU 
+  save state areas. In some cases, difference processors provide the same information in the save state, 
+  but not in the same format. These so-called pseudo-registers provide this information in a standard 
+  format.  
+
+  Copyright (c) 2009 - 2012, 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 _SMM_CPU_H_
+#define _SMM_CPU_H_
+
+#define EFI_SMM_CPU_PROTOCOL_GUID \
+  { \
+    0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 } \
+  }
+
+///
+/// Save State register index
+///
+typedef enum {
+  ///
+  /// x86/X64 standard registers
+  ///
+  EFI_SMM_SAVE_STATE_REGISTER_GDTBASE       = 4,
+  EFI_SMM_SAVE_STATE_REGISTER_IDTBASE       = 5,
+  EFI_SMM_SAVE_STATE_REGISTER_LDTBASE       = 6,
+  EFI_SMM_SAVE_STATE_REGISTER_GDTLIMIT      = 7,
+  EFI_SMM_SAVE_STATE_REGISTER_IDTLIMIT      = 8,
+  EFI_SMM_SAVE_STATE_REGISTER_LDTLIMIT      = 9,
+  EFI_SMM_SAVE_STATE_REGISTER_LDTINFO       = 10,
+  EFI_SMM_SAVE_STATE_REGISTER_ES            = 20,
+  EFI_SMM_SAVE_STATE_REGISTER_CS            = 21,
+  EFI_SMM_SAVE_STATE_REGISTER_SS            = 22,
+  EFI_SMM_SAVE_STATE_REGISTER_DS            = 23,
+  EFI_SMM_SAVE_STATE_REGISTER_FS            = 24,
+  EFI_SMM_SAVE_STATE_REGISTER_GS            = 25,
+  EFI_SMM_SAVE_STATE_REGISTER_LDTR_SEL      = 26,
+  EFI_SMM_SAVE_STATE_REGISTER_TR_SEL        = 27,
+  EFI_SMM_SAVE_STATE_REGISTER_DR7           = 28,
+  EFI_SMM_SAVE_STATE_REGISTER_DR6           = 29,
+  EFI_SMM_SAVE_STATE_REGISTER_R8            = 30,
+  EFI_SMM_SAVE_STATE_REGISTER_R9            = 31,
+  EFI_SMM_SAVE_STATE_REGISTER_R10           = 32,
+  EFI_SMM_SAVE_STATE_REGISTER_R11           = 33,
+  EFI_SMM_SAVE_STATE_REGISTER_R12           = 34,
+  EFI_SMM_SAVE_STATE_REGISTER_R13           = 35,
+  EFI_SMM_SAVE_STATE_REGISTER_R14           = 36,
+  EFI_SMM_SAVE_STATE_REGISTER_R15           = 37,  
+  EFI_SMM_SAVE_STATE_REGISTER_RAX           = 38,
+  EFI_SMM_SAVE_STATE_REGISTER_RBX           = 39,
+  EFI_SMM_SAVE_STATE_REGISTER_RCX           = 40,
+  EFI_SMM_SAVE_STATE_REGISTER_RDX           = 41,
+  EFI_SMM_SAVE_STATE_REGISTER_RSP           = 42,
+  EFI_SMM_SAVE_STATE_REGISTER_RBP           = 43,
+  EFI_SMM_SAVE_STATE_REGISTER_RSI           = 44,
+  EFI_SMM_SAVE_STATE_REGISTER_RDI           = 45,
+  EFI_SMM_SAVE_STATE_REGISTER_RIP           = 46,
+  EFI_SMM_SAVE_STATE_REGISTER_RFLAGS        = 51,
+  EFI_SMM_SAVE_STATE_REGISTER_CR0           = 52,
+  EFI_SMM_SAVE_STATE_REGISTER_CR3           = 53,
+  EFI_SMM_SAVE_STATE_REGISTER_CR4           = 54,
+  EFI_SMM_SAVE_STATE_REGISTER_FCW           = 256,
+  EFI_SMM_SAVE_STATE_REGISTER_FSW           = 257,
+  EFI_SMM_SAVE_STATE_REGISTER_FTW           = 258,  
+  EFI_SMM_SAVE_STATE_REGISTER_OPCODE        = 259,
+  EFI_SMM_SAVE_STATE_REGISTER_FP_EIP        = 260,
+  EFI_SMM_SAVE_STATE_REGISTER_FP_CS         = 261,
+  EFI_SMM_SAVE_STATE_REGISTER_DATAOFFSET    = 262,
+  EFI_SMM_SAVE_STATE_REGISTER_FP_DS         = 263,
+  EFI_SMM_SAVE_STATE_REGISTER_MM0           = 264,
+  EFI_SMM_SAVE_STATE_REGISTER_MM1           = 265,
+  EFI_SMM_SAVE_STATE_REGISTER_MM2           = 266,
+  EFI_SMM_SAVE_STATE_REGISTER_MM3           = 267,
+  EFI_SMM_SAVE_STATE_REGISTER_MM4           = 268,
+  EFI_SMM_SAVE_STATE_REGISTER_MM5           = 269,
+  EFI_SMM_SAVE_STATE_REGISTER_MM6           = 270,
+  EFI_SMM_SAVE_STATE_REGISTER_MM7           = 271,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM0          = 272,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM1          = 273,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM2          = 274,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM3          = 275,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM4          = 276,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM5          = 277,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM6          = 278,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM7          = 279,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM8          = 280,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM9          = 281,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM10         = 282,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM11         = 283,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM12         = 284,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM13         = 285,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM14         = 286,
+  EFI_SMM_SAVE_STATE_REGISTER_XMM15         = 287,  
+  ///
+  /// Pseudo-Registers
+  ///
+  EFI_SMM_SAVE_STATE_REGISTER_IO            = 512,
+  EFI_SMM_SAVE_STATE_REGISTER_LMA           = 513,
+  EFI_SMM_SAVE_STATE_REGISTER_PROCESSOR_ID  = 514
+} EFI_SMM_SAVE_STATE_REGISTER;  
+
+///
+/// The EFI_SMM_SAVE_STATE_REGISTER_LMA pseudo-register values
+/// If the processor acts in 32-bit mode at the time the SMI occurred, the pseudo register value 
+/// EFI_SMM_SAVE_STATE_REGISTER_LMA_32BIT is returned in Buffer. Otherwise, 
+/// EFI_SMM_SAVE_STATE_REGISTER_LMA_64BIT is returned in Buffer.
+///
+#define EFI_SMM_SAVE_STATE_REGISTER_LMA_32BIT  32
+#define EFI_SMM_SAVE_STATE_REGISTER_LMA_64BIT  64
+
+///
+/// Size width of I/O instruction
+///
+typedef enum {
+  EFI_SMM_SAVE_STATE_IO_WIDTH_UINT8      = 0,
+  EFI_SMM_SAVE_STATE_IO_WIDTH_UINT16     = 1,
+  EFI_SMM_SAVE_STATE_IO_WIDTH_UINT32     = 2,
+  EFI_SMM_SAVE_STATE_IO_WIDTH_UINT64     = 3
+} EFI_SMM_SAVE_STATE_IO_WIDTH;
+
+///
+/// Types of I/O instruction
+///
+typedef enum {
+  EFI_SMM_SAVE_STATE_IO_TYPE_INPUT       = 1,
+  EFI_SMM_SAVE_STATE_IO_TYPE_OUTPUT      = 2,
+  EFI_SMM_SAVE_STATE_IO_TYPE_STRING      = 4,
+  EFI_SMM_SAVE_STATE_IO_TYPE_REP_PREFIX  = 8
+} EFI_SMM_SAVE_STATE_IO_TYPE;
+
+///
+/// Structure of the data which is returned when ReadSaveState() is called with 
+/// EFI_SMM_SAVE_STATE_REGISTER_IO. If there was no I/O then ReadSaveState() will 
+/// return EFI_NOT_FOUND.
+///
+/// This structure describes the I/O operation which was in process when the SMI was generated.
+///
+typedef struct _EFI_SMM_SAVE_STATE_IO_INFO {
+  ///
+  /// For input instruction (IN, INS), this is data read before the SMI occurred. For output 
+  /// instructions (OUT, OUTS) this is data that was written before the SMI occurred. The 
+  /// width of the data is specified by IoWidth.
+  ///
+  UINT64                        IoData;
+  ///
+  /// The I/O port that was being accessed when the SMI was triggered.
+  ///
+  UINT16                        IoPort;
+  ///
+  /// Defines the size width (UINT8, UINT16, UINT32, UINT64) for IoData.
+  ///
+  EFI_SMM_SAVE_STATE_IO_WIDTH   IoWidth;
+  ///
+  /// Defines type of I/O instruction.
+  ///
+  EFI_SMM_SAVE_STATE_IO_TYPE    IoType;
+} EFI_SMM_SAVE_STATE_IO_INFO;
+  
+typedef struct _EFI_SMM_CPU_PROTOCOL  EFI_SMM_CPU_PROTOCOL;
+
+/**
+  Read data from the CPU save state.
+
+  This function is used to read the specified number of bytes of the specified register from the CPU 
+  save state of the specified CPU and place the value into the buffer. If the CPU does not support the
+  specified register Register, then EFI_NOT_FOUND  should be returned. If the CPU does not 
+  support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in]  This               The EFI_SMM_CPU_PROTOCOL instance.
+  @param[in]  Width              The number of bytes to read from the CPU save state.
+  @param[in]  Register           Specifies the CPU register to read form the save state.
+  @param[in]  CpuIndex           Specifies the zero-based index of the CPU save state.
+  @param[out] Buffer             Upon return, this holds the CPU register value read from the save state.
+    
+  @retval EFI_SUCCESS            The register was read from Save State.
+  @retval EFI_NOT_FOUND          The register is not defined for the Save State of Processor.
+  @retval EFI_INVALID_PARAMETER  Input parameters are not valid, for example, Processor No or register width 
+                                 is not correct.This or Buffer is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_READ_SAVE_STATE)(
+  IN CONST EFI_SMM_CPU_PROTOCOL   *This,
+  IN UINTN                        Width,
+  IN EFI_SMM_SAVE_STATE_REGISTER  Register,
+  IN UINTN                        CpuIndex,
+  OUT VOID                        *Buffer
+  );
+
+
+/**
+  Write data to the CPU save state.
+
+  This function is used to write the specified number of bytes of the specified register to the CPU save 
+  state of the specified CPU and place the value into the buffer. If the CPU does not support the 
+  specified register Register, then EFI_UNSUPPORTED should be returned. If the CPU does not 
+  support the specified register width Width, then EFI_INVALID_PARAMETER is returned.
+
+  @param[in]  This               The EFI_SMM_CPU_PROTOCOL instance.
+  @param[in]  Width              The number of bytes to write to the CPU save state.
+  @param[in]  Register           Specifies the CPU register to write to the save state.
+  @param[in]  CpuIndex           Specifies the zero-based index of the CPU save state.
+  @param[in]  Buffer             Upon entry, this holds the new CPU register value.
+  
+  @retval EFI_SUCCESS            The register was written to Save State.
+  @retval EFI_NOT_FOUND          The register is not defined for the Save State of Processor.
+  @retval EFI_INVALID_PARAMETER  Input parameters are not valid. For example: 
+                                 ProcessorIndex or Width is not correct.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_WRITE_SAVE_STATE)(
+  IN CONST EFI_SMM_CPU_PROTOCOL   *This,
+  IN UINTN                        Width, 
+  IN EFI_SMM_SAVE_STATE_REGISTER  Register,
+  IN UINTN                        CpuIndex,
+  IN CONST VOID                   *Buffer
+  );
+
+///
+/// EFI SMM CPU Protocol provides access to CPU-related information while in SMM.
+///
+/// This protocol allows SMM drivers to access architecture-standard registers from any of the CPU 
+/// save state areas. In some cases, difference processors provide the same information in the save state, 
+/// but not in the same format. These so-called pseudo-registers provide this information in a standard 
+/// format.  
+///
+struct _EFI_SMM_CPU_PROTOCOL {
+  EFI_SMM_READ_SAVE_STATE   ReadSaveState;
+  EFI_SMM_WRITE_SAVE_STATE  WriteSaveState;
+};
+
+extern EFI_GUID gEfiSmmCpuProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmCpuIo2.h b/MdePkg/Include/Protocol/SmmCpuIo2.h
new file mode 100644
index 000000000000..b580faf3cb55
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmCpuIo2.h
@@ -0,0 +1,96 @@
+/** @file
+  SMM CPU I/O 2 protocol as defined in the PI 1.2 specification.
+
+  This protocol provides CPU I/O and memory access within SMM.
+
+  Copyright (c) 2009 - 2010, 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 _SMM_CPU_IO2_H_
+#define _SMM_CPU_IO2_H_
+
+#define EFI_SMM_CPU_IO2_PROTOCOL_GUID \
+  { \
+    0x3242A9D8, 0xCE70, 0x4AA0, { 0x95, 0x5D, 0x5E, 0x7B, 0x14, 0x0D, 0xE4, 0xD2 } \
+  }
+
+typedef struct _EFI_SMM_CPU_IO2_PROTOCOL  EFI_SMM_CPU_IO2_PROTOCOL;
+
+///
+/// Width of the SMM CPU I/O operations
+///
+typedef enum {
+  SMM_IO_UINT8  = 0,
+  SMM_IO_UINT16 = 1,
+  SMM_IO_UINT32 = 2,
+  SMM_IO_UINT64 = 3
+} EFI_SMM_IO_WIDTH;
+
+/**
+  Provides the basic memory and I/O interfaces used toabstract accesses to devices.
+
+  The I/O operations are carried out exactly as requested.  The caller is 
+  responsible for any alignment and I/O width issues that the bus, device, 
+  platform, or type of I/O might require.
+
+  @param[in]      This     The EFI_SMM_CPU_IO2_PROTOCOL instance.
+  @param[in]      Width    Signifies the width of the I/O operations.
+  @param[in]      Address  The base address of the I/O operations.  The caller is 
+                           responsible for aligning the Address if required. 
+  @param[in]      Count    The number of I/O operations to perform.
+  @param[in,out]  Buffer   For read operations, the destination buffer to store 
+                           the results.  For write operations, the source buffer 
+                           from which to write data.
+
+  @retval EFI_SUCCESS            The data was read from or written to the device.
+  @retval EFI_UNSUPPORTED        The Address is not valid for this system.
+  @retval EFI_INVALID_PARAMETER  Width or Count, or both, were invalid.
+  @retval EFI_OUT_OF_RESOURCES   The request could not be completed due to a lack
+                                 of resources.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_CPU_IO2)(
+  IN     CONST EFI_SMM_CPU_IO2_PROTOCOL  *This,
+  IN     EFI_SMM_IO_WIDTH                Width,
+  IN     UINT64                          Address,
+  IN     UINTN                           Count,
+  IN OUT VOID                            *Buffer
+  );
+
+typedef struct {
+  ///
+  /// This service provides the various modalities of memory and I/O read.
+  ///
+  EFI_SMM_CPU_IO2  Read;
+  ///
+  /// This service provides the various modalities of memory and I/O write.
+  ///
+  EFI_SMM_CPU_IO2  Write;
+} EFI_SMM_IO_ACCESS2;
+
+///
+/// SMM CPU I/O Protocol provides CPU I/O and memory access within SMM.
+///
+struct _EFI_SMM_CPU_IO2_PROTOCOL {
+  ///
+  /// Allows reads and writes to memory-mapped I/O space.
+  ///
+  EFI_SMM_IO_ACCESS2 Mem;
+  ///
+  /// Allows reads and writes to I/O space.
+  ///
+  EFI_SMM_IO_ACCESS2 Io;
+};
+
+extern EFI_GUID gEfiSmmCpuIo2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmmEndOfDxe.h b/MdePkg/Include/Protocol/SmmEndOfDxe.h
new file mode 100644
index 000000000000..3f92ffc40cc3
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmEndOfDxe.h
@@ -0,0 +1,33 @@
+/** @file
+  SMM End Of Dxe protocol introduced in the PI 1.2.1 specification.
+
+  According to PI 1.4a specification, this protocol indicates end of the
+  execution phase when all of the components are under the authority of
+  the platform manufacturer.
+  This protocol is a mandatory protocol published by SMM Foundation code.
+  This protocol is an SMM counterpart of the End of DXE Event.
+  This protocol prorogates End of DXE notification into SMM environment.
+  This protocol is installed prior to installation of the SMM Ready to Lock Protocol.
+
+  Copyright (c) 2012 - 2016, 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 _SMM_END_OF_DXE_H_
+#define _SMM_END_OF_DXE_H_
+
+#define EFI_SMM_END_OF_DXE_PROTOCOL_GUID \
+  { \
+    0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d } \
+  }
+
+extern EFI_GUID gEfiSmmEndOfDxeProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmmGpiDispatch2.h b/MdePkg/Include/Protocol/SmmGpiDispatch2.h
new file mode 100644
index 000000000000..da1868f446e6
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmGpiDispatch2.h
@@ -0,0 +1,125 @@
+/** @file
+  SMM General Purpose Input (GPI) Dispatch2 Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides the parent dispatch service for the General Purpose Input 
+  (GPI) SMI source generator.
+
+  The EFI_SMM_GPI_DISPATCH2_PROTOCOL provides the ability to install child handlers for the 
+  given event types.  Several inputs can be enabled.  This purpose of this interface is to generate an 
+  SMI in response to any of these inputs having a true value provided.
+
+  Copyright (c) 2009 - 2015, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_GPI_DISPATCH2_H_
+#define _SMM_GPI_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_GPI_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 } \
+  }
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+  ///
+  /// A number from one of 2^64 possible GPIs that can generate an SMI. A
+  /// 0 corresponds to logical GPI[0]; 1 corresponds to logical GPI[1]; and
+  /// GpiNum of N corresponds to GPI[N], where N can span from 0 to 2^64-1.
+  ///
+  UINT64 GpiNum;
+} EFI_SMM_GPI_REGISTER_CONTEXT;
+
+typedef struct _EFI_SMM_GPI_DISPATCH2_PROTOCOL EFI_SMM_GPI_DISPATCH2_PROTOCOL;
+
+/**
+  Registers a child SMI source dispatch function with a parent SMM driver.
+
+  This service registers a function (DispatchFunction) which will be called when an SMI is 
+  generated because of one or more of the GPIs specified by RegisterContext. On return, 
+  DispatchHandle contains a unique handle which may be used later to unregister the function 
+  using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer pointing to another instance of 
+  EFI_SMM_GPI_REGISTER_CONTEXT describing the GPIs which actually caused the SMI and 
+  CommBufferSize pointing to the size of the structure.
+
+  @param[in]  This               Pointer to the EFI_SMM_GPI_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when the specified GPI causes an SMI.
+  @param[in]  RegisterContext    Pointer to the dispatch function's context.
+                                 The caller fills this context in before calling
+                                 the register function to indicate to the register
+                                 function the GPI(s) for which the dispatch function
+                                 should be invoked.
+  @param[out] DispatchHandle     Handle generated by the dispatcher to track the
+                                 function instance.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The GPI input value
+                                 is not within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_GPI_REGISTER2)(
+  IN CONST EFI_SMM_GPI_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_SMM_HANDLER_ENTRY_POINT2    DispatchFunction,
+  IN CONST EFI_SMM_GPI_REGISTER_CONTEXT    *RegisterContext,
+  OUT      EFI_HANDLE                      *DispatchHandle
+  );
+
+/**
+  Unregisters a General Purpose Input (GPI) service.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called when the GPI triggers an SMI. 
+
+  @param[in]  This               Pointer to the EFI_SMM_GPI_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchHandle     Handle of the service to remove.
+
+  @retval EFI_SUCCESS            Handle of the service to remove.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_GPI_UNREGISTER2)(
+  IN CONST EFI_SMM_GPI_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                      DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM GPI SMI Dispatch Protocol
+///
+/// The SMM GPI SMI Dispatch Protocol provides the parent dispatch service
+/// for the General Purpose Input (GPI) SMI source generator.
+///
+struct _EFI_SMM_GPI_DISPATCH2_PROTOCOL {
+  EFI_SMM_GPI_REGISTER2    Register;
+  EFI_SMM_GPI_UNREGISTER2  UnRegister;
+  ///
+  /// Denotes the maximum value of inputs that can have handlers attached.
+  ///
+  UINTN                   NumSupportedGpis;
+};
+
+extern EFI_GUID gEfiSmmGpiDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmIoTrapDispatch2.h b/MdePkg/Include/Protocol/SmmIoTrapDispatch2.h
new file mode 100644
index 000000000000..f57ae522fa1b
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmIoTrapDispatch2.h
@@ -0,0 +1,136 @@
+/** @file
+  SMM IO Trap Dispatch2 Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides a parent dispatch service for IO trap SMI sources.
+
+  Copyright (c) 2009, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_IO_TRAP_DISPATCH2_H_
+#define _SMM_IO_TRAP_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 } \
+  }
+
+///
+/// IO Trap valid types
+///
+typedef enum {
+  WriteTrap,
+  ReadTrap,
+  ReadWriteTrap,
+  IoTrapTypeMaximum
+} EFI_SMM_IO_TRAP_DISPATCH_TYPE;
+
+///
+/// IO Trap context structure containing information about the
+/// IO trap event that should invoke the handler
+///
+typedef struct {
+  UINT16                         Address;
+  UINT16                         Length;
+  EFI_SMM_IO_TRAP_DISPATCH_TYPE  Type;
+} EFI_SMM_IO_TRAP_REGISTER_CONTEXT;
+
+///
+/// IO Trap context structure containing information about the IO trap that occurred
+///
+typedef struct {
+  UINT32  WriteData;
+} EFI_SMM_IO_TRAP_CONTEXT;
+
+typedef struct _EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL;
+
+/**
+  Register an IO trap SMI child handler for a specified SMI.
+
+  This service registers a function (DispatchFunction) which will be called when an SMI is 
+  generated because of an access to an I/O port specified by RegisterContext. On return, 
+  DispatchHandle contains a unique handle which may be used later to unregister the function 
+  using UnRegister(). If the base of the I/O range specified is zero, then an I/O range with the 
+  specified length and characteristics will be allocated and the Address field in RegisterContext 
+  updated. If no range could be allocated, then EFI_OUT_OF_RESOURCES will be returned. 
+
+  The service will not perform GCD allocation if the base address is non-zero or 
+  EFI_SMM_READY_TO_LOCK has been installed.  In this case, the caller is responsible for the 
+  existence and allocation of the specific IO range.
+  An error may be returned if some or all of the requested resources conflict with an existing IO trap 
+  child handler.
+
+  It is not required that implementations will allow multiple children for a single IO trap SMI source.  
+  Some implementations may support multiple children.
+  The DispatchFunction will be called with Context updated to contain information 
+  concerning the I/O action that actually happened and is passed in RegisterContext, with 
+  CommBuffer pointing to the data actually written and CommBufferSize pointing to the size of 
+  the data in CommBuffer.
+
+  @param[in]  This               Pointer to the EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when I/O trap location is accessed.
+  @param[in]  RegisterContext    Pointer to the dispatch function's context.  The caller fills this
+                                 context in before calling the register function to indicate to the register
+                                 function the IO trap SMI source for which the dispatch function should be invoked.
+  @param[out] DispatchHandle     Handle of the dispatch function, for when interfacing with the parent SMM driver.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully registered.
+  @retval EFI_DEVICE_ERROR       The driver was unable to complete due to hardware error.
+  @retval EFI_OUT_OF_RESOURCES   Insufficient resources are available to fulfill the IO trap range request.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid.  The input value is not within a valid range.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_IO_TRAP_DISPATCH2_REGISTER)(
+  IN CONST EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_SMM_HANDLER_ENTRY_POINT2        DispatchFunction,
+  IN OUT   EFI_SMM_IO_TRAP_REGISTER_CONTEXT    *RegisterContext,
+     OUT   EFI_HANDLE                          *DispatchHandle
+  );
+
+/**
+  Unregister a child SMI source dispatch function with a parent SMM driver.
+
+  This service removes a previously installed child dispatch handler. This does not guarantee that the 
+  system resources will be freed from the GCD.
+
+  @param[in] This                Pointer to the EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL instance. 
+  @param[in] DispatchHandle      Handle of the child service to remove.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully unregistered.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_IO_TRAP_DISPATCH2_UNREGISTER)(
+  IN CONST EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                          DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM IO Trap Dispatch2 Protocol.
+///
+/// This protocol provides a parent dispatch service for IO trap SMI sources.
+///
+struct _EFI_SMM_IO_TRAP_DISPATCH2_PROTOCOL {
+  EFI_SMM_IO_TRAP_DISPATCH2_REGISTER    Register;
+  EFI_SMM_IO_TRAP_DISPATCH2_UNREGISTER  UnRegister;
+};
+
+extern EFI_GUID gEfiSmmIoTrapDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmPciRootBridgeIo.h b/MdePkg/Include/Protocol/SmmPciRootBridgeIo.h
new file mode 100644
index 000000000000..847418f73c01
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmPciRootBridgeIo.h
@@ -0,0 +1,37 @@
+/** @file
+  SMM PCI Root Bridge IO protocol as defined in the PI 1.2 specification.
+
+  This protocol provides PCI I/O and memory access within SMM.
+
+  Copyright (c) 2009, 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 _SMM_PCI_ROOT_BRIDGE_IO_H_
+#define _SMM_PCI_ROOT_BRIDGE_IO_H_
+
+#include <Protocol/PciRootBridgeIo.h>
+
+#define EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
+  { \
+    0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea } \
+  }
+
+///
+/// This protocol provides the same functionality as the PCI Root Bridge I/O Protocol defined in the 
+/// UEFI 2.1 Specifcation, section 13.2, except that the functions for Map() and Unmap() may return 
+/// EFI_UNSUPPORTED.
+///
+typedef EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+
+extern EFI_GUID gEfiSmmPciRootBridgeIoProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmPeriodicTimerDispatch2.h b/MdePkg/Include/Protocol/SmmPeriodicTimerDispatch2.h
new file mode 100644
index 000000000000..d0aae046741f
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmPeriodicTimerDispatch2.h
@@ -0,0 +1,170 @@
+/** @file
+  SMM Periodic Timer Dispatch Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides the parent dispatch service for the periodical timer SMI source generator.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_PERIODIC_TIMER_DISPATCH2_H_
+#define _SMM_PERIODIC_TIMER_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 } \
+  }
+
+///
+/// Example: A chipset supports periodic SMIs on every 64ms or 2 seconds.
+///   A child wishes schedule a period SMI to fire on a period of 3 seconds, there
+///   are several ways to approach the problem:
+///   1. The child may accept a 4 second periodic rate, in which case it registers with
+///        Period = 40000
+///        SmiTickInterval = 20000
+///      The resulting SMI will occur every 2 seconds with the child called back on
+///      every 2nd SMI.
+///      NOTE: the same result would occur if the child set SmiTickInterval = 0.
+///   2. The child may choose the finer granularity SMI (64ms):
+///        Period = 30000
+///        SmiTickInterval = 640
+///      The resulting SMI will occur every 64ms with the child called back on
+///      every 47th SMI.
+///      NOTE: the child driver should be aware that this will result in more
+///        SMIs occuring during system runtime which can negatively impact system
+///        performance.
+///
+typedef struct {
+  ///
+  /// The minimum period of time in 100 nanosecond units that the child gets called. The 
+  /// child will be called back after a time greater than the time Period.
+  ///
+  UINT64  Period;
+  ///
+  /// The period of time interval between SMIs. Children of this interface should use this 
+  /// field when registering for periodic timer intervals when a finer granularity periodic 
+  /// SMI is desired.
+  ///
+  UINT64  SmiTickInterval;
+} EFI_SMM_PERIODIC_TIMER_REGISTER_CONTEXT;
+
+///
+/// The DispatchFunction will be called with Context set to the same value as was passed into 
+/// Register() in RegisterContext and with CommBuffer pointing to an instance of 
+/// EFI_SMM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size.
+///
+typedef struct {
+  ///
+  /// ElapsedTime is the actual time in 100 nanosecond units elapsed since last called, a
+  /// value of 0 indicates an unknown amount of time.
+  ///
+  UINT64  ElapsedTime;
+} EFI_SMM_PERIODIC_TIMER_CONTEXT;
+
+typedef struct _EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL;
+
+/**
+  Register a child SMI source dispatch function for SMM periodic timer.
+
+  This service registers a function (DispatchFunction) which will be called when at least the 
+  amount of time specified by RegisterContext has elapsed. On return, DispatchHandle 
+  contains a unique handle which may be used later to unregister the function using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer pointing to an instance of 
+  EFI_SMM_PERIODIC_TIMER_CONTEXT and CommBufferSize pointing to its size.
+
+  @param[in]  This               Pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when at least the specified amount
+                                 of time has elapsed. 
+  @param[in]  RegisterContext    Pointer to the dispatch function's context.
+                                 The caller fills this context in before calling
+                                 the register function to indicate to the register
+                                 function the period at which the dispatch function
+                                 should be invoked.
+  @param[out] DispatchHandle     Handle generated by the dispatcher to track the function instance. 
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The period input value
+                                 is not within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_PERIODIC_TIMER_REGISTER2)(
+  IN CONST EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_SMM_HANDLER_ENTRY_POINT2               DispatchFunction,
+  IN CONST EFI_SMM_PERIODIC_TIMER_REGISTER_CONTEXT    *RegisterContext,
+  OUT      EFI_HANDLE                                 *DispatchHandle
+  );
+
+/**
+  Unregisters a periodic timer service.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called when the time has elapsed.
+
+  @param[in] This                Pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchHandle      Handle of the service to remove.
+
+  @retval EFI_SUCCESS            The service has been successfully removed.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_PERIODIC_TIMER_UNREGISTER2)(
+  IN CONST EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                                 DispatchHandle
+  );
+
+/**
+  Returns the next SMI tick period supported by the chipset.
+
+  The order returned is from longest to shortest interval period.
+
+  @param[in]     This             Pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL instance.
+  @param[in,out] SmiTickInterval  Pointer to pointer of next shorter SMI interval
+                                  period supported by the child. This parameter works as a get-first,
+                                  get-next field.The first time this function is called, *SmiTickInterval
+                                  should be set to NULL to get the longest SMI interval.The returned
+                                  *SmiTickInterval should be passed in on subsequent calls to get the
+                                  next shorter interval period until *SmiTickInterval = NULL.
+
+  @retval EFI_SUCCESS             The service returned successfully.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_PERIODIC_TIMER_INTERVAL2)(
+  IN CONST EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  *This,
+  IN OUT UINT64                                       **SmiTickInterval
+  );
+
+///
+/// Interface structure for the SMM Periodic Timer Dispatch Protocol
+///
+/// This protocol provides the parent dispatch service for the periodical timer SMI source generator.
+///
+struct _EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL {
+  EFI_SMM_PERIODIC_TIMER_REGISTER2    Register;
+  EFI_SMM_PERIODIC_TIMER_UNREGISTER2  UnRegister;
+  EFI_SMM_PERIODIC_TIMER_INTERVAL2    GetNextShorterInterval;
+};
+
+extern EFI_GUID gEfiSmmPeriodicTimerDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmPowerButtonDispatch2.h b/MdePkg/Include/Protocol/SmmPowerButtonDispatch2.h
new file mode 100644
index 000000000000..0bedee8666d5
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmPowerButtonDispatch2.h
@@ -0,0 +1,117 @@
+/** @file
+  SMM Power Button Dispatch2 Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides the parent dispatch service for the power button SMI source generator.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_POWER_BUTTON_DISPATCH2_H_
+#define _SMM_POWER_BUTTON_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d } \
+  }
+
+///
+/// Power Button phases.
+///
+typedef enum {
+  EfiPowerButtonEntry,
+  EfiPowerButtonExit,
+  EfiPowerButtonMax
+} EFI_POWER_BUTTON_PHASE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+  ///
+  /// Designates whether this handler should be invoked upon entry or exit.
+  ///
+  EFI_POWER_BUTTON_PHASE  Phase;
+} EFI_SMM_POWER_BUTTON_REGISTER_CONTEXT;
+
+typedef struct _EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL;
+
+/**
+  Provides the parent dispatch service for a power button event.
+
+  This service registers a function (DispatchFunction) which will be called when an SMI is 
+  generated because the power button was pressed or released, as specified by RegisterContext. 
+  On return, DispatchHandle contains a unique handle which may be used later to unregister the 
+  function using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL.
+
+  @param[in]  This               Pointer to the EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when power button is pressed or released.
+  @param[in]  RegisterContext    Pointer to the dispatch function's context. The caller fills in this context
+                                 before calling the Register() function to indicate to the Register() function
+                                 the power button SMI phase for which the dispatch function should be invoked.
+  @param[out] DispatchHandle     Handle generated by the dispatcher to track the function instance. 
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The power button input value
+                                 is not within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_POWER_BUTTON_REGISTER2)(
+  IN CONST EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_SMM_HANDLER_ENTRY_POINT2             DispatchFunction,
+  IN       EFI_SMM_POWER_BUTTON_REGISTER_CONTEXT    *RegisterContext,
+  OUT      EFI_HANDLE                               *DispatchHandle
+  );
+
+/**
+  Unregisters a power-button service.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called when the standby button is pressed or released. 
+
+  @param[in] This                Pointer to the EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchHandle      Handle of the service to remove.
+
+  @retval EFI_SUCCESS            The service has been successfully removed.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_POWER_BUTTON_UNREGISTER2)(
+  IN CONST EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                               DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM Power Button Dispatch2 Protocol.
+///
+/// This protocol provides the parent dispatch service for the power button SMI source generator.
+///
+struct _EFI_SMM_POWER_BUTTON_DISPATCH2_PROTOCOL {
+  EFI_SMM_POWER_BUTTON_REGISTER2    Register;
+  EFI_SMM_POWER_BUTTON_UNREGISTER2  UnRegister;
+};
+
+extern EFI_GUID gEfiSmmPowerButtonDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmReadyToLock.h b/MdePkg/Include/Protocol/SmmReadyToLock.h
new file mode 100644
index 000000000000..a55606deb457
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmReadyToLock.h
@@ -0,0 +1,35 @@
+/** @file
+  SMM Ready To Lock protocol introduced in the PI 1.2 specification.
+
+  According to PI 1.4a specification, this SMM protocol indicates that
+  SMM resources and services that should not be used by the third party
+  code are about to be locked.
+  This protocol is a mandatory protocol published by the SMM Foundation
+  code when the system is preparing to lock certain resources and interfaces
+  in anticipation of the invocation of 3rd party extensible modules.
+  This protocol is an SMM counterpart of the DXE SMM Ready to Lock Protocol.
+  This protocol prorogates resource locking notification into SMM environment.
+  This protocol is installed after installation of the SMM End of DXE Protocol.
+
+  Copyright (c) 2009 - 2016, 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 _SMM_READY_TO_LOCK_H_
+#define _SMM_READY_TO_LOCK_H_
+
+#define EFI_SMM_READY_TO_LOCK_PROTOCOL_GUID \
+  { \
+    0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 } \
+  }
+
+extern EFI_GUID gEfiSmmReadyToLockProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmmReportStatusCodeHandler.h b/MdePkg/Include/Protocol/SmmReportStatusCodeHandler.h
new file mode 100644
index 000000000000..ca290c7437ed
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmReportStatusCodeHandler.h
@@ -0,0 +1,81 @@
+/** @file
+  This protocol provides registering and unregistering services to status code consumers while in DXE SMM.
+  
+  Copyright (c) 2007 - 2009, 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 __SMM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+#define __SMM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
+
+#define EFI_SMM_RSC_HANDLER_PROTOCOL_GUID \
+  { \
+    0x2ff29fa7, 0x5e80, 0x4ed9, {0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4} \
+  }
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_RSC_HANDLER_CALLBACK)(
+  IN EFI_STATUS_CODE_TYPE   CodeType,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN UINT32                 Instance,
+  IN EFI_GUID               *CallerId,
+  IN EFI_STATUS_CODE_DATA   *Data
+);
+
+/**
+  Register the callback function for ReportStatusCode() notification.
+  
+  When this function is called the function pointer is added to an internal list and any future calls to
+  ReportStatusCode() will be forwarded to the Callback function.
+  
+  @param[in] Callback               A pointer to a function of type EFI_RSC_HANDLER_CALLBACK that is called when
+                                    a call to ReportStatusCode() occurs.
+
+  @retval EFI_SUCCESS               Function was successfully registered.
+  @retval EFI_INVALID_PARAMETER     The callback function was NULL.
+  @retval EFI_OUT_OF_RESOURCES      The internal buffer ran out of space. No more functions can be
+                                    registered.
+  @retval EFI_ALREADY_STARTED       The function was already registered. It can't be registered again.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_RSC_HANDLER_REGISTER)(
+  IN EFI_SMM_RSC_HANDLER_CALLBACK Callback
+);
+
+/**
+  Remove a previously registered callback function from the notification list.
+  
+  A callback function must be unregistered before it is deallocated. It is important that any registered
+  callbacks that are not runtime complaint be unregistered when ExitBootServices() is called.
+
+  @param[in] Callback           A pointer to a function of type EFI_SMM_RSC_HANDLER_CALLBACK that is to be
+                                unregistered.
+                        
+  @retval EFI_SUCCESS           The function was successfully unregistered.
+  @retval EFI_INVALID_PARAMETER The callback function was NULL.
+  @retval EFI_NOT_FOUND         The callback function was not found to be unregistered.
+                            
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_RSC_HANDLER_UNREGISTER)(
+  IN EFI_SMM_RSC_HANDLER_CALLBACK Callback
+);
+
+typedef struct _EFI_SMM_RSC_HANDLER_PROTOCOL {
+  EFI_SMM_RSC_HANDLER_REGISTER      Register;
+  EFI_SMM_RSC_HANDLER_UNREGISTER    Unregister;
+} EFI_SMM_RSC_HANDLER_PROTOCOL;
+
+extern EFI_GUID gEfiSmmRscHandlerProtocolGuid;
+
+#endif // __SMM_REPORT_STATUS_CODE_HANDLER_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/SmmStandbyButtonDispatch2.h b/MdePkg/Include/Protocol/SmmStandbyButtonDispatch2.h
new file mode 100644
index 000000000000..e8249495d2a6
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmStandbyButtonDispatch2.h
@@ -0,0 +1,119 @@
+/** @file
+  SMM Standby Button Dispatch2 Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides the parent dispatch service for the standby button SMI source generator.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_STANDBY_BUTTON_DISPATCH2_H_
+#define _SMM_STANDBY_BUTTON_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b } \
+  }
+
+///
+/// Standby Button phases
+///
+typedef enum {
+  EfiStandbyButtonEntry,
+  EfiStandbyButtonExit,
+  EfiStandbyButtonMax
+} EFI_STANDBY_BUTTON_PHASE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+  ///
+  /// Describes whether the child handler should be invoked upon the entry to the button 
+  /// activation or upon exit.
+  ///
+  EFI_STANDBY_BUTTON_PHASE  Phase;
+} EFI_SMM_STANDBY_BUTTON_REGISTER_CONTEXT;
+
+typedef struct _EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL;
+
+/**
+  Provides the parent dispatch service for a standby button event.
+
+  This service registers a function (DispatchFunction) which will be called when an SMI is 
+  generated because the standby button was pressed or released, as specified by 
+  RegisterContext. On return, DispatchHandle contains a unique handle which may be used 
+  later to unregister the function using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer and CommBufferSize set to NULL. 
+
+  @param[in]  This               Pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when the standby button is pressed or released.
+  @param[in]  RegisterContext    Pointer to the dispatch function's context. The caller fills in this context
+                                 before calling the register function to indicate to the register function the 
+                                 standby button SMI source for which the dispatch function should be invoked.
+  @param[out] DispatchHandle     Handle generated by the dispatcher to track the function instance. 
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The standby button input value
+                                 is not within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_STANDBY_BUTTON_REGISTER2)(
+  IN CONST EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_SMM_HANDLER_ENTRY_POINT2               DispatchFunction,
+  IN       EFI_SMM_STANDBY_BUTTON_REGISTER_CONTEXT    *RegisterContext,
+  OUT      EFI_HANDLE                                 *DispatchHandle
+  );
+
+/**
+  Unregisters a child SMI source dispatch function with a parent SMM driver.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called when the standby button is pressed or released.
+
+  @param[in] This                Pointer to the EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchHandle      Handle of the service to remove.
+
+  @retval EFI_SUCCESS            The service has been successfully removed.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_STANDBY_BUTTON_UNREGISTER2)(
+  IN CONST EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                                 DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM Standby Button Dispatch2 Protocol.
+///
+/// This protocol provides the parent dispatch service for the standby
+/// button SMI source generator.
+///
+struct _EFI_SMM_STANDBY_BUTTON_DISPATCH2_PROTOCOL {
+  EFI_SMM_STANDBY_BUTTON_REGISTER2    Register;
+  EFI_SMM_STANDBY_BUTTON_UNREGISTER2  UnRegister;
+};
+
+extern EFI_GUID gEfiSmmStandbyButtonDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmStatusCode.h b/MdePkg/Include/Protocol/SmmStatusCode.h
new file mode 100644
index 000000000000..cf9740737df8
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmStatusCode.h
@@ -0,0 +1,65 @@
+/** @file
+  EFI SMM Status Code Protocol as defined in the PI 1.2 specification.
+
+  This protocol provides the basic status code services while in SMM. 
+
+  Copyright (c) 2009 - 2010, 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 _SMM_STATUS_CODE_H__
+#define _SMM_STATUS_CODE_H__
+
+
+#define EFI_SMM_STATUS_CODE_PROTOCOL_GUID \
+  { \
+    0x6afd2b77, 0x98c1, 0x4acd, {0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1} \
+  }
+
+typedef struct _EFI_SMM_STATUS_CODE_PROTOCOL  EFI_SMM_STATUS_CODE_PROTOCOL;
+
+/**
+  Service to emit the status code in SMM.    
+
+  The EFI_SMM_STATUS_CODE_PROTOCOL.ReportStatusCode() function enables a driver 
+  to emit a status code while in SMM.  The reason that there is a separate protocol definition from the 
+  DXE variant of this service is that the publisher of this protocol will provide a service that is 
+  capability of coexisting with a foreground operational environment, such as an operating system 
+  after the termination of boot services.  
+
+  @param[in] This                Points to this instance of the EFI_SMM_STATUS_CODE_PROTOCOL.
+  @param[in] CodeType            DIndicates the type of status code being reported. 
+  @param[in] Value               Describes the current status of a hardware or software entity. 
+  @param[in] Instance            The enumeration of a hardware or software entity within the system.
+  @param[in] CallerId            This optional parameter may be used to identify the caller.
+  @param[in] Data                This optional parameter may be used to pass additional data.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_INVALID_PARAMETER  The function should not be completed due to a device error.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_REPORT_STATUS_CODE)(
+  IN CONST EFI_SMM_STATUS_CODE_PROTOCOL  *This,
+  IN EFI_STATUS_CODE_TYPE                CodeType,
+  IN EFI_STATUS_CODE_VALUE               Value,
+  IN UINT32                              Instance,
+  IN CONST EFI_GUID                      *CallerId,
+  IN EFI_STATUS_CODE_DATA                *Data OPTIONAL
+  );
+
+struct _EFI_SMM_STATUS_CODE_PROTOCOL {
+  EFI_SMM_REPORT_STATUS_CODE  ReportStatusCode;
+};
+
+extern EFI_GUID gEfiSmmStatusCodeProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/SmmSwDispatch2.h b/MdePkg/Include/Protocol/SmmSwDispatch2.h
new file mode 100644
index 000000000000..3b2969b9769a
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmSwDispatch2.h
@@ -0,0 +1,136 @@
+/** @file
+  SMM Software Dispatch Protocol introduced from PI 1.2 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  This protocol provides the parent dispatch service for a given SMI source generator.
+
+  Copyright (c) 2009 - 2016, 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 _SMM_SW_DISPATCH2_H_
+#define _SMM_SW_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_SW_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 } \
+  }
+
+///
+/// A particular chipset may not support all possible software SMI input values.
+/// For example, the ICH supports only values 00h to 0FFh.  The parent only allows a single
+/// child registration for each SwSmiInputValue.
+///
+typedef struct {
+  UINTN SwSmiInputValue;
+} EFI_SMM_SW_REGISTER_CONTEXT;
+
+///
+/// The DispatchFunction will be called with Context set to the same value as was passed into 
+/// this function in RegisterContext and with CommBuffer (and CommBufferSize) pointing
+/// to an instance of EFI_SMM_SW_CONTEXT indicating the index of the CPU which generated the 
+/// software SMI.
+///
+typedef struct {
+  ///
+  /// The 0-based index of the CPU which generated the software SMI.
+  ///
+  UINTN SwSmiCpuIndex;
+  ///
+  /// This value corresponds directly to the CommandPort parameter used in the call to Trigger().
+  ///
+  UINT8 CommandPort;
+  ///
+  /// This value corresponds directly to the DataPort parameter used in the call to Trigger().
+  ///
+  UINT8 DataPort;
+} EFI_SMM_SW_CONTEXT;
+
+typedef struct _EFI_SMM_SW_DISPATCH2_PROTOCOL  EFI_SMM_SW_DISPATCH2_PROTOCOL;
+
+/**
+  Register a child SMI source dispatch function for the specified software SMI.
+
+  This service registers a function (DispatchFunction) which will be called when the software 
+  SMI source specified by RegisterContext->SwSmiCpuIndex is detected. On return, 
+  DispatchHandle contains a unique handle which may be used later to unregister the function 
+  using UnRegister().
+
+  @param[in]  This                 Pointer to the EFI_SMM_SW_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction     Function to register for handler when the specified software 
+                                   SMI is generated. 
+  @param[in, out] RegisterContext  Pointer to the dispatch function's context.
+                                   The caller fills this context in before calling
+                                   the register function to indicate to the register
+                                   function which Software SMI input value the
+                                   dispatch function should be invoked for.
+  @param[out] DispatchHandle       Handle generated by the dispatcher to track the
+                                   function instance.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The SW driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The SW SMI input value
+                                 is not within a valid range or is already in use.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this
+                                 child.
+  @retval EFI_OUT_OF_RESOURCES   A unique software SMI value could not be assigned
+                                 for this dispatch.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_SW_REGISTER2)(
+  IN  CONST EFI_SMM_SW_DISPATCH2_PROTOCOL  *This,
+  IN        EFI_SMM_HANDLER_ENTRY_POINT2   DispatchFunction,
+  IN  OUT   EFI_SMM_SW_REGISTER_CONTEXT    *RegisterContext,
+  OUT       EFI_HANDLE                     *DispatchHandle
+  );
+
+/**
+  Unregister a child SMI source dispatch function for the specified software SMI.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called in response to a software SMI.
+
+  @param[in] This                Pointer to the EFI_SMM_SW_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchHandle      Handle of dispatch function to deregister.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully unregistered.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_SW_UNREGISTER2)(
+  IN CONST EFI_SMM_SW_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                     DispatchHandle
+);
+
+///
+/// Interface structure for the SMM Software SMI Dispatch Protocol.
+///
+/// The EFI_SMM_SW_DISPATCH2_PROTOCOL provides the ability to install child handlers for the 
+/// given software.  These handlers will respond to software interrupts, and the maximum software 
+/// interrupt in the EFI_SMM_SW_REGISTER_CONTEXT is denoted by MaximumSwiValue.
+///
+struct _EFI_SMM_SW_DISPATCH2_PROTOCOL {
+  EFI_SMM_SW_REGISTER2    Register;
+  EFI_SMM_SW_UNREGISTER2  UnRegister;
+  ///
+  /// A read-only field that describes the maximum value that can be used in the 
+  /// EFI_SMM_SW_DISPATCH2_PROTOCOL.Register() service.
+  ///
+  UINTN                  MaximumSwiValue;
+};
+
+extern EFI_GUID gEfiSmmSwDispatch2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmmSxDispatch2.h b/MdePkg/Include/Protocol/SmmSxDispatch2.h
new file mode 100644
index 000000000000..94508f3a3973
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmSxDispatch2.h
@@ -0,0 +1,135 @@
+/** @file
+  SMM Sx Dispatch Protocol as defined in PI 1.2 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  Provides the parent dispatch service for a given Sx-state source generator.
+
+  Copyright (c) 2009 - 2010, 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 _SMM_SX_DISPATCH2_H_
+#define _SMM_SX_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_SX_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d } \
+  }
+
+///
+/// Sleep states S0-S5
+///
+typedef enum {
+  SxS0,
+  SxS1,
+  SxS2,
+  SxS3,
+  SxS4,
+  SxS5,
+  EfiMaximumSleepType
+} EFI_SLEEP_TYPE;
+
+///
+/// Sleep state phase: entry or exit
+///
+typedef enum {
+  SxEntry,
+  SxExit,
+  EfiMaximumPhase
+} EFI_SLEEP_PHASE;
+
+///
+/// The dispatch function's context
+///
+typedef struct {
+  EFI_SLEEP_TYPE  Type;
+  EFI_SLEEP_PHASE Phase;
+} EFI_SMM_SX_REGISTER_CONTEXT;
+
+typedef struct _EFI_SMM_SX_DISPATCH2_PROTOCOL  EFI_SMM_SX_DISPATCH2_PROTOCOL;
+
+/**
+  Provides the parent dispatch service for a given Sx source generator.
+
+  This service registers a function (DispatchFunction) which will be called when the sleep state 
+  event specified by RegisterContext is detected. On return, DispatchHandle contains a 
+  unique handle which may be used later to unregister the function using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer and CommBufferSize set to 
+  NULL and 0 respectively.
+
+  @param[in] This                Pointer to the EFI_SMM_SX_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchFunction    Function to register for handler when the specified sleep state event occurs.
+  @param[in] RegisterContext     Pointer to the dispatch function's context.
+                                 The caller fills this context in before calling
+                                 the register function to indicate to the register
+                                 function which Sx state type and phase the caller
+                                 wishes to be called back on. For this intertace,
+                                 the Sx driver will call the registered handlers for
+                                 all Sx type and phases, so the Sx state handler(s)
+                                 must check the Type and Phase field of the Dispatch
+                                 context and act accordingly.
+  @param[out]  DispatchHandle    Handle of dispatch function, for when interfacing
+                                 with the parent Sx state SMM driver.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_UNSUPPORTED        The Sx driver or hardware does not support that
+                                 Sx Type/Phase.
+  @retval EFI_DEVICE_ERROR       The Sx driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. Type & Phase are not
+                                 within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this
+                                 child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_SX_REGISTER2)(
+  IN  CONST EFI_SMM_SX_DISPATCH2_PROTOCOL  *This,
+  IN        EFI_SMM_HANDLER_ENTRY_POINT2   DispatchFunction,
+  IN  CONST EFI_SMM_SX_REGISTER_CONTEXT    *RegisterContext,
+  OUT       EFI_HANDLE                     *DispatchHandle
+  );
+
+/**
+  Unregisters an Sx-state service.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called in response to sleep event.
+
+  @param[in] This                Pointer to the EFI_SMM_SX_DISPATCH2_PROTOCOL instance.
+  @param[in] DispatchHandle      Handle of the service to remove. 
+
+  @retval EFI_SUCCESS            The service has been successfully removed.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_SX_UNREGISTER2)(
+  IN CONST EFI_SMM_SX_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                     DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM Sx Dispatch Protocol
+///
+/// The EFI_SMM_SX_DISPATCH2_PROTOCOL provides the ability to install child handlers to 
+/// respond to sleep state related events.
+///
+struct _EFI_SMM_SX_DISPATCH2_PROTOCOL {
+  EFI_SMM_SX_REGISTER2    Register;
+  EFI_SMM_SX_UNREGISTER2  UnRegister;
+};
+
+extern EFI_GUID gEfiSmmSxDispatch2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SmmUsbDispatch2.h b/MdePkg/Include/Protocol/SmmUsbDispatch2.h
new file mode 100644
index 000000000000..75a7a7c0bc7f
--- /dev/null
+++ b/MdePkg/Include/Protocol/SmmUsbDispatch2.h
@@ -0,0 +1,130 @@
+/** @file
+  SMM USB Dispatch2 Protocol as defined in PI 1.1 Specification
+  Volume 4 System Management Mode Core Interface.
+
+  Provides the parent dispatch service for the USB SMI source generator.
+
+  Copyright (c) 2009 - 2010, 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.
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.1.
+
+**/
+
+#ifndef _SMM_USB_DISPATCH2_H_
+#define _SMM_USB_DISPATCH2_H_
+
+#include <Pi/PiSmmCis.h>
+
+#define EFI_SMM_USB_DISPATCH2_PROTOCOL_GUID \
+  { \
+    0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 } \
+  }
+
+///
+/// USB SMI event types
+///
+typedef enum {
+  UsbLegacy,
+  UsbWake
+} EFI_USB_SMI_TYPE;
+
+///
+/// The dispatch function's context.
+///
+typedef struct {
+  ///
+  /// Describes whether this child handler will be invoked in response to a USB legacy 
+  /// emulation event, such as port-trap on the PS/2* keyboard control registers, or to a 
+  /// USB wake event, such as resumption from a sleep state.
+  ///
+  EFI_USB_SMI_TYPE          Type;
+  ///
+  /// The device path is part of the context structure and describes the location of the 
+  /// particular USB host controller in the system for which this register event will occur.
+  /// This location is important because of the possible integration of several USB host 
+  /// controllers in a system.
+  ///
+  EFI_DEVICE_PATH_PROTOCOL  *Device;
+} EFI_SMM_USB_REGISTER_CONTEXT;
+
+typedef struct _EFI_SMM_USB_DISPATCH2_PROTOCOL EFI_SMM_USB_DISPATCH2_PROTOCOL;
+
+/**
+  Provides the parent dispatch service for the USB SMI source generator.
+
+  This service registers a function (DispatchFunction) which will be called when the USB-
+  related SMI specified by RegisterContext has occurred. On return, DispatchHandle 
+  contains a unique handle which may be used later to unregister the function using UnRegister().
+  The DispatchFunction will be called with Context set to the same value as was passed into 
+  this function in RegisterContext and with CommBuffer containing NULL and 
+  CommBufferSize containing zero.
+
+  @param[in]  This               Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchFunction   Function to register for handler when a USB-related SMI occurs. 
+  @param[in]  RegisterContext    Pointer to the dispatch function's context.
+                                 The caller fills this context in before calling
+                                 the register function to indicate to the register
+                                 function the USB SMI types for which the dispatch
+                                 function should be invoked.
+  @param[out] DispatchHandle     Handle generated by the dispatcher to track the function instance.
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 registered and the SMI source has been enabled.
+  @retval EFI_DEVICE_ERROR       The driver was unable to enable the SMI source.
+  @retval EFI_INVALID_PARAMETER  RegisterContext is invalid. The USB SMI type
+                                 is not within valid range.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory (system or SMM) to manage this child.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_USB_REGISTER2)(
+  IN  CONST EFI_SMM_USB_DISPATCH2_PROTOCOL  *This,
+  IN        EFI_SMM_HANDLER_ENTRY_POINT2    DispatchFunction,
+  IN  CONST EFI_SMM_USB_REGISTER_CONTEXT    *RegisterContext,
+  OUT       EFI_HANDLE                      *DispatchHandle
+  );
+
+/**
+  Unregisters a USB service.
+
+  This service removes the handler associated with DispatchHandle so that it will no longer be 
+  called when the USB event occurs.
+
+  @param[in]  This               Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
+  @param[in]  DispatchHandle     Handle of the service to remove. 
+
+  @retval EFI_SUCCESS            The dispatch function has been successfully
+                                 unregistered and the SMI source has been disabled
+                                 if there are no other registered child dispatch
+                                 functions for this SMI source.
+  @retval EFI_INVALID_PARAMETER  The DispatchHandle was not valid.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SMM_USB_UNREGISTER2)(
+  IN CONST EFI_SMM_USB_DISPATCH2_PROTOCOL  *This,
+  IN       EFI_HANDLE                      DispatchHandle
+  );
+
+///
+/// Interface structure for the SMM USB SMI Dispatch2 Protocol
+///
+/// This protocol provides the parent dispatch service for the USB SMI source generator.
+///
+struct _EFI_SMM_USB_DISPATCH2_PROTOCOL {
+  EFI_SMM_USB_REGISTER2    Register;
+  EFI_SMM_USB_UNREGISTER2  UnRegister;
+};
+
+extern EFI_GUID gEfiSmmUsbDispatch2ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/StatusCode.h b/MdePkg/Include/Protocol/StatusCode.h
new file mode 100644
index 000000000000..d5c62260a01d
--- /dev/null
+++ b/MdePkg/Include/Protocol/StatusCode.h
@@ -0,0 +1,59 @@
+/** @file
+  Status code Runtime Protocol as defined in PI Specification 1.4a VOLUME 2 DXE
+
+  Copyright (c) 2006 - 2016, 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 __STATUS_CODE_RUNTIME_PROTOCOL_H__
+#define __STATUS_CODE_RUNTIME_PROTOCOL_H__
+
+#define EFI_STATUS_CODE_RUNTIME_PROTOCOL_GUID  \
+{ 0xd2b2b828, 0x826, 0x48a7,  { 0xb3, 0xdf, 0x98, 0x3c, 0x0, 0x60, 0x24, 0xf0 } }
+
+/**
+  Provides an interface that a software module can call to report a status code.
+
+  @param  Type             Indicates the type of status code being reported.
+  @param  Value            Describes the current status of a hardware or software entity.
+                           This included information about the class and subclass that is used to
+                           classify the entity as well as an operation.
+  @param  Instance         The enumeration of a hardware or software entity within
+                           the system. Valid instance numbers start with 1.
+  @param  CallerId         This optional parameter may be used to identify the caller.
+                           This parameter allows the status code driver to apply different rules to
+                           different callers.
+  @param  Data             This optional parameter may be used to pass additional data.
+
+  @retval EFI_SUCCESS           The function completed successfully
+  @retval EFI_DEVICE_ERROR      The function should not be completed due to a device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REPORT_STATUS_CODE)(
+  IN EFI_STATUS_CODE_TYPE     Type,
+  IN EFI_STATUS_CODE_VALUE    Value,
+  IN UINT32                   Instance,
+  IN EFI_GUID                 *CallerId  OPTIONAL,
+  IN EFI_STATUS_CODE_DATA     *Data      OPTIONAL
+  );
+
+///
+/// Provides the service required to report a status code to the platform firmware.
+/// This protocol must be produced by a runtime DXE driver.
+///
+typedef struct _EFI_STATUS_CODE_PROTOCOL {
+  EFI_REPORT_STATUS_CODE         ReportStatusCode;
+} EFI_STATUS_CODE_PROTOCOL;
+
+extern EFI_GUID gEfiStatusCodeRuntimeProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/StorageSecurityCommand.h b/MdePkg/Include/Protocol/StorageSecurityCommand.h
new file mode 100644
index 000000000000..3fa6cbcd8e3b
--- /dev/null
+++ b/MdePkg/Include/Protocol/StorageSecurityCommand.h
@@ -0,0 +1,212 @@
+/** @file
+  EFI Storage Security Command Protocol as defined in UEFI 2.3.1 specification.
+  This protocol is used to abstract mass storage devices to allow code running in
+  the EFI boot services environment to send security protocol commands to mass
+  storage devices without specific knowledge of the type of device or controller
+  that manages the device.
+
+  Copyright (c) 2011, 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 __STORAGE_SECURITY_COMMAND_H__
+#define __STORAGE_SECURITY_COMMAND_H__
+
+#define EFI_STORAGE_SECURITY_COMMAND_PROTOCOL_GUID \
+  { \
+    0xC88B0B6D, 0x0DFC, 0x49A7, {0x9C, 0xB4, 0x49, 0x07, 0x4B, 0x4C, 0x3A, 0x78 } \
+  }
+
+typedef struct _EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL;
+
+/**
+  Send a security protocol command to a device that receives data and/or the result
+  of one or more commands sent by SendData.
+
+  The ReceiveData function sends a security protocol command to the given MediaId.
+  The security protocol command sent is defined by SecurityProtocolId and contains
+  the security protocol specific data SecurityProtocolSpecificData. The function
+  returns the data from the security protocol command in PayloadBuffer.
+
+  For devices supporting the SCSI command set, the security protocol command is sent
+  using the SECURITY PROTOCOL IN command defined in SPC-4.
+
+  For devices supporting the ATA command set, the security protocol command is sent
+  using one of the TRUSTED RECEIVE commands defined in ATA8-ACS if PayloadBufferSize
+  is non-zero.
+
+  If the PayloadBufferSize is zero, the security protocol command is sent using the
+  Trusted Non-Data command defined in ATA8-ACS.
+
+  If PayloadBufferSize is too small to store the available data from the security
+  protocol command, the function shall copy PayloadBufferSize bytes into the
+  PayloadBuffer and return EFI_WARN_BUFFER_TOO_SMALL.
+
+  If PayloadBuffer or PayloadTransferSize is NULL and PayloadBufferSize is non-zero,
+  the function shall return EFI_INVALID_PARAMETER.
+
+  If the given MediaId does not support security protocol commands, the function shall
+  return EFI_UNSUPPORTED. If there is no media in the device, the function returns
+  EFI_NO_MEDIA. If the MediaId is not the ID for the current media in the device,
+  the function returns EFI_MEDIA_CHANGED.
+
+  If the security protocol fails to complete within the Timeout period, the function
+  shall return EFI_TIMEOUT.
+
+  If the security protocol command completes without an error, the function shall
+  return EFI_SUCCESS. If the security protocol command completes with an error, the
+  function shall return EFI_DEVICE_ERROR.
+
+  @param  This                         Indicates a pointer to the calling context.
+  @param  MediaId                      ID of the medium to receive data from.
+  @param  Timeout                      The timeout, in 100ns units, to use for the execution
+                                       of the security protocol command. A Timeout value of 0
+                                       means that this function will wait indefinitely for the
+                                       security protocol command to execute. If Timeout is greater
+                                       than zero, then this function will return EFI_TIMEOUT if the
+                                       time required to execute the receive data command is greater than Timeout.
+  @param  SecurityProtocolId           The value of the "Security Protocol" parameter of
+                                       the security protocol command to be sent.
+  @param  SecurityProtocolSpecificData The value of the "Security Protocol Specific" parameter
+                                       of the security protocol command to be sent.
+  @param  PayloadBufferSize            Size in bytes of the payload data buffer.
+  @param  PayloadBuffer                A pointer to a destination buffer to store the security
+                                       protocol command specific payload data for the security
+                                       protocol command. The caller is responsible for having
+                                       either implicit or explicit ownership of the buffer.
+  @param  PayloadTransferSize          A pointer to a buffer to store the size in bytes of the
+                                       data written to the payload data buffer.
+
+  @retval EFI_SUCCESS                  The security protocol command completed successfully.
+  @retval EFI_WARN_BUFFER_TOO_SMALL    The PayloadBufferSize was too small to store the available
+                                       data from the device. The PayloadBuffer contains the truncated data.
+  @retval EFI_UNSUPPORTED              The given MediaId does not support security protocol commands.
+  @retval EFI_DEVICE_ERROR             The security protocol command completed with an error.
+  @retval EFI_NO_MEDIA                 There is no media in the device.
+  @retval EFI_MEDIA_CHANGED            The MediaId is not for the current media.
+  @retval EFI_INVALID_PARAMETER        The PayloadBuffer or PayloadTransferSize is NULL and
+                                       PayloadBufferSize is non-zero.
+  @retval EFI_TIMEOUT                  A timeout occurred while waiting for the security
+                                       protocol command to execute.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORAGE_SECURITY_RECEIVE_DATA)(
+  IN EFI_STORAGE_SECURITY_COMMAND_PROTOCOL    *This,
+  IN UINT32                                   MediaId,
+  IN UINT64                                   Timeout,
+  IN UINT8                                    SecurityProtocolId,
+  IN UINT16                                   SecurityProtocolSpecificData,
+  IN UINTN                                    PayloadBufferSize,
+  OUT VOID                                    *PayloadBuffer,
+  OUT UINTN                                   *PayloadTransferSize
+  );
+
+/**
+  Send a security protocol command to a device.
+
+  The SendData function sends a security protocol command containing the payload
+  PayloadBuffer to the given MediaId. The security protocol command sent is
+  defined by SecurityProtocolId and contains the security protocol specific data
+  SecurityProtocolSpecificData. If the underlying protocol command requires a
+  specific padding for the command payload, the SendData function shall add padding
+  bytes to the command payload to satisfy the padding requirements.
+
+  For devices supporting the SCSI command set, the security protocol command is sent
+  using the SECURITY PROTOCOL OUT command defined in SPC-4.
+
+  For devices supporting the ATA command set, the security protocol command is sent
+  using one of the TRUSTED SEND commands defined in ATA8-ACS if PayloadBufferSize
+  is non-zero. If the PayloadBufferSize is zero, the security protocol command is
+  sent using the Trusted Non-Data command defined in ATA8-ACS.
+
+  If PayloadBuffer is NULL and PayloadBufferSize is non-zero, the function shall
+  return EFI_INVALID_PARAMETER.
+
+  If the given MediaId does not support security protocol commands, the function
+  shall return EFI_UNSUPPORTED. If there is no media in the device, the function
+  returns EFI_NO_MEDIA. If the MediaId is not the ID for the current media in the
+  device, the function returns EFI_MEDIA_CHANGED.
+
+  If the security protocol fails to complete within the Timeout period, the function
+  shall return EFI_TIMEOUT.
+
+  If the security protocol command completes without an error, the function shall return
+  EFI_SUCCESS. If the security protocol command completes with an error, the function
+  shall return EFI_DEVICE_ERROR.
+
+  @param  This                         Indicates a pointer to the calling context.
+  @param  MediaId                      ID of the medium to receive data from.
+  @param  Timeout                      The timeout, in 100ns units, to use for the execution
+                                       of the security protocol command. A Timeout value of 0
+                                       means that this function will wait indefinitely for the
+                                       security protocol command to execute. If Timeout is greater
+                                       than zero, then this function will return EFI_TIMEOUT if the 
+                                       time required to execute the receive data command is greater than Timeout.
+  @param  SecurityProtocolId           The value of the "Security Protocol" parameter of
+                                       the security protocol command to be sent.
+  @param  SecurityProtocolSpecificData The value of the "Security Protocol Specific" parameter
+                                       of the security protocol command to be sent.
+  @param  PayloadBufferSize            Size in bytes of the payload data buffer.
+  @param  PayloadBuffer                A pointer to a destination buffer to store the security
+                                       protocol command specific payload data for the security
+                                       protocol command.
+
+  @retval EFI_SUCCESS                  The security protocol command completed successfully.
+  @retval EFI_UNSUPPORTED              The given MediaId does not support security protocol commands.
+  @retval EFI_DEVICE_ERROR             The security protocol command completed with an error.
+  @retval EFI_NO_MEDIA                 There is no media in the device.
+  @retval EFI_MEDIA_CHANGED            The MediaId is not for the current media.
+  @retval EFI_INVALID_PARAMETER        The PayloadBuffer is NULL and PayloadBufferSize is non-zero.
+  @retval EFI_TIMEOUT                  A timeout occurred while waiting for the security
+                                       protocol command to execute.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORAGE_SECURITY_SEND_DATA) (
+  IN EFI_STORAGE_SECURITY_COMMAND_PROTOCOL    *This,
+  IN UINT32                                   MediaId,
+  IN UINT64                                   Timeout,
+  IN UINT8                                    SecurityProtocolId,
+  IN UINT16                                   SecurityProtocolSpecificData,
+  IN UINTN                                    PayloadBufferSize,
+  IN VOID                                     *PayloadBuffer
+);
+
+///
+/// The EFI_STORAGE_SECURITY_COMMAND_PROTOCOL is used to send security protocol
+/// commands to a mass storage device. Two types of security protocol commands
+/// are supported. SendData sends a command with data to a device. ReceiveData
+/// sends a command that receives data and/or the result of one or more commands
+/// sent by SendData.
+///
+/// The security protocol command formats supported shall be based on the definition
+/// of the SECURITY PROTOCOL IN and SECURITY PROTOCOL OUT commands defined in SPC-4.
+/// If the device uses the SCSI command set, no translation is needed in the firmware
+/// and the firmware can package the parameters into a SECURITY PROTOCOL IN or SECURITY
+/// PROTOCOL OUT command and send the command to the device. If the device uses a
+/// non-SCSI command set, the firmware shall map the command and data payload to the
+/// corresponding command and payload format defined in the non-SCSI command set
+/// (for example, TRUSTED RECEIVE and TRUSTED SEND in ATA8-ACS).
+///
+/// The firmware shall automatically add an EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
+/// for any storage devices detected during system boot that support SPC-4, ATA8-ACS
+/// or their successors.
+///
+struct _EFI_STORAGE_SECURITY_COMMAND_PROTOCOL {
+  EFI_STORAGE_SECURITY_RECEIVE_DATA ReceiveData;
+  EFI_STORAGE_SECURITY_SEND_DATA    SendData;
+};
+
+extern EFI_GUID gEfiStorageSecurityCommandProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/SuperIo.h b/MdePkg/Include/Protocol/SuperIo.h
new file mode 100644
index 000000000000..f9714e2d1f87
--- /dev/null
+++ b/MdePkg/Include/Protocol/SuperIo.h
@@ -0,0 +1,175 @@
+/** @file
+  The Super I/O Protocol is installed by the Super I/O driver. The Super I/O driver is a UEFI driver
+  model compliant driver. In the Start() routine of the Super I/O driver, a handle with an instance
+  of EFI_SIO_PROTOCOL is created for each device within the Super I/O. The device within the
+  Super I/O is powered up, enabled, and assigned with the default set of resources. In the Stop()
+  routine of the Super I/O driver, the device is disabled and Super I/O protocol is uninstalled.
+
+  Copyright (c) 2006 - 2010, 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 __EFI_SUPER_IO_PROTOCOL_H__
+#define __EFI_SUPER_IO_PROTOCOL_H__
+#include <IndustryStandard/Acpi.h>
+
+#define EFI_SIO_PROTOCOL_GUID \
+  { 0x215fdd18, 0xbd50, 0x4feb, { 0x89, 0xb, 0x58, 0xca, 0xb, 0x47, 0x39, 0xe9 } }
+
+typedef union {
+  ACPI_SMALL_RESOURCE_HEADER *SmallHeader;
+  ACPI_LARGE_RESOURCE_HEADER *LargeHeader;
+} ACPI_RESOURCE_HEADER_PTR;
+
+typedef struct {
+  UINT8 Register;       ///< Register number.
+  UINT8 AndMask;        ///< Bitwise AND mask.
+  UINT8 OrMask;         ///< Bitwise OR mask.
+} EFI_SIO_REGISTER_MODIFY;
+  
+typedef struct _EFI_SIO_PROTOCOL  EFI_SIO_PROTOCOL;
+  
+/**
+  Provides a low level access to the registers for the Super I/O.
+  
+  @param[in]        This        Indicates a pointer to the calling context.
+  @param[in]        Write       Specifies the type of the register operation. If this parameter is TRUE, Value is
+                                interpreted as an input parameter and the operation is a register write. If this parameter
+                                is FALSE, Value is interpreted as an output parameter and the operation is a register
+                                read.
+  @param[in]        ExitCfgMode Exit Configuration Mode Indicator. If this parameter is set to TRUE, the Super I/O
+                                driver will turn off configuration mode of the Super I/O prior to returning from this
+                                function. If this parameter is set to FALSE, the Super I/O driver will leave Super I/O
+                                in the configuration mode.
+                                The Super I/O driver must track the current state of the Super I/O and enable the
+                                configuration mode of Super I/O if necessary prior to register access.
+  @param[in]        Register    Register number.
+  @param[in, out]   Value       If Write is TRUE, Value is a pointer to the buffer containing the byte of data to be
+                                written to the Super I/O register. If Write is FALSE, Value is a pointer to the
+                                destination buffer for the byte of data to be read from the Super I/O register. 
+
+  @retval EFI_SUCCESS           The operation completed successfully
+  @retval EFI_INVALID_PARAMETER The Value is NULL
+  @retval EFI_INVALID_PARAMETER Invalid Register number
+  
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_REGISTER_ACCESS)(
+  IN   CONST  EFI_SIO_PROTOCOL  *This,
+  IN          BOOLEAN           Write,
+  IN          BOOLEAN           ExitCfgMode,
+  IN          UINT8             Register,
+  IN OUT      UINT8             *Value
+);
+  
+/**
+  Provides an interface to get a list of the current resources consumed by the device in the ACPI
+  Resource Descriptor format.
+  
+  GetResources() returns a list of resources currently consumed by the device. The
+  ResourceList is a pointer to the buffer containing resource descriptors for the device. The
+  descriptors are in the format of Small or Large ACPI resource descriptor as defined by ACPI
+  specification (2.0 & 3.0). The buffer of resource descriptors is terminated with the 'End tag'
+  resource descriptor.
+  
+  @param[in]    This            Indicates a pointer to the calling context.
+  @param[out]   ResourceList    A pointer to an ACPI resource descriptor list that defines the current resources used by
+                                the device. Type ACPI_RESOURCE_HEADER_PTR is defined in the "Related
+                                Definitions" below.
+                                
+  @retval EFI_SUCCESS           The operation completed successfully
+  @retval EFI_INVALID_PARAMETER ResourceList is NULL
+                                
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_GET_RESOURCES)(
+  IN  CONST EFI_SIO_PROTOCOL            *This,
+  OUT       ACPI_RESOURCE_HEADER_PTR    *ResourceList
+);
+  
+/**
+  Sets the resources for the device.
+  
+  @param[in]  This          Indicates a pointer to the calling context.
+  @param[in]  ResourceList  Pointer to the ACPI resource descriptor list. Type ACPI_RESOURCE_HEADER_PTR
+                            is defined in the "Related Definitions" section of
+                            EFI_SIO_PROTOCOL.GetResources().
+
+  @retval EFI_SUCCESS           The operation completed successfully
+  @retval EFI_INVALID_PARAMETER ResourceList is invalid
+  @retval EFI_ACCESS_DENIED     Some of the resources in ResourceList are in use
+                            
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_SET_RESOURCES)(
+  IN CONST  EFI_SIO_PROTOCOL        *This,
+  IN        ACPI_RESOURCE_HEADER_PTR ResourceList
+);
+  
+/**
+  Provides a collection of resource descriptor lists. Each resource descriptor list in the collection
+  defines a combination of resources that can potentially be used by the device.
+  
+  @param[in]  This                  Indicates a pointer to the calling context.
+  @param[out] ResourceCollection    Collection of the resource descriptor lists.
+  
+  @retval EFI_SUCCESS               The operation completed successfully
+  @retval EFI_INVALID_PARAMETER     ResourceCollection is NULL
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_POSSIBLE_RESOURCES)(
+  IN  CONST EFI_SIO_PROTOCOL         *This,
+  OUT       ACPI_RESOURCE_HEADER_PTR *ResourceCollection
+);
+  
+/**
+  Provides an interface for a table based programming of the Super I/O registers.
+  
+  The Modify() function provides an interface for table based programming of the Super I/O
+  registers. This function can be used to perform programming of multiple Super I/O registers with a
+  single function call. For each table entry, the Register is read, its content is bitwise ANDed with
+  AndMask, and then ORed with OrMask before being written back to the Register. The Super
+  I/O driver must track the current state of the Super I/O and enable the configuration mode of Super I/
+  O if necessary prior to table processing. Once the table is processed, the Super I/O device has to be
+  returned to the original state.
+
+  @param[in] This       Indicates a pointer to the calling context.
+  @param[in] Command    A pointer to an array of NumberOfCommands EFI_SIO_REGISTER_MODIFY
+                        structures. Each structure specifies a single Super I/O register modify operation. Type
+                        EFI_SIO_REGISTER_MODIFY is defined in the "Related Definitions" below.
+  @param[in] NumberOfCommands Number of elements in the Command array.  
+  
+  @retval EFI_SUCCESS           The operation completed successfully
+  @retval EFI_INVALID_PARAMETER Command is NULL
+  
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_MODIFY)(
+  IN CONST EFI_SIO_PROTOCOL         *This,
+  IN CONST EFI_SIO_REGISTER_MODIFY  *Command,
+  IN       UINTN                    NumberOfCommands
+);
+  
+struct _EFI_SIO_PROTOCOL {
+  EFI_SIO_REGISTER_ACCESS       RegisterAccess;
+  EFI_SIO_GET_RESOURCES         GetResources;
+  EFI_SIO_SET_RESOURCES         SetResources;
+  EFI_SIO_POSSIBLE_RESOURCES    PossibleResources;
+  EFI_SIO_MODIFY Modify;
+};  
+
+extern EFI_GUID gEfiSioProtocolGuid;
+
+#endif // __EFI_SUPER_IO_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/SuperIoControl.h b/MdePkg/Include/Protocol/SuperIoControl.h
new file mode 100644
index 000000000000..0bcfb5a47388
--- /dev/null
+++ b/MdePkg/Include/Protocol/SuperIoControl.h
@@ -0,0 +1,92 @@
+/** @file
+  The Super I/O Control Protocol is installed by the Super I/O driver. It provides
+  the low-level services for SIO devices that enable them to be used in the UEFI
+  driver model.
+
+  Copyright (c) 2015, 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.             
+
+  @par Revision Reference:
+  This protocol is from PI Version 1.2.1.
+
+**/
+
+#ifndef __EFI_SUPER_IO_CONTROL_PROTOCOL_H__
+#define __EFI_SUPER_IO_CONTROL_PROTOCOL_H__
+
+#define EFI_SIO_CONTROL_PROTOCOL_GUID \
+  { \
+    0xb91978df, 0x9fc1, 0x427d, { 0xbb, 0x5, 0x4c, 0x82, 0x84, 0x55, 0xca, 0x27 } \
+  }
+
+typedef struct _EFI_SIO_CONTROL_PROTOCOL EFI_SIO_CONTROL_PROTOCOL;
+typedef struct _EFI_SIO_CONTROL_PROTOCOL *PEFI_SIO_CONTROL_PROTOCOL;
+
+/**
+  Enable an ISA-style device.
+
+  This function enables a logical ISA device and, if necessary, configures it
+  to default settings, including memory, I/O, DMA and IRQ resources.
+
+  @param This A pointer to this instance of the EFI_SIO_CONTROL_PROTOCOL.
+
+  @retval EFI_SUCCESS          The device is enabled successfully.
+  @retval EFI_OUT_OF_RESOURCES The device could not be enabled because there
+                               were insufficient resources either for the device 
+                               itself or for the records needed to track the device.
+  @retval EFI_ALREADY_STARTED  The device is already enabled.
+  @retval EFI_UNSUPPORTED      The device cannot be enabled.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_CONTROL_ENABLE)(
+  IN CONST EFI_SIO_CONTROL_PROTOCOL *This
+  );
+
+/**
+  Disable a logical ISA device.
+
+  This function disables a logical ISA device so that it no longer consumes
+  system resources, such as memory, I/O, DMA and IRQ resources. Enough information
+  must be available so that subsequent Enable() calls would properly reconfigure
+  the device.
+
+  @param This A pointer to this instance of the EFI_SIO_CONTROL_PROTOCOL.
+
+  @retval EFI_SUCCESS          The device is disabled successfully.
+  @retval EFI_OUT_OF_RESOURCES The device could not be disabled because there
+                               were insufficient resources either for the device 
+                               itself or for the records needed to track the device.
+  @retval EFI_ALREADY_STARTED  The device is already disabled.
+  @retval EFI_UNSUPPORTED      The device cannot be disabled.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIO_CONTROL_DISABLE)(
+  IN CONST EFI_SIO_CONTROL_PROTOCOL *This
+  );
+
+struct _EFI_SIO_CONTROL_PROTOCOL {
+  ///
+  /// The version of this protocol.
+  ///
+  UINT32                  Version;
+  ///
+  /// Enable a device.
+  ///
+  EFI_SIO_CONTROL_ENABLE  EnableDevice;
+  ///
+  /// Disable a device.
+  ///
+  EFI_SIO_CONTROL_DISABLE DisableDevice;
+};
+
+extern EFI_GUID gEfiSioControlProtocolGuid;
+
+#endif // __EFI_SUPER_IO_CONTROL_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/Supplicant.h b/MdePkg/Include/Protocol/Supplicant.h
new file mode 100644
index 000000000000..6376823c29ed
--- /dev/null
+++ b/MdePkg/Include/Protocol/Supplicant.h
@@ -0,0 +1,460 @@
+/** @file
+  This file defines the EFI Supplicant Protocol.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.6
+
+**/
+
+#ifndef __EFI_SUPPLICANT_PROTOCOL_H__
+#define __EFI_SUPPLICANT_PROTOCOL_H__
+
+#include <Protocol/WiFi2.h>
+
+///
+/// The EFI Supplicant Service Binding Protocol is used to locate EFI
+/// Supplicant Protocol drivers to create and destroy child of the driver to
+/// communicate with other host using Supplicant protocol.
+///
+#define EFI_SUPPLICANT_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x45bcd98e, 0x59ad, 0x4174, { 0x95, 0x46, 0x34, 0x4a, 0x7, 0x48, 0x58, 0x98 } \
+  }
+
+///
+/// The EFI Supplicant protocol provides services to process authentication and
+/// data encryption/decryption for security management.
+///
+#define EFI_SUPPLICANT_PROTOCOL_GUID \
+  { \
+    0x54fcc43e, 0xaa89, 0x4333, { 0x9a, 0x85, 0xcd, 0xea, 0x24, 0x5, 0x1e, 0x9e } \
+  }
+
+typedef struct _EFI_SUPPLICANT_PROTOCOL EFI_SUPPLICANT_PROTOCOL;
+
+///
+/// EFI_SUPPLICANT_CRYPT_MODE
+///
+typedef enum {
+  //
+  // Encrypt data provided in the fragment buffers.
+  //
+  EfiSupplicantEncrypt,
+  //
+  // Decrypt data provided in the fragment buffers.
+  //
+  EfiSupplicantDecrypt,
+} EFI_SUPPLICANT_CRYPT_MODE;
+
+///
+/// EFI_SUPPLICANT_DATA_TYPE
+///
+typedef enum {
+  //
+  // Session Configuration
+  //
+
+  //
+  // Current authentication type in use. The corresponding Data is of type
+  // EFI_80211_AKM_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211AKMSuite,
+  //
+  // Group data encryption type in use. The corresponding Data is of type
+  // EFI_SUPPLICANT_CIPHER_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211GroupDataCipherSuite,
+  //
+  // Pairwise encryption type in use. The corresponding Data is of type
+  // EFI_80211_CIPHER_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211PairwiseCipherSuite,
+  //
+  // PSK password. The corresponding Data is a NULL-terminated ASCII string.
+  //
+  EfiSupplicant80211PskPassword,
+  //
+  // Target SSID name. The corresponding Data is of type EFI_80211_SSID.
+  //
+  EfiSupplicant80211TargetSSIDName,
+  //
+  // Station MAC address. The corresponding Data is of type
+  // EFI_80211_MAC_ADDRESS.
+  //
+  EfiSupplicant80211StationMac,
+  //
+  // Target SSID MAC address. The corresponding Data is 6 bytes MAC address.
+  //
+  EfiSupplicant80211TargetSSIDMac,
+
+  //
+  // Session Information
+  //
+
+  //
+  // 802.11 PTK. The corresponding Data is of type EFI_SUPPLICANT_KEY.
+  //
+  EfiSupplicant80211PTK,
+  //
+  // 802.11 GTK. The corresponding Data is of type EFI_SUPPLICANT_GTK_LIST.
+  //
+  EfiSupplicant80211GTK,
+  //
+  // Supplicant state. The corresponding Data is
+  // EFI_EAPOL_SUPPLICANT_PAE_STATE.
+  //
+  EfiSupplicantState,
+  //
+  // 802.11 link state. The corresponding Data is EFI_80211_LINK_STATE.
+  //
+  EfiSupplicant80211LinkState,
+  //
+  // Flag indicates key is refreshed. The corresponding Data is
+  // EFI_SUPPLICANT_KEY_REFRESH.
+  //
+  EfiSupplicantKeyRefresh,
+
+  //
+  // Session Configuration
+  //
+
+  //
+  // Supported authentication types. The corresponding Data is of type
+  // EFI_80211_AKM_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211SupportedAKMSuites,
+  //
+  // Supported software encryption types provided by supplicant driver. The
+  // corresponding Data is of type EFI_80211_CIPHER_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211SupportedSoftwareCipherSuites,
+  //
+  // Supported hardware encryption types provided by wireless UNDI driver. The
+  // corresponding Data is of type EFI_80211_CIPHER_SUITE_SELECTOR.
+  //
+  EfiSupplicant80211SupportedHardwareCipherSuites,
+
+  //
+  // Session Information
+  //
+
+  //
+  // 802.11 Integrity GTK. The corresponding Data is of type
+  // EFI_SUPPLICANT_GTK_LIST.
+  //
+  EfiSupplicant80211IGTK,
+  EfiSupplicantDataTypeMaximum
+} EFI_SUPPLICANT_DATA_TYPE;
+
+///
+/// EFI_80211_LINK_STATE
+///
+typedef enum {
+  //
+  // Indicates initial start state, unauthenticated, unassociated.
+  //
+  Ieee80211UnauthenticatedUnassociated,
+  //
+  // Indicates authenticated, unassociated.
+  //
+  Ieee80211AuthenticatedUnassociated,
+  //
+  // Indicates authenticated and associated, but pending RSN authentication.
+  //
+  Ieee80211PendingRSNAuthentication,
+  //
+  // Indicates authenticated and associated.
+  //
+  Ieee80211AuthenticatedAssociated
+} EFI_80211_LINK_STATE;
+
+///
+/// EFI_SUPPLICANT_KEY_TYPE (IEEE Std 802.11 Section 6.3.19.1.2)
+///
+typedef enum {
+  Group,
+  Pairwise,
+  PeerKey,
+  IGTK
+} EFI_SUPPLICANT_KEY_TYPE;
+
+///
+/// EFI_SUPPLICANT_KEY_DIRECTION (IEEE Std 802.11 Section 6.3.19.1.2)
+///
+typedef enum {
+  //
+  // Indicates that the keys are being installed for the receive direction.
+  //
+  Receive,
+  //
+  // Indicates that the keys are being installed for the transmit direction.
+  //
+  Transmit,
+  //
+  // Indicates that the keys are being installed for both the receive and
+  // transmit directions.
+  //
+  Both
+} EFI_SUPPLICANT_KEY_DIRECTION;
+
+///
+/// EFI_SUPPLICANT_KEY_REFRESH
+///
+typedef struct {
+  //
+  // If TRUE, indicates GTK is just refreshed after a successful call to
+  // EFI_SUPPLICANT_PROTOCOL.BuildResponsePacket().
+  //
+  BOOLEAN                                 GTKRefresh;
+} EFI_SUPPLICANT_KEY_REFRESH;
+
+#define EFI_MAX_KEY_LEN 64
+
+///
+/// EFI_SUPPLICANT_KEY
+///
+typedef struct {
+  //
+  // The key value.
+  //
+  UINT8                                   Key[EFI_MAX_KEY_LEN];
+  //
+  // Length in bytes of the Key. Should be up to EFI_MAX_KEY_LEN.
+  //
+  UINT8                                   KeyLen;
+  //
+  // The key identifier.
+  //
+  UINT8                                   KeyId;
+  //
+  // Defines whether this key is a group key, pairwise key, PeerKey, or
+  // Integrity Group.
+  //
+  EFI_SUPPLICANT_KEY_TYPE                 KeyType;
+  //
+  // The value is set according to the KeyType.
+  //
+  EFI_80211_MAC_ADDRESS                   Addr;
+  //
+  // The Receive Sequence Count value.
+  //
+  UINT8                                   Rsc[8];
+  //
+  // Length in bytes of the Rsc. Should be up to 8.
+  //
+  UINT8                                   RscLen;
+  //
+  // Indicates whether the key is configured by the Authenticator or
+  // Supplicant. The value true indicates Authenticator.
+  //
+  BOOLEAN                                 IsAuthenticator;
+  //
+  // The cipher suite required for this association.
+  //
+  EFI_80211_SUITE_SELECTOR                CipherSuite;
+  //
+  // Indicates the direction for which the keys are to be installed.
+  //
+  EFI_SUPPLICANT_KEY_DIRECTION            Direction;
+} EFI_SUPPLICANT_KEY;
+
+///
+/// EFI_SUPPLICANT_GTK_LIST
+///
+typedef struct {
+  //
+  // Indicates the number of GTKs that are contained in GTKList.
+  //
+  UINT8                                   GTKCount;
+  //
+  // A variable-length array of GTKs of type EFI_SUPPLICANT_KEY. The number of
+  // entries is specified by GTKCount.
+  //
+  EFI_SUPPLICANT_KEY                      GTKList[1];
+} EFI_SUPPLICANT_GTK_LIST;
+
+///
+/// EFI_SUPPLICANT_FRAGMENT_DATA
+///
+typedef struct {
+  //
+  // Length of data buffer in the fragment.
+  //
+  UINT32                                  FragmentLength;
+  //
+  // Pointer to the data buffer in the fragment.
+  //
+  VOID                                    *FragmentBuffer;
+} EFI_SUPPLICANT_FRAGMENT_DATA;
+
+/**
+  BuildResponsePacket() is called during STA and AP authentication is in
+  progress. Supplicant derives the PTK or session keys depend on type of
+  authentication is being employed.
+
+  @param[in]       This           Pointer to the EFI_SUPPLICANT_PROTOCOL
+                                  instance.
+  @param[in]       RequestBuffer  Pointer to the most recently received EAPOL
+                                  packet. NULL means the supplicant need
+                                  initiate the EAP authentication session and
+                                  send EAPOL-Start message.
+  @param[in]       RequestBufferSize
+                                  Packet size in bytes for the most recently
+                                  received EAPOL packet. 0 is only valid when
+                                  RequestBuffer is NULL.
+  @param[out]      Buffer         Pointer to the buffer to hold the built
+                                  packet.
+  @param[in, out]  BufferSize     Pointer to the buffer size in bytes. On
+                                  input, it is the buffer size provided by the
+                                  caller. On output, it is the buffer size in
+                                  fact needed to contain the packet.
+
+  @retval EFI_SUCCESS             The required EAPOL packet is built
+                                  successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  RequestBuffer is NULL, but RequestSize is
+                                  NOT 0.
+                                  RequestBufferSize is 0.
+                                  Buffer is NULL, but RequestBuffer is NOT 0.
+                                  BufferSize is NULL.
+  @retval EFI_BUFFER_TOO_SMALL    BufferSize is too small to hold the response
+                                  packet.
+  @retval EFI_NOT_READY           Current EAPOL session state is NOT ready to
+                                  build ResponsePacket.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SUPPLICANT_BUILD_RESPONSE_PACKET) (
+  IN     EFI_SUPPLICANT_PROTOCOL          *This,
+  IN     UINT8                            *RequestBuffer,     OPTIONAL
+  IN     UINTN                            RequestBufferSize,  OPTIONAL
+     OUT UINT8                            *Buffer,
+  IN OUT UINTN                            *BufferSize
+  );
+
+/**
+  ProcessPacket() is called to Supplicant driver to encrypt or decrypt the data
+  depending type of authentication type.
+
+  @param[in]       This           Pointer to the EFI_SUPPLICANT_PROTOCOL
+                                  instance.
+  @param[in, out]  FragmentTable  Pointer to a list of fragment. The caller
+                                  will take responsible to handle the original
+                                  FragmentTable while it may be reallocated in
+                                  Supplicant driver.
+  @param[in]       FragmentCount  Number of fragment.
+  @param[in]       CryptMode      Crypt mode.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  FragmentTable is NULL.
+                                  FragmentCount is NULL.
+                                  CryptMode is invalid.
+  @retval EFI_NOT_READY           Current supplicant state is NOT Authenticated.
+  @retval EFI_ABORTED             Something wrong decryption the message.
+  @retval EFI_UNSUPPORTED         This API is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SUPPLICANT_PROCESS_PACKET) (
+  IN     EFI_SUPPLICANT_PROTOCOL          *This,
+  IN OUT EFI_SUPPLICANT_FRAGMENT_DATA     **FragmentTable,
+  IN     UINT32                           *FragmentCount,
+  IN     EFI_SUPPLICANT_CRYPT_MODE        CryptMode
+  );
+
+/**
+  Set Supplicant configuration data.
+
+  @param[in]  This                Pointer to the EFI_SUPPLICANT_PROTOCOL
+                                  instance.
+  @param[in]  DataType            The type of data.
+  @param[in]  Data                Pointer to the buffer to hold the data.
+  @param[in]  DataSize            Pointer to the buffer size in bytes.
+
+  @retval EFI_SUCCESS             The Supplicant configuration data is set
+                                  successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  Data is NULL.
+                                  DataSize is 0.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SUPPLICANT_SET_DATA) (
+  IN EFI_SUPPLICANT_PROTOCOL              *This,
+  IN EFI_SUPPLICANT_DATA_TYPE             DataType,
+  IN VOID                                 *Data,
+  IN UINTN                                DataSize
+  );
+
+/**
+  Get Supplicant configuration data.
+
+  @param[in]       This           Pointer to the EFI_SUPPLICANT_PROTOCOL
+                                  instance.
+  @param[in]       DataType       The type of data.
+  @param[out]      Data           Pointer to the buffer to hold the data.
+                                  Ignored if DataSize is 0.
+  @param[in, out]  DataSize       Pointer to the buffer size in bytes. On
+                                  input, it is the buffer size provided by the
+                                  caller. On output, it is the buffer size in
+                                  fact needed to contain the packet.
+
+  @retval EFI_SUCCESS             The Supplicant configuration data is got
+                                  successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  This is NULL.
+                                  DataSize is NULL.
+                                  Data is NULL if *DataSize is not zero.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_NOT_FOUND           The Supplicant configuration data is not
+                                  found.
+  @retval EFI_BUFFER_TOO_SMALL    The size of Data is too small for the
+                                  specified configuration data and the required
+                                  size is returned in DataSize.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SUPPLICANT_GET_DATA) (
+  IN     EFI_SUPPLICANT_PROTOCOL          *This,
+  IN     EFI_SUPPLICANT_DATA_TYPE         DataType,
+     OUT UINT8                            *Data,     OPTIONAL
+  IN OUT UINTN                            *DataSize
+  );
+
+///
+/// The EFI_SUPPLICANT_PROTOCOL is designed to provide unified place for WIFI
+/// and EAP security management. Both PSK authentication and 802.1X EAP
+/// authentication can be managed via this protocol and driver or application
+/// as a consumer can only focus on about packet transmitting or receiving.
+///
+struct _EFI_SUPPLICANT_PROTOCOL {
+  EFI_SUPPLICANT_BUILD_RESPONSE_PACKET    BuildResponsePacket;
+  EFI_SUPPLICANT_PROCESS_PACKET           ProcessPacket;
+  EFI_SUPPLICANT_SET_DATA                 SetData;
+  EFI_SUPPLICANT_GET_DATA                 GetData;
+};
+
+extern EFI_GUID gEfiSupplicantServiceBindingProtocolGuid;
+extern EFI_GUID gEfiSupplicantProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/TapeIo.h b/MdePkg/Include/Protocol/TapeIo.h
new file mode 100644
index 000000000000..74c7b3f6587d
--- /dev/null
+++ b/MdePkg/Include/Protocol/TapeIo.h
@@ -0,0 +1,237 @@
+/** @file
+  EFI_TAPE_IO_PROTOCOL as defined in the UEFI 2.0.
+  Provide services to control and access a tape device.
+
+Copyright (c) 2006 - 2010, 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_TAPE_IO_PROTOCOL_H__
+#define __EFI_TAPE_IO_PROTOCOL_H__
+
+#define EFI_TAPE_IO_PROTOCOL_GUID \
+  { \
+    0x1e93e633, 0xd65a, 0x459e, {0xab, 0x84, 0x93, 0xd9, 0xec, 0x26, 0x6d, 0x18 } \
+  }
+
+typedef struct _EFI_TAPE_IO_PROTOCOL EFI_TAPE_IO_PROTOCOL;
+
+typedef struct _EFI_TAPE_HEADER {
+  UINT64     Signature;
+  UINT32     Revision;
+  UINT32     BootDescSize;
+  UINT32     BootDescCRC;
+  EFI_GUID   TapeGUID;
+  EFI_GUID   TapeType;
+  EFI_GUID   TapeUnique;
+  UINT32     BLLocation;
+  UINT32     BLBlocksize;
+  UINT32     BLFilesize;
+  CHAR8      OSVersion[40];
+  CHAR8      AppVersion[40];
+  CHAR8      CreationDate[10];
+  CHAR8      CreationTime[10];
+  CHAR8      SystemName[256];  // UTF-8
+  CHAR8      TapeTitle[120];   // UTF-8
+  CHAR8      pad[468];         // pad to 1024
+} EFI_TAPE_HEADER;
+
+/**
+  Reads from the tape.
+
+  @param  This       A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+  @param  BufferSize The size of the buffer in bytes pointed to by Buffer.
+  @param  Buffer     The pointer to the buffer for data to be read into.
+
+  @retval EFI_SUCCESS           Data was successfully transferred from the media.
+  @retval EFI_END_OF_FILE       A filemark was encountered which limited the data
+                                transferred by the read operation or the head is positioned
+                                just after a filemark.
+  @retval EFI_NO_MEDIA          No media is loaded in the device.
+  @retval EFI_NOT_READY         The transfer failed since the device was not ready (e.g. not
+                                online). The transfer may be retried at a later time.
+  @retval EFI_UNSUPPORTED       The device does not support this type of transfer.
+  @retval EFI_TIMEOUT           The transfer failed to complete within the timeout specified.
+  @retval EFI_MEDIA_CHANGED     The media in the device was changed since the last access.
+                                The transfer was aborted since the current position of the
+                                media may be incorrect.
+  @retval EFI_INVALID_PARAMETER A NULL Buffer was specified with a non-zero
+                                BufferSize, or the device is operating in fixed block
+                                size mode and the BufferSize was not a multiple of
+                                device's fixed block size
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to transfer data
+                                from the media.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TAPE_READ)(
+  IN EFI_TAPE_IO_PROTOCOL *This,
+  IN OUT UINTN            *BufferSize,
+  OUT VOID                *Buffer
+  );    
+
+/**
+  Writes to the tape.
+
+  @param  This       A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+  @param  BufferSize Size of the buffer in bytes pointed to by Buffer.
+  @param  Buffer     The pointer to the buffer for data to be written from.
+
+  @retval EFI_SUCCESS           Data was successfully transferred to the media.
+  @retval EFI_END_OF_MEDIA      The logical end of media has been reached. Data may have
+                                been successfully transferred to the media.
+  @retval EFI_NO_MEDIA          No media is loaded in the device.
+  @retval EFI_NOT_READY         The transfer failed since the device was not ready (e.g. not
+                                online). The transfer may be retried at a later time.
+  @retval EFI_UNSUPPORTED       The device does not support this type of transfer.
+  @retval EFI_TIMEOUT           The transfer failed to complete within the timeout specified.
+  @retval EFI_MEDIA_CHANGED     The media in the device was changed since the last access.
+                                The transfer was aborted since the current position of the
+                                media may be incorrect.
+  @retval EFI_WRITE_PROTECTED   The media in the device is write-protected. The transfer
+                                was aborted since a write cannot be completed.
+  @retval EFI_INVALID_PARAMETER A NULL Buffer was specified with a non-zero
+                                BufferSize, or the device is operating in fixed block
+                                size mode and the BufferSize was not a multiple of
+                                device's fixed block size
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to transfer data
+                                from the media.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TAPE_WRITE)(
+  IN EFI_TAPE_IO_PROTOCOL *This,
+  IN UINTN                *BufferSize,
+  IN VOID                 *Buffer
+  ); 
+  
+
+/**
+  Rewinds the tape.
+
+  @param  This A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+
+  @retval EFI_SUCCESS      The media was successfully repositioned.
+  @retval EFI_NO_MEDIA     No media is loaded in the device.
+  @retval EFI_NOT_READY    Repositioning the media failed since the device was not
+                           ready (e.g. not online). The transfer may be retried at a later time.
+  @retval EFI_UNSUPPORTED  The device does not support this type of media repositioning.
+  @retval EFI_TIMEOUT      Repositioning of the media did not complete within the timeout specified.
+  @retval EFI_DEVICE_ERROR A device error occurred while attempting to reposition the media.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TAPE_REWIND)(
+  IN EFI_TAPE_IO_PROTOCOL *This
+  );   
+
+
+/**
+  Positions the tape.
+
+  @param  This      A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+  @param  Direction Direction and number of data blocks or filemarks to space over on media.
+  @param  Type      Type of mark to space over on media.
+                    The following Type marks are mandatory:
+                    BLOCK type    : 0 
+                    FILEMARK type : 1
+
+  @retval EFI_SUCCESS       The media was successfully repositioned.
+  @retval EFI_END_OF_MEDIA  Beginning or end of media was reached before the
+                            indicated number of data blocks or filemarks were found.
+  @retval EFI_NO_MEDIA      No media is loaded in the device.
+  @retval EFI_NOT_READY     The reposition failed since the device was not ready (e.g. not
+                            online). The reposition may be retried at a later time.
+  @retval EFI_UNSUPPORTED   The device does not support this type of repositioning.
+  @retval EFI_TIMEOUT       The repositioning failed to complete within the timeout specified.
+  @retval EFI_MEDIA_CHANGED The media in the device was changed since the last access.
+                            Repositioning the media was aborted since the current
+                            position of the media may be incorrect.
+  @retval EFI_DEVICE_ERROR  A device error occurred while attempting to reposition the media.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TAPE_SPACE)(
+  IN EFI_TAPE_IO_PROTOCOL *This,
+  IN INTN                 Direction,
+  IN UINTN                Type
+  );   
+
+
+/**
+  Writes filemarks to the media.
+
+  @param  This  A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+  @param  Count Number of filemarks to write to the media.
+
+  @retval EFI_SUCCESS       Data was successfully transferred from the media.
+  @retval EFI_NO_MEDIA      No media is loaded in the device.
+  @retval EFI_NOT_READY     The transfer failed since the device was not ready (e.g. not
+                            online). The transfer may be retried at a later time.
+  @retval EFI_UNSUPPORTED   The device does not support this type of repositioning.
+  @retval EFI_TIMEOUT       The transfer failed to complete within the timeout specified.
+  @retval EFI_MEDIA_CHANGED The media in the device was changed since the last access.
+                            The transfer was aborted since the current position of the
+                            media may be incorrect.
+  @retval EFI_DEVICE_ERROR  A device error occurred while attempting to transfer data from the media.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TAPE_WRITEFM)(
+  IN EFI_TAPE_IO_PROTOCOL *This,
+  IN UINTN                Count
+  );   
+
+
+/**
+  Resets the tape device.
+
+  @param  This                 A pointer to the EFI_TAPE_IO_PROTOCOL instance.
+  @param  ExtendedVerification Indicates whether the parent bus should also be reset.
+
+  @retval  EFI_SUCCESS      The bus and/or device were successfully reset.
+  @retval  EFI_NO_MEDIA     No media is loaded in the device.
+  @retval  EFI_NOT_READY    The reset failed since the device and/or bus was not ready.
+                            The reset may be retried at a later time.
+  @retval  EFI_UNSUPPORTED  The device does not support this type of reset.
+  @retval  EFI_TIMEOUT      The reset did not complete within the timeout allowed.
+  @retval  EFI_DEVICE_ERROR A device error occurred while attempting to reset the bus and/or device.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TAPE_RESET)(
+  IN EFI_TAPE_IO_PROTOCOL *This,
+  IN BOOLEAN              ExtendedVerification
+  );    
+
+///
+/// The EFI_TAPE_IO_PROTOCOL provides basic sequential operations for tape devices. 
+/// These include read, write, rewind, space, write filemarks and reset functions. 
+/// Per this specification, a boot application uses the services of this protocol 
+/// to load the bootloader image from tape.
+///
+struct _EFI_TAPE_IO_PROTOCOL {
+  EFI_TAPE_READ           TapeRead;
+  EFI_TAPE_WRITE          TapeWrite;
+  EFI_TAPE_REWIND         TapeRewind;
+  EFI_TAPE_SPACE          TapeSpace;
+  EFI_TAPE_WRITEFM        TapeWriteFM;
+  EFI_TAPE_RESET          TapeReset;
+};
+
+extern EFI_GUID gEfiTapeIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Tcg2Protocol.h b/MdePkg/Include/Protocol/Tcg2Protocol.h
new file mode 100644
index 000000000000..042bdffa1f71
--- /dev/null
+++ b/MdePkg/Include/Protocol/Tcg2Protocol.h
@@ -0,0 +1,341 @@
+/** @file
+  TPM2 Protocol as defined in TCG PC Client Platform EFI Protocol Specification Family "2.0".
+  See http://trustedcomputinggroup.org for the latest specification
+
+Copyright (c) 2015, 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 __TCG2_PROTOCOL_H__
+#define __TCG2_PROTOCOL_H__
+
+#include <IndustryStandard/UefiTcgPlatform.h>
+#include <IndustryStandard/Tpm20.h>
+
+#define EFI_TCG2_PROTOCOL_GUID \
+  {0x607f766c, 0x7455, 0x42be, { 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f }}
+
+typedef struct tdEFI_TCG2_PROTOCOL EFI_TCG2_PROTOCOL;
+
+typedef struct tdEFI_TCG2_VERSION {
+  UINT8 Major;
+  UINT8 Minor;
+} EFI_TCG2_VERSION;
+
+typedef UINT32 EFI_TCG2_EVENT_LOG_BITMAP;
+typedef UINT32 EFI_TCG2_EVENT_LOG_FORMAT;
+typedef UINT32 EFI_TCG2_EVENT_ALGORITHM_BITMAP;
+
+#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2       0x00000001
+#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2         0x00000002
+
+typedef struct tdEFI_TCG2_BOOT_SERVICE_CAPABILITY {
+  //
+  // Allocated size of the structure
+  //
+  UINT8                            Size;
+  //
+  // Version of the EFI_TCG2_BOOT_SERVICE_CAPABILITY structure itself.
+  // For this version of the protocol, the Major version shall be set to 1
+  // and the Minor version shall be set to 1. 
+  //
+  EFI_TCG2_VERSION                 StructureVersion;
+  //
+  // Version of the EFI TCG2 protocol.
+  // For this version of the protocol, the Major version shall be set to 1
+  // and the Minor version shall be set to 1. 
+  //
+  EFI_TCG2_VERSION                 ProtocolVersion;
+  //
+  // Supported hash algorithms (this bitmap is determined by the supported PCR
+  // banks in the TPM and the hashing algorithms supported by the firmware)
+  //
+  EFI_TCG2_EVENT_ALGORITHM_BITMAP  HashAlgorithmBitmap;
+  //
+  // Bitmap of supported event log formats
+  //
+  EFI_TCG2_EVENT_LOG_BITMAP        SupportedEventLogs;
+  //
+  // False = TPM not present
+  //
+  BOOLEAN                          TPMPresentFlag;
+  //
+  // Max size (in bytes) of a command that can be sent to the TPM
+  //
+  UINT16                           MaxCommandSize;
+  //
+  // Max size (in bytes) of a response that can be provided by the TPM
+  //
+  UINT16                           MaxResponseSize;
+  //
+  // 4-byte Vendor ID
+  // (see TCG Vendor ID registry, Section "TPM Capabilities Vendor ID")
+  //
+  UINT32                           ManufacturerID;
+  //
+  // Maximum number of PCR banks (hashing algorithms) supported.
+  // No granularity is provided to support a specific set of algorithms.
+  // Minimum value is 1.
+  //
+  UINT32                           NumberOfPCRBanks;
+  //
+  // A bitmap of currently active PCR banks (hashing algorithms).
+  // This is a subset of the supported hashing algorithms reported in HashAlgorithmBitMap.
+  // NumberOfPcrBanks defines the number of bits that are set.
+  //
+  EFI_TCG2_EVENT_ALGORITHM_BITMAP  ActivePcrBanks;
+} EFI_TCG2_BOOT_SERVICE_CAPABILITY;
+
+#define EFI_TCG2_BOOT_HASH_ALG_SHA1    0x00000001
+#define EFI_TCG2_BOOT_HASH_ALG_SHA256  0x00000002
+#define EFI_TCG2_BOOT_HASH_ALG_SHA384  0x00000004
+#define EFI_TCG2_BOOT_HASH_ALG_SHA512  0x00000008
+#define EFI_TCG2_BOOT_HASH_ALG_SM3_256 0x00000010
+
+//
+// This bit is shall be set when an event shall be extended but not logged.
+//
+#define EFI_TCG2_EXTEND_ONLY  0x0000000000000001
+//
+// This bit shall be set when the intent is to measure a PE/COFF image.
+//
+#define PE_COFF_IMAGE     0x0000000000000010
+
+#define MAX_PCR_INDEX  23
+
+#pragma pack(1)
+
+#define EFI_TCG2_EVENT_HEADER_VERSION  1
+
+typedef struct {
+  //
+  // Size of the event header itself (sizeof(EFI_TCG2_EVENT_HEADER)). 
+  //
+  UINT32            HeaderSize;
+  //
+  // Header version. For this version of this specification, the value shall be 1.
+  //
+  UINT16            HeaderVersion;
+  //
+  // Index of the PCR that shall be extended (0 - 23). 
+  //
+  TCG_PCRINDEX      PCRIndex;
+  //
+  // Type of the event that shall be extended (and optionally logged). 
+  //
+  TCG_EVENTTYPE     EventType;
+} EFI_TCG2_EVENT_HEADER;
+
+typedef struct tdEFI_TCG2_EVENT {
+  //
+  // Total size of the event including the Size component, the header and the Event data. 
+  //
+  UINT32                Size;
+  EFI_TCG2_EVENT_HEADER Header;
+  UINT8                 Event[1];
+} EFI_TCG2_EVENT;
+
+#pragma pack()
+
+/**
+  The EFI_TCG2_PROTOCOL GetCapability function call provides protocol
+  capability information and state information.
+
+  @param[in]      This               Indicates the calling context
+  @param[in, out] ProtocolCapability The caller allocates memory for a EFI_TCG2_BOOT_SERVICE_CAPABILITY
+                                     structure and sets the size field to the size of the structure allocated.
+                                     The callee fills in the fields with the EFI protocol capability information
+                                     and the current EFI TCG2 state information up to the number of fields which
+                                     fit within the size of the structure passed in.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_DEVICE_ERROR       The command was unsuccessful.
+                                 The ProtocolCapability variable will not be populated. 
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+                                 The ProtocolCapability variable will not be populated.
+  @retval EFI_BUFFER_TOO_SMALL   The ProtocolCapability variable is too small to hold the full response.
+                                 It will be partially populated (required Size field will be set). 
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_GET_CAPABILITY) (
+  IN EFI_TCG2_PROTOCOL                    *This,
+  IN OUT EFI_TCG2_BOOT_SERVICE_CAPABILITY *ProtocolCapability
+  );
+
+/**
+  The EFI_TCG2_PROTOCOL Get Event Log function call allows a caller to
+  retrieve the address of a given event log and its last entry. 
+
+  @param[in]  This               Indicates the calling context
+  @param[in]  EventLogFormat     The type of the event log for which the information is requested.
+  @param[out] EventLogLocation   A pointer to the memory address of the event log.
+  @param[out] EventLogLastEntry  If the Event Log contains more than one entry, this is a pointer to the
+                                 address of the start of the last entry in the event log in memory.
+  @param[out] EventLogTruncated  If the Event Log is missing at least one entry because an event would
+                                 have exceeded the area allocated for events, this value is set to TRUE.
+                                 Otherwise, the value will be FALSE and the Event Log will be complete.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect
+                                 (e.g. asking for an event log whose format is not supported).
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_GET_EVENT_LOG) (
+  IN EFI_TCG2_PROTOCOL         *This,
+  IN EFI_TCG2_EVENT_LOG_FORMAT EventLogFormat,
+  OUT EFI_PHYSICAL_ADDRESS     *EventLogLocation,
+  OUT EFI_PHYSICAL_ADDRESS     *EventLogLastEntry,
+  OUT BOOLEAN                  *EventLogTruncated
+  );
+
+/**
+  The EFI_TCG2_PROTOCOL HashLogExtendEvent function call provides callers with
+  an opportunity to extend and optionally log events without requiring
+  knowledge of actual TPM commands. 
+  The extend operation will occur even if this function cannot create an event
+  log entry (e.g. due to the event log being full). 
+
+  @param[in]  This               Indicates the calling context
+  @param[in]  Flags              Bitmap providing additional information.
+  @param[in]  DataToHash         Physical address of the start of the data buffer to be hashed. 
+  @param[in]  DataToHashLen      The length in bytes of the buffer referenced by DataToHash.
+  @param[in]  EfiTcgEvent        Pointer to data buffer containing information about the event.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_DEVICE_ERROR       The command was unsuccessful.
+  @retval EFI_VOLUME_FULL        The extend operation occurred, but the event could not be written to one or more event logs.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+  @retval EFI_UNSUPPORTED        The PE/COFF image type is not supported.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_TCG2_HASH_LOG_EXTEND_EVENT) (
+  IN EFI_TCG2_PROTOCOL    *This,
+  IN UINT64               Flags,
+  IN EFI_PHYSICAL_ADDRESS DataToHash,
+  IN UINT64               DataToHashLen,
+  IN EFI_TCG2_EVENT       *EfiTcgEvent
+  );
+
+/**
+  This service enables the sending of commands to the TPM.
+
+  @param[in]  This                     Indicates the calling context
+  @param[in]  InputParameterBlockSize  Size of the TPM input parameter block.
+  @param[in]  InputParameterBlock      Pointer to the TPM input parameter block.
+  @param[in]  OutputParameterBlockSize Size of the TPM output parameter block.
+  @param[in]  OutputParameterBlock     Pointer to the TPM output parameter block.
+
+  @retval EFI_SUCCESS            The command byte stream was successfully sent to the device and a response was successfully received.
+  @retval EFI_DEVICE_ERROR       The command was not successfully sent to the device or a response was not successfully received from the device.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+  @retval EFI_BUFFER_TOO_SMALL   The output parameter block is too small. 
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_SUBMIT_COMMAND) (
+  IN EFI_TCG2_PROTOCOL *This,
+  IN UINT32            InputParameterBlockSize,
+  IN UINT8             *InputParameterBlock,
+  IN UINT32            OutputParameterBlockSize,
+  IN UINT8             *OutputParameterBlock
+  );
+
+/**
+  This service returns the currently active PCR banks.
+
+  @param[in]  This            Indicates the calling context
+  @param[out] ActivePcrBanks  Pointer to the variable receiving the bitmap of currently active PCR banks.
+
+  @retval EFI_SUCCESS           The bitmap of active PCR banks was stored in the ActivePcrBanks parameter.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters are incorrect. 
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_GET_ACTIVE_PCR_BANKS) (
+  IN  EFI_TCG2_PROTOCOL *This,
+  OUT UINT32            *ActivePcrBanks
+  );
+
+/**
+  This service sets the currently active PCR banks.
+
+  @param[in]  This            Indicates the calling context
+  @param[in]  ActivePcrBanks  Bitmap of the requested active PCR banks. At least one bit SHALL be set.
+
+  @retval EFI_SUCCESS           The bitmap in ActivePcrBank parameter is already active.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters are incorrect.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_SET_ACTIVE_PCR_BANKS) (
+  IN EFI_TCG2_PROTOCOL *This,
+  IN UINT32            ActivePcrBanks
+  );
+
+/**
+  This service retrieves the result of a previous invocation of SetActivePcrBanks.
+
+  @param[in]  This              Indicates the calling context
+  @param[out] OperationPresent  Non-zero value to indicate a SetActivePcrBank operation was invoked during the last boot.
+  @param[out] Response          The response from the SetActivePcrBank request.
+
+  @retval EFI_SUCCESS           The result value could be returned.
+  @retval EFI_INVALID_PARAMETER One or more of the parameters are incorrect.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG2_GET_RESULT_OF_SET_ACTIVE_PCR_BANKS) (
+  IN  EFI_TCG2_PROTOCOL  *This,
+  OUT UINT32             *OperationPresent,
+  OUT UINT32             *Response
+  );
+
+struct tdEFI_TCG2_PROTOCOL {
+  EFI_TCG2_GET_CAPABILITY                     GetCapability;
+  EFI_TCG2_GET_EVENT_LOG                      GetEventLog;
+  EFI_TCG2_HASH_LOG_EXTEND_EVENT              HashLogExtendEvent;
+  EFI_TCG2_SUBMIT_COMMAND                     SubmitCommand;
+  EFI_TCG2_GET_ACTIVE_PCR_BANKS               GetActivePcrBanks;
+  EFI_TCG2_SET_ACTIVE_PCR_BANKS               SetActivePcrBanks;
+  EFI_TCG2_GET_RESULT_OF_SET_ACTIVE_PCR_BANKS GetResultOfSetActivePcrBanks;
+};
+
+extern EFI_GUID gEfiTcg2ProtocolGuid;
+
+//
+// Log entries after Get Event Log service
+//
+
+#define EFI_TCG2_FINAL_EVENTS_TABLE_GUID \
+  {0x1e2ed096, 0x30e2, 0x4254, { 0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25 }}
+
+extern EFI_GUID gEfiTcg2FinalEventsTableGuid;
+
+typedef struct tdEFI_TCG2_FINAL_EVENTS_TABLE {
+  //
+  // The version of this structure.
+  //
+  UINT64                  Version;
+  //
+  // Number of events recorded after invocation of GetEventLog API
+  //
+  UINT64                  NumberOfEvents;
+  //
+  // List of events of type TCG_PCR_EVENT2.
+  //
+//TCG_PCR_EVENT2          Event[1];
+} EFI_TCG2_FINAL_EVENTS_TABLE;
+
+#define EFI_TCG2_FINAL_EVENTS_TABLE_VERSION   1
+
+#endif
diff --git a/MdePkg/Include/Protocol/TcgService.h b/MdePkg/Include/Protocol/TcgService.h
new file mode 100644
index 000000000000..7e8ba0c25669
--- /dev/null
+++ b/MdePkg/Include/Protocol/TcgService.h
@@ -0,0 +1,201 @@
+/** @file
+  TCG Service Protocol as defined in TCG_EFI_Protocol_1_22_Final
+  See http://trustedcomputinggroup.org for the latest specification
+
+Copyright (c) 2007 - 2014, 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 _TCG_SERVICE_PROTOCOL_H_
+#define _TCG_SERVICE_PROTOCOL_H_
+
+#include <IndustryStandard/UefiTcgPlatform.h>
+
+#define EFI_TCG_PROTOCOL_GUID  \
+  {0xf541796d, 0xa62e, 0x4954, { 0xa7, 0x75, 0x95, 0x84, 0xf6, 0x1b, 0x9c, 0xdd } } 
+
+typedef struct _EFI_TCG_PROTOCOL EFI_TCG_PROTOCOL;
+
+typedef struct {
+  UINT8  Major;
+  UINT8  Minor;
+  UINT8  RevMajor;
+  UINT8  RevMinor;
+} TCG_VERSION;
+
+typedef struct _TCG_EFI_BOOT_SERVICE_CAPABILITY {
+  UINT8          Size;                /// Size of this structure.
+  TCG_VERSION    StructureVersion;    
+  TCG_VERSION    ProtocolSpecVersion;
+  UINT8          HashAlgorithmBitmap; /// Hash algorithms . 
+                                      /// This protocol is capable of : 01=SHA-1.
+  BOOLEAN        TPMPresentFlag;      /// 00h = TPM not present.
+  BOOLEAN        TPMDeactivatedFlag;  /// 01h = TPM currently deactivated.
+} TCG_EFI_BOOT_SERVICE_CAPABILITY;
+
+typedef UINT32   TCG_ALGORITHM_ID;
+
+/**
+  This service provides EFI protocol capability information, state information 
+  about the TPM, and Event Log state information.
+
+  @param  This                   Indicates the calling context
+  @param  ProtocolCapability     The callee allocates memory for a TCG_BOOT_SERVICE_CAPABILITY 
+                                 structure and fills in the fields with the EFI protocol 
+                                 capability information and the current TPM state information.
+  @param  TCGFeatureFlags        This is a pointer to the feature flags. No feature 
+                                 flags are currently defined so this parameter 
+                                 MUST be set to 0. However, in the future, 
+                                 feature flags may be defined that, for example, 
+                                 enable hash algorithm agility.
+  @param  EventLogLocation       This is a pointer to the address of the event log in memory.
+  @param  EventLogLastEntry      If the Event Log contains more than one entry, 
+                                 this is a pointer to the address of the start of 
+                                 the last entry in the event log in memory. 
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  ProtocolCapability does not match TCG capability.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG_STATUS_CHECK)(
+  IN      EFI_TCG_PROTOCOL          *This,
+  OUT     TCG_EFI_BOOT_SERVICE_CAPABILITY
+                                    *ProtocolCapability,
+  OUT     UINT32                    *TCGFeatureFlags,
+  OUT     EFI_PHYSICAL_ADDRESS      *EventLogLocation,
+  OUT     EFI_PHYSICAL_ADDRESS      *EventLogLastEntry
+  );
+
+/**
+  This service abstracts the capability to do a hash operation on a data buffer.
+  
+  @param  This                   Indicates the calling context.
+  @param  HashData               The pointer to the data buffer to be hashed.
+  @param  HashDataLen            The length of the data buffer to be hashed.
+  @param  AlgorithmId            Identification of the Algorithm to use for the hashing operation.
+  @param  HashedDataLen          Resultant length of the hashed data.
+  @param  HashedDataResult       Resultant buffer of the hashed data.
+  
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  HashDataLen is NULL.
+  @retval EFI_INVALID_PARAMETER  HashDataLenResult is NULL.
+  @retval EFI_OUT_OF_RESOURCES   Cannot allocate buffer of size *HashedDataLen.
+  @retval EFI_UNSUPPORTED        AlgorithmId not supported.
+  @retval EFI_BUFFER_TOO_SMALL   *HashedDataLen < sizeof (TCG_DIGEST).
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG_HASH_ALL)(
+  IN      EFI_TCG_PROTOCOL          *This,
+  IN      UINT8                     *HashData,
+  IN      UINT64                    HashDataLen,
+  IN      TCG_ALGORITHM_ID          AlgorithmId,
+  IN OUT  UINT64                    *HashedDataLen,
+  IN OUT  UINT8                     **HashedDataResult
+  );
+
+/**
+  This service abstracts the capability to add an entry to the Event Log.
+
+  @param  This                   Indicates the calling context
+  @param  TCGLogData             The pointer to the start of the data buffer containing 
+                                 the TCG_PCR_EVENT data structure. All fields in 
+                                 this structure are properly filled by the caller.
+  @param  EventNumber            The event number of the event just logged.
+  @param  Flags                  Indicates additional flags. Only one flag has been 
+                                 defined at this time, which is 0x01 and means the 
+                                 extend operation should not be performed. All 
+                                 other bits are reserved. 
+ 
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_OUT_OF_RESOURCES   Insufficient memory in the event log to complete this action.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG_LOG_EVENT)(
+  IN      EFI_TCG_PROTOCOL          *This,
+  IN      TCG_PCR_EVENT             *TCGLogData,
+  IN OUT  UINT32                    *EventNumber,
+  IN      UINT32                    Flags
+  );
+
+/**
+  This service is a proxy for commands to the TPM.
+
+  @param  This                        Indicates the calling context.
+  @param  TpmInputParameterBlockSize  Size of the TPM input parameter block.
+  @param  TpmInputParameterBlock      The pointer to the TPM input parameter block.
+  @param  TpmOutputParameterBlockSize Size of the TPM output parameter block.
+  @param  TpmOutputParameterBlock     The pointer to the TPM output parameter block.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  Invalid ordinal.
+  @retval EFI_UNSUPPORTED        Current Task Priority Level  >= EFI_TPL_CALLBACK.
+  @retval EFI_TIMEOUT            The TIS timed-out.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG_PASS_THROUGH_TO_TPM)(
+  IN      EFI_TCG_PROTOCOL          *This,
+  IN      UINT32                    TpmInputParameterBlockSize,
+  IN      UINT8                     *TpmInputParameterBlock,
+  IN      UINT32                    TpmOutputParameterBlockSize,
+  IN      UINT8                     *TpmOutputParameterBlock
+  );
+
+/**
+  This service abstracts the capability to do a hash operation on a data buffer, extend a specific TPM PCR with the hash result, and add an entry to the Event Log
+
+  @param  This                   Indicates the calling context
+  @param  HashData               The physical address of the start of the data buffer 
+                                 to be hashed, extended, and logged.
+  @param  HashDataLen            The length, in bytes, of the buffer referenced by HashData
+  @param  AlgorithmId            Identification of the Algorithm to use for the hashing operation
+  @param  TCGLogData             The physical address of the start of the data 
+                                 buffer containing the TCG_PCR_EVENT data structure.
+  @param  EventNumber            The event number of the event just logged.
+  @param  EventLogLastEntry      The physical address of the first byte of the entry 
+                                 just placed in the Event Log. If the Event Log was 
+                                 empty when this function was called then this physical 
+                                 address will be the same as the physical address of 
+                                 the start of the Event Log.
+
+  @retval EFI_SUCCESS            The operation completed successfully.
+  @retval EFI_UNSUPPORTED        AlgorithmId != TPM_ALG_SHA.
+  @retval EFI_UNSUPPORTED        Current TPL >= EFI_TPL_CALLBACK.
+  @retval EFI_DEVICE_ERROR       The command was unsuccessful.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCG_HASH_LOG_EXTEND_EVENT)(
+  IN      EFI_TCG_PROTOCOL          *This,
+  IN      EFI_PHYSICAL_ADDRESS      HashData,
+  IN      UINT64                    HashDataLen,
+  IN      TCG_ALGORITHM_ID          AlgorithmId,
+  IN OUT  TCG_PCR_EVENT             *TCGLogData,
+  IN OUT  UINT32                    *EventNumber,
+     OUT  EFI_PHYSICAL_ADDRESS      *EventLogLastEntry
+  );
+
+///
+/// The EFI_TCG Protocol abstracts TCG activity.
+///
+struct _EFI_TCG_PROTOCOL {
+  EFI_TCG_STATUS_CHECK              StatusCheck;
+  EFI_TCG_HASH_ALL                  HashAll;
+  EFI_TCG_LOG_EVENT                 LogEvent;
+  EFI_TCG_PASS_THROUGH_TO_TPM       PassThroughToTpm;
+  EFI_TCG_HASH_LOG_EXTEND_EVENT     HashLogExtendEvent;
+};
+
+extern EFI_GUID gEfiTcgProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Tcp4.h b/MdePkg/Include/Protocol/Tcp4.h
new file mode 100644
index 000000000000..49d279b013fb
--- /dev/null
+++ b/MdePkg/Include/Protocol/Tcp4.h
@@ -0,0 +1,577 @@
+/** @file
+  EFI TCPv4(Transmission Control Protocol version 4) Protocol Definition
+  The EFI TCPv4 Service Binding Protocol is used to locate EFI TCPv4 Protocol drivers to create
+  and destroy child of the driver to communicate with other host using TCP protocol.
+  The EFI TCPv4 Protocol provides services to send and receive data stream.
+
+Copyright (c) 2006 - 2014, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.0.
+
+**/
+
+#ifndef __EFI_TCP4_PROTOCOL_H__
+#define __EFI_TCP4_PROTOCOL_H__
+
+#include <Protocol/Ip4.h>
+
+#define EFI_TCP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x00720665, 0x67EB, 0x4a99, {0xBA, 0xF7, 0xD3, 0xC3, 0x3A, 0x1C, 0x7C, 0xC9 } \
+  }
+
+#define EFI_TCP4_PROTOCOL_GUID \
+  { \
+    0x65530BC7, 0xA359, 0x410f, {0xB0, 0x10, 0x5A, 0xAD, 0xC7, 0xEC, 0x2B, 0x62 } \
+  }
+
+typedef struct _EFI_TCP4_PROTOCOL EFI_TCP4_PROTOCOL;
+
+///
+/// EFI_TCP4_SERVICE_POINT is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              InstanceHandle;
+  EFI_IPv4_ADDRESS        LocalAddress;
+  UINT16                  LocalPort;
+  EFI_IPv4_ADDRESS        RemoteAddress;
+  UINT16                  RemotePort;
+} EFI_TCP4_SERVICE_POINT;
+
+///
+/// EFI_TCP4_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              DriverHandle;
+  UINT32                  ServiceCount;
+  EFI_TCP4_SERVICE_POINT  Services[1];
+} EFI_TCP4_VARIABLE_DATA;
+
+typedef struct {
+  BOOLEAN                 UseDefaultAddress;
+  EFI_IPv4_ADDRESS        StationAddress;
+  EFI_IPv4_ADDRESS        SubnetMask;
+  UINT16                  StationPort;
+  EFI_IPv4_ADDRESS        RemoteAddress;
+  UINT16                  RemotePort;
+  BOOLEAN                 ActiveFlag;
+} EFI_TCP4_ACCESS_POINT;
+
+typedef struct {
+  UINT32                  ReceiveBufferSize;
+  UINT32                  SendBufferSize;
+  UINT32                  MaxSynBackLog;
+  UINT32                  ConnectionTimeout;
+  UINT32                  DataRetries;
+  UINT32                  FinTimeout;
+  UINT32                  TimeWaitTimeout;
+  UINT32                  KeepAliveProbes;
+  UINT32                  KeepAliveTime;
+  UINT32                  KeepAliveInterval;
+  BOOLEAN                 EnableNagle;
+  BOOLEAN                 EnableTimeStamp;
+  BOOLEAN                 EnableWindowScaling;
+  BOOLEAN                 EnableSelectiveAck;
+  BOOLEAN                 EnablePathMtuDiscovery;
+} EFI_TCP4_OPTION;
+
+typedef struct {
+  //
+  // I/O parameters
+  //
+  UINT8                   TypeOfService;
+  UINT8                   TimeToLive;
+
+  //
+  // Access Point
+  //
+  EFI_TCP4_ACCESS_POINT   AccessPoint;
+
+  //
+  // TCP Control Options
+  //
+  EFI_TCP4_OPTION         *ControlOption;
+} EFI_TCP4_CONFIG_DATA;
+
+///
+/// TCP4 connnection state
+///
+typedef enum {
+  Tcp4StateClosed         = 0,
+  Tcp4StateListen         = 1,
+  Tcp4StateSynSent        = 2,
+  Tcp4StateSynReceived    = 3,
+  Tcp4StateEstablished    = 4,
+  Tcp4StateFinWait1       = 5,
+  Tcp4StateFinWait2       = 6,
+  Tcp4StateClosing        = 7,
+  Tcp4StateTimeWait       = 8,
+  Tcp4StateCloseWait      = 9,
+  Tcp4StateLastAck        = 10
+} EFI_TCP4_CONNECTION_STATE;
+
+typedef struct {
+  EFI_EVENT   Event;
+  EFI_STATUS  Status;
+} EFI_TCP4_COMPLETION_TOKEN;
+
+typedef struct {
+  ///
+  /// The Status in the CompletionToken will be set to one of
+  /// the following values if the active open succeeds or an unexpected
+  /// error happens:
+  /// EFI_SUCCESS:              The active open succeeds and the instance's
+  ///                           state is Tcp4StateEstablished.
+  /// EFI_CONNECTION_RESET:     The connect fails because the connection is reset
+  ///                           either by instance itself or the communication peer.
+  /// EFI_CONNECTION_REFUSED:   The connect fails because this connection is initiated with
+  ///                           an active open and the connection is refused.
+  /// EFI_ABORTED:              The active open is aborted.
+  /// EFI_TIMEOUT:              The connection establishment timer expires and
+  ///                           no more specific information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The active open fails because
+  ///                           an ICMP network unreachable error is received.
+  /// EFI_HOST_UNREACHABLE:     The active open fails because an
+  ///                           ICMP host unreachable error is received.
+  /// EFI_PROTOCOL_UNREACHABLE: The active open fails
+  ///                           because an ICMP protocol unreachable error is received.
+  /// EFI_PORT_UNREACHABLE:     The connection establishment
+  ///                           timer times out and an ICMP port unreachable error is received.
+  /// EFI_ICMP_ERROR:           The connection establishment timer timeout and some other ICMP
+  ///                           error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurred.
+  /// EFI_NO_MEDIA:             There was a media error.
+  ///
+  EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+} EFI_TCP4_CONNECTION_TOKEN;
+
+typedef struct {
+  EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+  EFI_HANDLE                NewChildHandle;
+} EFI_TCP4_LISTEN_TOKEN;
+
+typedef struct {
+  UINT32 FragmentLength;
+  VOID   *FragmentBuffer;
+} EFI_TCP4_FRAGMENT_DATA;
+
+typedef struct {
+  BOOLEAN                   UrgentFlag;
+  UINT32                    DataLength;
+  UINT32                    FragmentCount;
+  EFI_TCP4_FRAGMENT_DATA    FragmentTable[1];
+} EFI_TCP4_RECEIVE_DATA;
+
+typedef struct {
+  BOOLEAN                   Push;
+  BOOLEAN                   Urgent;
+  UINT32                    DataLength;
+  UINT32                    FragmentCount;
+  EFI_TCP4_FRAGMENT_DATA    FragmentTable[1];
+} EFI_TCP4_TRANSMIT_DATA;
+
+typedef struct {
+  ///
+  /// When transmission finishes or meets any unexpected error it will
+  /// be set to one of the following values:
+  /// EFI_SUCCESS:              The receiving or transmission operation
+  ///                           completes successfully.
+  /// EFI_CONNECTION_FIN:       The receiving operation fails because the communication peer
+  ///                           has closed the connection and there is no more data in the
+  ///                           receive buffer of the instance.
+  /// EFI_CONNECTION_RESET:     The receiving or transmission operation fails
+  ///                           because this connection is reset either by instance
+  ///                           itself or the communication peer.
+  /// EFI_ABORTED:              The receiving or transmission is aborted.
+  /// EFI_TIMEOUT:              The transmission timer expires and no more
+  ///                           specific information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The transmission fails
+  ///                           because an ICMP network unreachable error is received.
+  /// EFI_HOST_UNREACHABLE:     The transmission fails because an
+  ///                           ICMP host unreachable error is received.
+  /// EFI_PROTOCOL_UNREACHABLE: The transmission fails
+  ///                           because an ICMP protocol unreachable error is received.
+  /// EFI_PORT_UNREACHABLE:     The transmission fails and an
+  ///                           ICMP port unreachable error is received.
+  /// EFI_ICMP_ERROR:           The transmission fails and some other
+  ///                           ICMP error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurs.
+  /// EFI_NO_MEDIA:             There was a media error.
+  ///
+  EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+  union {
+    ///
+    /// When this token is used for receiving, RxData is a pointer to EFI_TCP4_RECEIVE_DATA.
+    ///
+    EFI_TCP4_RECEIVE_DATA   *RxData;
+    ///
+    /// When this token is used for transmitting, TxData is a pointer to EFI_TCP4_TRANSMIT_DATA.
+    ///
+    EFI_TCP4_TRANSMIT_DATA  *TxData;
+  } Packet;
+} EFI_TCP4_IO_TOKEN;
+
+typedef struct {
+  EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+  BOOLEAN                   AbortOnClose;
+} EFI_TCP4_CLOSE_TOKEN;
+
+//
+// Interface definition for TCP4 protocol
+//
+
+/**
+  Get the current operational status.
+
+  @param  This           The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  Tcp4State      The pointer to the buffer to receive the current TCP state.
+  @param  Tcp4ConfigData The pointer to the buffer to receive the current TCP configuration.
+  @param  Ip4ModeData    The pointer to the buffer to receive the current IPv4 configuration
+                         data used by the TCPv4 instance.
+  @param  MnpConfigData  The pointer to the buffer to receive the current MNP configuration
+                         data used indirectly by the TCPv4 instance.
+  @param  SnpModeData    The pointer to the buffer to receive the current SNP configuration
+                         data used indirectly by the TCPv4 instance.
+
+  @retval EFI_SUCCESS           The mode data was read.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_NOT_STARTED       No configuration data is available because this instance hasn't
+                                 been started.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_GET_MODE_DATA)(
+  IN   EFI_TCP4_PROTOCOL                  *This,
+  OUT  EFI_TCP4_CONNECTION_STATE          *Tcp4State      OPTIONAL,
+  OUT  EFI_TCP4_CONFIG_DATA               *Tcp4ConfigData OPTIONAL,
+  OUT  EFI_IP4_MODE_DATA                  *Ip4ModeData    OPTIONAL,
+  OUT  EFI_MANAGED_NETWORK_CONFIG_DATA    *MnpConfigData  OPTIONAL,
+  OUT  EFI_SIMPLE_NETWORK_MODE            *SnpModeData    OPTIONAL
+  );
+
+/**
+  Initialize or brutally reset the operational parameters for this EFI TCPv4 instance.
+
+  @param  This           The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  Tcp4ConfigData The pointer to the configure data to configure the instance.
+
+  @retval EFI_SUCCESS           The operational settings are set, changed, or reset
+                                successfully.
+  @retval EFI_INVALID_PARAMETER Some parameter is invalid.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (through
+                                DHCP, BOOTP, RARP, etc.) is not finished yet.
+  @retval EFI_ACCESS_DENIED     Configuring TCP instance when it is configured without
+                                calling Configure() with NULL to reset it.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+  @retval EFI_UNSUPPORTED       One or more of the control options are not supported in
+                                the implementation.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough system resources when
+                                executing Configure().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CONFIGURE)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_CONFIG_DATA                *TcpConfigData OPTIONAL
+  );
+
+
+/**
+  Add or delete a route entry to the route table
+
+  @param  This           The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  DeleteRoute    Set it to TRUE to delete this route from the routing table. Set it to
+                         FALSE to add this route to the routing table.
+                         DestinationAddress and SubnetMask are used as the
+                         keywords to search route entry.
+  @param  SubnetAddress  The destination network.
+  @param  SubnetMask     The subnet mask of the destination network.
+  @param  GatewayAddress The gateway address for this route. It must be on the same
+                         subnet with the station address unless a direct route is specified.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_NOT_STARTED       The EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - SubnetAddress is NULL.
+                                - SubnetMask is NULL.
+                                - GatewayAddress is NULL.
+                                - *SubnetAddress is not NULL a valid subnet address.
+                                - *SubnetMask is not a valid subnet mask.
+                                - *GatewayAddress is not a valid unicast IP address or it
+                                is not in the same subnet.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough resources to add the entry to the
+                                routing table.
+  @retval EFI_NOT_FOUND         This route is not in the routing table.
+  @retval EFI_ACCESS_DENIED     The route is already defined in the routing table.
+  @retval EFI_UNSUPPORTED       The TCP driver does not support this operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_ROUTES)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN BOOLEAN                             DeleteRoute,
+  IN EFI_IPv4_ADDRESS                    *SubnetAddress,
+  IN EFI_IPv4_ADDRESS                    *SubnetMask,
+  IN EFI_IPv4_ADDRESS                    *GatewayAddress
+  );
+
+/**
+  Initiate a nonblocking TCP connection request for an active TCP instance.
+
+  @param  This                  The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  ConnectionToken       The pointer to the connection token to return when the TCP three
+                                way handshake finishes.
+
+  @retval EFI_SUCCESS           The connection request is successfully initiated and the state
+                                of this TCPv4 instance has been changed to Tcp4StateSynSent.
+  @retval EFI_NOT_STARTED       This EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED     One or more of the following conditions are TRUE:
+                                - This instance is not configured as an active one.
+                                - This instance is not in Tcp4StateClosed state.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+                                - ConnectionToken is NULL.
+                                - ConnectionToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The driver can't allocate enough resource to initiate the activ eopen.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CONNECT)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_CONNECTION_TOKEN           *ConnectionToken
+  );
+
+
+/**
+  Listen on the passive instance to accept an incoming connection request. This is a nonblocking operation.
+
+  @param  This        The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  ListenToken The pointer to the listen token to return when operation finishes.
+
+  @retval EFI_SUCCESS           The listen token has been queued successfully.
+  @retval EFI_NOT_STARTED       This EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED     One or more of the following are TRUE:
+                                - This instance is not a passive instance.
+                                - This instance is not in Tcp4StateListen state.
+                                - The same listen token has already existed in the listen
+                                token queue of this TCP instance.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+                                - ListenToken is NULL.
+                                - ListentToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR      Any unexpected and not belonged to above category error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_ACCEPT)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_LISTEN_TOKEN               *ListenToken
+  );
+
+/**
+  Queues outgoing data into the transmit queue.
+
+  @param  This  The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  Token The pointer to the completion token to queue to the transmit queue.
+
+  @retval EFI_SUCCESS             The data has been queued for transmission.
+  @retval EFI_NOT_STARTED         This EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_NO_MAPPING          When using a default address, configuration (DHCP, BOOTP,
+                                  RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER   One or more of the following are TRUE:
+                                  - This is NULL.
+                                  - Token is NULL.
+                                  - Token->CompletionToken.Event is NULL.
+                                  - Token->Packet.TxData is NULL L.
+                                  - Token->Packet.FragmentCount is zero.
+                                  - Token->Packet.DataLength is not equal to the sum of fragment lengths.
+  @retval EFI_ACCESS_DENIED       One or more of the following conditions is TRUE:
+                                  - A transmit completion token with the same Token->CompletionToken.Event
+                                  was already in the transmission queue.
+                                  - The current instance is in Tcp4StateClosed state.
+                                  - The current instance is a passive one and it is in
+                                  Tcp4StateListen state.
+                                  - User has called Close() to disconnect this connection.
+  @retval EFI_NOT_READY           The completion token could not be queued because the
+                                  transmit queue is full.
+  @retval EFI_OUT_OF_RESOURCES    Could not queue the transmit data because of resource
+                                  shortage.
+  @retval EFI_NETWORK_UNREACHABLE There is no route to the destination network or address.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_TRANSMIT)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_IO_TOKEN                   *Token
+  );
+
+
+/**
+  Places an asynchronous receive request into the receiving queue.
+
+  @param  This  The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  Token The pointer to a token that is associated with the receive data
+                descriptor.
+
+  @retval EFI_SUCCESS           The receive completion token was cached.
+  @retval EFI_NOT_STARTED       This EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP, RARP,
+                                etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - Token is NULL.
+                                - Token->CompletionToken.Event is NULL.
+                                - Token->Packet.RxData is NULL.
+                                - Token->Packet.RxData->DataLength is 0.
+                                - The Token->Packet.RxData->DataLength is not
+                                the sum of all FragmentBuffer length in FragmentTable.
+  @retval EFI_OUT_OF_RESOURCES The receive completion token could not be queued due to a lack of
+                               system resources (usually memory).
+  @retval EFI_DEVICE_ERROR     An unexpected system or network error occurred.
+  @retval EFI_ACCESS_DENIED    One or more of the following conditions is TRUE:
+                               - A receive completion token with the same Token-
+                               >CompletionToken.Event was already in the receive
+                               queue.
+                               - The current instance is in Tcp4StateClosed state.
+                               - The current instance is a passive one and it is in
+                               Tcp4StateListen state.
+                               - User has called Close() to disconnect this connection.
+  @retval EFI_CONNECTION_FIN   The communication peer has closed the connection and there is
+                               no any buffered data in the receive buffer of this instance.
+  @retval EFI_NOT_READY        The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_RECEIVE)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_IO_TOKEN                   *Token
+  );
+
+/**
+  Disconnecting a TCP connection gracefully or reset a TCP connection. This function is a
+  nonblocking operation.
+
+  @param  This       The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  CloseToken The pointer to the close token to return when operation finishes.
+
+  @retval EFI_SUCCESS           The Close() is called successfully.
+  @retval EFI_NOT_STARTED       This EFI TCPv4 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED     One or more of the following are TRUE:
+                                - Configure() has been called with
+                                TcpConfigData set to NULL and this function has
+                                not returned.
+                                - Previous Close() call on this instance has not
+                                finished.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+                                - CloseToken is NULL.
+                                - CloseToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR      Any unexpected and not belonged to above category error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CLOSE)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_CLOSE_TOKEN                *CloseToken
+  );
+
+/**
+  Abort an asynchronous connection, listen, transmission or receive request.
+
+  @param  This  The pointer to the EFI_TCP4_PROTOCOL instance.
+  @param  Token The pointer to a token that has been issued by
+                EFI_TCP4_PROTOCOL.Connect(),
+                EFI_TCP4_PROTOCOL.Accept(),
+                EFI_TCP4_PROTOCOL.Transmit() or
+                EFI_TCP4_PROTOCOL.Receive(). If NULL, all pending
+                tokens issued by above four functions will be aborted. Type
+                EFI_TCP4_COMPLETION_TOKEN is defined in
+                EFI_TCP4_PROTOCOL.Connect().
+
+  @retval  EFI_SUCCESS             The asynchronous I/O request is aborted and Token->Event
+                                   is signaled.
+  @retval  EFI_INVALID_PARAMETER   This is NULL.
+  @retval  EFI_NOT_STARTED         This instance hasn't been configured.
+  @retval  EFI_NO_MAPPING          When using the default address, configuration
+                                   (DHCP, BOOTP,RARP, etc.) hasn't finished yet.
+  @retval  EFI_NOT_FOUND           The asynchronous I/O request isn't found in the
+                                   transmission or receive queue. It has either
+                                   completed or wasn't issued by Transmit() and Receive().
+  @retval  EFI_UNSUPPORTED         The implementation does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CANCEL)(
+  IN EFI_TCP4_PROTOCOL                   *This,
+  IN EFI_TCP4_COMPLETION_TOKEN           *Token OPTIONAL
+  );
+
+
+/**
+  Poll to receive incoming data and transmit outgoing segments.
+
+  @param  This The pointer to the EFI_TCP4_PROTOCOL instance.
+
+  @retval  EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval  EFI_NOT_READY         No incoming or outgoing data is processed.
+  @retval  EFI_TIMEOUT           Data was dropped out of the transmission or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_POLL)(
+  IN EFI_TCP4_PROTOCOL                   *This
+  );
+
+///
+/// The EFI_TCP4_PROTOCOL defines the EFI TCPv4 Protocol child to be used by
+/// any network drivers or applications to send or receive data stream.
+/// It can either listen on a specified port as a service or actively connected
+/// to remote peer as a client. Each instance has its own independent settings,
+/// such as the routing table.
+///
+struct _EFI_TCP4_PROTOCOL {
+  EFI_TCP4_GET_MODE_DATA                 GetModeData;
+  EFI_TCP4_CONFIGURE                     Configure;
+  EFI_TCP4_ROUTES                        Routes;
+  EFI_TCP4_CONNECT                       Connect;
+  EFI_TCP4_ACCEPT                        Accept;
+  EFI_TCP4_TRANSMIT                      Transmit;
+  EFI_TCP4_RECEIVE                       Receive;
+  EFI_TCP4_CLOSE                         Close;
+  EFI_TCP4_CANCEL                        Cancel;
+  EFI_TCP4_POLL                          Poll;
+};
+
+extern EFI_GUID gEfiTcp4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiTcp4ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Tcp6.h b/MdePkg/Include/Protocol/Tcp6.h
new file mode 100644
index 000000000000..b725391518f2
--- /dev/null
+++ b/MdePkg/Include/Protocol/Tcp6.h
@@ -0,0 +1,864 @@
+/** @file
+  EFI TCPv6(Transmission Control Protocol version 6) Protocol Definition
+  The EFI TCPv6 Service Binding Protocol is used to locate EFI TCPv6 Protocol drivers to create
+  and destroy child of the driver to communicate with other host using TCP protocol.
+  The EFI TCPv6 Protocol provides services to send and receive data stream.
+
+  Copyright (c) 2008 - 2014, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_TCP6_PROTOCOL_H__
+#define __EFI_TCP6_PROTOCOL_H__
+
+#include <Protocol/ManagedNetwork.h>
+#include <Protocol/Ip6.h>
+
+#define EFI_TCP6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0xec20eb79, 0x6c1a, 0x4664, {0x9a, 0x0d, 0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64 } \
+  }
+
+#define EFI_TCP6_PROTOCOL_GUID \
+  { \
+    0x46e44855, 0xbd60, 0x4ab7, {0xab, 0x0d, 0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77 } \
+  }
+
+
+typedef struct _EFI_TCP6_PROTOCOL EFI_TCP6_PROTOCOL;
+
+///
+/// EFI_TCP6_SERVICE_POINT is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  ///
+  /// The EFI TCPv6 Protocol instance handle that is using this
+  /// address/port pair.
+  ///
+  EFI_HANDLE        InstanceHandle;
+  ///
+  /// The local IPv6 address to which this TCP instance is bound. Set
+  /// to 0::/128, if this TCP instance is configured to listen on all
+  /// available source addresses.
+  ///
+  EFI_IPv6_ADDRESS  LocalAddress;
+  ///
+  /// The local port number in host byte order.
+  ///
+  UINT16            LocalPort;
+  ///
+  /// The remote IPv6 address. It may be 0::/128 if this TCP instance is
+  /// not connected to any remote host.
+  ///
+  EFI_IPv6_ADDRESS  RemoteAddress;
+  ///
+  /// The remote port number in host byte order. It may be zero if this
+  /// TCP instance is not connected to any remote host.
+  ///
+  UINT16            RemotePort;
+} EFI_TCP6_SERVICE_POINT;
+
+///
+/// EFI_TCP6_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE             DriverHandle; ///< The handle of the driver that creates this entry.
+  UINT32                 ServiceCount; ///< The number of address/port pairs following this data structure.
+  EFI_TCP6_SERVICE_POINT Services[1];  ///< List of address/port pairs that are currently in use.
+} EFI_TCP6_VARIABLE_DATA;
+
+///
+/// EFI_TCP6_ACCESS_POINT
+///
+typedef struct {
+  ///
+  /// The local IP address assigned to this TCP instance. The EFI
+  /// TCPv6 driver will only deliver incoming packets whose
+  /// destination addresses exactly match the IP address. Set to zero to
+  /// let the underlying IPv6 driver choose a source address. If not zero
+  /// it must be one of the configured IP addresses in the underlying
+  /// IPv6 driver.
+  ///
+  EFI_IPv6_ADDRESS  StationAddress;
+  ///
+  /// The local port number to which this EFI TCPv6 Protocol instance
+  /// is bound. If the instance doesn't care the local port number, set
+  /// StationPort to zero to use an ephemeral port.
+  ///
+  UINT16            StationPort;
+  ///
+  /// The remote IP address to which this EFI TCPv6 Protocol instance
+  /// is connected. If ActiveFlag is FALSE (i.e. a passive TCPv6
+  /// instance), the instance only accepts connections from the
+  /// RemoteAddress. If ActiveFlag is TRUE the instance will
+  /// connect to the RemoteAddress, i.e., outgoing segments will be
+  /// sent to this address and only segments from this address will be
+  /// delivered to the application. When ActiveFlag is FALSE, it
+  /// can be set to zero and means that incoming connection requests
+  /// from any address will be accepted.
+  ///
+  EFI_IPv6_ADDRESS  RemoteAddress;
+  ///
+  /// The remote port to which this EFI TCPv6 Protocol instance
+  /// connects or from which connection request will be accepted by
+  /// this EFI TCPv6 Protocol instance. If ActiveFlag is FALSE it
+  /// can be zero and means that incoming connection request from
+  /// any port will be accepted. Its value can not be zero when
+  /// ActiveFlag is TRUE.
+  ///
+  UINT16            RemotePort;
+  ///
+  /// Set it to TRUE to initiate an active open. Set it to FALSE to
+  /// initiate a passive open to act as a server.
+  ///
+  BOOLEAN           ActiveFlag;
+} EFI_TCP6_ACCESS_POINT;
+
+///
+/// EFI_TCP6_OPTION
+///
+typedef struct {
+  ///
+  /// The size of the TCP receive buffer.
+  ///
+  UINT32   ReceiveBufferSize;
+  ///
+  /// The size of the TCP send buffer.
+  ///
+  UINT32   SendBufferSize;
+  ///
+  /// The length of incoming connect request queue for a passive
+  /// instance. When set to zero, the value is implementation specific.
+  ///
+  UINT32   MaxSynBackLog;
+  ///
+  /// The maximum seconds a TCP instance will wait for before a TCP
+  /// connection established. When set to zero, the value is
+  /// implementation specific.
+  ///
+  UINT32   ConnectionTimeout;
+  ///
+  ///The number of times TCP will attempt to retransmit a packet on
+  ///an established connection. When set to zero, the value is
+  ///implementation specific.
+  ///
+  UINT32   DataRetries;
+  ///
+  /// How many seconds to wait in the FIN_WAIT_2 states for a final
+  /// FIN flag before the TCP instance is closed. This timeout is in
+  /// effective only if the application has called Close() to
+  /// disconnect the connection completely. It is also called
+  /// FIN_WAIT_2 timer in other implementations. When set to zero,
+  /// it should be disabled because the FIN_WAIT_2 timer itself is
+  /// against the standard. The default value is 60.
+  ///
+  UINT32   FinTimeout;
+  ///
+  /// How many seconds to wait in TIME_WAIT state before the TCP
+  /// instance is closed. The timer is disabled completely to provide a
+  /// method to close the TCP connection quickly if it is set to zero. It
+  /// is against the related RFC documents.
+  ///
+  UINT32   TimeWaitTimeout;
+  ///
+  /// The maximum number of TCP keep-alive probes to send before
+  /// giving up and resetting the connection if no response from the
+  /// other end. Set to zero to disable keep-alive probe.
+  ///
+  UINT32   KeepAliveProbes;
+  ///
+  /// The number of seconds a connection needs to be idle before TCP
+  /// sends out periodical keep-alive probes. When set to zero, the
+  /// value is implementation specific. It should be ignored if keep-
+  /// alive probe is disabled.
+  ///
+  UINT32   KeepAliveTime;
+  ///
+  /// The number of seconds between TCP keep-alive probes after the
+  /// periodical keep-alive probe if no response. When set to zero, the
+  /// value is implementation specific. It should be ignored if keep-
+  /// alive probe is disabled.
+  ///
+  UINT32   KeepAliveInterval;
+  ///
+  /// Set it to TRUE to enable the Nagle algorithm as defined in
+  /// RFC896. Set it to FALSE to disable it.
+  ///
+  BOOLEAN  EnableNagle;
+  ///
+  /// Set it to TRUE to enable TCP timestamps option as defined in
+  /// RFC1323. Set to FALSE to disable it.
+  ///
+  BOOLEAN  EnableTimeStamp;
+  ///
+  /// Set it to TRUE to enable TCP window scale option as defined in
+  /// RFC1323. Set it to FALSE to disable it.
+  ///
+  BOOLEAN  EnableWindowScaling;
+  ///
+  /// Set it to TRUE to enable selective acknowledge mechanism
+  /// described in RFC 2018. Set it to FALSE to disable it.
+  /// Implementation that supports SACK can optionally support
+  /// DSAK as defined in RFC 2883.
+  ///
+  BOOLEAN  EnableSelectiveAck;
+  ///
+  /// Set it to TRUE to enable path MTU discovery as defined in
+  /// RFC 1191. Set to FALSE to disable it.
+  ///
+  BOOLEAN  EnablePathMtuDiscovery;
+} EFI_TCP6_OPTION;
+
+///
+/// EFI_TCP6_CONFIG_DATA
+///
+typedef struct {
+  ///
+  /// TrafficClass field in transmitted IPv6 packets.
+  ///
+  UINT8                 TrafficClass;
+  ///
+  /// HopLimit field in transmitted IPv6 packets.
+  ///
+  UINT8                 HopLimit;
+  ///
+  /// Used to specify TCP communication end settings for a TCP instance.
+  ///
+  EFI_TCP6_ACCESS_POINT AccessPoint;
+  ///
+  /// Used to configure the advance TCP option for a connection. If set
+  /// to NULL, implementation specific options for TCP connection will be used.
+  ///
+  EFI_TCP6_OPTION       *ControlOption;
+} EFI_TCP6_CONFIG_DATA;
+
+///
+/// EFI_TCP6_CONNECTION_STATE
+///
+typedef enum {
+  Tcp6StateClosed      = 0,
+  Tcp6StateListen      = 1,
+  Tcp6StateSynSent     = 2,
+  Tcp6StateSynReceived = 3,
+  Tcp6StateEstablished = 4,
+  Tcp6StateFinWait1    = 5,
+  Tcp6StateFinWait2    = 6,
+  Tcp6StateClosing     = 7,
+  Tcp6StateTimeWait    = 8,
+  Tcp6StateCloseWait   = 9,
+  Tcp6StateLastAck     = 10
+} EFI_TCP6_CONNECTION_STATE;
+
+///
+/// EFI_TCP6_COMPLETION_TOKEN
+/// is used as a common header for various asynchronous tokens.
+///
+typedef struct {
+  ///
+  /// The Event to signal after request is finished and Status field is
+  /// updated by the EFI TCPv6 Protocol driver.
+  ///
+  EFI_EVENT   Event;
+  ///
+  /// The result of the completed operation.
+  ///
+  EFI_STATUS  Status;
+} EFI_TCP6_COMPLETION_TOKEN;
+
+///
+/// EFI_TCP6_CONNECTION_TOKEN
+/// will be set if the active open succeeds or an unexpected
+/// error happens.
+///
+typedef struct {
+  ///
+  /// The Status in the CompletionToken will be set to one of
+  /// the following values if the active open succeeds or an unexpected
+  /// error happens:
+  /// EFI_SUCCESS:              The active open succeeds and the instance's
+  ///                           state is Tcp6StateEstablished.
+  /// EFI_CONNECTION_RESET:     The connect fails because the connection is reset
+  ///                           either by instance itself or the communication peer.
+  /// EFI_CONNECTION_REFUSED:   The receiving or transmission operation fails because this
+  ///                           connection is refused.
+  /// EFI_ABORTED:              The active open is aborted.
+  /// EFI_TIMEOUT:              The connection establishment timer expires and
+  ///                           no more specific information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The active open fails because
+  ///                           an ICMP network unreachable error is received.
+  /// EFI_HOST_UNREACHABLE:     The active open fails because an
+  ///                           ICMP host unreachable error is received.
+  /// EFI_PROTOCOL_UNREACHABLE: The active open fails
+  ///                           because an ICMP protocol unreachable error is received.
+  /// EFI_PORT_UNREACHABLE:     The connection establishment
+  ///                           timer times out and an ICMP port unreachable error is received.
+  /// EFI_ICMP_ERROR:           The connection establishment timer times
+  ///                           out and some other ICMP error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurred.
+  /// EFI_SECURITY_VIOLATION:   The active open was failed because of IPSec policy check.
+  /// EFI_NO_MEDIA:             There was a media error.
+  ///
+  EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+} EFI_TCP6_CONNECTION_TOKEN;
+
+///
+/// EFI_TCP6_LISTEN_TOKEN
+/// returns when list operation finishes.
+///
+typedef struct {
+  ///
+  /// The Status in CompletionToken will be set to the
+  /// following value if accept finishes:
+  /// EFI_SUCCESS:            A remote peer has successfully established a
+  ///                         connection to this instance. A new TCP instance has also been
+  ///                         created for the connection.
+  /// EFI_CONNECTION_RESET:   The accept fails because the connection is reset either
+  ///                         by instance itself or communication peer.
+  /// EFI_ABORTED:            The accept request has been aborted.
+  /// EFI_SECURITY_VIOLATION: The accept operation was failed because of IPSec policy check.
+  ///
+  EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+  EFI_HANDLE                NewChildHandle;
+} EFI_TCP6_LISTEN_TOKEN;
+
+///
+/// EFI_TCP6_FRAGMENT_DATA
+/// allows multiple receive or transmit buffers to be specified. The
+/// purpose of this structure is to provide scattered read and write.
+///
+typedef struct {
+  UINT32 FragmentLength;   ///< Length of data buffer in the fragment.
+  VOID   *FragmentBuffer;  ///< Pointer to the data buffer in the fragment.
+} EFI_TCP6_FRAGMENT_DATA;
+
+///
+/// EFI_TCP6_RECEIVE_DATA
+/// When TCPv6 driver wants to deliver received data to the application,
+/// it will pick up the first queued receiving token, update its
+/// Token->Packet.RxData then signal the Token->CompletionToken.Event.
+///
+typedef struct {
+  ///
+  /// Whether the data is urgent. When this flag is set, the instance is in
+  /// urgent mode.
+  ///
+  BOOLEAN                 UrgentFlag;
+  ///
+  /// When calling Receive() function, it is the byte counts of all
+  /// Fragmentbuffer in FragmentTable allocated by user.
+  /// When the token is signaled by TCPv6 driver it is the length of
+  /// received data in the fragments.
+  ///
+  UINT32                  DataLength;
+  ///
+  /// Number of fragments.
+  ///
+  UINT32                  FragmentCount;
+  ///
+  /// An array of fragment descriptors.
+  ///
+  EFI_TCP6_FRAGMENT_DATA  FragmentTable[1];
+} EFI_TCP6_RECEIVE_DATA;
+
+///
+/// EFI_TCP6_TRANSMIT_DATA
+/// The EFI TCPv6 Protocol user must fill this data structure before sending a packet.
+/// The packet may contain multiple buffers in non-continuous memory locations.
+///
+typedef struct {
+  ///
+  /// Push If TRUE, data must be transmitted promptly, and the PUSH bit in
+  /// the last TCP segment created will be set. If FALSE, data
+  /// transmission may be delayed to combine with data from
+  /// subsequent Transmit()s for efficiency.
+  ///
+  BOOLEAN                 Push;
+  ///
+  /// The data in the fragment table are urgent and urgent point is in
+  /// effect if TRUE. Otherwise those data are NOT considered urgent.
+  ///
+  BOOLEAN                 Urgent;
+  ///
+  /// Length of the data in the fragments.
+  ///
+  UINT32                  DataLength;
+  ///
+  /// Number of fragments.
+  ///
+  UINT32                  FragmentCount;
+  ///
+  /// An array of fragment descriptors.
+  ///
+  EFI_TCP6_FRAGMENT_DATA  FragmentTable[1];
+} EFI_TCP6_TRANSMIT_DATA;
+
+///
+/// EFI_TCP6_IO_TOKEN
+/// returns When transmission finishes or meets any unexpected error.
+///
+typedef struct {
+  ///
+  /// When transmission finishes or meets any unexpected error it will
+  /// be set to one of the following values:
+  /// EFI_SUCCESS:              The receiving or transmission operation
+  ///                           completes successfully.
+  /// EFI_CONNECTION_FIN:       The receiving operation fails because the communication peer
+  ///                           has closed the connection and there is no more data in the
+  ///                           receive buffer of the instance.
+  /// EFI_CONNECTION_RESET:     The receiving or transmission operation fails
+  ///                           because this connection is reset either by instance
+  ///                           itself or the communication peer.
+  /// EFI_ABORTED:              The receiving or transmission is aborted.
+  /// EFI_TIMEOUT:              The transmission timer expires and no more
+  ///                           specific information is available.
+  /// EFI_NETWORK_UNREACHABLE:  The transmission fails
+  ///                           because an ICMP network unreachable error is received.
+  /// EFI_HOST_UNREACHABLE:     The transmission fails because an
+  ///                           ICMP host unreachable error is received.
+  /// EFI_PROTOCOL_UNREACHABLE: The transmission fails
+  ///                           because an ICMP protocol unreachable error is received.
+  /// EFI_PORT_UNREACHABLE:     The transmission fails and an
+  ///                           ICMP port unreachable error is received.
+  /// EFI_ICMP_ERROR:           The transmission fails and some other
+  ///                           ICMP error is received.
+  /// EFI_DEVICE_ERROR:         An unexpected system or network error occurs.
+  /// EFI_SECURITY_VIOLATION:   The receiving or transmission
+  ///                           operation was failed because of IPSec policy check
+  /// EFI_NO_MEDIA:             There was a media error.
+  ///
+  EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+  union {
+    ///
+    /// When this token is used for receiving, RxData is a pointer to
+    /// EFI_TCP6_RECEIVE_DATA.
+    ///
+    EFI_TCP6_RECEIVE_DATA   *RxData;
+    ///
+    /// When this token is used for transmitting, TxData is a pointer to
+    /// EFI_TCP6_TRANSMIT_DATA.
+    ///
+    EFI_TCP6_TRANSMIT_DATA  *TxData;
+  } Packet;
+} EFI_TCP6_IO_TOKEN;
+
+///
+/// EFI_TCP6_CLOSE_TOKEN
+/// returns when close operation finishes.
+///
+typedef struct {
+  ///
+  /// When close finishes or meets any unexpected error it will be set
+  /// to one of the following values:
+  /// EFI_SUCCESS:            The close operation completes successfully.
+  /// EFI_ABORTED:            User called configure with NULL without close stopping.
+  /// EFI_SECURITY_VIOLATION: The close operation was failed because of IPSec policy check.
+  ///
+  EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+  ///
+  /// Abort the TCP connection on close instead of the standard TCP
+  /// close process when it is set to TRUE. This option can be used to
+  /// satisfy a fast disconnect.
+  ///
+  BOOLEAN                   AbortOnClose;
+} EFI_TCP6_CLOSE_TOKEN;
+
+/**
+  Get the current operational status.
+
+  The GetModeData() function copies the current operational settings of this EFI TCPv6
+  Protocol instance into user-supplied buffers. This function can also be used to retrieve
+  the operational setting of underlying drivers such as IPv6, MNP, or SNP.
+
+  @param[in]  This              Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[out] Tcp6State         The buffer in which the current TCP state is returned.
+  @param[out] Tcp6ConfigData    The buffer in which the current TCP configuration is returned.
+  @param[out] Ip6ModeData       The buffer in which the current IPv6 configuration data used by
+                                the TCP instance is returned.
+  @param[out] MnpConfigData     The buffer in which the current MNP configuration data used
+                                indirectly by the TCP instance is returned.
+  @param[out] SnpModeData       The buffer in which the current SNP mode data used indirectly by
+                                the TCP instance is returned.
+
+  @retval EFI_SUCCESS           The mode data was read.
+  @retval EFI_NOT_STARTED       No configuration data is available because this instance hasn't
+                                been started.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_GET_MODE_DATA)(
+  IN  EFI_TCP6_PROTOCOL                  *This,
+  OUT EFI_TCP6_CONNECTION_STATE          *Tcp6State OPTIONAL,
+  OUT EFI_TCP6_CONFIG_DATA               *Tcp6ConfigData OPTIONAL,
+  OUT EFI_IP6_MODE_DATA                  *Ip6ModeData OPTIONAL,
+  OUT EFI_MANAGED_NETWORK_CONFIG_DATA    *MnpConfigData OPTIONAL,
+  OUT EFI_SIMPLE_NETWORK_MODE            *SnpModeData OPTIONAL
+  );
+
+/**
+  Initialize or brutally reset the operational parameters for this EFI TCPv6 instance.
+
+  The Configure() function does the following:
+  - Initialize this TCP instance, i.e., initialize the communication end settings and
+    specify active open or passive open for an instance.
+  - Reset this TCP instance brutally, i.e., cancel all pending asynchronous tokens, flush
+    transmission and receiving buffer directly without informing the communication peer.
+
+  No other TCPv6 Protocol operation except Poll() can be executed by this instance until
+  it is configured properly. For an active TCP instance, after a proper configuration it
+  may call Connect() to initiates the three-way handshake. For a passive TCP instance,
+  its state will transit to Tcp6StateListen after configuration, and Accept() may be
+  called to listen the incoming TCP connection requests. If Tcp6ConfigData is set to NULL,
+  the instance is reset. Resetting process will be done brutally, the state machine will
+  be set to Tcp6StateClosed directly, the receive queue and transmit queue will be flushed,
+  and no traffic is allowed through this instance.
+
+  @param[in] This               Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] Tcp6ConfigData     Pointer to the configure data to configure the instance.
+                                If Tcp6ConfigData is set to NULL, the instance is reset.
+
+  @retval EFI_SUCCESS           The operational settings are set, changed, or reset
+                                successfully.
+  @retval EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                address for this instance, but no source address was available for
+                                use.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions are TRUE:
+                                - This is NULL.
+                                - Tcp6ConfigData->AccessPoint.StationAddress is neither zero nor
+                                  one of the configured IP addresses in the underlying IPv6 driver.
+                                - Tcp6ConfigData->AccessPoint.RemoteAddress isn't a valid unicast
+                                  IPv6 address.
+                                - Tcp6ConfigData->AccessPoint.RemoteAddress is zero or
+                                  Tcp6ConfigData->AccessPoint.RemotePort is zero when
+                                  Tcp6ConfigData->AccessPoint.ActiveFlag is TRUE.
+                                - A same access point has been configured in other TCP
+                                  instance properly.
+  @retval EFI_ACCESS_DENIED     Configuring TCP instance when it is configured without
+                                calling Configure() with NULL to reset it.
+  @retval EFI_UNSUPPORTED       One or more of the control options are not supported in
+                                the implementation.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate enough system resources when
+                                executing Configure().
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CONFIGURE)(
+  IN EFI_TCP6_PROTOCOL        *This,
+  IN EFI_TCP6_CONFIG_DATA     *Tcp6ConfigData OPTIONAL
+  );
+
+/**
+  Initiate a nonblocking TCP connection request for an active TCP instance.
+
+  The Connect() function will initiate an active open to the remote peer configured
+  in current TCP instance if it is configured active. If the connection succeeds or
+  fails due to any error, the ConnectionToken->CompletionToken.Event will be signaled
+  and ConnectionToken->CompletionToken.Status will be updated accordingly. This
+  function can only be called for the TCP instance in Tcp6StateClosed state. The
+  instance will transfer into Tcp6StateSynSent if the function returns EFI_SUCCESS.
+  If TCP three-way handshake succeeds, its state will become Tcp6StateEstablished,
+  otherwise, the state will return to Tcp6StateClosed.
+
+  @param[in] This                Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] ConnectionToken     Pointer to the connection token to return when the TCP three
+                                 way handshake finishes.
+
+  @retval EFI_SUCCESS            The connection request is successfully initiated and the state of
+                                 this TCP instance has been changed to Tcp6StateSynSent.
+  @retval EFI_NOT_STARTED        This EFI TCPv6 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED      One or more of the following conditions are TRUE:
+                                 - This instance is not configured as an active one.
+                                 - This instance is not in Tcp6StateClosed state.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - ConnectionToken is NULL.
+                                 - ConnectionToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES   The driver can't allocate enough resource to initiate the active open.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CONNECT)(
+  IN EFI_TCP6_PROTOCOL           *This,
+  IN EFI_TCP6_CONNECTION_TOKEN   *ConnectionToken
+  );
+
+/**
+  Listen on the passive instance to accept an incoming connection request. This is a
+  nonblocking operation.
+
+  The Accept() function initiates an asynchronous accept request to wait for an incoming
+  connection on the passive TCP instance. If a remote peer successfully establishes a
+  connection with this instance, a new TCP instance will be created and its handle will
+  be returned in ListenToken->NewChildHandle. The newly created instance is configured
+  by inheriting the passive instance's configuration and is ready for use upon return.
+  The new instance is in the Tcp6StateEstablished state.
+
+  The ListenToken->CompletionToken.Event will be signaled when a new connection is
+  accepted, user aborts the listen or connection is reset.
+
+  This function only can be called when current TCP instance is in Tcp6StateListen state.
+
+  @param[in] This                Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] ListenToken         Pointer to the listen token to return when operation finishes.
+
+
+  @retval EFI_SUCCESS            The listen token has been queued successfully.
+  @retval EFI_NOT_STARTED        This EFI TCPv6 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED      One or more of the following are TRUE:
+                                 - This instance is not a passive instance.
+                                 - This instance is not in Tcp6StateListen state.
+                                 - The same listen token has already existed in the listen
+                                   token queue of this TCP instance.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - ListenToken is NULL.
+                                 - ListentToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES   Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR       Any unexpected and not belonged to above category error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_ACCEPT)(
+  IN EFI_TCP6_PROTOCOL             *This,
+  IN EFI_TCP6_LISTEN_TOKEN         *ListenToken
+  );
+
+/**
+  Queues outgoing data into the transmit queue.
+
+  The Transmit() function queues a sending request to this TCP instance along with the
+  user data. The status of the token is updated and the event in the token will be
+  signaled once the data is sent out or some error occurs.
+
+  @param[in] This                 Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] Token                Pointer to the completion token to queue to the transmit queue.
+
+  @retval EFI_SUCCESS             The data has been queued for transmission.
+  @retval EFI_NOT_STARTED         This EFI TCPv6 Protocol instance has not been configured.
+  @retval EFI_NO_MAPPING          The underlying IPv6 driver was responsible for choosing a
+                                  source address for this instance, but no source address was
+                                  available for use.
+  @retval EFI_INVALID_PARAMETER   One or more of the following are TRUE:
+                                  - This is NULL.
+                                  - Token is NULL.
+                                  - Token->CompletionToken.Event is NULL.
+                                  - Token->Packet.TxData is NULL.
+                                  - Token->Packet.FragmentCount is zero.
+                                  - Token->Packet.DataLength is not equal to the sum of fragment lengths.
+  @retval EFI_ACCESS_DENIED       One or more of the following conditions are TRUE:
+                                  - A transmit completion token with the same Token->
+                                    CompletionToken.Event was already in the
+                                    transmission queue.
+                                  - The current instance is in Tcp6StateClosed state.
+                                  - The current instance is a passive one and it is in
+                                    Tcp6StateListen state.
+                                  - User has called Close() to disconnect this connection.
+  @retval EFI_NOT_READY           The completion token could not be queued because the
+                                  transmit queue is full.
+  @retval EFI_OUT_OF_RESOURCES    Could not queue the transmit data because of resource
+                                  shortage.
+  @retval EFI_NETWORK_UNREACHABLE There is no route to the destination network or address.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_TRANSMIT)(
+  IN EFI_TCP6_PROTOCOL            *This,
+  IN EFI_TCP6_IO_TOKEN            *Token
+  );
+
+/**
+  Places an asynchronous receive request into the receiving queue.
+
+  The Receive() function places a completion token into the receive packet queue. This
+  function is always asynchronous. The caller must allocate the Token->CompletionToken.Event
+  and the FragmentBuffer used to receive data. The caller also must fill the DataLength which
+  represents the whole length of all FragmentBuffer. When the receive operation completes, the
+  EFI TCPv6 Protocol driver updates the Token->CompletionToken.Status and Token->Packet.RxData
+  fields and the Token->CompletionToken.Event is signaled. If got data the data and its length
+  will be copied into the FragmentTable, at the same time the full length of received data will
+  be recorded in the DataLength fields. Providing a proper notification function and context
+  for the event will enable the user to receive the notification and receiving status. That
+  notification function is guaranteed to not be re-entered.
+
+  @param[in] This               Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] Token              Pointer to a token that is associated with the receive data
+                                descriptor.
+
+  @retval EFI_SUCCESS            The receive completion token was cached.
+  @retval EFI_NOT_STARTED        This EFI TCPv6 Protocol instance has not been configured.
+  @retval EFI_NO_MAPPING         The underlying IPv6 driver was responsible for choosing a source
+                                 address for this instance, but no source address was available for use.
+  @retval EFI_INVALID_PARAMETER  One or more of the following conditions is TRUE:
+                                 - This is NULL.
+                                 - Token is NULL.
+                                 - Token->CompletionToken.Event is NULL.
+                                 - Token->Packet.RxData is NULL.
+                                 - Token->Packet.RxData->DataLength is 0.
+                                 - The Token->Packet.RxData->DataLength is not the
+                                   sum of all FragmentBuffer length in FragmentTable.
+  @retval EFI_OUT_OF_RESOURCES   The receive completion token could not be queued due to a lack of
+                                 system resources (usually memory).
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+                                 The EFI TCPv6 Protocol instance has been reset to startup defaults.
+  @retval EFI_ACCESS_DENIED      One or more of the following conditions is TRUE:
+                                 - A receive completion token with the same Token->CompletionToken.Event
+                                   was already in the receive queue.
+                                 - The current instance is in Tcp6StateClosed state.
+                                 - The current instance is a passive one and it is in
+                                   Tcp6StateListen state.
+                                 - User has called Close() to disconnect this connection.
+  @retval EFI_CONNECTION_FIN     The communication peer has closed the connection and there is no
+                                 any buffered data in the receive buffer of this instance
+  @retval EFI_NOT_READY          The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_RECEIVE)(
+  IN EFI_TCP6_PROTOCOL           *This,
+  IN EFI_TCP6_IO_TOKEN           *Token
+  );
+
+/**
+  Disconnecting a TCP connection gracefully or reset a TCP connection. This function is a
+  nonblocking operation.
+
+  Initiate an asynchronous close token to TCP driver. After Close() is called, any buffered
+  transmission data will be sent by TCP driver and the current instance will have a graceful close
+  working flow described as RFC 793 if AbortOnClose is set to FALSE, otherwise, a rest packet
+  will be sent by TCP driver to fast disconnect this connection. When the close operation completes
+  successfully the TCP instance is in Tcp6StateClosed state, all pending asynchronous
+  operations are signaled and any buffers used for TCP network traffic are flushed.
+
+  @param[in] This                Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] CloseToken          Pointer to the close token to return when operation finishes.
+
+  @retval EFI_SUCCESS            The Close() is called successfully.
+  @retval EFI_NOT_STARTED        This EFI TCPv6 Protocol instance has not been configured.
+  @retval EFI_ACCESS_DENIED      One or more of the following are TRUE:
+                                 - CloseToken or CloseToken->CompletionToken.Event is already in use.
+                                 - Previous Close() call on this instance has not finished.
+  @retval EFI_INVALID_PARAMETER  One or more of the following are TRUE:
+                                 - This is NULL.
+                                 - CloseToken is NULL.
+                                 - CloseToken->CompletionToken.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES   Could not allocate enough resource to finish the operation.
+  @retval EFI_DEVICE_ERROR       Any unexpected and not belonged to above category error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CLOSE)(
+  IN EFI_TCP6_PROTOCOL           *This,
+  IN EFI_TCP6_CLOSE_TOKEN        *CloseToken
+  );
+
+/**
+  Abort an asynchronous connection, listen, transmission or receive request.
+
+  The Cancel() function aborts a pending connection, listen, transmit or
+  receive request.
+
+  If Token is not NULL and the token is in the connection, listen, transmission
+  or receive queue when it is being cancelled, its Token->Status will be set
+  to EFI_ABORTED and then Token->Event will be signaled.
+
+  If the token is not in one of the queues, which usually means that the
+  asynchronous operation has completed, EFI_NOT_FOUND is returned.
+
+  If Token is NULL all asynchronous token issued by Connect(), Accept(),
+  Transmit() and Receive() will be aborted.
+
+  @param[in] This                Pointer to the EFI_TCP6_PROTOCOL instance.
+  @param[in] Token               Pointer to a token that has been issued by
+                                 EFI_TCP6_PROTOCOL.Connect(),
+                                 EFI_TCP6_PROTOCOL.Accept(),
+                                 EFI_TCP6_PROTOCOL.Transmit() or
+                                 EFI_TCP6_PROTOCOL.Receive(). If NULL, all pending
+                                 tokens issued by above four functions will be aborted. Type
+                                 EFI_TCP6_COMPLETION_TOKEN is defined in
+                                 EFI_TCP_PROTOCOL.Connect().
+
+  @retval EFI_SUCCESS            The asynchronous I/O request is aborted and Token->Event
+                                 is signaled.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_NOT_STARTED        This instance hasn't been configured.
+  @retval EFI_NOT_FOUND          The asynchronous I/O request isn't found in the transmission or
+                                 receive queue. It has either completed or wasn't issued by
+                                 Transmit() and Receive().
+  @retval EFI_UNSUPPORTED        The implementation does not support this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CANCEL)(
+  IN EFI_TCP6_PROTOCOL           *This,
+  IN EFI_TCP6_COMPLETION_TOKEN   *Token OPTIONAL
+  );
+
+/**
+  Poll to receive incoming data and transmit outgoing segments.
+
+  The Poll() function increases the rate that data is moved between the network
+  and application and can be called when the TCP instance is created successfully.
+  Its use is optional.
+
+  @param[in] This                Pointer to the EFI_TCP6_PROTOCOL instance.
+
+  @retval EFI_SUCCESS            Incoming or outgoing data was processed.
+  @retval EFI_INVALID_PARAMETER  This is NULL.
+  @retval EFI_DEVICE_ERROR       An unexpected system or network error occurred.
+  @retval EFI_NOT_READY          No incoming or outgoing data is processed.
+  @retval EFI_TIMEOUT            Data was dropped out of the transmission or receive queue.
+                                 Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_POLL)(
+  IN EFI_TCP6_PROTOCOL        *This
+  );
+
+///
+/// EFI_TCP6_PROTOCOL
+/// defines the EFI TCPv6 Protocol child to be used by any network drivers or
+/// applications to send or receive data stream. It can either listen on a
+/// specified port as a service or actively connect to remote peer as a client.
+/// Each instance has its own independent settings.
+///
+struct _EFI_TCP6_PROTOCOL {
+  EFI_TCP6_GET_MODE_DATA  GetModeData;
+  EFI_TCP6_CONFIGURE      Configure;
+  EFI_TCP6_CONNECT        Connect;
+  EFI_TCP6_ACCEPT         Accept;
+  EFI_TCP6_TRANSMIT       Transmit;
+  EFI_TCP6_RECEIVE        Receive;
+  EFI_TCP6_CLOSE          Close;
+  EFI_TCP6_CANCEL         Cancel;
+  EFI_TCP6_POLL           Poll;
+};
+
+extern EFI_GUID gEfiTcp6ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiTcp6ProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Timer.h b/MdePkg/Include/Protocol/Timer.h
new file mode 100644
index 000000000000..29d65215b184
--- /dev/null
+++ b/MdePkg/Include/Protocol/Timer.h
@@ -0,0 +1,180 @@
+/** @file
+  Timer Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  This code is used to provide the timer tick for the DXE core.
+
+  Copyright (c) 2006 - 2016, 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 __ARCH_PROTOCOL_TIMER_H__
+#define __ARCH_PROTOCOL_TIMER_H__
+
+///
+/// Global ID for the Timer Architectural Protocol
+///
+#define EFI_TIMER_ARCH_PROTOCOL_GUID \
+  { 0x26baccb3, 0x6f42, 0x11d4, {0xbc, 0xe7, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+///
+/// Declare forward reference for the Timer Architectural Protocol
+///
+typedef struct _EFI_TIMER_ARCH_PROTOCOL   EFI_TIMER_ARCH_PROTOCOL;
+
+/**
+  This function of this type is called when a timer interrupt fires.  This 
+  function executes at TPL_HIGH_LEVEL.  The DXE Core will register a function
+  of this type to be called for the timer interrupt, so it can know how much 
+  time has passed.  This information is used to signal timer based events.  
+
+  @param  Time   Time since the last timer interrupt in 100 ns units. This will
+                 typically be TimerPeriod, but if a timer interrupt is missed, and the
+                 EFI_TIMER_ARCH_PROTOCOL driver can detect missed interrupts, then Time
+                 will contain the actual amount of time since the last interrupt.
+
+  None.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_TIMER_NOTIFY)(
+  IN UINT64  Time
+  );
+
+/**
+  This function registers the handler NotifyFunction so it is called every time 
+  the timer interrupt fires.  It also passes the amount of time since the last 
+  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 
+  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 
+  returned.  If the CPU does not support registering a timer interrupt handler, 
+  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 
+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
+  If an attempt is made to unregister a handler when a handler is not registered, 
+  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 
+  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 
+  is returned.
+
+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
+  @param  NotifyFunction   The function to call when a timer interrupt fires. This
+                           function executes at TPL_HIGH_LEVEL. The DXE Core will
+                           register a handler for the timer interrupt, so it can know
+                           how much time has passed. This information is used to
+                           signal timer based events. NULL will unregister the handler.
+
+  @retval EFI_SUCCESS           The timer handler was registered.
+  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
+                                registered.
+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
+                                previously registered.
+  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TIMER_REGISTER_HANDLER)(
+  IN EFI_TIMER_ARCH_PROTOCOL    *This,
+  IN EFI_TIMER_NOTIFY           NotifyFunction
+);
+
+/**
+  This function adjusts the period of timer interrupts to the value specified 
+  by TimerPeriod.  If the timer period is updated, then the selected timer 
+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 
+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  
+  If an error occurs while attempting to update the timer period, then the 
+  timer hardware will be put back in its state prior to this call, and 
+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 
+  is disabled.  This is not the same as disabling the CPU's interrupts.  
+  Instead, it must either turn off the timer hardware, or it must adjust the 
+  interrupt controller so that a CPU interrupt is not generated when the timer 
+  interrupt fires. 
+
+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
+  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
+                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
+                           returned. If the timer is programmable, then the timer period
+                           will be rounded up to the nearest timer period that is supported
+                           by the timer hardware. If TimerPeriod is set to 0, then the
+                           timer interrupts will be disabled.
+
+  @retval EFI_SUCCESS           The timer period was changed.
+  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
+  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TIMER_SET_TIMER_PERIOD)(
+  IN EFI_TIMER_ARCH_PROTOCOL    *This,
+  IN UINT64                     TimerPeriod
+  );
+
+/**
+  This function retrieves the period of timer interrupts in 100 ns units, 
+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 
+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 
+  returned, then the timer is currently disabled.
+
+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
+  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
+                           0 is returned, then the timer is currently disabled.
+
+  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TIMER_GET_TIMER_PERIOD)(
+  IN EFI_TIMER_ARCH_PROTOCOL      *This,
+  OUT UINT64                      *TimerPeriod
+  );
+
+/**
+  This function generates a soft timer interrupt. If the platform does not support soft 
+  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 
+  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 
+  service, then a soft timer interrupt will be generated. If the timer interrupt is 
+  enabled when this service is called, then the registered handler will be invoked. The 
+  registered handler should not be able to distinguish a hardware-generated timer 
+  interrupt from a software-generated timer interrupt.
+
+  @param  This                  The EFI_TIMER_ARCH_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The soft timer interrupt was generated.
+  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_TIMER_GENERATE_SOFT_INTERRUPT)(
+  IN EFI_TIMER_ARCH_PROTOCOL    *This
+  );
+
+
+///
+/// This protocol provides the services to initialize a periodic timer 
+/// interrupt, and to register a handler that is called each time the timer
+/// interrupt fires.  It may also provide a service to adjust the rate of the
+/// periodic timer interrupt.  When a timer interrupt occurs, the handler is 
+/// passed the amount of time that has passed since the previous timer 
+/// interrupt.
+///
+struct _EFI_TIMER_ARCH_PROTOCOL {
+  EFI_TIMER_REGISTER_HANDLER          RegisterHandler;
+  EFI_TIMER_SET_TIMER_PERIOD          SetTimerPeriod;
+  EFI_TIMER_GET_TIMER_PERIOD          GetTimerPeriod;
+  EFI_TIMER_GENERATE_SOFT_INTERRUPT   GenerateSoftInterrupt;
+};
+
+extern EFI_GUID gEfiTimerArchProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Timestamp.h b/MdePkg/Include/Protocol/Timestamp.h
new file mode 100644
index 000000000000..9746903922e3
--- /dev/null
+++ b/MdePkg/Include/Protocol/Timestamp.h
@@ -0,0 +1,101 @@
+/** @file
+  EFI Timestamp Protocol as defined in UEFI2.4 Specification. 
+  Used to provide a platform independent interface for retrieving a high resolution timestamp counter.
+  
+  Copyright (c) 2013, 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.    
+  
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.4    
+       
+**/
+
+#ifndef __EFI_TIME_STAMP_PROTOCOL_H__
+#define __EFI_TIME_STAMP_PROTOCOL_H__
+
+
+#define EFI_TIMESTAMP_PROTOCOL_GUID \
+  { 0xafbfde41, 0x2e6e, 0x4262, {0xba, 0x65, 0x62, 0xb9, 0x23, 0x6e, 0x54, 0x95 } }
+
+///
+/// Declare forward reference for the Time Stamp Protocol
+///
+typedef struct _EFI_TIMESTAMP_PROTOCOL  EFI_TIMESTAMP_PROTOCOL;
+
+///
+/// EFI_TIMESTAMP_PROPERTIES
+///
+typedef struct {
+  /// 
+  /// The frequency of the timestamp counter in Hz.
+  /// 
+  UINT64                               Frequency;
+  /// 
+  /// The value that the timestamp counter ends with immediately before it rolls over.
+  /// For example, a 64-bit free running counter would have an EndValue of 0xFFFFFFFFFFFFFFFF.
+  /// A 24-bit free running counter would have an EndValue of 0xFFFFFF.
+  ///
+  UINT64                               EndValue;
+} EFI_TIMESTAMP_PROPERTIES;
+ 
+/**
+  Retrieves the current value of a 64-bit free running timestamp counter.
+  
+  The counter shall count up in proportion to the amount of time that has passed. The counter value
+  will always roll over to zero. The properties of the counter can be retrieved from GetProperties().
+  The caller should be prepared for the function to return the same value twice across successive calls.
+  The counter value will not go backwards other than when wrapping, as defined by EndValue in GetProperties().
+  The frequency of the returned timestamp counter value must remain constant. Power management operations that 
+  affect clocking must not change the returned counter frequency. The quantization of counter value updates may 
+  vary as long as the value reflecting time passed remains consistent.
+
+  @param  None.             
+
+  @retval The current value of the free running timestamp counter.
+
+**/
+typedef
+UINT64
+(EFIAPI *TIMESTAMP_GET)(
+  VOID
+  );
+
+/**
+  Obtains timestamp counter properties including frequency and value limits.
+
+  @param[out]  Properties              The properties of the timestamp counter.
+
+  @retval      EFI_SUCCESS             The properties were successfully retrieved. 
+  @retval      EFI_DEVICE_ERROR        An error occurred trying to retrieve the properties of the timestamp 
+                                       counter subsystem. Properties is not pedated.                                
+  @retval      EFI_INVALID_PARAMETER   Properties is NULL.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *TIMESTAMP_GET_PROPERTIES)(
+  OUT   EFI_TIMESTAMP_PROPERTIES       *Properties
+  );
+
+
+
+///
+/// EFI_TIMESTAMP_PROTOCOL
+/// The protocol provides a platform independent interface for retrieving a high resolution 
+/// timestamp counter.
+///
+struct _EFI_TIMESTAMP_PROTOCOL {
+  TIMESTAMP_GET                        GetTimestamp;
+  TIMESTAMP_GET_PROPERTIES             GetProperties;
+};
+
+extern EFI_GUID gEfiTimestampProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/Tls.h b/MdePkg/Include/Protocol/Tls.h
new file mode 100644
index 000000000000..f3cfccc9538f
--- /dev/null
+++ b/MdePkg/Include/Protocol/Tls.h
@@ -0,0 +1,460 @@
+/** @file
+  EFI TLS Protocols as defined in UEFI 2.5.
+
+  The EFI TLS Service Binding Protocol is used to locate EFI TLS Protocol drivers
+  to create and destroy child of the driver to communicate with other host using
+  TLS protocol.
+  The EFI TLS Protocol provides the ability to manage TLS session.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_TLS_PROTOCOL_H__
+#define __EFI_TLS_PROTOCOL_H__
+
+///
+/// The EFI TLS Service Binding Protocol is used to locate EFI TLS Protocol drivers to
+/// create and destroy child of the driver to communicate with other host using TLS
+/// protocol.
+///
+#define EFI_TLS_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x952cb795, 0xff36, 0x48cf, {0xa2, 0x49, 0x4d, 0xf4, 0x86, 0xd6, 0xab, 0x8d } \
+  }
+
+///
+/// The EFI TLS protocol provides the ability to manage TLS session.
+///
+#define EFI_TLS_PROTOCOL_GUID \
+  { \
+    0xca959f, 0x6cfa, 0x4db1, {0x95, 0xbc, 0xe4, 0x6c, 0x47, 0x51, 0x43, 0x90 } \
+  }
+
+typedef struct _EFI_TLS_PROTOCOL EFI_TLS_PROTOCOL;
+
+///
+/// EFI_TLS_SESSION_DATA_TYPE
+///
+typedef enum {
+  ///
+  /// Session Configuration
+  ///
+
+  ///
+  /// TLS session Version. The corresponding Data is of type EFI_TLS_VERSION.
+  ///
+  EfiTlsVersion,
+  ///
+  /// TLS session as client or as server. The corresponding Data is of
+  /// EFI_TLS_CONNECTION_END.
+  ///
+  EfiTlsConnectionEnd,
+  ///
+  /// A priority list of preferred algorithms for the TLS session.
+  /// The corresponding Data is a list of EFI_TLS_CIPHER.
+  ///
+  EfiTlsCipherList,
+  ///
+  /// TLS session compression method.
+  /// The corresponding Data is of type EFI_TLS_COMPRESSION.
+  ///
+  EfiTlsCompressionMethod,
+  ///
+  /// TLS session extension data.
+  /// The corresponding Data is a list of type EFI_TLS_EXTENSION .
+  ///
+  EfiTlsExtensionData,
+  ///
+  /// TLS session verify method.
+  /// The corresponding Data is of type EFI_TLS_VERIFY.
+  ///
+  EfiTlsVerifyMethod,
+  ///
+  /// TLS session data session ID.
+  /// For SetSessionData(), it is TLS session ID used for session resumption.
+  /// For GetSessionData(), it is the TLS session ID used for current session.
+  /// The corresponding Data is of type EFI_TLS_SESSION_ID.
+  ///
+  EfiTlsSessionID,
+  ///
+  /// TLS session data session state.
+  /// The corresponding Data is of type EFI_TLS_SESSION_STATE.
+  ///
+  EfiTlsSessionState,
+
+  ///
+  /// Session information
+  ///
+
+  ///
+  /// TLS session data client random.
+  /// The corresponding Data is of type EFI_TLS_RANDOM.
+  ///
+  EfiTlsClientRandom,
+  ///
+  /// TLS session data server random.
+  /// The corresponding Data is of type EFI_TLS_RANDOM.
+  ///
+  EfiTlsServerRandom,
+  ///
+  /// TLS session data key material.
+  /// The corresponding Data is of type EFI_TLS_MASTER_SECRET.
+  ///
+  EfiTlsKeyMaterial,
+
+  EfiTlsSessionDataTypeMaximum
+
+} EFI_TLS_SESSION_DATA_TYPE;
+
+///
+/// EFI_TLS_VERSION
+/// Note: The TLS version definition is from SSL3.0 to the latest TLS (e.g. 1.2).
+///       SSL2.0 is obsolete and should not be used.
+///
+typedef struct {
+  UINT8                         Major;
+  UINT8                         Minor;
+} EFI_TLS_VERSION;
+
+///
+/// EFI_TLS_CONNECTION_END to define TLS session as client or server.
+///
+typedef enum {
+  EfiTlsClient,
+  EfiTlsServer,
+} EFI_TLS_CONNECTION_END;
+
+///
+/// EFI_TLS_CIPHER
+/// Note: The definition of EFI_TLS_CIPHER definition is from "RFC 5246, A.4.1.
+///       Hello Messages". The value of EFI_TLS_CIPHER is from TLS Cipher
+///       Suite Registry of IANA.
+///
+typedef struct {
+  UINT8                         Data1;
+  UINT8                         Data2;
+} EFI_TLS_CIPHER;
+
+///
+/// EFI_TLS_COMPRESSION
+/// Note: The value of EFI_TLS_COMPRESSION definition is from "RFC 3749".
+///
+typedef UINT8 EFI_TLS_COMPRESSION;
+
+///
+/// EFI_TLS_EXTENSION
+/// Note: The definition of EFI_TLS_EXTENSION if from "RFC 5246 A.4.1.
+///       Hello Messages".
+///
+typedef struct {
+  UINT16                        ExtensionType;
+  UINT16                        Length;
+  UINT8                         Data[1];
+} EFI_TLS_EXTENSION;
+
+///
+/// EFI_TLS_VERIFY
+/// Use either EFI_TLS_VERIFY_NONE or EFI_TLS_VERIFY_PEER, the last two options
+/// are 'ORed' with EFI_TLS_VERIFY_PEER if they are desired.
+///
+typedef UINT32  EFI_TLS_VERIFY;
+///
+/// No certificates will be sent or the TLS/SSL handshake will be continued regardless
+/// of the certificate verification result.
+///
+#define EFI_TLS_VERIFY_NONE                  0x0
+///
+/// The TLS/SSL handshake is immediately terminated with an alert message containing
+/// the reason for the certificate verification failure.
+///
+#define EFI_TLS_VERIFY_PEER                  0x1
+///
+/// TLS session will fail peer certificate is absent.
+///
+#define EFI_TLS_VERIFY_FAIL_IF_NO_PEER_CERT  0x2
+///
+/// TLS session only verify client once, and doesn't request certificate during
+/// re-negotiation.
+///
+#define EFI_TLS_VERIFY_CLIENT_ONCE           0x4
+
+///
+/// EFI_TLS_RANDOM
+/// Note: The definition of EFI_TLS_RANDOM is from "RFC 5246 A.4.1.
+///       Hello Messages".
+///
+typedef struct {
+  UINT32                        GmtUnixTime;
+  UINT8                         RandomBytes[28];
+} EFI_TLS_RANDOM;
+
+///
+/// EFI_TLS_MASTER_SECRET
+/// Note: The definition of EFI_TLS_MASTER_SECRET is from "RFC 5246 8.1.
+///       Computing the Master Secret".
+///
+typedef struct {
+  UINT8                         Data[48];
+} EFI_TLS_MASTER_SECRET;
+
+///
+/// EFI_TLS_SESSION_ID
+/// Note: The definition of EFI_TLS_SESSION_ID is from "RFC 5246 A.4.1. Hello Messages".
+///
+#define MAX_TLS_SESSION_ID_LENGTH  32
+typedef struct {
+  UINT16                        Length;
+  UINT8                         Data[MAX_TLS_SESSION_ID_LENGTH];
+} EFI_TLS_SESSION_ID;
+
+///
+/// EFI_TLS_SESSION_STATE
+///
+typedef enum {
+  ///
+  /// When a new child of TLS protocol is created, the initial state of TLS session
+  /// is EfiTlsSessionNotStarted.
+  ///
+  EfiTlsSessionNotStarted,
+  ///
+  /// The consumer can call BuildResponsePacket() with NULL to get ClientHello to
+  /// start the TLS session. Then the status is EfiTlsSessionHandShaking.
+  ///
+  EfiTlsSessionHandShaking,
+  ///
+  /// During handshake, the consumer need call BuildResponsePacket() with input
+  /// data from peer, then get response packet and send to peer. After handshake
+  /// finish, the TLS session status becomes EfiTlsSessionDataTransferring, and
+  /// consumer can use ProcessPacket() for data transferring.
+  ///
+  EfiTlsSessionDataTransferring,
+  ///
+  /// Finally, if consumer wants to active close TLS session, consumer need
+  /// call SetSessionData to set TLS session state to EfiTlsSessionClosing, and
+  /// call BuildResponsePacket() with NULL to get CloseNotify alert message,
+  /// and sent it out.
+  ///
+  EfiTlsSessionClosing,
+  ///
+  /// If any error happen during parsing ApplicationData content type, EFI_ABORT
+  /// will be returned by ProcessPacket(), and TLS session state will become
+  /// EfiTlsSessionError. Then consumer need call BuildResponsePacket() with
+  /// NULL to get alert message and sent it out.
+  ///
+  EfiTlsSessionError,
+
+  EfiTlsSessionStateMaximum
+
+} EFI_TLS_SESSION_STATE;
+
+///
+/// EFI_TLS_FRAGMENT_DATA
+///
+typedef struct {
+  ///
+  /// Length of data buffer in the fragment.
+  ///
+  UINT32                        FragmentLength;
+  ///
+  /// Pointer to the data buffer in the fragment.
+  ///
+  VOID                          *FragmentBuffer;
+} EFI_TLS_FRAGMENT_DATA;
+
+///
+/// EFI_TLS_CRYPT_MODE
+///
+typedef enum {
+  ///
+  /// Encrypt data provided in the fragment buffers.
+  ///
+  EfiTlsEncrypt,
+  ///
+  /// Decrypt data provided in the fragment buffers.
+  ///
+  EfiTlsDecrypt,
+} EFI_TLS_CRYPT_MODE;
+
+/**
+  Set TLS session data.
+
+  The SetSessionData() function set data for a new TLS session. All session data should
+  be set before BuildResponsePacket() invoked.
+
+  @param[in]  This                Pointer to the EFI_TLS_PROTOCOL instance.
+  @param[in]  DataType            TLS session data type.
+  @param[in]  Data                Pointer to session data.
+  @param[in]  DataSize            Total size of session data.
+
+  @retval EFI_SUCCESS             The TLS session data is set successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  DataSize is 0.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_ACCESS_DENIED       If the DataType is one of below:
+                                  EfiTlsClientRandom
+                                  EfiTlsServerRandom
+                                  EfiTlsKeyMaterial
+  @retval EFI_NOT_READY           Current TLS session state is NOT
+                                  EfiTlsSessionStateNotStarted.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_SET_SESSION_DATA) (
+  IN EFI_TLS_PROTOCOL                *This,
+  IN EFI_TLS_SESSION_DATA_TYPE       DataType,
+  IN VOID                            *Data,
+  IN UINTN                           DataSize
+  );
+
+/**
+  Get TLS session data.
+
+  The GetSessionData() function return the TLS session information.
+
+  @param[in]       This           Pointer to the EFI_TLS_PROTOCOL instance.
+  @param[in]       DataType       TLS session data type.
+  @param[in, out]  Data           Pointer to session data.
+  @param[in, out]  DataSize       Total size of session data. On input, it means
+                                  the size of Data buffer. On output, it means the size
+                                  of copied Data buffer if EFI_SUCCESS, and means the
+                                  size of desired Data buffer if EFI_BUFFER_TOO_SMALL.
+
+  @retval EFI_SUCCESS             The TLS session data is got successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  DataSize is NULL.
+                                  Data is NULL if *DataSize is not zero.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_NOT_FOUND           The TLS session data is not found.
+  @retval EFI_NOT_READY           The DataType is not ready in current session state.
+  @retval EFI_BUFFER_TOO_SMALL    The buffer is too small to hold the data.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_GET_SESSION_DATA) (
+  IN EFI_TLS_PROTOCOL                *This,
+  IN EFI_TLS_SESSION_DATA_TYPE       DataType,
+  IN OUT VOID                        *Data,  OPTIONAL
+  IN OUT UINTN                       *DataSize
+  );
+
+/**
+  Build response packet according to TLS state machine. This function is only valid for
+  alert, handshake and change_cipher_spec content type.
+
+  The BuildResponsePacket() function builds TLS response packet in response to the TLS
+  request packet specified by RequestBuffer and RequestSize. If RequestBuffer is NULL and
+  RequestSize is 0, and TLS session status is EfiTlsSessionNotStarted, the TLS session
+  will be initiated and the response packet needs to be ClientHello. If RequestBuffer is
+  NULL and RequestSize is 0, and TLS session status is EfiTlsSessionClosing, the TLS
+  session will be closed and response packet needs to be CloseNotify. If RequestBuffer is
+  NULL and RequestSize is 0, and TLS session status is EfiTlsSessionError, the TLS
+  session has errors and the response packet needs to be Alert message based on error
+  type.
+
+  @param[in]       This           Pointer to the EFI_TLS_PROTOCOL instance.
+  @param[in]       RequestBuffer  Pointer to the most recently received TLS packet. NULL
+                                  means TLS need initiate the TLS session and response
+                                  packet need to be ClientHello.
+  @param[in]       RequestSize    Packet size in bytes for the most recently received TLS
+                                  packet. 0 is only valid when RequestBuffer is NULL.
+  @param[out]      Buffer         Pointer to the buffer to hold the built packet.
+  @param[in, out]  BufferSize     Pointer to the buffer size in bytes. On input, it is
+                                  the buffer size provided by the caller. On output, it
+                                  is the buffer size in fact needed to contain the
+                                  packet.
+
+  @retval EFI_SUCCESS             The required TLS packet is built successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  RequestBuffer is NULL but RequestSize is NOT 0.
+                                  RequestSize is 0 but RequestBuffer is NOT NULL.
+                                  BufferSize is NULL.
+                                  Buffer is NULL if *BufferSize is not zero.
+  @retval EFI_BUFFER_TOO_SMALL    BufferSize is too small to hold the response packet.
+  @retval EFI_NOT_READY           Current TLS session state is NOT ready to build
+                                  ResponsePacket.
+  @retval EFI_ABORTED             Something wrong build response packet.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_BUILD_RESPONSE_PACKET) (
+  IN EFI_TLS_PROTOCOL                *This,
+  IN UINT8                           *RequestBuffer, OPTIONAL
+  IN UINTN                           RequestSize, OPTIONAL
+  OUT UINT8                          *Buffer, OPTIONAL
+  IN OUT UINTN                       *BufferSize
+  );
+
+/**
+  Decrypt or encrypt TLS packet during session. This function is only valid after
+  session connected and for application_data content type.
+
+  The ProcessPacket () function process each inbound or outbound TLS APP packet.
+
+  @param[in]       This           Pointer to the EFI_TLS_PROTOCOL instance.
+  @param[in, out]  FragmentTable  Pointer to a list of fragment. The caller will take
+                                  responsible to handle the original FragmentTable while
+                                  it may be reallocated in TLS driver. If CryptMode is
+                                  EfiTlsEncrypt, on input these fragments contain the TLS
+                                  header and plain text TLS APP payload; on output these
+                                  fragments contain the TLS header and cipher text TLS
+                                  APP payload. If CryptMode is EfiTlsDecrypt, on input
+                                  these fragments contain the TLS header and cipher text
+                                  TLS APP payload; on output these fragments contain the
+                                  TLS header and plain text TLS APP payload.
+  @param[in]       FragmentCount  Number of fragment.
+  @param[in]       CryptMode      Crypt mode.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  FragmentTable is NULL.
+                                  FragmentCount is NULL.
+                                  CryptoMode is invalid.
+  @retval EFI_NOT_READY           Current TLS session state is NOT
+                                  EfiTlsSessionDataTransferring.
+  @retval EFI_ABORTED             Something wrong decryption the message. TLS session
+                                  status will become EfiTlsSessionError. The caller need
+                                  call BuildResponsePacket() to generate Error Alert
+                                  message and send it out.
+  @retval EFI_OUT_OF_RESOURCES    No enough resource to finish the operation.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_PROCESS_PACKET) (
+  IN EFI_TLS_PROTOCOL                *This,
+  IN OUT EFI_TLS_FRAGMENT_DATA       **FragmentTable,
+  IN UINT32                          *FragmentCount,
+  IN EFI_TLS_CRYPT_MODE              CryptMode
+  );
+
+///
+/// The EFI_TLS_PROTOCOL is used to create, destroy and manage TLS session.
+/// For detail of TLS, please refer to TLS related RFC.
+///
+struct _EFI_TLS_PROTOCOL {
+  EFI_TLS_SET_SESSION_DATA           SetSessionData;
+  EFI_TLS_GET_SESSION_DATA           GetSessionData;
+  EFI_TLS_BUILD_RESPONSE_PACKET      BuildResponsePacket;
+  EFI_TLS_PROCESS_PACKET             ProcessPacket;
+};
+
+extern EFI_GUID gEfiTlsServiceBindingProtocolGuid;
+extern EFI_GUID gEfiTlsProtocolGuid;
+
+#endif  // __EFI_TLS_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/TlsConfig.h b/MdePkg/Include/Protocol/TlsConfig.h
new file mode 100644
index 000000000000..012f4ce75e77
--- /dev/null
+++ b/MdePkg/Include/Protocol/TlsConfig.h
@@ -0,0 +1,132 @@
+/** @file
+  EFI TLS Configuration Protocol as defined in UEFI 2.5.
+  The EFI TLS Configuration Protocol provides a way to set and get TLS configuration.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+#ifndef __EFI_TLS_CONFIGURATION_PROTOCOL_H__
+#define __EFI_TLS_CONFIGURATION_PROTOCOL_H__
+
+///
+/// The EFI Configuration protocol provides a way to set and get TLS configuration.
+///
+#define EFI_TLS_CONFIGURATION_PROTOCOL_GUID  \
+  { \
+    0x1682fe44, 0xbd7a, 0x4407, { 0xb7, 0xc7, 0xdc, 0xa3, 0x7c, 0xa3, 0x92, 0x2d }  \
+  }
+
+typedef struct _EFI_TLS_CONFIGURATION_PROTOCOL EFI_TLS_CONFIGURATION_PROTOCOL;
+
+///
+/// EFI_TLS_CONFIG_DATA_TYPE
+///
+typedef enum {
+  ///
+  /// Local host configuration data: public certificate data.
+  /// This data should be DER-encoded binary X.509 certificate 
+  /// or PEM-encoded X.509 certificate.
+  ///
+  EfiTlsConfigDataTypeHostPublicCert,
+  ///
+  /// Local host configuration data: private key data.
+  ///
+  EfiTlsConfigDataTypeHostPrivateKey,
+  ///
+  /// CA certificate to verify peer. This data should be PEM-encoded 
+  /// RSA or PKCS#8 private key.
+  ///
+  EfiTlsConfigDataTypeCACertificate,
+  ///
+  /// CA-supplied Certificate Revocation List data. This data should
+  /// be DER-encoded CRL data.
+  ///
+  EfiTlsConfigDataTypeCertRevocationList,
+
+  EfiTlsConfigDataTypeMaximum
+
+} EFI_TLS_CONFIG_DATA_TYPE;
+
+/**
+  Set TLS configuration data.
+
+  The SetData() function sets TLS configuration to non-volatile storage or volatile
+  storage.
+
+  @param[in]  This                Pointer to the EFI_TLS_CONFIGURATION_PROTOCOL instance.
+  @param[in]  DataType            Configuration data type.
+  @param[in]  Data                Pointer to configuration data.
+  @param[in]  DataSize            Total size of configuration data.
+
+  @retval EFI_SUCCESS             The TLS configuration data is set successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  DataSize is 0.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_CONFIGURATION_SET_DATA)(
+  IN EFI_TLS_CONFIGURATION_PROTOCOL  *This,
+  IN EFI_TLS_CONFIG_DATA_TYPE        DataType,
+  IN VOID                            *Data,
+  IN UINTN                           DataSize
+  );
+
+/**
+  Get TLS configuration data.
+
+  The GetData() function gets TLS configuration.
+
+  @param[in]       This           Pointer to the EFI_TLS_CONFIGURATION_PROTOCOL instance.
+  @param[in]       DataType       Configuration data type.
+  @param[in, out]  Data           Pointer to configuration data.
+  @param[in, out]  DataSize       Total size of configuration data. On input, it means
+                                  the size of Data buffer. On output, it means the size
+                                  of copied Data buffer if EFI_SUCCESS, and means the
+                                  size of desired Data buffer if EFI_BUFFER_TOO_SMALL.
+
+  @retval EFI_SUCCESS             The TLS configuration data is got successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  DataSize is NULL.
+                                  Data is NULL if *DataSize is not zero.
+  @retval EFI_UNSUPPORTED         The DataType is unsupported.
+  @retval EFI_NOT_FOUND           The TLS configuration data is not found.
+  @retval EFI_BUFFER_TOO_SMALL    The buffer is too small to hold the data.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TLS_CONFIGURATION_GET_DATA)(
+  IN EFI_TLS_CONFIGURATION_PROTOCOL  *This,
+  IN EFI_TLS_CONFIG_DATA_TYPE        DataType,
+  IN OUT VOID                        *Data,  OPTIONAL
+  IN OUT UINTN                       *DataSize
+  );
+
+///
+/// The EFI_TLS_CONFIGURATION_PROTOCOL is designed to provide a way to set and get
+/// TLS configuration, such as Certificate, private key data.
+///
+struct _EFI_TLS_CONFIGURATION_PROTOCOL {
+  EFI_TLS_CONFIGURATION_SET_DATA     SetData;
+  EFI_TLS_CONFIGURATION_GET_DATA     GetData;
+};
+
+extern EFI_GUID gEfiTlsConfigurationProtocolGuid;
+
+#endif  //__EFI_TLS_CONFIGURATION_PROTOCOL_H__
diff --git a/MdePkg/Include/Protocol/TrEEProtocol.h b/MdePkg/Include/Protocol/TrEEProtocol.h
new file mode 100644
index 000000000000..d98cedcee692
--- /dev/null
+++ b/MdePkg/Include/Protocol/TrEEProtocol.h
@@ -0,0 +1,249 @@
+/** @file
+  This protocol is defined to abstract TPM2 hardware access in boot phase.
+
+Copyright (c) 2013 - 2016, 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 __TREE_H__
+#define __TREE_H__
+
+#include <IndustryStandard/UefiTcgPlatform.h>
+#include <IndustryStandard/Tpm20.h>
+
+#define EFI_TREE_PROTOCOL_GUID \
+  {0x607f766c, 0x7455, 0x42be, 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f}
+
+typedef struct _EFI_TREE_PROTOCOL EFI_TREE_PROTOCOL;
+
+typedef struct _TREE_VERSION {
+  UINT8 Major;
+  UINT8 Minor;
+} TREE_VERSION;
+
+typedef UINT32 TREE_EVENT_LOG_BITMAP;
+typedef UINT32 TREE_EVENT_LOG_FORMAT;
+
+#define TREE_EVENT_LOG_FORMAT_TCG_1_2       0x00000001
+
+typedef struct _TREE_BOOT_SERVICE_CAPABILITY {
+  //
+  // Allocated size of the structure passed in 
+  //
+  UINT8                 Size;
+  //
+  // Version of the TREE_BOOT_SERVICE_CAPABILITY structure itself.
+  // For this version of the protocol, the Major version shall be set to 1
+  // and the Minor version shall be set to 0. 
+  //
+  TREE_VERSION          StructureVersion;
+  //
+  // Version of the TrEE protocol.
+  // For this version of the protocol, the Major version shall be set to 1
+  // and the Minor version shall be set to 0. 
+  //
+  TREE_VERSION          ProtocolVersion;
+  //
+  // Supported hash algorithms
+  //
+  UINT32                HashAlgorithmBitmap;
+  //
+  // Bitmap of supported event log formats
+  //
+  TREE_EVENT_LOG_BITMAP SupportedEventLogs;
+  //
+  // False = TrEE not present 
+  //
+  BOOLEAN               TrEEPresentFlag;
+  //
+  // Max size (in bytes) of a command that can be sent to the TrEE 
+  //
+  UINT16                MaxCommandSize;
+  //
+  // Max size (in bytes) of a response that can be provided by the TrEE 
+  //
+  UINT16                MaxResponseSize;
+  //
+  // 4-byte Vendor ID (see Trusted Computing Group, "TCG Vendor ID Registry,"
+  // Version 1.0, Revision 0.1, August 31, 2007, "TPM Capabilities Vendor ID" section) 
+  //
+  UINT32                ManufacturerID;
+} TREE_BOOT_SERVICE_CAPABILITY_1_0;
+
+typedef TREE_BOOT_SERVICE_CAPABILITY_1_0 TREE_BOOT_SERVICE_CAPABILITY;
+
+#define TREE_BOOT_HASH_ALG_SHA1   0x00000001
+#define TREE_BOOT_HASH_ALG_SHA256 0x00000002
+#define TREE_BOOT_HASH_ALG_SHA384 0x00000004
+#define TREE_BOOT_HASH_ALG_SHA512 0x00000008
+
+//
+// This bit is shall be set when an event shall be extended but not logged.
+//
+#define TREE_EXTEND_ONLY  0x0000000000000001
+//
+// This bit shall be set when the intent is to measure a PE/COFF image.
+//
+#define PE_COFF_IMAGE     0x0000000000000010
+
+typedef UINT32 TrEE_PCRINDEX;
+typedef UINT32 TrEE_EVENTTYPE;
+
+#define MAX_PCR_INDEX  23
+#define TREE_EVENT_HEADER_VERSION  1
+
+#pragma pack(1)
+
+typedef struct {
+  //
+  // Size of the event header itself (sizeof(TrEE_EVENT_HEADER)). 
+  //
+  UINT32            HeaderSize;
+  //
+  // Header version. For this version of this specification, the value shall be 1.
+  //
+  UINT16            HeaderVersion;
+  //
+  // Index of the PCR that shall be extended (0 - 23). 
+  //
+  TrEE_PCRINDEX     PCRIndex;
+  //
+  // Type of the event that shall be extended (and optionally logged). 
+  //
+  TrEE_EVENTTYPE    EventType;
+} TrEE_EVENT_HEADER;
+
+typedef struct {
+  //
+  // Total size of the event including the Size component, the header and the Event data. 
+  //
+  UINT32            Size;
+  TrEE_EVENT_HEADER Header;
+  UINT8             Event[1];
+} TrEE_EVENT;
+
+#pragma pack()
+
+/**
+  The EFI_TREE_PROTOCOL GetCapability function call provides protocol
+  capability information and state information about the TrEE.
+
+  @param[in]  This               Indicates the calling context
+  @param[out] ProtocolCapability The caller allocates memory for a TREE_BOOT_SERVICE_CAPABILITY
+                                 structure and sets the size field to the size of the structure allocated.
+                                 The callee fills in the fields with the EFI protocol capability information
+                                 and the current TrEE state information up to the number of fields which
+                                 fit within the size of the structure passed in.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_DEVICE_ERROR       The command was unsuccessful.
+                                 The ProtocolCapability variable will not be populated. 
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+                                 The ProtocolCapability variable will not be populated.
+  @retval EFI_BUFFER_TOO_SMALL   The ProtocolCapability variable is too small to hold the full response.
+                                 It will be partially populated (required Size field will be set). 
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TREE_GET_CAPABILITY) (
+  IN EFI_TREE_PROTOCOL                *This,
+  IN OUT TREE_BOOT_SERVICE_CAPABILITY *ProtocolCapability
+  );
+
+/**
+  The EFI_TREE_PROTOCOL Get Event Log function call allows a caller to
+  retrieve the address of a given event log and its last entry. 
+
+  @param[in]  This               Indicates the calling context
+  @param[in]  EventLogFormat     The type of the event log for which the information is requested.
+  @param[out] EventLogLocation   A pointer to the memory address of the event log.
+  @param[out] EventLogLastEntry  If the Event Log contains more than one entry, this is a pointer to the
+                                 address of the start of the last entry in the event log in memory.
+  @param[out] EventLogTruncated  If the Event Log is missing at least one entry because an event would
+                                 have exceeded the area allocated for events, this value is set to TRUE.
+                                 Otherwise, the value will be FALSE and the Event Log will be complete.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect
+                                 (e.g. asking for an event log whose format is not supported).
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TREE_GET_EVENT_LOG) (
+  IN EFI_TREE_PROTOCOL     *This,
+  IN TREE_EVENT_LOG_FORMAT EventLogFormat,
+  OUT EFI_PHYSICAL_ADDRESS *EventLogLocation,
+  OUT EFI_PHYSICAL_ADDRESS *EventLogLastEntry,
+  OUT BOOLEAN              *EventLogTruncated
+  );
+
+/**
+  The EFI_TREE_PROTOCOL HashLogExtendEvent function call provides callers with
+  an opportunity to extend and optionally log events without requiring
+  knowledge of actual TPM commands. 
+  The extend operation will occur even if this function cannot create an event
+  log entry (e.g. due to the event log being full). 
+
+  @param[in]  This               Indicates the calling context
+  @param[in]  Flags              Bitmap providing additional information.
+  @param[in]  DataToHash         Physical address of the start of the data buffer to be hashed. 
+  @param[in]  DataToHashLen      The length in bytes of the buffer referenced by DataToHash.
+  @param[in]  Event              Pointer to data buffer containing information about the event.
+
+  @retval EFI_SUCCESS            Operation completed successfully.
+  @retval EFI_DEVICE_ERROR       The command was unsuccessful.
+  @retval EFI_VOLUME_FULL        The extend operation occurred, but the event could not be written to one or more event logs.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+  @retval EFI_UNSUPPORTED        The PE/COFF image type is not supported.
+**/
+typedef
+EFI_STATUS
+(EFIAPI * EFI_TREE_HASH_LOG_EXTEND_EVENT) (
+  IN EFI_TREE_PROTOCOL    *This,
+  IN UINT64               Flags,
+  IN EFI_PHYSICAL_ADDRESS DataToHash,
+  IN UINT64               DataToHashLen,
+  IN TrEE_EVENT           *Event
+  );
+
+/**
+  This service enables the sending of commands to the TrEE.
+
+  @param[in]  This                     Indicates the calling context
+  @param[in]  InputParameterBlockSize  Size of the TrEE input parameter block.
+  @param[in]  InputParameterBlock      Pointer to the TrEE input parameter block.
+  @param[in]  OutputParameterBlockSize Size of the TrEE output parameter block.
+  @param[in]  OutputParameterBlock     Pointer to the TrEE output parameter block.
+
+  @retval EFI_SUCCESS            The command byte stream was successfully sent to the device and a response was successfully received.
+  @retval EFI_DEVICE_ERROR       The command was not successfully sent to the device or a response was not successfully received from the device.
+  @retval EFI_INVALID_PARAMETER  One or more of the parameters are incorrect.
+  @retval EFI_BUFFER_TOO_SMALL   The output parameter block is too small. 
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TREE_SUBMIT_COMMAND) (
+  IN EFI_TREE_PROTOCOL *This,
+  IN UINT32            InputParameterBlockSize,
+  IN UINT8             *InputParameterBlock,
+  IN UINT32            OutputParameterBlockSize,
+  IN UINT8             *OutputParameterBlock
+  );
+
+struct _EFI_TREE_PROTOCOL {
+  EFI_TREE_GET_CAPABILITY        GetCapability;
+  EFI_TREE_GET_EVENT_LOG         GetEventLog;
+  EFI_TREE_HASH_LOG_EXTEND_EVENT HashLogExtendEvent;
+  EFI_TREE_SUBMIT_COMMAND        SubmitCommand;
+};
+
+extern EFI_GUID gEfiTrEEProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Udp4.h b/MdePkg/Include/Protocol/Udp4.h
new file mode 100644
index 000000000000..9163866a0b83
--- /dev/null
+++ b/MdePkg/Include/Protocol/Udp4.h
@@ -0,0 +1,445 @@
+/** @file
+  UDP4 Service Binding Protocol as defined in UEFI specification.
+
+  The EFI UDPv4 Protocol provides simple packet-oriented services 
+  to transmit and receive UDP packets.  
+
+Copyright (c) 2006 - 2014, 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.      
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.0.       
+
+**/
+
+#ifndef __EFI_UDP4_PROTOCOL_H__
+#define __EFI_UDP4_PROTOCOL_H__
+
+#include <Protocol/Ip4.h>
+//
+//GUID definitions
+//
+#define EFI_UDP4_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x83f01464, 0x99bd, 0x45e5, {0xb3, 0x83, 0xaf, 0x63, 0x05, 0xd8, 0xe9, 0xe6 } \
+  }
+
+#define EFI_UDP4_PROTOCOL_GUID \
+  { \
+    0x3ad9df29, 0x4501, 0x478d, {0xb1, 0xf8, 0x7f, 0x7f, 0xe7, 0x0e, 0x50, 0xf3 } \
+  }
+
+typedef struct _EFI_UDP4_PROTOCOL EFI_UDP4_PROTOCOL; 
+  
+///
+/// EFI_UDP4_SERVICE_POINT is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              InstanceHandle;
+  EFI_IPv4_ADDRESS        LocalAddress;
+  UINT16                  LocalPort;
+  EFI_IPv4_ADDRESS        RemoteAddress;
+  UINT16                  RemotePort;
+} EFI_UDP4_SERVICE_POINT; 
+
+///
+/// EFI_UDP4_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  EFI_HANDLE              DriverHandle;
+  UINT32                  ServiceCount;
+  EFI_UDP4_SERVICE_POINT  Services[1];
+} EFI_UDP4_VARIABLE_DATA;
+
+typedef struct {
+  UINT32             FragmentLength;
+  VOID               *FragmentBuffer;
+} EFI_UDP4_FRAGMENT_DATA;
+
+typedef struct {
+  EFI_IPv4_ADDRESS   SourceAddress;
+  UINT16             SourcePort;
+  EFI_IPv4_ADDRESS   DestinationAddress;
+  UINT16             DestinationPort;
+} EFI_UDP4_SESSION_DATA;
+typedef struct {
+  //
+  // Receiving Filters
+  //
+  BOOLEAN            AcceptBroadcast;
+  BOOLEAN            AcceptPromiscuous;
+  BOOLEAN            AcceptAnyPort;
+  BOOLEAN            AllowDuplicatePort;
+  //
+  // I/O parameters
+  //
+  UINT8              TypeOfService;
+  UINT8              TimeToLive;
+  BOOLEAN            DoNotFragment;
+  UINT32             ReceiveTimeout;
+  UINT32             TransmitTimeout;
+  //
+  // Access Point
+  //
+  BOOLEAN            UseDefaultAddress;
+  EFI_IPv4_ADDRESS   StationAddress;
+  EFI_IPv4_ADDRESS   SubnetMask;
+  UINT16             StationPort;
+  EFI_IPv4_ADDRESS   RemoteAddress;
+  UINT16             RemotePort;
+} EFI_UDP4_CONFIG_DATA;
+
+typedef struct {
+  EFI_UDP4_SESSION_DATA     *UdpSessionData;       //OPTIONAL
+  EFI_IPv4_ADDRESS          *GatewayAddress;       //OPTIONAL
+  UINT32                    DataLength;
+  UINT32                    FragmentCount; 
+  EFI_UDP4_FRAGMENT_DATA    FragmentTable[1];
+} EFI_UDP4_TRANSMIT_DATA;
+
+typedef struct {
+  EFI_TIME                  TimeStamp;
+  EFI_EVENT                 RecycleSignal;
+  EFI_UDP4_SESSION_DATA     UdpSession;
+  UINT32                    DataLength;
+  UINT32                    FragmentCount;
+  EFI_UDP4_FRAGMENT_DATA    FragmentTable[1];
+} EFI_UDP4_RECEIVE_DATA;
+
+
+typedef struct {
+  EFI_EVENT                 Event;
+  EFI_STATUS                Status;
+  union {
+    EFI_UDP4_RECEIVE_DATA   *RxData;
+    EFI_UDP4_TRANSMIT_DATA  *TxData;
+  } Packet;
+} EFI_UDP4_COMPLETION_TOKEN;
+
+/**
+  Reads the current operational settings.
+
+  The GetModeData() function copies the current operational settings of this EFI
+  UDPv4 Protocol instance into user-supplied buffers. This function is used
+  optionally to retrieve the operational mode data of underlying networks or
+  drivers.
+
+  @param  This           The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  Udp4ConfigData The pointer to the buffer to receive the current configuration data.
+  @param  Ip4ModeData    The pointer to the EFI IPv4 Protocol mode data structure.
+  @param  MnpConfigData  The pointer to the managed network configuration data structure.
+  @param  SnpModeData    The pointer to the simple network mode data structure.
+
+  @retval EFI_SUCCESS           The mode data was read.
+  @retval EFI_NOT_STARTED       When Udp4ConfigData is queried, no configuration data is
+                                available because this instance has not been started.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_GET_MODE_DATA)(
+  IN  EFI_UDP4_PROTOCOL                *This,
+  OUT EFI_UDP4_CONFIG_DATA             *Udp4ConfigData OPTIONAL,
+  OUT EFI_IP4_MODE_DATA                *Ip4ModeData    OPTIONAL,
+  OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
+  OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
+  );  
+  
+
+/**
+  Initializes, changes, or resets the operational parameters for this instance of the EFI UDPv4
+  Protocol.
+  
+  The Configure() function is used to do the following:
+  * Initialize and start this instance of the EFI UDPv4 Protocol.
+  * Change the filtering rules and operational parameters.
+  * Reset this instance of the EFI UDPv4 Protocol.
+  Until these parameters are initialized, no network traffic can be sent or
+  received by this instance. This instance can be also reset by calling Configure()
+  with UdpConfigData set to NULL. Once reset, the receiving queue and transmitting
+  queue are flushed and no traffic is allowed through this instance.
+  With different parameters in UdpConfigData, Configure() can be used to bind
+  this instance to specified port.
+
+  @param  This           The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  Udp4ConfigData The pointer to the buffer to receive the current configuration data.
+
+  @retval EFI_SUCCESS           The configuration settings were set, changed, or reset successfully.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER UdpConfigData.StationAddress is not a valid unicast IPv4 address.
+  @retval EFI_INVALID_PARAMETER UdpConfigData.SubnetMask is not a valid IPv4 address mask. The subnet
+                                mask must be contiguous.
+  @retval EFI_INVALID_PARAMETER UdpConfigData.RemoteAddress is not a valid unicast IPv4 address if it
+                                is not zero.
+  @retval EFI_ALREADY_STARTED   The EFI UDPv4 Protocol instance is already started/configured
+                                and must be stopped/reset before it can be reconfigured.
+  @retval EFI_ACCESS_DENIED     UdpConfigData. AllowDuplicatePort is FALSE
+                                and UdpConfigData.StationPort is already used by
+                                other instance.
+  @retval EFI_OUT_OF_RESOURCES  The EFI UDPv4 Protocol driver cannot allocate memory for this
+                                EFI UDPv4 Protocol instance.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred and this instance
+                                 was not opened. 
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_CONFIGURE)(
+  IN EFI_UDP4_PROTOCOL      *This,
+  IN EFI_UDP4_CONFIG_DATA   *UdpConfigData OPTIONAL
+  );  
+
+/**
+  Joins and leaves multicast groups.
+  
+  The Groups() function is used to enable and disable the multicast group
+  filtering. If the JoinFlag is FALSE and the MulticastAddress is NULL, then all
+  currently joined groups are left.
+
+  @param  This             The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  JoinFlag         Set to TRUE to join a multicast group. Set to FALSE to leave one
+                           or all multicast groups.
+  @param  MulticastAddress The pointer to multicast group address to join or leave.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_NOT_STARTED       The EFI UDPv4 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate resources to join the group.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - JoinFlag is TRUE and MulticastAddress is NULL.
+                                - JoinFlag is TRUE and *MulticastAddress is not
+                                  a valid multicast address.
+  @retval EFI_ALREADY_STARTED   The group address is already in the group table (when
+                                JoinFlag is TRUE).
+  @retval EFI_NOT_FOUND         The group address is not in the group table (when JoinFlag is
+                                FALSE).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_GROUPS)(
+  IN EFI_UDP4_PROTOCOL      *This,
+  IN BOOLEAN                JoinFlag,
+  IN EFI_IPv4_ADDRESS       *MulticastAddress    OPTIONAL
+  );   
+
+/**
+  Adds and deletes routing table entries.
+  
+  The Routes() function adds a route to or deletes a route from the routing table.
+  Routes are determined by comparing the SubnetAddress with the destination IP
+  address and arithmetically AND-ing it with the SubnetMask. The gateway address
+  must be on the same subnet as the configured station address.
+  The default route is added with SubnetAddress and SubnetMask both set to 0.0.0.0.
+  The default route matches all destination IP addresses that do not match any
+  other routes.
+  A zero GatewayAddress is a nonroute. Packets are sent to the destination IP
+  address if it can be found in the Address Resolution Protocol (ARP) cache or
+  on the local subnet. One automatic nonroute entry will be inserted into the
+  routing table for outgoing packets that are addressed to a local subnet
+  (gateway address of 0.0.0.0).
+  Each instance of the EFI UDPv4 Protocol has its own independent routing table.
+  Instances of the EFI UDPv4 Protocol that use the default IP address will also
+  have copies of the routing table provided by the EFI_IP4_CONFIG_PROTOCOL. These
+  copies will be updated automatically whenever the IP driver reconfigures its
+  instances; as a result, the previous modification to these copies will be lost.
+
+  @param  This           The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  DeleteRoute    Set to TRUE to delete this route from the routing table.
+                         Set to FALSE to add this route to the routing table.
+  @param  SubnetAddress  The destination network address that needs to be routed.
+  @param  SubnetMask     The subnet mask of SubnetAddress.
+  @param  GatewayAddress The gateway IP address for this route.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_NOT_STARTED       The EFI UDPv4 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                - RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  Could not add the entry to the routing table.
+  @retval EFI_NOT_FOUND         This route is not in the routing table.
+  @retval EFI_ACCESS_DENIED     The route is already defined in the routing table.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_ROUTES)(
+  IN EFI_UDP4_PROTOCOL      *This,
+  IN BOOLEAN                DeleteRoute,
+  IN EFI_IPv4_ADDRESS       *SubnetAddress,
+  IN EFI_IPv4_ADDRESS       *SubnetMask,
+  IN EFI_IPv4_ADDRESS       *GatewayAddress
+  );     
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+  
+  The Poll() function can be used by network drivers and applications to increase
+  the rate that data packets are moved between the communications device and the
+  transmit and receive queues.
+  In some systems, the periodic timer event in the managed network driver may not
+  poll the underlying communications device fast enough to transmit and/or receive
+  all data packets without missing incoming packets or dropping outgoing packets.
+  Drivers and applications that are experiencing packet loss should try calling
+  the Poll() function more often.
+
+  @param  This The pointer to the EFI_UDP4_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_POLL)(
+  IN EFI_UDP4_PROTOCOL      *This
+  );   
+
+/**
+  Places an asynchronous receive request into the receiving queue.
+  
+  The Receive() function places a completion token into the receive packet queue.
+  This function is always asynchronous.
+  The caller must fill in the Token.Event field in the completion token, and this
+  field cannot be NULL. When the receive operation completes, the EFI UDPv4 Protocol
+  driver updates the Token.Status and Token.Packet.RxData fields and the Token.Event
+  is signaled. Providing a proper notification function and context for the event
+  will enable the user to receive the notification and receiving status. That
+  notification function is guaranteed to not be re-entered.
+
+  @param  This  The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  Token The pointer to a token that is associated with the receive data
+                descriptor.
+
+  @retval EFI_SUCCESS           The receive completion token was cached.
+  @retval EFI_NOT_STARTED       This EFI UDPv4 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP, RARP, etc.)
+                                is not finished yet.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_INVALID_PARAMETER Token is NULL.
+  @retval EFI_INVALID_PARAMETER Token.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The receive completion token could not be queued due to a lack of system
+                                resources (usually memory).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+  @retval EFI_ACCESS_DENIED     A receive completion token with the same Token.Event was already in
+                                the receive queue.
+  @retval EFI_NOT_READY         The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_RECEIVE)(
+  IN EFI_UDP4_PROTOCOL          *This,
+  IN EFI_UDP4_COMPLETION_TOKEN  *Token
+  );   
+
+/**
+  Queues outgoing data packets into the transmit queue.
+  
+  The Transmit() function places a sending request to this instance of the EFI
+  UDPv4 Protocol, alongside the transmit data that was filled by the user. Whenever
+  the packet in the token is sent out or some errors occur, the Token.Event will
+  be signaled and Token.Status is updated. Providing a proper notification function
+  and context for the event will enable the user to receive the notification and
+  transmitting status.
+
+  @param  This  The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  Token The pointer to the completion token that will be placed into the
+                transmit queue.
+
+  @retval EFI_SUCCESS           The data has been queued for transmission.
+  @retval EFI_NOT_STARTED       This EFI UDPv4 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        When using a default address, configuration (DHCP, BOOTP,
+                                RARP, etc.) is not finished yet.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_ACCESS_DENIED     The transmit completion token with the same
+                                Token.Event was already in the transmit queue.
+  @retval EFI_NOT_READY         The completion token could not be queued because the
+                                transmit queue is full.
+  @retval EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
+  @retval EFI_NOT_FOUND         There is no route to the destination network or address.
+  @retval EFI_BAD_BUFFER_SIZE   The data length is greater than the maximum UDP packet
+                                size. Or the length of the IP header + UDP header + data
+                                length is greater than MTU if DoNotFragment is TRUE.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_TRANSMIT)(
+  IN EFI_UDP4_PROTOCOL           *This,
+  IN EFI_UDP4_COMPLETION_TOKEN   *Token
+  );     
+
+/**
+  Aborts an asynchronous transmit or receive request.
+  
+  The Cancel() function is used to abort a pending transmit or receive request.
+  If the token is in the transmit or receive request queues, after calling this
+  function, Token.Status will be set to EFI_ABORTED and then Token.Event will be
+  signaled. If the token is not in one of the queues, which usually means that
+  the asynchronous operation has completed, this function will not signal the
+  token and EFI_NOT_FOUND is returned.
+
+  @param  This  The pointer to the EFI_UDP4_PROTOCOL instance.
+  @param  Token The pointer to a token that has been issued by
+                EFI_UDP4_PROTOCOL.Transmit() or
+                EFI_UDP4_PROTOCOL.Receive().If NULL, all pending
+                tokens are aborted.
+
+  @retval  EFI_SUCCESS           The asynchronous I/O request was aborted and Token.Event
+                                 was signaled. When Token is NULL, all pending requests are
+                                 aborted and their events are signaled.
+  @retval  EFI_INVALID_PARAMETER This is NULL.
+  @retval  EFI_NOT_STARTED       This instance has not been started.
+  @retval  EFI_NO_MAPPING        When using the default address, configuration (DHCP, BOOTP,
+                                 RARP, etc.) is not finished yet.
+  @retval  EFI_NOT_FOUND         When Token is not NULL, the asynchronous I/O request was
+                                 not found in the transmit or receive queue. It has either completed
+                                 or was not issued by Transmit() and Receive().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_CANCEL)(
+  IN EFI_UDP4_PROTOCOL          *This,
+  IN EFI_UDP4_COMPLETION_TOKEN  *Token  OPTIONAL
+  );       
+
+///
+/// The EFI_UDP4_PROTOCOL defines an EFI UDPv4 Protocol session that can be used 
+/// by any network drivers, applications, or daemons to transmit or receive UDP packets. 
+/// This protocol instance can either be bound to a specified port as a service or 
+/// connected to some remote peer as an active client. Each instance has its own settings, 
+/// such as the routing table and group table, which are independent from each other.
+///
+struct _EFI_UDP4_PROTOCOL {
+  EFI_UDP4_GET_MODE_DATA        GetModeData;
+  EFI_UDP4_CONFIGURE            Configure;
+  EFI_UDP4_GROUPS               Groups;
+  EFI_UDP4_ROUTES               Routes;
+  EFI_UDP4_TRANSMIT             Transmit;
+  EFI_UDP4_RECEIVE              Receive;
+  EFI_UDP4_CANCEL               Cancel;
+  EFI_UDP4_POLL                 Poll;
+};
+
+extern EFI_GUID gEfiUdp4ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiUdp4ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Udp6.h b/MdePkg/Include/Protocol/Udp6.h
new file mode 100644
index 000000000000..e1e1dc694e86
--- /dev/null
+++ b/MdePkg/Include/Protocol/Udp6.h
@@ -0,0 +1,580 @@
+/** @file
+  The EFI UDPv6 (User Datagram Protocol version 6) Protocol Definition, which is built upon
+  the EFI IPv6 Protocol and provides simple packet-oriented services to transmit and receive
+  UDP packets.
+
+  Copyright (c) 2008 - 2014, 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. 
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_UDP6_PROTOCOL_H__
+#define __EFI_UDP6_PROTOCOL_H__
+
+#include <Protocol/Ip6.h>
+
+#define EFI_UDP6_SERVICE_BINDING_PROTOCOL_GUID \
+  { \
+    0x66ed4721, 0x3c98, 0x4d3e, {0x81, 0xe3, 0xd0, 0x3d, 0xd3, 0x9a, 0x72, 0x54 } \
+  }
+
+#define EFI_UDP6_PROTOCOL_GUID \
+  { \
+    0x4f948815, 0xb4b9, 0x43cb, {0x8a, 0x33, 0x90, 0xe0, 0x60, 0xb3, 0x49, 0x55 } \
+  }
+
+///
+/// EFI_UDP6_SERVICE_POINT is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  ///
+  /// The EFI UDPv6 Protocol instance handle that is using this address/port pair.
+  ///
+  EFI_HANDLE          InstanceHandle;
+  ///
+  /// The IPv6 address to which this instance of the EFI UDPv6 Protocol is bound.
+  /// Set to 0::/128, if this instance is used to listen all packets from any
+  /// source address.
+  ///
+  EFI_IPv6_ADDRESS    LocalAddress;
+  ///
+  /// The port number in host byte order on which the service is listening.
+  ///
+  UINT16              LocalPort;
+  ///
+  /// The IPv6 address of the remote host. May be 0::/128 if it is not connected
+  /// to any remote host or connected with more than one remote host.
+  ///
+  EFI_IPv6_ADDRESS    RemoteAddress;
+  ///
+  /// The port number in host byte order on which the remote host is 
+  /// listening. Maybe zero if it is not connected to any remote host.
+  ///
+  UINT16              RemotePort;
+} EFI_UDP6_SERVICE_POINT;
+
+///
+/// EFI_UDP6_VARIABLE_DATA is deprecated in the UEFI 2.4B and should not be used any more.
+/// The definition in here is only present to provide backwards compatability.
+///
+typedef struct {
+  ///
+  /// The handle of the driver that creates this entry.
+  ///
+  EFI_HANDLE              DriverHandle;
+  ///
+  /// The number of address/port pairs that follow this data structure.
+  ///
+  UINT32                  ServiceCount;
+  ///
+  /// List of address/port pairs that are currently in use.
+  ///
+  EFI_UDP6_SERVICE_POINT  Services[1];
+} EFI_UDP6_VARIABLE_DATA;
+
+typedef struct _EFI_UDP6_PROTOCOL EFI_UDP6_PROTOCOL;
+
+///
+/// EFI_UDP6_FRAGMENT_DATA allows multiple receive or transmit buffers to be specified.
+/// The purpose of this structure is to avoid copying the same packet multiple times.
+///
+typedef struct {
+  UINT32        FragmentLength;  ///< Length of the fragment data buffer.
+  VOID          *FragmentBuffer; ///< Pointer to the fragment data buffer.
+} EFI_UDP6_FRAGMENT_DATA;
+
+///
+/// The EFI_UDP6_SESSION_DATA is used to retrieve the settings when receiving packets or
+/// to override the existing settings (only DestinationAddress and DestinationPort can
+/// be overridden) of this EFI UDPv6 Protocol instance when sending packets.
+///
+typedef struct {
+  ///
+  /// Address from which this packet is sent. This field should not be used when
+  /// sending packets.
+  ///
+  EFI_IPv6_ADDRESS   SourceAddress;
+  ///
+  /// Port from which this packet is sent. It is in host byte order. This field should
+  /// not be used when sending packets.
+  ///
+  UINT16             SourcePort;
+  ///
+  /// Address to which this packet is sent. When sending packet, it'll be ignored
+  /// if it is zero.
+  ///
+  EFI_IPv6_ADDRESS   DestinationAddress;
+  ///
+  /// Port to which this packet is sent. When sending packet, it'll be 
+  /// ignored if it is zero.
+  ///
+  UINT16             DestinationPort;
+} EFI_UDP6_SESSION_DATA;
+
+typedef struct {
+  ///
+  /// Set to TRUE to accept UDP packets that are sent to any address.
+  ///
+  BOOLEAN           AcceptPromiscuous;
+  ///
+  /// Set to TRUE to accept UDP packets that are sent to any port.
+  ///
+  BOOLEAN           AcceptAnyPort;
+  ///
+  /// Set to TRUE to allow this EFI UDPv6 Protocol child instance to open a port number
+  /// that is already being used by another EFI UDPv6 Protocol child instance.
+  ///
+  BOOLEAN           AllowDuplicatePort;
+  ///
+  /// TrafficClass field in transmitted IPv6 packets.
+  ///
+  UINT8             TrafficClass;
+  ///
+  /// HopLimit field in transmitted IPv6 packets.
+  ///
+  UINT8             HopLimit;
+  ///
+  /// The receive timeout value (number of microseconds) to be associated with each
+  /// incoming packet. Zero means do not drop incoming packets.
+  ///
+  UINT32            ReceiveTimeout;
+  ///
+  /// The transmit timeout value (number of microseconds) to be associated with each
+  /// outgoing packet. Zero means do not drop outgoing packets.
+  ///
+  UINT32            TransmitTimeout;
+  ///
+  /// The station IP address that will be assigned to this EFI UDPv6 Protocol instance.
+  /// The EFI UDPv6 and EFI IPv6 Protocol drivers will only deliver incoming packets
+  /// whose destination matches this IP address exactly. Address 0::/128 is also accepted
+  /// as a special case. Under this situation, underlying IPv6 driver is responsible for
+  /// binding a source address to this EFI IPv6 protocol instance according to source
+  /// address selection algorithm. Only incoming packet from the selected source address
+  /// is delivered. This field can be set and changed only when the EFI IPv6 driver is
+  /// transitioning from the stopped to the started states. If no address is available
+  /// for selecting, the EFI IPv6 Protocol driver will use EFI_IP6_CONFIG_PROTOCOL to
+  /// retrieve the IPv6 address.
+  EFI_IPv6_ADDRESS  StationAddress;
+  ///
+  /// The port number to which this EFI UDPv6 Protocol instance is bound. If a client
+  /// of the EFI UDPv6 Protocol does not care about the port number, set StationPort
+  /// to zero. The EFI UDPv6 Protocol driver will assign a random port number to transmitted 
+  /// UDP packets. Ignored it if AcceptAnyPort is TRUE.
+  ///
+  UINT16            StationPort;
+  ///
+  /// The IP address of remote host to which this EFI UDPv6 Protocol instance is connecting.
+  /// If RemoteAddress is not 0::/128, this EFI UDPv6 Protocol instance will be connected to
+  /// RemoteAddress; i.e., outgoing packets of this EFI UDPv6 Protocol instance will be sent
+  /// to this address by default and only incoming packets from this address will be delivered
+  /// to client. Ignored for incoming filtering if AcceptPromiscuous is TRUE.
+  EFI_IPv6_ADDRESS  RemoteAddress;
+  ///
+  /// The port number of the remote host to which this EFI UDPv6 Protocol instance is connecting.
+  /// If it is not zero, outgoing packets of this EFI UDPv6 Protocol instance will be sent to
+  /// this port number by default and only incoming packets from this port will be delivered
+  /// to client. Ignored if RemoteAddress is 0::/128 and ignored for incoming filtering if
+  /// AcceptPromiscuous is TRUE.
+  UINT16            RemotePort;
+} EFI_UDP6_CONFIG_DATA;
+
+///
+/// The EFI UDPv6 Protocol client must fill this data structure before sending a packet.
+/// The packet may contain multiple buffers that may be not in a continuous memory location.
+///
+typedef struct {
+  ///
+  /// If not NULL, the data that is used to override the transmitting settings.Only the two
+  /// filed UdpSessionData.DestinationAddress and UdpSessionData.DestionPort can be used as
+  /// the transmitting setting filed.
+  ///
+  EFI_UDP6_SESSION_DATA     *UdpSessionData;
+  ///
+  /// Sum of the fragment data length. Must not exceed the maximum UDP packet size.
+  ///
+  UINT32                    DataLength;
+  ///
+  /// Number of fragments.
+  ///
+  UINT32                    FragmentCount;
+  ///
+  /// Array of fragment descriptors.
+  ///
+  EFI_UDP6_FRAGMENT_DATA    FragmentTable[1];
+} EFI_UDP6_TRANSMIT_DATA;
+
+///
+/// EFI_UDP6_RECEIVE_DATA is filled by the EFI UDPv6 Protocol driver when this EFI UDPv6
+/// Protocol instance receives an incoming packet. If there is a waiting token for incoming
+/// packets, the CompletionToken.Packet.RxData field is updated to this incoming packet and
+/// the CompletionToken.Event is signaled. The EFI UDPv6 Protocol client must signal the
+/// RecycleSignal after processing the packet.
+/// FragmentTable could contain multiple buffers that are not in the continuous memory locations. 
+/// The EFI UDPv6 Protocol client might need to combine two or more buffers in FragmentTable to 
+/// form their own protocol header.
+///
+typedef struct {
+  ///
+  /// Time when the EFI UDPv6 Protocol accepted the packet.
+  ///
+  EFI_TIME                  TimeStamp;
+  ///
+  /// Indicates the event to signal when the received data has been processed.
+  ///
+  EFI_EVENT                 RecycleSignal;
+  ///
+  /// The UDP session data including SourceAddress, SourcePort, DestinationAddress,
+  /// and DestinationPort.
+  ///
+  EFI_UDP6_SESSION_DATA     UdpSession;
+  ///
+  /// The sum of the fragment data length.
+  ///
+  UINT32                    DataLength;
+  ///
+  /// Number of fragments. Maybe zero.
+  ///
+  UINT32                    FragmentCount;
+  ///
+  /// Array of fragment descriptors. Maybe zero.
+  ///
+  EFI_UDP6_FRAGMENT_DATA    FragmentTable[1];
+} EFI_UDP6_RECEIVE_DATA;
+
+///
+/// The EFI_UDP6_COMPLETION_TOKEN structures are used for both transmit and receive operations.
+/// When used for transmitting, the Event and TxData fields must be filled in by the EFI UDPv6
+/// Protocol client. After the transmit operation completes, the Status field is updated by the
+/// EFI UDPv6 Protocol and the Event is signaled.
+/// When used for receiving, only the Event field must be filled in by the EFI UDPv6 Protocol
+/// client. After a packet is received, RxData and Status are filled in by the EFI UDPv6 Protocol
+/// and the Event is signaled.
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI UDPv6 Protocol
+  /// driver. The type of Event must be EVT_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                             Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   - EFI_SUCCESS: The receive or transmit operation completed successfully.
+  ///   - EFI_ABORTED: The receive or transmit was aborted.
+  ///   - EFI_TIMEOUT: The transmit timeout expired.
+  ///   - EFI_NETWORK_UNREACHABLE: The destination network is unreachable. RxData is set to 
+  ///     NULL in this situation.
+  ///   - EFI_HOST_UNREACHABLE: The destination host is unreachable. RxData is set to NULL in 
+  ///     this situation.
+  ///   - EFI_PROTOCOL_UNREACHABLE: The UDP protocol is unsupported in the remote system. 
+  ///     RxData is set to NULL in this situation.
+  ///   - EFI_PORT_UNREACHABLE: No service is listening on the remote port. RxData is set to 
+  ///     NULL in this situation.
+  ///   - EFI_ICMP_ERROR: Some other Internet Control Message Protocol (ICMP) error report was 
+  ///     received. For example, packets are being sent too fast for the destination to receive them
+  ///     and the destination sent an ICMP source quench report. RxData is set to NULL in this situation.
+  ///   - EFI_DEVICE_ERROR: An unexpected system or network error occurred.
+  ///   - EFI_SECURITY_VIOLATION: The transmit or receive was failed because of IPsec policy check.
+  ///   - EFI_NO_MEDIA: There was a media error.
+  ///
+  EFI_STATUS                            Status;
+  union {
+    ///
+    /// When this token is used for receiving, RxData is a pointer to EFI_UDP6_RECEIVE_DATA.
+    ///
+    EFI_UDP6_RECEIVE_DATA               *RxData;
+    ///
+    /// When this token is used for transmitting, TxData is a pointer to EFI_UDP6_TRANSMIT_DATA.
+    ///
+    EFI_UDP6_TRANSMIT_DATA              *TxData;
+  } Packet;
+} EFI_UDP6_COMPLETION_TOKEN;
+
+/**
+  Read the current operational settings.
+
+  The GetModeData() function copies the current operational settings of this EFI UDPv6 Protocol
+  instance into user-supplied buffers. This function is used optionally to retrieve the operational
+  mode data of underlying networks or drivers. 
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[out]  Udp6ConfigData   The buffer in which the current UDP configuration data is returned.
+  @param[out]  Ip6ModeData      The buffer in which the current EFI IPv6 Protocol mode data is returned.
+  @param[out]  MnpConfigData    The buffer in which the current managed network configuration data is
+                                returned.
+  @param[out]  SnpModeData      The buffer in which the simple network mode data is returned.
+
+  @retval EFI_SUCCESS           The mode data was read.
+  @retval EFI_NOT_STARTED       When Udp6ConfigData is queried, no configuration data is available
+                                because this instance has not been started.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_GET_MODE_DATA)(
+  IN EFI_UDP6_PROTOCOL                 *This,
+  OUT EFI_UDP6_CONFIG_DATA             *Udp6ConfigData OPTIONAL,
+  OUT EFI_IP6_MODE_DATA                *Ip6ModeData    OPTIONAL,
+  OUT EFI_MANAGED_NETWORK_CONFIG_DATA  *MnpConfigData  OPTIONAL,
+  OUT EFI_SIMPLE_NETWORK_MODE          *SnpModeData    OPTIONAL
+);
+
+/**
+  Initializes, changes, or resets the operational parameters for this instance of the EFI UDPv6 
+  Protocol.
+
+  The Configure() function is used to do the following:
+  - Initialize and start this instance of the EFI UDPv6 Protocol.
+  - Change the filtering rules and operational parameters.
+  - Reset this instance of the EFI UDPv6 Protocol. 
+
+  Until these parameters are initialized, no network traffic can be sent or received by this instance.
+  This instance can be also reset by calling Configure() with UdpConfigData set to NULL.
+  Once reset, the receiving queue and transmitting queue are flushed and no traffic is allowed through
+  this instance.
+
+  With different parameters in UdpConfigData, Configure() can be used to bind this instance to specified
+  port.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[in]   UdpConfigData    Pointer to the buffer contained the configuration data.
+
+  @retval EFI_SUCCESS           The configuration settings were set, changed, or reset successfully.
+  @retval EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source 
+                                address for this instance, but no source address was available for use.
+  @retval EFI_INVALID_PARAMETER One or more following conditions are TRUE:
+                                - This is NULL.
+                                - UdpConfigData.StationAddress neither zero nor one of the configured IP
+                                  addresses in the underlying IPv6 driver.
+                                - UdpConfigData.RemoteAddress is not a valid unicast IPv6 address if it
+                                  is not zero.
+  @retval EFI_ALREADY_STARTED   The EFI UDPv6 Protocol instance is already started/configured and must be
+                                stopped/reset before it can be reconfigured. Only TrafficClass, HopLimit,
+                                ReceiveTimeout, and TransmitTimeout can be reconfigured without stopping
+                                the current instance of the EFI UDPv6 Protocol.
+  @retval EFI_ACCESS_DENIED     UdpConfigData.AllowDuplicatePort is FALSE and UdpConfigData.StationPort
+                                is already used by other instance. 
+  @retval EFI_OUT_OF_RESOURCES  The EFI UDPv6 Protocol driver cannot allocate memory for this EFI UDPv6
+                                Protocol instance.
+  @retval EFI_DEVICE_ERROR      An unexpected network or system error occurred and this instance was not
+                                opened.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_CONFIGURE)(
+  IN EFI_UDP6_PROTOCOL     *This,
+  IN EFI_UDP6_CONFIG_DATA  *UdpConfigData OPTIONAL
+);
+
+/**
+  Joins and leaves multicast groups.
+
+  The Groups() function is used to join or leave one or more multicast group.
+  If the JoinFlag is FALSE and the MulticastAddress is NULL, then all currently joined groups are left.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[in]   JoinFlag         Set to TRUE to join a multicast group. Set to FALSE to leave one
+                                or all multicast groups.
+  @param[in]   MulticastAddress Pointer to multicast group address to join or leave.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_NOT_STARTED       The EFI UDPv6 Protocol instance has not been started.
+  @retval EFI_OUT_OF_RESOURCES  Could not allocate resources to join the group.
+  @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE:
+                                - This is NULL.
+                                - JoinFlag is TRUE and MulticastAddress is NULL.
+                                - JoinFlag is TRUE and *MulticastAddress is not a valid multicast address.
+  @retval EFI_ALREADY_STARTED   The group address is already in the group table (when JoinFlag is TRUE).
+  @retval EFI_NOT_FOUND         The group address is not in the group table (when JoinFlag is FALSE).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_GROUPS)(
+  IN EFI_UDP6_PROTOCOL  *This,
+  IN BOOLEAN            JoinFlag,
+  IN EFI_IPv6_ADDRESS   *MulticastAddress OPTIONAL
+);
+
+/**
+  Queues outgoing data packets into the transmit queue.
+
+  The Transmit() function places a sending request to this instance of the EFI UDPv6 Protocol,
+  alongside the transmit data that was filled by the user. Whenever the packet in the token is
+  sent out or some errors occur, the Token.Event will be signaled and Token.Status is updated.
+  Providing a proper notification function and context for the event will enable the user to
+  receive the notification and transmitting status.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[in]   Token            Pointer to the completion token that will be placed into the 
+                                transmit queue.
+
+  @retval EFI_SUCCESS           The data has been queued for transmission.
+  @retval EFI_NOT_STARTED       This EFI UDPv6 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                address for this instance, but no source address was available
+                                for use.
+  @retval EFI_INVALID_PARAMETER One or more of the following are TRUE:
+                                - This is NULL.
+                                - Token is NULL.
+                                - Token.Event is NULL.
+                                - Token.Packet.TxData is NULL.
+                                - Token.Packet.TxData.FragmentCount is zero.
+                                - Token.Packet.TxData.DataLength is not equal to the sum of fragment
+                                  lengths.
+                                - One or more of the Token.Packet.TxData.FragmentTable[].FragmentLength
+                                  fields is zero.
+                                - One or more of the Token.Packet.TxData.FragmentTable[].FragmentBuffer
+                                  fields is NULL.
+                                - Token.Packet.TxData.UdpSessionData.DestinationAddress is not zero
+                                  and is not valid unicast Ipv6 address if UdpSessionData is not NULL.
+                                - Token.Packet.TxData.UdpSessionData is NULL and this instance's 
+                                  UdpConfigData.RemoteAddress is unspecified.
+                                - Token.Packet.TxData.UdpSessionData.DestinationAddress is non-zero
+                                  when DestinationAddress is configured as non-zero when doing Configure()
+                                  for this EFI Udp6 protocol instance.
+                                - Token.Packet.TxData.UdpSesionData.DestinationAddress is zero when 
+                                  DestinationAddress is unspecified when doing Configure() for this
+                                  EFI Udp6 protocol instance.
+  @retval EFI_ACCESS_DENIED     The transmit completion token with the same Token.Event was already
+                                in the transmit queue.
+  @retval EFI_NOT_READY         The completion token could not be queued because the transmit queue
+                                is full.
+  @retval EFI_OUT_OF_RESOURCES  Could not queue the transmit data.
+  @retval EFI_NOT_FOUND         There is no route to the destination network or address.
+  @retval EFI_BAD_BUFFER_SIZE   The data length is greater than the maximum UDP packet size.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_TRANSMIT)(
+  IN EFI_UDP6_PROTOCOL          *This,
+  IN EFI_UDP6_COMPLETION_TOKEN  *Token
+);
+
+/**
+  Places an asynchronous receive request into the receiving queue.
+
+  The Receive() function places a completion token into the receive packet queue. This function is
+  always asynchronous.
+  The caller must fill in the Token.Event field in the completion token, and this field cannot be 
+  NULL. When the receive operation completes, the EFI UDPv6 Protocol driver updates the Token.Status
+  and Token.Packet.RxData fields and the Token.Event is signaled.
+  Providing a proper notification function and context for the event will enable the user to receive
+  the notification and receiving status. That notification function is guaranteed to not be re-entered.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[in]   Token            Pointer to a token that is associated with the receive data descriptor.
+
+  @retval EFI_SUCCESS           The receive completion token was cached.
+  @retval EFI_NOT_STARTED       This EFI UDPv6 Protocol instance has not been started.
+  @retval EFI_NO_MAPPING        The underlying IPv6 driver was responsible for choosing a source
+                                address for this instance, but no source address was available
+                                for use.
+  @retval EFI_INVALID_PARAMETER One or more of the following is TRUE:
+                                - This is NULL.
+                                - Token is NULL.
+                                - Token.Event is NULL.
+  @retval EFI_OUT_OF_RESOURCES  The receive completion token could not be queued due to a lack of system 
+                                resources (usually memory).
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred. The EFI UDPv6 Protocol
+                                instance has been reset to startup defaults.
+  @retval EFI_ACCESS_DENIED     A receive completion token with the same Token.Event was already in 
+                                the receive queue.
+  @retval EFI_NOT_READY         The receive request could not be queued because the receive queue is full.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_RECEIVE)(
+  IN EFI_UDP6_PROTOCOL          *This,
+  IN EFI_UDP6_COMPLETION_TOKEN  *Token
+);
+
+/**
+  Aborts an asynchronous transmit or receive request.
+
+  The Cancel() function is used to abort a pending transmit or receive request. If the token is in the
+  transmit or receive request queues, after calling this function, Token.Status will be set to
+  EFI_ABORTED and then Token.Event will be signaled. If the token is not in one of the queues,
+  which usually means that the asynchronous operation has completed, this function will not signal the
+  token and EFI_NOT_FOUND is returned.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+  @param[in]   Token            Pointer to a token that has been issued by EFI_UDP6_PROTOCOL.Transmit()
+                                or EFI_UDP6_PROTOCOL.Receive().If NULL, all pending tokens are aborted.
+
+  @retval EFI_SUCCESS           The asynchronous I/O request was aborted and Token.Event was signaled.
+                                When Token is NULL, all pending requests are aborted and their events
+                                are signaled.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_NOT_STARTED       This instance has not been started.
+  @retval EFI_NOT_FOUND         When Token is not NULL, the asynchronous I/O request was not found in
+                                the transmit or receive queue. It has either completed or was not issued
+                                by Transmit() and Receive().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_CANCEL)(
+  IN EFI_UDP6_PROTOCOL          *This,
+  IN EFI_UDP6_COMPLETION_TOKEN  *Token OPTIONAL
+);
+
+/**
+  Polls for incoming data packets and processes outgoing data packets.
+
+  The Poll() function can be used by network drivers and applications to increase the rate that data
+  packets are moved between the communications device and the transmit and receive queues.
+  In some systems, the periodic timer event in the managed network driver may not poll the underlying
+  communications device fast enough to transmit and/or receive all data packets without missing incoming
+  packets or dropping outgoing packets. Drivers and applications that are experiencing packet loss should
+  try calling the Poll() function more often.
+
+  @param[in]   This             Pointer to the EFI_UDP6_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           Incoming or outgoing data was processed.
+  @retval EFI_INVALID_PARAMETER This is NULL.
+  @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred. 
+  @retval EFI_TIMEOUT           Data was dropped out of the transmit and/or receive queue.
+                                Consider increasing the polling rate.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_POLL)(
+  IN EFI_UDP6_PROTOCOL  *This
+);
+
+///
+/// The EFI_UDP6_PROTOCOL defines an EFI UDPv6 Protocol session that can be used by any network drivers,
+/// applications, or daemons to transmit or receive UDP packets. This protocol instance can either be
+/// bound to a specified port as a service or connected to some remote peer as an active client.
+/// Each instance has its own settings, such as group table, that are independent from each other.
+/// 
+struct _EFI_UDP6_PROTOCOL {
+  EFI_UDP6_GET_MODE_DATA  GetModeData;
+  EFI_UDP6_CONFIGURE      Configure;
+  EFI_UDP6_GROUPS         Groups;
+  EFI_UDP6_TRANSMIT       Transmit;
+  EFI_UDP6_RECEIVE        Receive;
+  EFI_UDP6_CANCEL         Cancel;
+  EFI_UDP6_POLL           Poll;
+};
+
+extern EFI_GUID gEfiUdp6ServiceBindingProtocolGuid;
+extern EFI_GUID gEfiUdp6ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UgaDraw.h b/MdePkg/Include/Protocol/UgaDraw.h
new file mode 100644
index 000000000000..f501a6c17f43
--- /dev/null
+++ b/MdePkg/Include/Protocol/UgaDraw.h
@@ -0,0 +1,166 @@
+/** @file
+  UGA Draw protocol from the EFI 1.10 specification.
+
+  Abstraction of a very simple graphics device.
+
+  Copyright (c) 2006 - 2008, 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 __UGA_DRAW_H__
+#define __UGA_DRAW_H__
+
+
+#define EFI_UGA_DRAW_PROTOCOL_GUID \
+  { \
+    0x982c298b, 0xf4fa, 0x41cb, {0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39 } \
+  }
+
+typedef struct _EFI_UGA_DRAW_PROTOCOL EFI_UGA_DRAW_PROTOCOL;
+
+/**
+  Return the current video mode information.
+
+  @param  This                  The EFI_UGA_DRAW_PROTOCOL instance.
+  @param  HorizontalResolution  The size of video screen in pixels in the X dimension.
+  @param  VerticalResolution    The size of video screen in pixels in the Y dimension.
+  @param  ColorDepth            Number of bits per pixel, currently defined to be 32.
+  @param  RefreshRate           The refresh rate of the monitor in Hertz.
+
+  @retval EFI_SUCCESS           Mode information returned.
+  @retval EFI_NOT_STARTED       Video display is not initialized. Call SetMode ()
+  @retval EFI_INVALID_PARAMETER One of the input args was NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UGA_DRAW_PROTOCOL_GET_MODE)(
+  IN  EFI_UGA_DRAW_PROTOCOL *This,
+  OUT UINT32                *HorizontalResolution,
+  OUT UINT32                *VerticalResolution,
+  OUT UINT32                *ColorDepth,
+  OUT UINT32                *RefreshRate
+  );
+
+/**
+  Set the current video mode information.
+
+  @param  This                 The EFI_UGA_DRAW_PROTOCOL instance.
+  @param  HorizontalResolution The size of video screen in pixels in the X dimension.
+  @param  VerticalResolution   The size of video screen in pixels in the Y dimension.
+  @param  ColorDepth           Number of bits per pixel, currently defined to be 32.
+  @param  RefreshRate          The refresh rate of the monitor in Hertz.
+
+  @retval EFI_SUCCESS          Mode information returned.
+  @retval EFI_NOT_STARTED      Video display is not initialized. Call SetMode ()
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UGA_DRAW_PROTOCOL_SET_MODE)(
+  IN  EFI_UGA_DRAW_PROTOCOL *This,
+  IN  UINT32                HorizontalResolution,
+  IN  UINT32                VerticalResolution,
+  IN  UINT32                ColorDepth,
+  IN  UINT32                RefreshRate
+  );
+
+typedef struct {
+  UINT8 Blue;
+  UINT8 Green;
+  UINT8 Red;
+  UINT8 Reserved;
+} EFI_UGA_PIXEL;
+
+typedef union {
+  EFI_UGA_PIXEL Pixel;
+  UINT32        Raw;
+} EFI_UGA_PIXEL_UNION;
+
+///
+/// Enumration value for actions of Blt operations.
+///
+typedef enum {
+  EfiUgaVideoFill,          ///< Write data from the  BltBuffer pixel (SourceX, SourceY)
+                            ///< directly to every pixel of the video display rectangle
+                            ///< (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
+                            ///< Only one pixel will be used from the BltBuffer. Delta is NOT used.
+                            
+  EfiUgaVideoToBltBuffer,   ///< Read data from the video display rectangle
+                            ///< (SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in
+                            ///< the BltBuffer rectangle (DestinationX, DestinationY )
+                            ///< (DestinationX + Width, DestinationY + Height). If DestinationX or
+                            ///< DestinationY is not zero then Delta must be set to the length in bytes
+                            ///< of a row in the BltBuffer.
+                            
+  EfiUgaBltBufferToVideo,   ///< Write data from the  BltBuffer rectangle
+                            ///< (SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the
+                            ///< video display rectangle (DestinationX, DestinationY)
+                            ///< (DestinationX + Width, DestinationY + Height). If SourceX or SourceY is
+                            ///< not zero then Delta must be set to the length in bytes of a row in the
+                            ///< BltBuffer.
+  
+  EfiUgaVideoToVideo,       ///< Copy from the video display rectangle (SourceX, SourceY)
+                            ///< (SourceX + Width, SourceY + Height) .to the video display rectangle
+                            ///< (DestinationX, DestinationY) (DestinationX + Width, DestinationY + Height).
+                            ///< The BltBuffer and Delta  are not used in this mode.
+                            
+  EfiUgaBltMax              ///< Maxmimum value for enumration value of Blt operation. If a Blt operation
+                            ///< larger or equal to this enumration value, it is invalid.
+} EFI_UGA_BLT_OPERATION;
+
+/**
+    Blt a rectangle of pixels on the graphics screen.
+
+    @param[in] This          - Protocol instance pointer.
+    @param[in] BltBuffer     - Buffer containing data to blit into video buffer. This
+                               buffer has a size of Width*Height*sizeof(EFI_UGA_PIXEL)
+    @param[in] BltOperation  - Operation to perform on BlitBuffer and video memory
+    @param[in] SourceX       - X coordinate of source for the BltBuffer.
+    @param[in] SourceY       - Y coordinate of source for the BltBuffer.
+    @param[in] DestinationX  - X coordinate of destination for the BltBuffer.
+    @param[in] DestinationY  - Y coordinate of destination for the BltBuffer.
+    @param[in] Width         - Width of rectangle in BltBuffer in pixels.
+    @param[in] Height        - Hight of rectangle in BltBuffer in pixels.
+    @param[in] Delta         - OPTIONAL
+
+    @retval EFI_SUCCESS           - The Blt operation completed.
+    @retval EFI_INVALID_PARAMETER - BltOperation is not valid.
+    @retval EFI_DEVICE_ERROR      - A hardware error occured writting to the video buffer.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UGA_DRAW_PROTOCOL_BLT)(
+  IN  EFI_UGA_DRAW_PROTOCOL                   * This,
+  IN  EFI_UGA_PIXEL                           * BltBuffer, OPTIONAL
+  IN  EFI_UGA_BLT_OPERATION                   BltOperation,
+  IN  UINTN                                   SourceX,
+  IN  UINTN                                   SourceY,
+  IN  UINTN                                   DestinationX,
+  IN  UINTN                                   DestinationY,
+  IN  UINTN                                   Width,
+  IN  UINTN                                   Height,
+  IN  UINTN                                   Delta         OPTIONAL
+  );
+
+///
+/// This protocol provides a basic abstraction to set video modes and 
+/// copy pixels to and from the graphics controller's frame buffer. 
+///
+struct _EFI_UGA_DRAW_PROTOCOL {
+  EFI_UGA_DRAW_PROTOCOL_GET_MODE  GetMode;
+  EFI_UGA_DRAW_PROTOCOL_SET_MODE  SetMode;
+  EFI_UGA_DRAW_PROTOCOL_BLT       Blt;
+};
+
+extern EFI_GUID gEfiUgaDrawProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UgaIo.h b/MdePkg/Include/Protocol/UgaIo.h
new file mode 100644
index 000000000000..9638a72240e5
--- /dev/null
+++ b/MdePkg/Include/Protocol/UgaIo.h
@@ -0,0 +1,197 @@
+/** @file
+  UGA IO protocol from the EFI 1.10 specification.
+
+  Abstraction of a very simple graphics device.
+  
+  Copyright (c) 2006 - 2008, 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 __UGA_IO_H__
+#define __UGA_IO_H__
+
+#define EFI_UGA_IO_PROTOCOL_GUID \
+  { 0x61a4d49e, 0x6f68, 0x4f1b, { 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0xb, 0x7, 0xa2 } }
+
+typedef struct _EFI_UGA_IO_PROTOCOL EFI_UGA_IO_PROTOCOL;
+
+typedef UINT32                      UGA_STATUS;
+
+typedef enum {
+  UgaDtParentBus          = 1,
+  UgaDtGraphicsController,
+  UgaDtOutputController,
+  UgaDtOutputPort,
+  UgaDtOther
+} UGA_DEVICE_TYPE, *PUGA_DEVICE_TYPE;
+
+typedef UINT32 UGA_DEVICE_ID, *PUGA_DEVICE_ID;
+
+typedef struct {
+  UGA_DEVICE_TYPE deviceType;
+  UGA_DEVICE_ID   deviceId;
+  UINT32          ui32DeviceContextSize;
+  UINT32          ui32SharedContextSize;
+} UGA_DEVICE_DATA, *PUGA_DEVICE_DATA;
+
+typedef struct _UGA_DEVICE {
+  VOID                *pvDeviceContext;
+  VOID                *pvSharedContext;
+  VOID                *pvRunTimeContext;
+  struct _UGA_DEVICE  *pParentDevice;
+  VOID                *pvBusIoServices;
+  VOID                *pvStdIoServices;
+  UGA_DEVICE_DATA     deviceData;
+} UGA_DEVICE, *PUGA_DEVICE;
+
+typedef enum {
+  UgaIoGetVersion             = 1,
+  UgaIoGetChildDevice,
+  UgaIoStartDevice,
+  UgaIoStopDevice,
+  UgaIoFlushDevice,
+  UgaIoResetDevice,
+  UgaIoGetDeviceState,
+  UgaIoSetDeviceState,
+  UgaIoSetPowerState,
+  UgaIoGetMemoryConfiguration,
+  UgaIoSetVideoMode,
+  UgaIoCopyRectangle,
+  UgaIoGetEdidSegment,
+  UgaIoDeviceChannelOpen,
+  UgaIoDeviceChannelClose,
+  UgaIoDeviceChannelRead,
+  UgaIoDeviceChannelWrite,
+  UgaIoGetPersistentDataSize,
+  UgaIoGetPersistentData,
+  UgaIoSetPersistentData,
+  UgaIoGetDevicePropertySize,
+  UgaIoGetDeviceProperty,
+  UgaIoBtPrivateInterface
+} UGA_IO_REQUEST_CODE, *PUGA_IO_REQUEST_CODE;
+
+typedef struct {
+  IN UGA_IO_REQUEST_CODE  ioRequestCode;
+  IN VOID                 *pvInBuffer;
+  IN UINT64               ui64InBufferSize;
+  OUT VOID                *pvOutBuffer;
+  IN UINT64               ui64OutBufferSize;
+  OUT UINT64              ui64BytesReturned;
+} UGA_IO_REQUEST, *PUGA_IO_REQUEST;
+
+
+/**
+  Dynamically allocate storage for a child UGA_DEVICE.
+
+  @param[in]     This            The EFI_UGA_IO_PROTOCOL instance. 
+  @param[in]     ParentDevice    ParentDevice specifies a pointer to the parent device of Device.
+  @param[in]     DeviceData      A pointer to UGA_DEVICE_DATA returned from a call to DispatchService()
+                                 with a UGA_DEVICE of Parent and an IoRequest of type UgaIoGetChildDevice.      
+  @param[in]     RunTimeContext  Context to associate with Device.  
+  @param[out]    Device          The Device returns a dynamically allocated child UGA_DEVICE object
+                                 for ParentDevice. The caller is responsible for deleting Device.
+
+                                 
+  @retval  EFI_SUCCESS           Device was returned.
+  @retval  EFI_INVALID_PARAMETER One of the arguments was not valid.
+  @retval  EFI_DEVICE_ERROR      The device had an error and could not complete the request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UGA_IO_PROTOCOL_CREATE_DEVICE)(
+  IN  EFI_UGA_IO_PROTOCOL  *This,
+  IN  UGA_DEVICE           *ParentDevice,
+  IN  UGA_DEVICE_DATA      *DeviceData,
+  IN  VOID                 *RunTimeContext,
+  OUT UGA_DEVICE           **Device
+  );
+
+
+/**
+  Delete a dynamically allocated child UGA_DEVICE object that was allocated via CreateDevice().
+
+  @param[in]     This            The EFI_UGA_IO_PROTOCOL instance. Type EFI_UGA_IO_PROTOCOL is 
+                                 defined in Section 10.7.
+  @param[in]     Device          The Device points to a UGA_DEVICE object that was dynamically
+                                 allocated via a CreateDevice() call.
+
+                                 
+  @retval  EFI_SUCCESS           Device was returned.
+  @retval  EFI_INVALID_PARAMETER The Device was not allocated via CreateDevice().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UGA_IO_PROTOCOL_DELETE_DEVICE)(
+  IN EFI_UGA_IO_PROTOCOL  * This,
+  IN UGA_DEVICE           * Device
+  );
+
+/**
+  This is the main UGA service dispatch routine for all UGA_IO_REQUEST s.
+
+  @param pDevice pDevice specifies a pointer to a device object associated with a 
+                 device enumerated by a pIoRequest->ioRequestCode of type 
+                 UgaIoGetChildDevice. The root device for the EFI_UGA_IO_PROTOCOL 
+                 is represented by pDevice being set to NULL.
+
+  @param pIoRequest 
+                 pIoRequest points to a caller allocated buffer that contains data
+                 defined by pIoRequest->ioRequestCode. See Related Definitions for
+                 a definition of UGA_IO_REQUEST_CODE s and their associated data 
+                 structures.
+
+  @return UGA_STATUS
+
+**/
+typedef UGA_STATUS 
+(EFIAPI *PUGA_FW_SERVICE_DISPATCH)(
+  IN PUGA_DEVICE pDevice, 
+  IN OUT PUGA_IO_REQUEST pIoRequest
+  );
+
+///
+/// Provides a basic abstraction to send I/O requests to the graphics device and any of its children.
+///
+struct _EFI_UGA_IO_PROTOCOL {
+  EFI_UGA_IO_PROTOCOL_CREATE_DEVICE CreateDevice;
+  EFI_UGA_IO_PROTOCOL_DELETE_DEVICE DeleteDevice;
+  PUGA_FW_SERVICE_DISPATCH          DispatchService;
+};
+
+extern EFI_GUID gEfiUgaIoProtocolGuid;
+
+//
+// Data structure that is stored in the EFI Configuration Table with the
+// EFI_UGA_IO_PROTOCOL_GUID.  The option ROMs listed in this table may have
+// EBC UGA drivers.
+//
+typedef struct {
+  UINT32  Version;
+  UINT32  HeaderSize;
+  UINT32  SizeOfEntries;
+  UINT32  NumberOfEntries;
+} EFI_DRIVER_OS_HANDOFF_HEADER;
+
+typedef enum {
+  EfiUgaDriverFromPciRom,
+  EfiUgaDriverFromSystem,
+  EfiDriverHandoffMax
+} EFI_DRIVER_HANOFF_ENUM;
+
+typedef struct {
+  EFI_DRIVER_HANOFF_ENUM    Type;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
+  VOID                      *PciRomImage;
+  UINT64                    PciRomSize;
+} EFI_DRIVER_OS_HANDOFF;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UnicodeCollation.h b/MdePkg/Include/Protocol/UnicodeCollation.h
new file mode 100644
index 000000000000..96cff3444e4e
--- /dev/null
+++ b/MdePkg/Include/Protocol/UnicodeCollation.h
@@ -0,0 +1,192 @@
+/** @file
+  Unicode Collation protocol that follows the UEFI 2.0 specification.
+  This protocol is used to allow code running in the boot services environment 
+  to perform lexical comparison functions on Unicode strings for given languages.
+
+Copyright (c) 2006 - 2011, 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 __UNICODE_COLLATION_H__
+#define __UNICODE_COLLATION_H__
+
+#define EFI_UNICODE_COLLATION_PROTOCOL_GUID \
+  { \
+    0x1d85cd7f, 0xf43d, 0x11d2, {0x9a, 0xc, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
+  }
+
+#define EFI_UNICODE_COLLATION_PROTOCOL2_GUID \
+  { \
+    0xa4c751fc, 0x23ae, 0x4c3e, {0x92, 0xe9, 0x49, 0x64, 0xcf, 0x63, 0xf3, 0x49 } \
+  }
+
+typedef struct _EFI_UNICODE_COLLATION_PROTOCOL  EFI_UNICODE_COLLATION_PROTOCOL;
+
+
+///
+/// Protocol GUID name defined in EFI1.1.
+/// 
+#define UNICODE_COLLATION_PROTOCOL              EFI_UNICODE_COLLATION_PROTOCOL_GUID
+
+///
+/// Protocol defined in EFI1.1.
+/// 
+typedef EFI_UNICODE_COLLATION_PROTOCOL          UNICODE_COLLATION_INTERFACE;
+
+///
+/// Protocol data structures and defines
+///
+#define EFI_UNICODE_BYTE_ORDER_MARK (CHAR16) (0xfeff)
+
+//
+// Protocol member functions
+//
+/**
+  Performs a case-insensitive comparison of two Null-terminated strings.
+
+  @param  This A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  Str1 A pointer to a Null-terminated string.
+  @param  Str2 A pointer to a Null-terminated string.
+
+  @retval 0   Str1 is equivalent to Str2.
+  @retval >0  Str1 is lexically greater than Str2.
+  @retval <0  Str1 is lexically less than Str2.
+
+**/
+typedef
+INTN
+(EFIAPI *EFI_UNICODE_COLLATION_STRICOLL)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN CHAR16                                 *Str1,
+  IN CHAR16                                 *Str2
+  );
+
+/**
+  Performs a case-insensitive comparison of a Null-terminated 
+  pattern string and a Null-terminated string.
+
+  @param  This    A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  String  A pointer to a Null-terminated string.
+  @param  Pattern A pointer to a Null-terminated pattern string.
+
+  @retval TRUE    Pattern was found in String.
+  @retval FALSE   Pattern was not found in String.
+
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_UNICODE_COLLATION_METAIMATCH)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN CHAR16                                 *String,
+  IN CHAR16                                 *Pattern
+  );
+
+/**
+  Converts all the characters in a Null-terminated string to 
+  lower case characters.
+
+  @param  This   A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  String A pointer to a Null-terminated string.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_UNICODE_COLLATION_STRLWR)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN OUT CHAR16                             *Str
+  );
+
+/**
+  Converts all the characters in a Null-terminated string to upper
+  case characters.
+
+  @param  This   A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  String A pointer to a Null-terminated string.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_UNICODE_COLLATION_STRUPR)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN OUT CHAR16                             *Str
+  );
+
+/**
+  Converts an 8.3 FAT file name in an OEM character set to a Null-terminated 
+  string.
+
+  @param  This    A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  FatSize The size of the string Fat in bytes.
+  @param  Fat     A pointer to a Null-terminated string that contains an 8.3 file
+                  name using an 8-bit OEM character set.
+  @param  String  A pointer to a Null-terminated string. The string must
+                  be allocated in advance to hold FatSize characters.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_UNICODE_COLLATION_FATTOSTR)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN UINTN                                  FatSize,
+  IN CHAR8                                  *Fat,
+  OUT CHAR16                                *String
+  );
+
+/**
+  Converts a Null-terminated string to legal characters in a FAT 
+  filename using an OEM character set. 
+
+  @param  This    A pointer to the EFI_UNICODE_COLLATION_PROTOCOL instance.
+  @param  String  A pointer to a Null-terminated string.
+  @param  FatSize The size of the string Fat in bytes.
+  @param  Fat     A pointer to a string that contains the converted version of 
+                  String using legal FAT characters from an OEM character set.
+
+  @retval TRUE    One or more conversions failed and were substituted with '_'
+  @retval FALSE   None of the conversions failed.
+
+**/
+typedef
+BOOLEAN
+(EFIAPI *EFI_UNICODE_COLLATION_STRTOFAT)(
+  IN EFI_UNICODE_COLLATION_PROTOCOL         *This,
+  IN CHAR16                                 *String,
+  IN UINTN                                  FatSize,
+  OUT CHAR8                                 *Fat
+  );
+
+///
+/// The EFI_UNICODE_COLLATION_PROTOCOL is used to perform case-insensitive 
+/// comparisons of strings. 
+///
+struct _EFI_UNICODE_COLLATION_PROTOCOL {
+  EFI_UNICODE_COLLATION_STRICOLL    StriColl;
+  EFI_UNICODE_COLLATION_METAIMATCH  MetaiMatch;
+  EFI_UNICODE_COLLATION_STRLWR      StrLwr;
+  EFI_UNICODE_COLLATION_STRUPR      StrUpr;
+
+  //
+  // for supporting fat volumes
+  //
+  EFI_UNICODE_COLLATION_FATTOSTR    FatToStr;
+  EFI_UNICODE_COLLATION_STRTOFAT    StrToFat;
+  
+  ///
+  /// A Null-terminated ASCII string array that contains one or more language codes.
+  /// When this field is used for UnicodeCollation2, it is specified in RFC 4646 format.
+  /// When it is used for UnicodeCollation, it is specified in ISO 639-2 format.
+  ///
+  CHAR8                             *SupportedLanguages;
+};
+
+extern EFI_GUID gEfiUnicodeCollationProtocolGuid;
+extern EFI_GUID gEfiUnicodeCollation2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Usb2HostController.h b/MdePkg/Include/Protocol/Usb2HostController.h
new file mode 100644
index 000000000000..6a0e7be80a0c
--- /dev/null
+++ b/MdePkg/Include/Protocol/Usb2HostController.h
@@ -0,0 +1,664 @@
+/** @file
+  EFI_USB2_HC_PROTOCOL as defined in UEFI 2.0.
+  The USB Host Controller Protocol is used by code, typically USB bus drivers, 
+  running in the EFI boot services environment, to perform data transactions over 
+  a USB bus. In addition, it provides an abstraction for the root hub of the USB bus.
+
+  Copyright (c) 2006 - 2015, 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 _USB2_HOSTCONTROLLER_H_
+#define _USB2_HOSTCONTROLLER_H_
+
+#include <Protocol/UsbIo.h>
+
+#define EFI_USB2_HC_PROTOCOL_GUID \
+  { \
+    0x3e745226, 0x9818, 0x45b6, {0xa2, 0xac, 0xd7, 0xcd, 0xe, 0x8b, 0xa2, 0xbc } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_USB2_HC_PROTOCOL EFI_USB2_HC_PROTOCOL;
+
+
+typedef struct {
+  UINT16          PortStatus;        ///< Contains current port status bitmap.
+  UINT16          PortChangeStatus;  ///< Contains current port status change bitmap.
+} EFI_USB_PORT_STATUS;
+
+///
+/// EFI_USB_PORT_STATUS.PortStatus bit definition 
+///
+#define USB_PORT_STAT_CONNECTION    0x0001
+#define USB_PORT_STAT_ENABLE        0x0002
+#define USB_PORT_STAT_SUSPEND       0x0004
+#define USB_PORT_STAT_OVERCURRENT   0x0008
+#define USB_PORT_STAT_RESET         0x0010
+#define USB_PORT_STAT_POWER         0x0100
+#define USB_PORT_STAT_LOW_SPEED     0x0200
+#define USB_PORT_STAT_HIGH_SPEED    0x0400
+#define USB_PORT_STAT_SUPER_SPEED   0x0800
+#define USB_PORT_STAT_OWNER         0x2000
+
+///
+/// EFI_USB_PORT_STATUS.PortChangeStatus bit definition 
+///
+#define USB_PORT_STAT_C_CONNECTION  0x0001
+#define USB_PORT_STAT_C_ENABLE      0x0002
+#define USB_PORT_STAT_C_SUSPEND     0x0004
+#define USB_PORT_STAT_C_OVERCURRENT 0x0008
+#define USB_PORT_STAT_C_RESET       0x0010
+
+
+///
+/// Usb port features value
+/// Each value indicates its bit index in the port status and status change bitmaps, 
+/// if combines these two bitmaps into a 32-bit bitmap.
+///
+typedef enum {
+  EfiUsbPortEnable            = 1,
+  EfiUsbPortSuspend           = 2,
+  EfiUsbPortReset             = 4,
+  EfiUsbPortPower             = 8,
+  EfiUsbPortOwner             = 13,
+  EfiUsbPortConnectChange     = 16,
+  EfiUsbPortEnableChange      = 17,
+  EfiUsbPortSuspendChange     = 18,
+  EfiUsbPortOverCurrentChange = 19,
+  EfiUsbPortResetChange       = 20
+} EFI_USB_PORT_FEATURE;
+
+#define EFI_USB_SPEED_FULL      0x0000  ///< 12 Mb/s, USB 1.1 OHCI and UHCI HC.
+#define EFI_USB_SPEED_LOW       0x0001  ///< 1 Mb/s, USB 1.1 OHCI and UHCI HC.
+#define EFI_USB_SPEED_HIGH      0x0002  ///< 480 Mb/s, USB 2.0 EHCI HC.
+#define EFI_USB_SPEED_SUPER     0x0003  ///< 4.8 Gb/s, USB 3.0 XHCI HC.
+
+typedef struct {
+  UINT8      TranslatorHubAddress; ///< device address
+  UINT8      TranslatorPortNumber; ///< the port number of the hub that device is connected to.
+} EFI_USB2_HC_TRANSACTION_TRANSLATOR;
+
+//
+// Protocol definitions
+//
+
+/**
+  Retrieves the Host Controller capabilities.
+
+  @param  This           A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  MaxSpeed       Host controller data transfer speed.
+  @param  PortNumber     Number of the root hub ports.
+  @param  Is64BitCapable TRUE if controller supports 64-bit memory addressing,
+                         FALSE otherwise.
+
+  @retval EFI_SUCCESS           The host controller capabilities were retrieved successfully.
+  @retval EFI_INVALID_PARAMETER One of the input args was NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to
+                                retrieve the capabilities.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_CAPABILITY)(
+  IN  EFI_USB2_HC_PROTOCOL  *This,
+  OUT UINT8                 *MaxSpeed,
+  OUT UINT8                 *PortNumber,
+  OUT UINT8                 *Is64BitCapable
+  );
+
+#define EFI_USB_HC_RESET_GLOBAL             0x0001
+#define EFI_USB_HC_RESET_HOST_CONTROLLER    0x0002
+#define EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG  0x0004
+#define EFI_USB_HC_RESET_HOST_WITH_DEBUG    0x0008
+/**
+  Provides software reset for the USB host controller.
+
+  @param  This       A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  Attributes A bit mask of the reset operation to perform.
+
+  @retval EFI_SUCCESS           The reset operation succeeded.
+  @retval EFI_INVALID_PARAMETER Attributes is not valid.
+  @retval EFI_UNSUPPORTED       The type of reset specified by Attributes is not currently
+                                supported by the host controller hardware.
+  @retval EFI_ACCESS_DENIED     Reset operation is rejected due to the debug port being configured
+                                and active; only EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG or
+                                EFI_USB_HC_RESET_HOST_WITH_DEBUG reset Attributes can be used to
+                                perform reset operation for this host controller.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to
+                                retrieve the capabilities.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_RESET)(
+  IN EFI_USB2_HC_PROTOCOL   *This,
+  IN UINT16                 Attributes
+  );
+
+/**
+  Enumration value for status of USB HC.
+**/
+typedef enum {
+  EfiUsbHcStateHalt,                ///< The host controller is in halt
+                                    ///< state. No USB transactions can occur
+                                    ///< while in this state. The host
+                                    ///< controller can enter this state for
+                                    ///< three reasons: 1) After host
+                                    ///< controller hardware reset. 2)
+                                    ///< Explicitly set by software. 3)
+                                    ///< Triggered by a fatal error such as
+                                    ///< consistency check failure.
+                                    
+  EfiUsbHcStateOperational,         ///< The host controller is in an
+                                    ///< operational state. When in
+                                    ///< this state, the host
+                                    ///< controller can execute bus
+                                    ///< traffic. This state must be
+                                    ///< explicitly set to enable the
+                                    ///< USB bus traffic.
+                                    
+  EfiUsbHcStateSuspend,             ///< The host controller is in the
+                                    ///< suspend state. No USB
+                                    ///< transactions can occur while in
+                                    ///< this state. The host controller
+                                    ///< enters this state for the
+                                    ///< following reasons: 1) Explicitly
+                                    ///< set by software. 2) Triggered
+                                    ///< when there is no bus traffic for
+                                    ///< 3 microseconds.
+                                    
+  EfiUsbHcStateMaximum              ///< Maximum value for enumration value of HC status.
+} EFI_USB_HC_STATE;
+
+/**
+  Retrieves current state of the USB host controller.
+
+  @param  This  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  State A pointer to the EFI_USB_HC_STATE data structure that
+                indicates current state of the USB host controller.
+
+  @retval EFI_SUCCESS           The state information of the host controller was returned in State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the
+                                host controller's current state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_STATE)(
+  IN        EFI_USB2_HC_PROTOCOL    *This,
+  OUT       EFI_USB_HC_STATE        *State
+);
+
+/**
+  Sets the USB host controller to a specific state.
+
+  @param  This  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  State Indicates the state of the host controller that will be set.
+
+  @retval EFI_SUCCESS           The USB host controller was successfully placed in the state
+                                specified by State.
+  @retval EFI_INVALID_PARAMETER State is not valid.
+  @retval EFI_DEVICE_ERROR      Failed to set the state specified by State due to device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SET_STATE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN EFI_USB_HC_STATE        State
+  );
+
+/**
+  Submits control transfer to a target USB device.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size that the default control transfer
+                              endpoint is capable of sending or receiving.
+  @param  Request             A pointer to the USB device request that will be sent to the USB device.
+  @param  TransferDirection   Specifies the data direction for the transfer. There are three values
+                              available, EfiUsbDataIn, EfiUsbDataOut and EfiUsbNoData.
+  @param  Data                A pointer to the buffer of data that will be transmitted to USB device or
+                              received from USB device.
+  @param  DataLength          On input, indicates the size, in bytes, of the data buffer specified by Data.
+                              On output, indicates the amount of data actually transferred.
+  @param  TimeOut             Indicates the maximum time, in milliseconds, which the transfer is
+                              allowed to complete.
+  @param  Translator          A pointer to the transaction translator data.
+  @param  TransferResult      A pointer to the detailed result information generated by this control
+                              transfer.
+
+  @retval EFI_SUCCESS           The control transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The control transfer could not be completed due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The control transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_CONTROL_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     EFI_USB_DEVICE_REQUEST             *Request,
+  IN     EFI_USB_DATA_DIRECTION             TransferDirection,
+  IN OUT VOID                               *Data       OPTIONAL,
+  IN OUT UINTN                              *DataLength OPTIONAL,
+  IN     UINTN                              TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+#define EFI_USB_MAX_BULK_BUFFER_NUM 10
+
+/**
+  Submits bulk transfer to a bulk endpoint of a USB device.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  EndPointAddress     The combination of an endpoint number and an endpoint direction of the
+                              target USB device.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size the target endpoint is capable of
+                              sending or receiving.
+  @param  DataBuffersNumber   Number of data buffers prepared for the transfer.
+  @param  Data                Array of pointers to the buffers of data that will be transmitted to USB
+                              device or received from USB device.
+  @param  DataLength          When input, indicates the size, in bytes, of the data buffers specified by
+                              Data. When output, indicates the actually transferred data size.
+  @param  DataToggle          A pointer to the data toggle value.
+  @param  TimeOut             Indicates the maximum time, in milliseconds, which the transfer is
+                              allowed to complete.
+  @param  Translator          A pointer to the transaction translator data.
+  @param  TransferResult      A pointer to the detailed result information of the bulk transfer.
+
+  @retval EFI_SUCCESS           The bulk transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The bulk transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_BULK_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_BULK_BUFFER_NUM],
+  IN OUT UINTN                              *DataLength,
+  IN OUT UINT8                              *DataToggle,
+  IN     UINTN                              TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+/**
+  Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
+  Translator parameter doesn't exist in UEFI2.0 spec, but it will be updated in the following specification version.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  EndPointAddress     The combination of an endpoint number and an endpoint direction of the
+                              target USB device.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size the target endpoint is capable of
+                              sending or receiving.
+  @param  IsNewTransfer       If TRUE, an asynchronous interrupt pipe is built between the host and the
+                              target interrupt endpoint. If FALSE, the specified asynchronous interrupt
+                              pipe is canceled. If TRUE, and an interrupt transfer exists for the target
+                              end point, then EFI_INVALID_PARAMETER is returned.
+  @param  DataToggle          A pointer to the data toggle value.
+  @param  PollingInterval     Indicates the interval, in milliseconds, that the asynchronous interrupt
+                              transfer is polled.
+  @param  DataLength          Indicates the length of data to be received at the rate specified by
+                              PollingInterval from the target asynchronous interrupt endpoint.
+  @param  Translator          A pointr to the transaction translator data.
+  @param  CallBackFunction    The Callback function. This function is called at the rate specified by
+                              PollingInterval.
+  @param  Context             The context that is passed to the CallBackFunction. This is an
+                              optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous interrupt transfer request has been successfully
+                                submitted or canceled.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL                                *This,
+  IN     UINT8                                               DeviceAddress,
+  IN     UINT8                                               EndPointAddress,
+  IN     UINT8                                               DeviceSpeed,
+  IN     UINTN                                               MaxiumPacketLength,
+  IN     BOOLEAN                                             IsNewTransfer,
+  IN OUT UINT8                                               *DataToggle,
+  IN     UINTN                                               PollingInterval  OPTIONAL,
+  IN     UINTN                                               DataLength       OPTIONAL,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR                  *Translator      OPTIONAL,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK                     CallBackFunction OPTIONAL,
+  IN     VOID                                                *Context         OPTIONAL
+  );
+
+/**
+  Submits synchronous interrupt transfer to an interrupt endpoint of a USB device.
+  Translator parameter doesn't exist in UEFI2.0 spec, but it will be updated in the following specification version.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB device or
+                                received from USB device.
+  @param  DataLength            On input, the size, in bytes, of the data buffer specified by Data. On
+                                output, the number of bytes transferred.
+  @param  DataToggle            A pointer to the data toggle value.
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer is
+                                allowed to complete.
+  @param  Translator            A pointr to the transaction translator data.
+  @param  TransferResult        A pointer to the detailed result information from the synchronous
+                                interrupt transfer.
+
+  @retval EFI_SUCCESS           The synchronous interrupt transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The synchronous interrupt transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The synchronous interrupt transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The synchronous interrupt transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL                        *This,
+  IN     UINT8                                       DeviceAddress,
+  IN     UINT8                                       EndPointAddress,
+  IN     UINT8                                       DeviceSpeed,
+  IN     UINTN                                       MaximumPacketLength,
+  IN OUT VOID                                        *Data,
+  IN OUT UINTN                                       *DataLength,
+  IN OUT UINT8                                       *DataToggle,
+  IN     UINTN                                       TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR          *Translator,
+  OUT    UINT32                                      *TransferResult
+  );
+
+#define EFI_USB_MAX_ISO_BUFFER_NUM  7
+#define EFI_USB_MAX_ISO_BUFFER_NUM1 2
+
+/**
+  Submits isochronous transfer to an isochronous endpoint of a USB device.
+
+  This function is used to submit isochronous transfer to a target endpoint of a USB device. 
+  The target endpoint is specified by DeviceAddressand EndpointAddress. Isochronous transfers are 
+  used when working with isochronous date. It provides periodic, continuous communication between 
+  the host and a device. Isochronous transfers can beused only by full-speed, high-speed, and 
+  super-speed devices.
+
+  High-speed isochronous transfers can be performed using multiple data buffers. The number of 
+  buffers that are actually prepared for the transfer is specified by DataBuffersNumber. For
+  full-speed isochronous transfers this value is ignored.
+
+  Data represents a list of pointers to the data buffers. For full-speed isochronous transfers
+  only the data pointed by Data[0]shall be used. For high-speed isochronous transfers and for
+  the split transactions depending on DataLengththere several data buffers canbe used. For the
+  high-speed isochronous transfers the total number of buffers must not exceed EFI_USB_MAX_ISO_BUFFER_NUM. 
+
+  For split transactions performed on full-speed device by high-speed host controller the total
+  number of buffers is limited to EFI_USB_MAX_ISO_BUFFER_NUM1.
+  If the isochronous transfer is successful, then EFI_SUCCESSis returned. The isochronous transfer 
+  is designed to be completed within one USB frame time, if it cannot be completed, EFI_TIMEOUT
+  is returned. If an error other than timeout occurs during the USB transfer, then EFI_DEVICE_ERROR
+  is returned and the detailed status code will be returned in TransferResult.
+
+  EFI_INVALID_PARAMETERis returned if one of the following conditionsis satisfied:
+    - Data is NULL. 
+    - DataLength is 0.
+    - DeviceSpeed is not one of the supported values listed above.
+    - MaximumPacketLength is invalid. MaximumPacketLength must be 1023 or less for full-speed devices,
+      and 1024 or less for high-speed and super-speed devices.
+    - TransferResult is NULL.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed. The supported values are EFI_USB_SPEED_FULL, 
+                                EFI_USB_SPEED_HIGH, or EFI_USB_SPEED_SUPER.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  DataBuffersNumber     Number of data buffers prepared for the transfer.
+  @param  Data                  Array of pointers to the buffers of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received from
+                                the USB device.
+  @param  Translator            A pointer to the transaction translator data.
+  @param  TransferResult        A pointer to the detailed result information of the isochronous transfer.
+
+  @retval EFI_SUCCESS           The isochronous transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The isochronous transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The isochronous transfer cannot be completed within the one USB frame time.
+  @retval EFI_DEVICE_ERROR      The isochronous transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
+  IN     UINTN                              DataLength,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+/**
+  Submits nonblocking isochronous transfer to an isochronous endpoint of a USB device.
+
+  This is an asynchronous type of USB isochronous transfer. If the caller submits a USB
+  isochronous transfer request through this function, this function will return immediately.
+
+  When the isochronous transfer completes, the IsochronousCallbackfunction will be triggered,
+  the caller can know the transfer results. If the transfer is successful, the caller can get
+  the data received or sent in this callback function.
+
+  The target endpoint is specified by DeviceAddressand EndpointAddress. Isochronous transfers
+  are used when working with isochronous date. It provides periodic, continuous communication
+  between the host and a device. Isochronous transfers can be used only by full-speed, high-speed,
+  and super-speed devices.
+
+  High-speed isochronous transfers can be performed using multiple data buffers. The number of 
+  buffers that are actually prepared for the transfer is specified by DataBuffersNumber. For
+  full-speed isochronous transfers this value is ignored.
+
+  Data represents a list of pointers to the data buffers. For full-speed isochronous transfers
+  only the data pointed by Data[0] shall be used. For high-speed isochronous transfers and for
+  the split transactions depending on DataLength there several data buffers can be used. For
+  the high-speed isochronous transfers the total number of buffers must not exceed EFI_USB_MAX_ISO_BUFFER_NUM.
+
+  For split transactions performed on full-speed device by high-speed host controller the total
+  number of buffers is limited to EFI_USB_MAX_ISO_BUFFER_NUM1.
+
+  EFI_INVALID_PARAMETER is returned if one of the following conditionsis satisfied:
+    - Data is NULL. 
+    - DataLength is 0.
+    - DeviceSpeed is not one of the supported values listed above.
+    - MaximumPacketLength is invalid. MaximumPacketLength must be 1023 or less for full-speed 
+      devices and 1024 or less for high-speed and super-speed devices.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed. The supported values are EFI_USB_SPEED_FULL, 
+                                EFI_USB_SPEED_HIGH, or EFI_USB_SPEED_SUPER.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  DataBuffersNumber     Number of data buffers prepared for the transfer.
+  @param  Data                  Array of pointers to the buffers of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received from
+                                the USB device.
+  @param  Translator            A pointer to the transaction translator data.
+  @param  IsochronousCallback   The Callback function. This function is called if the requested
+                                isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback function. This is an
+                                optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer request has been successfully
+                                submitted or canceled.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The asynchronous isochronous transfer could not be submitted due to
+                                a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
+  IN     UINTN                              DataLength,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK    IsochronousCallBack,
+  IN     VOID                               *Context OPTIONAL
+  );
+
+/**
+  Retrieves the current status of a USB root hub port.
+
+  @param  This       A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber Specifies the root hub port from which the status is to be retrieved.
+                     This value is zero based.
+  @param  PortStatus A pointer to the current port status bits and port status change bits.
+
+  @retval EFI_SUCCESS           The status of the USB root hub port specified by PortNumber
+                                was returned in PortStatus.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS)(
+  IN        EFI_USB2_HC_PROTOCOL    *This,
+  IN        UINT8                   PortNumber,
+  OUT       EFI_USB_PORT_STATUS     *PortStatus
+  );
+
+/**
+  Sets a feature for the specified root hub port.
+
+  @param  This        A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber  Specifies the root hub port whose feature is requested to be set. This
+                      value is zero based.
+  @param  PortFeature Indicates the feature selector associated with the feature set request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was set for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+/**
+  Clears a feature for the specified root hub port.
+
+  @param  This        A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber  Specifies the root hub port whose feature is requested to be cleared. This
+                      value is zero based.
+  @param  PortFeature Indicates the feature selector associated with the feature clear request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was cleared for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+///
+/// The EFI_USB2_HC_PROTOCOL provides USB host controller management, basic 
+/// data transactions over a USB bus, and USB root hub access. A device driver 
+/// that wishes to manage a USB bus in a system retrieves the EFI_USB2_HC_PROTOCOL 
+/// instance that is associated with the USB bus to be managed. A device handle 
+/// for a USB host controller will minimally contain an EFI_DEVICE_PATH_PROTOCOL 
+/// instance, and an EFI_USB2_HC_PROTOCOL instance.
+///
+struct _EFI_USB2_HC_PROTOCOL {
+  EFI_USB2_HC_PROTOCOL_GET_CAPABILITY              GetCapability;
+  EFI_USB2_HC_PROTOCOL_RESET                       Reset;
+  EFI_USB2_HC_PROTOCOL_GET_STATE                   GetState;
+  EFI_USB2_HC_PROTOCOL_SET_STATE                   SetState;
+  EFI_USB2_HC_PROTOCOL_CONTROL_TRANSFER            ControlTransfer;
+  EFI_USB2_HC_PROTOCOL_BULK_TRANSFER               BulkTransfer;
+  EFI_USB2_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER    AsyncInterruptTransfer;
+  EFI_USB2_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER     SyncInterruptTransfer;
+  EFI_USB2_HC_PROTOCOL_ISOCHRONOUS_TRANSFER        IsochronousTransfer;
+  EFI_USB2_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER  AsyncIsochronousTransfer;
+  EFI_USB2_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS     GetRootHubPortStatus;
+  EFI_USB2_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE    SetRootHubPortFeature;
+  EFI_USB2_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE  ClearRootHubPortFeature;
+  
+  ///
+  /// The major revision number of the USB host controller. The revision information 
+  /// indicates the release of the Universal Serial Bus Specification with which the 
+  /// host controller is compliant.
+  ///
+  UINT16                                           MajorRevision;
+
+  ///
+  /// The minor revision number of the USB host controller. The revision information 
+  /// indicates the release of the Universal Serial Bus Specification with which the 
+  /// host controller is compliant.  
+  ///
+  UINT16                                           MinorRevision;
+};
+
+extern EFI_GUID gEfiUsb2HcProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UsbFunctionIo.h b/MdePkg/Include/Protocol/UsbFunctionIo.h
new file mode 100644
index 000000000000..4422567f1920
--- /dev/null
+++ b/MdePkg/Include/Protocol/UsbFunctionIo.h
@@ -0,0 +1,683 @@
+/** @file
+  The USB Function Protocol provides an I/O abstraction for a USB Controller
+  operating in Function mode (also commonly referred to as Device, Peripheral,
+  or Target mode) and the mechanisms by which the USB Function can communicate
+  with the USB Host. It is used by other UEFI drivers or applications to
+  perform data transactions and basic USB controller management over a USB
+  Function port.
+
+  This simple protocol only supports USB 2.0 bulk transfers on systems with a
+  single configuration and a single interface. It does not support isochronous
+  or interrupt transfers, alternate interfaces, or USB 3.0 functionality.
+  Future revisions of this protocol may support these or additional features.
+
+  Copyright (c) 2015, 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 __USB_FUNCTION_IO_H__
+#define __USB_FUNCTION_IO_H__
+
+#include <Protocol/UsbIo.h>
+
+#define EFI_USBFN_IO_PROTOCOL_GUID \
+    { \
+      0x32d2963a, 0xfe5d, 0x4f30, {0xb6, 0x33, 0x6e, 0x5d, 0xc5, 0x58, 0x3, 0xcc} \
+    }
+
+typedef struct _EFI_USBFN_IO_PROTOCOL  EFI_USBFN_IO_PROTOCOL;
+
+#define EFI_USBFN_IO_PROTOCOL_REVISION 0x00010001
+
+typedef enum _EFI_USBFN_PORT_TYPE {
+  EfiUsbUnknownPort = 0,
+  EfiUsbStandardDownstreamPort,
+  EfiUsbChargingDownstreamPort,
+  EfiUsbDedicatedChargingPort,
+  EfiUsbInvalidDedicatedChargingPort
+} EFI_USBFN_PORT_TYPE;
+
+typedef struct {
+  EFI_USB_INTERFACE_DESCRIPTOR         *InterfaceDescriptor;
+  EFI_USB_ENDPOINT_DESCRIPTOR          **EndpointDescriptorTable;
+} EFI_USB_INTERFACE_INFO;
+
+typedef struct {
+  EFI_USB_CONFIG_DESCRIPTOR            *ConfigDescriptor;
+  EFI_USB_INTERFACE_INFO               **InterfaceInfoTable;
+} EFI_USB_CONFIG_INFO;
+
+typedef struct {
+  EFI_USB_DEVICE_DESCRIPTOR            *DeviceDescriptor;
+  EFI_USB_CONFIG_INFO                  **ConfigInfoTable;
+} EFI_USB_DEVICE_INFO;
+
+typedef enum _EFI_USB_ENDPOINT_TYPE {
+  UsbEndpointControl = 0x00,
+  //UsbEndpointIsochronous = 0x01,
+  UsbEndpointBulk = 0x02,
+  //UsbEndpointInterrupt = 0x03
+} EFI_USB_ENDPOINT_TYPE;
+
+typedef enum _EFI_USBFN_DEVICE_INFO_ID {
+  EfiUsbDeviceInfoUnknown = 0,
+  EfiUsbDeviceInfoSerialNumber,
+  EfiUsbDeviceInfoManufacturerName,
+  EfiUsbDeviceInfoProductName
+} EFI_USBFN_DEVICE_INFO_ID;
+
+typedef enum _EFI_USBFN_ENDPOINT_DIRECTION {
+  EfiUsbEndpointDirectionHostOut = 0,
+  EfiUsbEndpointDirectionHostIn,
+  EfiUsbEndpointDirectionDeviceTx = EfiUsbEndpointDirectionHostIn,
+  EfiUsbEndpointDirectionDeviceRx = EfiUsbEndpointDirectionHostOut
+} EFI_USBFN_ENDPOINT_DIRECTION;
+
+typedef enum _EFI_USBFN_MESSAGE {
+  //
+  // Nothing
+  //
+  EfiUsbMsgNone = 0,
+  //
+  // SETUP packet is received, returned Buffer contains
+  // EFI_USB_DEVICE_REQUEST struct
+  //
+  EfiUsbMsgSetupPacket,
+  //
+  // Indicates that some of the requested data has been received from the
+  // host. It is the responsibility of the class driver to determine if it
+  // needs to wait for any remaining data. Returned Buffer contains
+  // EFI_USBFN_TRANSFER_RESULT struct containing endpoint number, transfer
+  // status and count of bytes received.
+  //
+  EfiUsbMsgEndpointStatusChangedRx,
+  //
+  // Indicates that some of the requested data has been transmitted to the
+  // host. It is the responsibility of the class driver to determine if any
+  // remaining data needs to be resent. Returned Buffer contains
+  // EFI_USBFN_TRANSFER_RESULT struct containing endpoint number, transfer
+  // status and count of bytes sent.
+  //
+  EfiUsbMsgEndpointStatusChangedTx,
+  //
+  // DETACH bus event signaled
+  //
+  EfiUsbMsgBusEventDetach,
+  //
+  // ATTACH bus event signaled
+  //
+  EfiUsbMsgBusEventAttach,
+  //
+  // RESET bus event signaled
+  //
+  EfiUsbMsgBusEventReset,
+  //
+  // SUSPEND bus event signaled
+  //
+  EfiUsbMsgBusEventSuspend,
+  //
+  // RESUME bus event signaled
+  //
+  EfiUsbMsgBusEventResume,
+  //
+  // Bus speed updated, returned buffer indicated bus speed using
+  // following enumeration named EFI_USB_BUS_SPEED
+  //
+  EfiUsbMsgBusEventSpeed
+} EFI_USBFN_MESSAGE;
+
+typedef enum _EFI_USBFN_TRANSFER_STATUS {
+  UsbTransferStatusUnknown = 0,
+  UsbTransferStatusComplete,
+  UsbTransferStatusAborted,
+  UsbTransferStatusActive,
+  UsbTransferStatusNone
+} EFI_USBFN_TRANSFER_STATUS;
+
+typedef struct _EFI_USBFN_TRANSFER_RESULT {
+  UINTN                         BytesTransferred;
+  EFI_USBFN_TRANSFER_STATUS     TransferStatus;
+  UINT8                         EndpointIndex;
+  EFI_USBFN_ENDPOINT_DIRECTION  Direction;
+  VOID                          *Buffer;
+} EFI_USBFN_TRANSFER_RESULT;
+
+typedef enum _EFI_USB_BUS_SPEED {
+  UsbBusSpeedUnknown = 0,
+  UsbBusSpeedLow,
+  UsbBusSpeedFull,
+  UsbBusSpeedHigh,
+  UsbBusSpeedSuper,
+  UsbBusSpeedMaximum = UsbBusSpeedSuper
+} EFI_USB_BUS_SPEED;
+
+typedef union _EFI_USBFN_MESSAGE_PAYLOAD {
+  EFI_USB_DEVICE_REQUEST       udr;
+  EFI_USBFN_TRANSFER_RESULT    utr;
+  EFI_USB_BUS_SPEED            ubs;
+} EFI_USBFN_MESSAGE_PAYLOAD;
+
+typedef enum _EFI_USBFN_POLICY_TYPE {
+  EfiUsbPolicyUndefined = 0,
+  EfiUsbPolicyMaxTransactionSize,
+  EfiUsbPolicyZeroLengthTerminationSupport,
+  EfiUsbPolicyZeroLengthTermination
+} EFI_USBFN_POLICY_TYPE;
+
+/**
+  Returns information about what USB port type was attached.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[out] PortType          Returns the USB port type.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to
+                                process this request or there is no USB port
+                                attached to the device.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_DETECT_PORT) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+     OUT EFI_USBFN_PORT_TYPE           *PortType
+  );
+
+/**
+  Configures endpoints based on supplied device and configuration descriptors.
+
+  Assuming that the hardware has already been initialized, this function configures
+  the endpoints using the device information supplied by DeviceInfo, activates the
+  port, and starts receiving USB events.
+
+  This function must ignore the bMaxPacketSize0field of the Standard Device Descriptor
+  and the wMaxPacketSize field of the Standard Endpoint Descriptor that are made
+  available through DeviceInfo.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[out] DeviceInfo        A pointer to EFI_USBFN_DEVICE_INFO instance.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to lack of
+                                resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_CONFIGURE_ENABLE_ENDPOINTS) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+     OUT EFI_USB_DEVICE_INFO           *DeviceInfo
+  );
+
+/**
+  Returns the maximum packet size of the specified endpoint type for the supplied
+  bus speed.
+
+  If the BusSpeed is UsbBusSpeedUnknown, the maximum speed the underlying controller
+  supports is assumed.
+
+  This protocol currently does not support isochronous or interrupt transfers. Future
+  revisions of this protocol may eventually support it.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOLinstance.
+  @param[in]  EndpointType      Endpoint type as defined as EFI_USB_ENDPOINT_TYPE.
+  @param[in]  BusSpeed          Bus speed as defined as EFI_USB_BUS_SPEED.
+  @param[out] MaxPacketSize     The maximum packet size, in bytes, of the specified
+                                endpoint type.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_ENDPOINT_MAXPACKET_SIZE) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     EFI_USB_ENDPOINT_TYPE         EndpointType,
+  IN     EFI_USB_BUS_SPEED             BusSpeed,
+     OUT UINT16                        *MaxPacketSize
+  );
+
+/**
+  Returns device specific information based on the supplied identifier as a Unicode string.
+
+  If the supplied Buffer isn't large enough, or is NULL, the method fails with
+  EFI_BUFFER_TOO_SMALL and the required size is returned through BufferSize. All returned
+  strings are in Unicode format.
+
+  An Id of EfiUsbDeviceInfoUnknown is treated as an invalid parameter.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOLinstance.
+  @param[in]  Id                The requested information id.
+
+
+  @param[in]  BufferSize        On input, the size of the Buffer in bytes. On output, the
+                                amount of data returned in Buffer in bytes.
+  @param[out] Buffer            A pointer to a buffer to returnthe requested information
+                                as a Unicode string.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_BUFFER_TOO_SMALL  Supplied buffer isn't large enough to hold the request string.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_DEVICE_INFO) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     EFI_USBFN_DEVICE_INFO_ID      Id,
+  IN OUT UINTN                         *BufferSize,
+     OUT VOID                          *Buffer OPTIONAL
+);
+
+/**
+  Returns the vendor-id and product-id of the device.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[out] Vid               Returned vendor-id of the device.
+  @param[out] Pid               Returned product-id of the device.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_NOT_FOUND         Unable to return the vendor-id or the product-id.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_VENDOR_ID_PRODUCT_ID) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+     OUT UINT16                        *Vid,
+     OUT UINT16                        *Pid
+);
+
+/**
+  Aborts the transfer on the specified endpoint.
+
+  This function should fail with EFI_INVALID_PARAMETER if the specified direction
+  is incorrect for the endpoint.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]  EndpointIndex     Indicates the endpoint on which the ongoing transfer
+                                needs to be canceled.
+  @param[in]  Direction         Direction of the endpoint.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_ABORT_TRANSFER) (
+  IN  EFI_USBFN_IO_PROTOCOL            *This,
+  IN  UINT8                            EndpointIndex,
+  IN  EFI_USBFN_ENDPOINT_DIRECTION     Direction
+);
+
+/**
+  Returns the stall state on the specified endpoint.
+
+  This function should fail with EFI_INVALID_PARAMETER if the specified direction
+  is incorrect for the endpoint.
+
+  @param[in]      This          A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]      EndpointIndex Indicates the endpoint.
+  @param[in]      Direction     Direction of the endpoint.
+  @param[in, out] State         Boolean, true value indicates that the endpoint
+                                is in a stalled state, false otherwise.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_ENDPOINT_STALL_STATE) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     UINT8                         EndpointIndex,
+  IN     EFI_USBFN_ENDPOINT_DIRECTION  Direction,
+  IN OUT BOOLEAN                       *State
+);
+
+/**
+  Sets or clears the stall state on the specified endpoint.
+
+  This function should fail with EFI_INVALID_PARAMETER if the specified direction
+  is incorrect for the endpoint.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]  EndpointIndex     Indicates the endpoint.
+  @param[in]  Direction         Direction of the endpoint.
+  @param[in]  State             Requested stall state on the specified endpoint.
+                                True value causes the endpoint to stall; false
+                                value clears an existing stall.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_SET_ENDPOINT_STALL_STATE) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     UINT8                         EndpointIndex,
+  IN     EFI_USBFN_ENDPOINT_DIRECTION  Direction,
+  IN OUT BOOLEAN                       *State
+);
+
+/**
+  This function is called repeatedly to get information on USB bus states,
+  receive-completion and transmit-completion events on the endpoints, and
+  notification on setup packet on endpoint 0.
+
+  A class driver must call EFI_USBFN_IO_PROTOCOL.EventHandler()repeatedly
+  to receive updates on the transfer status and number of bytes transferred
+  on various endpoints.
+
+  @param[in]      This          A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[out]     Message       Indicates the event that initiated this notification.
+  @param[in, out] PayloadSize   On input, the size of the memory pointed by
+                                Payload. On output, the amount ofdata returned
+                                in Payload.
+  @param[out]     Payload       A pointer to EFI_USBFN_MESSAGE_PAYLOAD instance
+                                to return additional payload for current message.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+  @retval EFI_BUFFER_TOO_SMALL  The Supplied buffer is not large enough to hold
+                                the message payload.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_EVENTHANDLER) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+     OUT EFI_USBFN_MESSAGE             *Message,
+  IN OUT UINTN                         *PayloadSize,
+     OUT EFI_USBFN_MESSAGE_PAYLOAD     *Payload
+);
+
+/**
+  This function handles transferring data to or from the host on the specified
+  endpoint, depending on the direction specified.
+
+  A class driver must call EFI_USBFN_IO_PROTOCOL.EventHandler() repeatedly to
+  receive updates on the transfer status and the number of bytes transferred on
+  various endpoints. Upon an update of the transfer status, the Buffer field of
+  the EFI_USBFN_TRANSFER_RESULT structure (as described in the function description
+  for EFI_USBFN_IO_PROTOCOL.EventHandler()) must be initialized with the Buffer
+  pointer that was supplied to this method.
+
+  The overview of the call sequence is illustrated in the Figure 54.
+
+  This function should fail with EFI_INVALID_PARAMETER if the specified direction
+  is incorrect for the endpoint.
+
+  @param[in]      This          A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]      EndpointIndex Indicates the endpoint on which TX or RX transfer
+                                needs to take place.
+  @param[in]      Direction     Direction of the endpoint.
+  @param[in, out] BufferSize    If Direction is EfiUsbEndpointDirectionDeviceRx:
+                                  On input, the size of the Bufferin bytes.
+                                  On output, the amount of data returned in Buffer
+                                  in bytes.
+                                If Direction is EfiUsbEndpointDirectionDeviceTx:
+                                  On input, the size of the Bufferin bytes.
+                                  On output, the amount of data transmitted in bytes.
+  @param[in, out] Buffer        If Direction is EfiUsbEndpointDirectionDeviceRx:
+                                  The Buffer to return the received data.
+                                If Directionis EfiUsbEndpointDirectionDeviceTx:
+                                  The Buffer that contains the data to be transmitted.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_TRANSFER) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     UINT8                         EndpointIndex,
+  IN     EFI_USBFN_ENDPOINT_DIRECTION  Direction,
+  IN OUT UINTN                         *BufferSize,
+  IN OUT VOID                          *Buffer
+);
+
+/**
+  Returns the maximum supported transfer size.
+
+  Returns the maximum number of bytes that the underlying controller can accommodate
+  in a single transfer.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[out] MaxTransferSize   The maximum supported transfer size, in bytes.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_NOT_READY         The physical device is busy or not ready to process
+                                this request.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_MAXTRANSFER_SIZE) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+     OUT UINTN                         *MaxTransferSize
+  );
+
+/**
+  Allocates a transfer buffer of the specified sizethat satisfies the controller
+  requirements.
+
+  The AllocateTransferBuffer() function allocates a memory region of Size bytes and
+  returns the address of the allocated memory that satisfies the underlying controller
+  requirements in the location referenced by Buffer.
+
+  The allocated transfer buffer must be freed using a matching call to
+  EFI_USBFN_IO_PROTOCOL.FreeTransferBuffer()function.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]  Size              The number of bytes to allocate for the transfer buffer.
+  @param[out] Buffer            A pointer to a pointer to the allocated buffer if the
+                                call succeeds; undefined otherwise.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_OUT_OF_RESOURCES  The requested transfer buffer could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_ALLOCATE_TRANSFER_BUFFER) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     UINTN                         Size,
+     OUT VOID                          **Buffer
+  );
+
+/**
+  Deallocates the memory allocated for the transfer buffer by the
+  EFI_USBFN_IO_PROTOCOL.AllocateTransferBuffer() function.
+
+  The EFI_USBFN_IO_PROTOCOL.FreeTransferBuffer() function deallocates the
+  memory specified by Buffer. The Buffer that is freed must have been allocated
+  by EFI_USBFN_IO_PROTOCOL.AllocateTransferBuffer().
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]  Buffer            A pointer to the transfer buffer to deallocate.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_FREE_TRANSFER_BUFFER) (
+  IN  EFI_USBFN_IO_PROTOCOL         *This,
+  IN  VOID                          *Buffer
+  );
+
+/**
+  This function supplies power to the USB controller if needed and initializes
+  the hardware and the internal data structures. The port must not be activated
+  by this function.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_START_CONTROLLER) (
+  IN  EFI_USBFN_IO_PROTOCOL         *This
+  );
+
+/**
+  This function stops the USB hardware device.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_STOP_CONTROLLER) (
+  IN  EFI_USBFN_IO_PROTOCOL         *This
+  );
+
+/**
+  This function sets the configuration policy for the specified non-control
+  endpoint.
+
+  This function can only be called before EFI_USBFN_IO_PROTOCOL.StartController()
+  or after EFI_USBFN_IO_PROTOCOL.StopController() has been called.
+
+  @param[in]  This              A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]  EndpointIndex     Indicates the non-control endpoint for which the
+                                policy needs to be set.
+  @param[in]  Direction         Direction of the endpoint.
+  @param[in]  PolicyType        Policy type the user is trying to set for the
+                                specified non-control endpoint.
+  @param[in]  BufferSize        The size of the Bufferin bytes.
+  @param[in]  Buffer            The new value for the policy parameter that
+                                PolicyType specifies.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The physical device reported an error.
+  @retval EFI_UNSUPPORTED       Changing this policy value is not supported.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_SET_ENDPOINT_POLICY) (
+  IN  EFI_USBFN_IO_PROTOCOL         *This,
+  IN  UINT8                         EndpointIndex,
+  IN  EFI_USBFN_ENDPOINT_DIRECTION  Direction,
+  IN  EFI_USBFN_POLICY_TYPE         PolicyType,
+  IN  UINTN                         BufferSize,
+  IN  VOID                          *Buffer
+  );
+
+/**
+  This function sets the configuration policy for the specified non-control
+  endpoint.
+
+  This function can only be called before EFI_USBFN_IO_PROTOCOL.StartController()
+  or after EFI_USBFN_IO_PROTOCOL.StopController() has been called.
+
+  @param[in]      This          A pointer to the EFI_USBFN_IO_PROTOCOL instance.
+  @param[in]      EndpointIndex Indicates the non-control endpoint for which the
+                                policy needs to be set.
+  @param[in]      Direction     Direction of the endpoint.
+  @param[in]      PolicyType    Policy type the user is trying to retrieve for
+                                the specified non-control endpoint.
+  @param[in, out] BufferSize    On input, the size of Bufferin bytes. On output,
+                                the amount of data returned in Bufferin bytes.
+  @param[in, out] Buffer        A pointer to a buffer to return requested endpoint
+                                policy value.
+
+  @retval EFI_SUCCESS           The function returned successfully.
+  @retval EFI_INVALID_PARAMETER A parameter is invalid.
+  @retval EFI_DEVICE_ERROR      The specified policy value is not supported.
+  @retval EFI_BUFFER_TOO_SMALL  Supplied buffer is not large enough to hold requested
+                                policy value.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USBFN_IO_GET_ENDPOINT_POLICY) (
+  IN     EFI_USBFN_IO_PROTOCOL         *This,
+  IN     UINT8                         EndpointIndex,
+  IN     EFI_USBFN_ENDPOINT_DIRECTION  Direction,
+  IN     EFI_USBFN_POLICY_TYPE         PolicyType,
+  IN OUT UINTN                         *BufferSize,
+  IN OUT VOID                          *Buffer
+  );
+
+///
+/// The EFI_USBFN_IO_PROTOCOL provides basic data transactions and basic USB
+/// controller management for a USB Function port.
+///
+struct _EFI_USBFN_IO_PROTOCOL {
+  UINT32                                    Revision;
+  EFI_USBFN_IO_DETECT_PORT                  DetectPort;
+  EFI_USBFN_IO_CONFIGURE_ENABLE_ENDPOINTS   ConfigureEnableEndpoints;
+  EFI_USBFN_IO_GET_ENDPOINT_MAXPACKET_SIZE  GetEndpointMaxPacketSize;
+  EFI_USBFN_IO_GET_DEVICE_INFO              GetDeviceInfo;
+  EFI_USBFN_IO_GET_VENDOR_ID_PRODUCT_ID     GetVendorIdProductId;
+  EFI_USBFN_IO_ABORT_TRANSFER               AbortTransfer;
+  EFI_USBFN_IO_GET_ENDPOINT_STALL_STATE     GetEndpointStallState;
+  EFI_USBFN_IO_SET_ENDPOINT_STALL_STATE     SetEndpointStallState;
+  EFI_USBFN_IO_EVENTHANDLER                 EventHandler;
+  EFI_USBFN_IO_TRANSFER                     Transfer;
+  EFI_USBFN_IO_GET_MAXTRANSFER_SIZE         GetMaxTransferSize;
+  EFI_USBFN_IO_ALLOCATE_TRANSFER_BUFFER     AllocateTransferBuffer;
+  EFI_USBFN_IO_FREE_TRANSFER_BUFFER         FreeTransferBuffer;
+  EFI_USBFN_IO_START_CONTROLLER             StartController;
+  EFI_USBFN_IO_STOP_CONTROLLER              StopController;
+  EFI_USBFN_IO_SET_ENDPOINT_POLICY          SetEndpointPolicy;
+  EFI_USBFN_IO_GET_ENDPOINT_POLICY          GetEndpointPolicy;
+};
+
+extern EFI_GUID gEfiUsbFunctionIoProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/UsbHostController.h b/MdePkg/Include/Protocol/UsbHostController.h
new file mode 100644
index 000000000000..2196903a0f32
--- /dev/null
+++ b/MdePkg/Include/Protocol/UsbHostController.h
@@ -0,0 +1,508 @@
+/** @file
+  EFI_USB_HC_PROTOCOL as defined in EFI 1.10.
+
+  The USB Host Controller Protocol is used by code, typically USB bus drivers, 
+  running in the EFI boot services environment, to perform data transactions 
+  over a USB bus. In addition, it provides an abstraction for the root hub of the USB bus.
+
+  Copyright (c) 2006 - 2008, 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 _USB_HOSTCONTROLLER_H_
+#define _USB_HOSTCONTROLLER_H_
+
+#include <Protocol/Usb2HostController.h>
+
+#define EFI_USB_HC_PROTOCOL_GUID \
+  { \
+    0xf5089266, 0x1aa0, 0x4953, {0x97, 0xd8, 0x56, 0x2f, 0x8a, 0x73, 0xb5, 0x19 } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_USB_HC_PROTOCOL EFI_USB_HC_PROTOCOL;
+
+//
+// Protocol definitions
+//
+
+/**                                                                 
+  Provides software reset for the USB host controller.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  Attributes            A bit mask of the reset operation to perform.
+                                
+  @retval EFI_SUCCESS           The reset operation succeeded.
+  @retval EFI_UNSUPPORTED       The type of reset specified by Attributes is not currently supported
+                                by the host controller hardware.                                    
+  @retval EFI_INVALID_PARAMETER Attributes is not valid.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to perform the reset operation.
+                                   
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_RESET)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT16                  Attributes
+  );
+
+/**                                                                 
+  Retrieves current state of the USB host controller.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  State                 A pointer to the EFI_USB_HC_STATE data structure that
+                                indicates current state of the USB host controller.  
+                                
+  @retval EFI_SUCCESS           The state information of the host controller was returned in State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the host controller's
+                                current state.                                                                 
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_STATE)(
+  IN  EFI_USB_HC_PROTOCOL    *This,
+  OUT EFI_USB_HC_STATE       *State
+  );
+
+/**                                                                 
+  Sets the USB host controller to a specific state.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  State                 Indicates the state of the host controller that will be set.                                
+                                
+  @retval EFI_SUCCESS           The USB host controller was successfully placed in the state specified by
+                                State.                                                                   
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      Failed to set the state specified by State due to device error.                                
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SET_STATE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN EFI_USB_HC_STATE        State
+  );
+
+/**                                                                 
+  Submits control transfer to a target USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.                                                         
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving.     
+  @param  Request               A pointer to the USB device request that will be sent to the USB
+                                device.
+  @param  TransferDirection     Specifies the data direction for the transfer. There are three 
+                                values available, EfiUsbDataIn, EfiUsbDataOut and EfiUsbNoData.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB  
+                                device or received from USB device.                            
+  @param  DataLength            On input, indicates the size, in bytes, of the data buffer specified
+                                by Data. On output, indicates the amount of data actually           
+                                transferred.                                                        
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer
+                                is allowed to complete.                                        
+  @param  TransferResult        A pointer to the detailed result information generated by this  
+                                control transfer.
+                                
+  @retval EFI_SUCCESS           The control transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The control transfer could not be completed due to a lack of resources.                                
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The control transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The control transfer failed due to host controller or device error.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_CONTROL_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL       *This,
+  IN     UINT8                     DeviceAddress,
+  IN     BOOLEAN                   IsSlowDevice,
+  IN     UINT8                     MaximumPacketLength,
+  IN     EFI_USB_DEVICE_REQUEST    *Request,
+  IN     EFI_USB_DATA_DIRECTION    TransferDirection,
+  IN OUT VOID                      *Data       OPTIONAL,
+  IN OUT UINTN                     *DataLength OPTIONAL,
+  IN     UINTN                     TimeOut,
+  OUT    UINT32                    *TransferResult
+  );
+
+/**                                                                 
+  Submits bulk transfer to a bulk endpoint of a USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint 
+                                direction of the target USB device. Each endpoint address 
+                                supports data transfer in one direction except the control 
+                                endpoint (whose default endpoint address is 0). It is the 
+                                caller's responsibility to make sure that the EndPointAddress 
+                                represents a bulk endpoint.                 
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving.     
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB  
+                                device or received from USB device.                            
+  @param  DataLength            On input, indicates the size, in bytes, of the data buffer specified
+                                by Data. On output, indicates the amount of data actually           
+                                transferred.             
+  @param  DataToggle            A pointer to the data toggle value.                                                                           
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer
+                                is allowed to complete.                                        
+  @param  TransferResult        A pointer to the detailed result information of the bulk transfer.
+                                
+  @retval EFI_SUCCESS           The bulk transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The bulk transfer could not be completed due to a lack of resources.                                
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_BULK_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN OUT UINTN                  *DataLength,
+  IN OUT UINT8                  *DataToggle,
+  IN     UINTN                  TimeOut,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**                                                                 
+  Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an interrupt endpoint.     
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.                                                                          
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving.     
+  @param  IsNewTransfer         If TRUE, an asynchronous interrupt pipe is built between the host                       
+                                and the target interrupt endpoint. If FALSE, the specified asynchronous 
+                                interrupt pipe is canceled. If TRUE, and an interrupt transfer exists 
+                                for the target end point, then EFI_INVALID_PARAMETER is returned.      
+  @param  DataToggle            A pointer to the data toggle value. On input, it is valid when 
+                                IsNewTransfer is TRUE, and it indicates the initial data toggle 
+                                value the asynchronous interrupt transfer should adopt. On output, 
+                                it is valid when IsNewTransfer is FALSE, and it is updated to indicate 
+                                the data toggle value of the subsequent asynchronous interrupt transfer.     
+  @param  PollingInterval       Indicates the interval, in milliseconds, that the asynchronous
+                                interrupt transfer is polled. 
+  @param  DataLength            Indicates the length of data to be received at the rate specified by
+                                PollingInterval from the target asynchronous interrupt              
+                                endpoint. This parameter is only required when IsNewTransfer is TRUE.                                                            
+  @param  CallBackFunction      The Callback function. This function is called at the rate specified by 
+                                PollingInterval. This parameter is only required when IsNewTransfer is TRUE.                               
+  @param  Context               The context that is passed to the CallBackFunction.
+                                
+  @retval EFI_SUCCESS           The asynchronous interrupt transfer request has been successfully
+                                submitted or canceled.    
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.                                
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL                                 *This,
+  IN     UINT8                                               DeviceAddress,
+  IN     UINT8                                               EndPointAddress,
+  IN     BOOLEAN                                             IsSlowDevice,
+  IN     UINT8                                               MaxiumPacketLength,
+  IN     BOOLEAN                                             IsNewTransfer,
+  IN OUT UINT8                                               *DataToggle,
+  IN     UINTN                                               PollingInterval  OPTIONAL,
+  IN     UINTN                                               DataLength       OPTIONAL,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK                     CallBackFunction OPTIONAL,
+  IN     VOID                                                *Context         OPTIONAL
+  );
+
+/**                                                                 
+  Submits synchronous interrupt transfer to an interrupt endpoint of a USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an interrupt endpoint.  
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.                                                                          
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving.       
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.                         
+  @param  DataLength            On input, the size, in bytes, of the data buffer specified by Data.
+                                On output, the number of bytes transferred.                          
+  @param  DataToggle            A pointer to the data toggle value. On input, it indicates the initial 
+                                data toggle value the synchronous interrupt transfer should adopt; 
+                                on output, it is updated to indicate the data toggle value of the 
+                                subsequent synchronous interrupt transfer.                               
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer    
+                                is allowed to complete.                                            
+  @param  TransferResult        A pointer to the detailed result information from the synchronous
+                                interrupt transfer.
+                                
+  @retval EFI_SUCCESS           The synchronous interrupt transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.                                  
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The synchronous interrupt transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The synchronous interrupt transfer failed due to host controller or device error.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     BOOLEAN                IsSlowDevice,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN OUT UINTN                  *DataLength,
+  IN OUT UINT8                  *DataToggle,
+  IN     UINTN                  TimeOut,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**                                                                 
+  Submits isochronous transfer to an isochronous endpoint of a USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is 0). It is the caller's
+                                responsibility to make sure that the EndPointAddress
+                                represents an isochronous endpoint.                  
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving.       
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.                         
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received
+                                from the USB device.                                                 
+  @param  TransferResult        A pointer to the detailed result information from the isochronous
+                                transfer.
+                                
+  @retval EFI_SUCCESS           The isochronous transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The isochronous could not be completed due to a lack of resources.                                  
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The isochronous transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The isochronous transfer failed due to host controller or device error.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN     UINTN                  DataLength,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**                                                                 
+  Submits nonblocking isochronous transfer to an isochronous endpoint of a USB device.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.                                
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an isochronous endpoint.             
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control 
+                                transfer endpoint is capable of sending or receiving. For isochronous 
+                                endpoints, this value is used to reserve the bus time in the schedule, 
+                                required for the perframe data payloads. The pipe may, on an ongoing basis,
+                                actually use less bandwidth than that reserved.      
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.                         
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received
+                                from the USB device.                                                 
+  @param  IsochronousCallback   The Callback function.This function is called if the requested
+                                isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback function. This is
+                                an optional parameter and may be NULL.
+                                
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The asynchronous isochronous could not be completed due to a lack of resources.                                  
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL                *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              MaximumPacketLength,
+  IN OUT VOID                               *Data,
+  IN     UINTN                              DataLength,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK    IsochronousCallBack,
+  IN     VOID                               *Context OPTIONAL
+  );
+
+/**                                                                 
+  Retrieves the number of root hub ports.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            A pointer to the number of the root hub ports.                                
+                                
+  @retval EFI_SUCCESS           The port number was retrieved successfully.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the port number.
+  @retval EFI_INVALID_PARAMETER PortNumber is NULL.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_NUMBER)(
+  IN EFI_USB_HC_PROTOCOL    *This,
+  OUT UINT8                 *PortNumber
+  );
+
+/**                                                                 
+  Retrieves the current status of a USB root hub port.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortStatus            A pointer to the current port status bits and port status change bits.                                
+                                
+  @retval EFI_SUCCESS           The status of the USB root hub port specified by PortNumber
+                                was returned in PortStatus.                                
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN  UINT8                  PortNumber,
+  OUT EFI_USB_PORT_STATUS    *PortStatus
+  );
+
+/**                                                                 
+  Sets a feature for the specified root hub port.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortFeature           Indicates the feature selector associated with the feature set
+                                request.
+                                
+  @retval EFI_SUCCESS           The feature specified by PortFeature was set for the USB
+                                root hub port specified by PortNumber.                  
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+/**                                                                 
+  Clears a feature for the specified root hub port.
+    
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortFeature           Indicates the feature selector associated with the feature clear
+                                request.
+                                
+  @retval EFI_SUCCESS           The feature specified by PortFeature was cleared for the USB
+                                root hub port specified by PortNumber.                  
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+
+///
+/// The EFI_USB_HC_PROTOCOL provides USB host controller management, basic data transactions
+/// over a USB bus, and USB root hub access. A device driver that wishes to manage a USB bus in a
+/// system retrieves the EFI_USB_HC_PROTOCOL instance that is associated with the USB bus to be
+/// managed. A device handle for a USB host controller will minimally contain an
+/// EFI_DEVICE_PATH_PROTOCOL instance, and an EFI_USB_HC_PROTOCOL instance. 
+///
+struct _EFI_USB_HC_PROTOCOL {
+  EFI_USB_HC_PROTOCOL_RESET                       Reset;
+  EFI_USB_HC_PROTOCOL_GET_STATE                   GetState;
+  EFI_USB_HC_PROTOCOL_SET_STATE                   SetState;
+  EFI_USB_HC_PROTOCOL_CONTROL_TRANSFER            ControlTransfer;
+  EFI_USB_HC_PROTOCOL_BULK_TRANSFER               BulkTransfer;
+  EFI_USB_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER    AsyncInterruptTransfer;
+  EFI_USB_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER     SyncInterruptTransfer;
+  EFI_USB_HC_PROTOCOL_ISOCHRONOUS_TRANSFER        IsochronousTransfer;
+  EFI_USB_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER  AsyncIsochronousTransfer;
+  EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_NUMBER     GetRootHubPortNumber;
+  EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS     GetRootHubPortStatus;
+  EFI_USB_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE    SetRootHubPortFeature;
+  EFI_USB_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE  ClearRootHubPortFeature;
+  ///
+  /// The major revision number of the USB host controller. The revision information 
+  /// indicates the release of the Universal Serial Bus Specification with which the 
+  /// host controller is compliant.
+  ///  
+  UINT16                                          MajorRevision;
+  ///
+  /// The minor revision number of the USB host controller. The revision information 
+  /// indicates the release of the Universal Serial Bus Specification with which the 
+  /// host controller is compliant.  
+  ///  
+  UINT16                                          MinorRevision;
+};
+
+extern EFI_GUID gEfiUsbHcProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UsbIo.h b/MdePkg/Include/Protocol/UsbIo.h
new file mode 100644
index 000000000000..cc7263b6aa67
--- /dev/null
+++ b/MdePkg/Include/Protocol/UsbIo.h
@@ -0,0 +1,512 @@
+/** @file
+  EFI Usb I/O Protocol as defined in UEFI specification.
+  This protocol is used by code, typically drivers, running in the EFI 
+  boot services environment to access USB devices like USB keyboards, 
+  mice and mass storage devices. In particular, functions for managing devices 
+  on USB buses are defined here.
+  
+  Copyright (c) 2006 - 2008, 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 __USB_IO_H__
+#define __USB_IO_H__
+
+#include <IndustryStandard/Usb.h>
+
+//
+// Global ID for the USB I/O Protocol
+//
+#define EFI_USB_IO_PROTOCOL_GUID \
+  { \
+    0x2B2F68D6, 0x0CD2, 0x44cf, {0x8E, 0x8B, 0xBB, 0xA2, 0x0B, 0x1B, 0x5B, 0x75 } \
+  }
+
+typedef struct _EFI_USB_IO_PROTOCOL   EFI_USB_IO_PROTOCOL;
+
+//
+// Related Definition for EFI USB I/O protocol
+//
+
+//
+// USB standard descriptors and reqeust
+//
+typedef USB_DEVICE_REQUEST        EFI_USB_DEVICE_REQUEST;
+typedef USB_DEVICE_DESCRIPTOR     EFI_USB_DEVICE_DESCRIPTOR;
+typedef USB_CONFIG_DESCRIPTOR     EFI_USB_CONFIG_DESCRIPTOR;
+typedef USB_INTERFACE_DESCRIPTOR  EFI_USB_INTERFACE_DESCRIPTOR;
+typedef USB_ENDPOINT_DESCRIPTOR   EFI_USB_ENDPOINT_DESCRIPTOR;
+
+///
+/// USB data transfer direction
+///
+typedef enum {
+  EfiUsbDataIn,
+  EfiUsbDataOut,
+  EfiUsbNoData
+} EFI_USB_DATA_DIRECTION;
+
+//
+// USB Transfer Results
+//
+#define EFI_USB_NOERROR             0x00
+#define EFI_USB_ERR_NOTEXECUTE      0x01
+#define EFI_USB_ERR_STALL           0x02
+#define EFI_USB_ERR_BUFFER          0x04
+#define EFI_USB_ERR_BABBLE          0x08
+#define EFI_USB_ERR_NAK             0x10
+#define EFI_USB_ERR_CRC             0x20
+#define EFI_USB_ERR_TIMEOUT         0x40
+#define EFI_USB_ERR_BITSTUFF        0x80
+#define EFI_USB_ERR_SYSTEM          0x100
+
+/**
+  Async USB transfer callback routine.
+
+  @param  Data                  Data received or sent via the USB Asynchronous Transfer, if the
+                                transfer completed successfully.
+  @param  DataLength            The length of Data received or sent via the Asynchronous
+                                Transfer, if transfer successfully completes.
+  @param  Context               Data passed from UsbAsyncInterruptTransfer() request.
+  @param  Status                Indicates the result of the asynchronous transfer.
+
+  @retval EFI_SUCCESS           The asynchronous USB transfer request has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The asynchronous USB transfer request failed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ASYNC_USB_TRANSFER_CALLBACK)(
+  IN VOID         *Data,
+  IN UINTN        DataLength,
+  IN VOID         *Context,
+  IN UINT32       Status
+  );
+
+//
+// Prototype for EFI USB I/O protocol
+//
+
+
+/**
+  This function is used to manage a USB device with a control transfer pipe. A control transfer is
+  typically used to perform device initialization and configuration.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  Request               A pointer to the USB device request that will be sent to the USB
+                                device.
+  @param  Direction             Indicates the data direction.
+  @param  Timeout               Indicating the transfer should be completed within this time frame.
+                                The units are in milliseconds.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+  @param  Status                A pointer to the result of the USB transfer.
+
+  @retval EFI_SUCCESS           The control transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The transfer failed. The transfer status is returned in Status.
+  @retval EFI_INVALID_PARAMETE  One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer fails due to timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_CONTROL_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL                        *This,
+  IN EFI_USB_DEVICE_REQUEST                     *Request,
+  IN EFI_USB_DATA_DIRECTION                     Direction,
+  IN UINT32                                     Timeout,
+  IN OUT VOID                                   *Data OPTIONAL,
+  IN UINTN                                      DataLength  OPTIONAL,
+  OUT UINT32                                    *Status
+  );
+
+/**
+  This function is used to manage a USB device with the bulk transfer pipe. Bulk Transfers are
+  typically used to transfer large amounts of data to/from USB devices.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the 
+                                device request is being sent. DeviceEndpoint must 
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F, 
+                                otherwise EFI_INVALID_PARAMETER is returned. If 
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER 
+                                is returned. The MSB of this parameter indicates 
+                                the endpoint direction. The number "1" stands for 
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+                                On input, the size, in bytes, of the data buffer specified by Data.
+                                On output, the number of bytes that were actually transferred.
+  @param  Timeout               Indicating the transfer should be completed within this time frame.
+                                The units are in milliseconds. If Timeout is 0, then the 
+                                caller must wait for the function to be completed until 
+                                EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The bulk transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The transfer failed. The transfer status is returned in Status.
+  @retval EFI_INVALID_PARAMETE  One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer fails due to timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_BULK_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN UINT8                          DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN OUT UINTN                      *DataLength,
+  IN UINTN                          Timeout,
+  OUT UINT32                        *Status
+  );
+
+/**
+  This function is used to manage a USB device with an interrupt transfer pipe. An Asynchronous
+  Interrupt Transfer is typically used to query a device's status at a fixed rate. For example,
+  keyboard, mouse, and hub devices use this type of transfer to query their interrupt endpoints at
+  a fixed rate.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the 
+                                device request is being sent. DeviceEndpoint must 
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F, 
+                                otherwise EFI_INVALID_PARAMETER is returned. If 
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER 
+                                is returned. The MSB of this parameter indicates 
+                                the endpoint direction. The number "1" stands for 
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  IsNewTransfer         If TRUE, a new transfer will be submitted to USB controller. If
+                                FALSE, the interrupt transfer is deleted from the device's interrupt
+                                transfer queue.
+  @param  PollingInterval       Indicates the periodic rate, in milliseconds, that the transfer is to be
+                                executed.This parameter is required when IsNewTransfer is TRUE. The 
+                                value must be between 1 to 255, otherwise EFI_INVALID_PARAMETER is returned. 
+                                The units are in milliseconds.
+  @param  DataLength            Specifies the length, in bytes, of the data to be received from the
+                                USB device. This parameter is only required when IsNewTransfer is TRUE.
+  @param  InterruptCallback     The Callback function. This function is called if the asynchronous
+                                interrupt transfer is completed. This parameter is required 
+                                when IsNewTransfer is TRUE.
+  @param  Context               Data passed to the InterruptCallback function. This is an optional 
+                                parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous USB transfer request transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The asynchronous USB transfer request failed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ASYNC_INTERRUPT_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL                                 *This,
+  IN UINT8                                               DeviceEndpoint,
+  IN BOOLEAN                                             IsNewTransfer,
+  IN UINTN                                               PollingInterval    OPTIONAL,
+  IN UINTN                                               DataLength         OPTIONAL,
+  IN EFI_ASYNC_USB_TRANSFER_CALLBACK                     InterruptCallBack  OPTIONAL,
+  IN VOID                                                *Context OPTIONAL
+  );
+
+/**
+  This function is used to manage a USB device with an interrupt transfer pipe.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the 
+                                device request is being sent. DeviceEndpoint must 
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F, 
+                                otherwise EFI_INVALID_PARAMETER is returned. If 
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER 
+                                is returned. The MSB of this parameter indicates 
+                                the endpoint direction. The number "1" stands for 
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            On input, then size, in bytes, of the buffer Data. On output, the
+                                amount of data actually transferred.
+  @param  Timeout               The time out, in seconds, for this transfer. If Timeout is 0, 
+                                then the caller must wait for the function to be completed 
+                                until EFI_SUCCESS or EFI_DEVICE_ERROR is returned. If the 
+                                transfer is not completed in this time frame, then EFI_TIMEOUT is returned.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The sync interrupt transfer has been successfully executed.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_DEVICE_ERROR      The sync interrupt transfer request failed.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The transfer fails due to timeout.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_SYNC_INTERRUPT_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN     UINT8                      DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN OUT UINTN                      *DataLength,
+  IN     UINTN                      Timeout,
+  OUT    UINT32                     *Status
+  );
+
+/**
+  This function is used to manage a USB device with an isochronous transfer pipe. An Isochronous
+  transfer is typically used to transfer streaming data.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the 
+                                device request is being sent. DeviceEndpoint must 
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F, 
+                                otherwise EFI_INVALID_PARAMETER is returned. If 
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER 
+                                is returned. The MSB of this parameter indicates 
+                                the endpoint direction. The number "1" stands for 
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The isochronous transfer has been successfully executed.
+  @retval EFI_INVALID_PARAMETER The parameter DeviceEndpoint is not valid.
+  @retval EFI_DEVICE_ERROR      The transfer failed due to the reason other than timeout, The error status
+                                is returned in Status.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The transfer fails due to timeout.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ISOCHRONOUS_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN     UINT8                      DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN     UINTN                      DataLength,
+  OUT    UINT32                     *Status
+  );
+
+/**
+  This function is used to manage a USB device with an isochronous transfer pipe. An Isochronous
+  transfer is typically used to transfer streaming data.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the 
+                                device request is being sent. DeviceEndpoint must 
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F, 
+                                otherwise EFI_INVALID_PARAMETER is returned. If 
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER 
+                                is returned. The MSB of this parameter indicates 
+                                the endpoint direction. The number "1" stands for 
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+                                This is an optional parameter and may be NULL.
+  @param  IsochronousCallback   The IsochronousCallback() function.This function is 
+                                called if the requested isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback() function.
+
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer has been successfully submitted
+                                to the system.
+  @retval EFI_INVALID_PARAMETER The parameter DeviceEndpoint is not valid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL              *This,
+  IN UINT8                            DeviceEndpoint,
+  IN OUT VOID                         *Data,
+  IN     UINTN                        DataLength,
+  IN EFI_ASYNC_USB_TRANSFER_CALLBACK  IsochronousCallBack,
+  IN VOID                             *Context OPTIONAL
+  );
+
+/**
+  Resets and reconfigures the USB controller. This function will work for all USB devices except
+  USB Hub Controllers.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The USB controller was reset.
+  @retval EFI_INVALID_PARAMETER If the controller specified by This is a USB hub.
+  @retval EFI_DEVICE_ERROR      An error occurred during the reconfiguration process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_PORT_RESET)(
+  IN EFI_USB_IO_PROTOCOL    *This
+  );
+
+/**
+  Retrieves the USB Device Descriptor.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceDescriptor      A pointer to the caller allocated USB Device Descriptor.
+
+  @retval EFI_SUCCESS           The device descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER DeviceDescriptor is NULL.
+  @retval EFI_NOT_FOUND         The device descriptor was not found. The device may not be configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_DEVICE_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_DEVICE_DESCRIPTOR     *DeviceDescriptor
+  );
+
+/**
+  Retrieves the USB Device Descriptor.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  ConfigurationDescriptor A pointer to the caller allocated USB Active Configuration
+                                  Descriptor.
+  @retval EFI_SUCCESS             The active configuration descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   ConfigurationDescriptor is NULL.
+  @retval EFI_NOT_FOUND           An active configuration descriptor cannot be found. The device may not
+                                  be configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_CONFIG_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_CONFIG_DESCRIPTOR     *ConfigurationDescriptor
+  );
+
+/**
+  Retrieves the Interface Descriptor for a USB Device Controller. As stated earlier, an interface
+  within a USB device is equivalently to a USB Controller within the current configuration.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  InterfaceDescriptor     A pointer to the caller allocated USB Interface Descriptor within
+                                  the configuration setting.
+  @retval EFI_SUCCESS             The interface descriptor retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   InterfaceDescriptor is NULL.
+  @retval EFI_NOT_FOUND           The interface descriptor cannot be found. The device may not be
+                                  correctly configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_INTERFACE_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_INTERFACE_DESCRIPTOR  *InterfaceDescriptor
+  );
+
+/**
+  Retrieves an Endpoint Descriptor within a USB Controller.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  EndpointIndex           Indicates which endpoint descriptor to retrieve.
+  @param  EndpointDescriptor      A pointer to the caller allocated USB Endpoint Descriptor of
+                                  a USB controller.
+
+  @retval EFI_SUCCESS             The endpoint descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   One or more parameters are invalid.
+  @retval EFI_NOT_FOUND           The endpoint descriptor cannot be found. The device may not be
+                                  correctly configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_ENDPOINT_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN  UINT8                         EndpointIndex,
+  OUT EFI_USB_ENDPOINT_DESCRIPTOR   *EndpointDescriptor
+  );
+
+/**
+  Retrieves a string stored in a USB Device.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  LangID                  The Language ID for the string being retrieved.
+  @param  StringID                The ID of the string being retrieved.
+  @param  String                  A pointer to a buffer allocated by this function with
+                                  AllocatePool() to store the string.If this function 
+                                  returns EFI_SUCCESS, it stores the string the caller 
+                                  wants to get. The caller should release the string 
+                                  buffer with FreePool() after the string is not used any more.
+
+  @retval EFI_SUCCESS             The string was retrieved successfully.
+  @retval EFI_NOT_FOUND           The string specified by LangID and StringID was not found.
+  @retval EFI_OUT_OF_RESOURCES    There are not enough resources to allocate the return buffer String.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_STRING_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN  UINT16                        LangID,
+  IN  UINT8                         StringID,
+  OUT CHAR16                        **String
+  );
+
+/**
+  Retrieves all the language ID codes that the USB device supports.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  LangIDTable             Language ID for the string the caller wants to get.
+                                  This is a 16-bit ID defined by Microsoft. This 
+                                  buffer pointer is allocated and maintained by 
+                                  the USB Bus Driver, the caller should not modify 
+                                  its contents.
+  @param  TableSize               The size, in bytes, of the table LangIDTable.
+
+  @retval EFI_SUCCESS             The support languages were retrieved successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_SUPPORTED_LANGUAGE)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT UINT16                        **LangIDTable,
+  OUT UINT16                        *TableSize
+  );
+
+///
+/// The EFI_USB_IO_PROTOCOL provides four basic transfers types described 
+/// in the USB 1.1 Specification. These include control transfer, interrupt 
+/// transfer, bulk transfer and isochronous transfer. The EFI_USB_IO_PROTOCOL 
+/// also provides some basic USB device/controller management and configuration 
+/// interfaces. A USB device driver uses the services of this protocol to manage USB devices.  
+///
+struct _EFI_USB_IO_PROTOCOL {
+  //
+  // IO transfer
+  //
+  EFI_USB_IO_CONTROL_TRANSFER           UsbControlTransfer;
+  EFI_USB_IO_BULK_TRANSFER              UsbBulkTransfer;
+  EFI_USB_IO_ASYNC_INTERRUPT_TRANSFER   UsbAsyncInterruptTransfer;
+  EFI_USB_IO_SYNC_INTERRUPT_TRANSFER    UsbSyncInterruptTransfer;
+  EFI_USB_IO_ISOCHRONOUS_TRANSFER       UsbIsochronousTransfer;
+  EFI_USB_IO_ASYNC_ISOCHRONOUS_TRANSFER UsbAsyncIsochronousTransfer;
+
+  //
+  // Common device request
+  //
+  EFI_USB_IO_GET_DEVICE_DESCRIPTOR      UsbGetDeviceDescriptor;
+  EFI_USB_IO_GET_CONFIG_DESCRIPTOR      UsbGetConfigDescriptor;
+  EFI_USB_IO_GET_INTERFACE_DESCRIPTOR   UsbGetInterfaceDescriptor;
+  EFI_USB_IO_GET_ENDPOINT_DESCRIPTOR    UsbGetEndpointDescriptor;
+  EFI_USB_IO_GET_STRING_DESCRIPTOR      UsbGetStringDescriptor;
+  EFI_USB_IO_GET_SUPPORTED_LANGUAGE     UsbGetSupportedLanguages;
+
+  //
+  // Reset controller's parent port
+  //
+  EFI_USB_IO_PORT_RESET                 UsbPortReset;
+};
+
+extern EFI_GUID gEfiUsbIoProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UserCredential.h b/MdePkg/Include/Protocol/UserCredential.h
new file mode 100644
index 000000000000..6dea64358732
--- /dev/null
+++ b/MdePkg/Include/Protocol/UserCredential.h
@@ -0,0 +1,292 @@
+/** @file
+  UEFI 2.2 User Credential Protocol definition.It has been removed from UEFI 2.3.1 and replaced
+  by EFI_USER_CREDENTIAL2_PROTOCOL.
+
+  Attached to a device handle, this protocol identifies a single means of identifying the user.
+
+  Copyright (c) 2009 - 2010, 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 __USER_CREDENTIAL_H__
+#define __USER_CREDENTIAL_H__
+
+#include <Protocol/UserManager.h>
+
+#define EFI_USER_CREDENTIAL_PROTOCOL_GUID \
+  { \
+    0x71ee5e94, 0x65b9, 0x45d5, { 0x82, 0x1a, 0x3a, 0x4d, 0x86, 0xcf, 0xe6, 0xbe } \
+  }
+
+typedef struct _EFI_USER_CREDENTIAL_PROTOCOL  EFI_USER_CREDENTIAL_PROTOCOL;
+
+/**
+  Enroll a user on a credential provider.
+
+  This function enrolls and deletes a user profile using this credential provider. If a user profile
+  is successfully enrolled, it calls the User Manager Protocol function Notify() to notify the user 
+  manager driver that credential information has changed. If an enrolled user does exist, delete the 
+  user on the credential provider.
+
+  @param[in] This                Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[in] User                The user profile to enroll.
+ 
+  @retval EFI_SUCCESS            User profile was successfully enrolled.
+  @retval EFI_ACCESS_DENIED      Current user profile does not permit enrollment on the user profile 
+                                 handle. Either the user profile cannot enroll on any user profile or 
+                                 cannot enroll on a user profile other than the current user profile.
+  @retval EFI_UNSUPPORTED        This credential provider does not support enrollment in the pre-OS.
+  @retval EFI_DEVICE_ERROR       The new credential could not be created because of a device error.
+  @retval EFI_INVALID_PARAMETER  User does not refer to a valid user profile handle.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_ENROLL)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE       User
+  );
+
+/**
+  Returns the user interface information used during user identification.
+
+  This function returns information about the form used when interacting with the user during user 
+  identification. The form is the first enabled form in the form-set class 
+  EFI_HII_USER_CREDENTIAL_FORMSET_GUID installed on the HII handle HiiHandle. If 
+  the user credential provider does not require a form to identify the user, then this function should 
+  return EFI_NOT_FOUND.
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[out] Hii                On return, holds the HII database handle.
+  @param[out] FormSetId          On return, holds the identifier of the form set which contains
+                                 the form used during user identification.
+  @param[out] FormId             On return, holds the identifier of the form used during user 
+                                 identification.
+ 
+  @retval EFI_SUCCESS            Form returned successfully.
+  @retval EFI_NOT_FOUND          Form not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or FormSetId is NULL or FormId is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_FORM)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_GUID                      *FormSetId,
+  OUT      EFI_FORM_ID                   *FormId
+  );
+
+/**
+  Returns bitmap used to describe the credential provider type.
+
+  This optional function returns a bitmap which is less than or equal to the number of pixels specified 
+  by Width and Height. If no such bitmap exists, then EFI_NOT_FOUND is returned. 
+
+  @param[in]      This           Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[in, out] Width          On entry, points to the desired bitmap width. If NULL then no bitmap
+                                 information will be returned. On exit, points to the width of the  
+                                 bitmap returned.
+  @param[in, out] Height         On entry, points to the desired bitmap height. If NULL then no bitmap 
+                                 information will be returned. On exit, points to the height of the  
+                                 bitmap returned
+  @param[out]     Hii            On return, holds the HII database handle. 
+  @param[out]     Image          On return, holds the HII image identifier. 
+ 
+  @retval EFI_SUCCESS            Image identifier returned successfully.
+  @retval EFI_NOT_FOUND          Image identifier not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or Image is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_TILE)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  IN OUT   UINTN                         *Width,
+  IN OUT   UINTN                         *Height,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_IMAGE_ID                  *Image
+  );
+
+/**
+  Returns string used to describe the credential provider type.
+
+  This function returns a string which describes the credential provider. If no such string exists, then 
+  EFI_NOT_FOUND is returned. 
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[out] Hii                On return, holds the HII database handle.
+  @param[out] String             On return, holds the HII string identifier.
+ 
+  @retval EFI_SUCCESS            String identifier returned successfully.
+  @retval EFI_NOT_FOUND          String identifier not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or String is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_TITLE)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_STRING_ID                 *String
+  );
+
+/**
+  Return the user identifier associated with the currently authenticated user.
+
+  This function returns the user identifier of the user authenticated by this credential provider. This 
+  function is called after the credential-related information has been submitted on a form OR after a 
+  call to Default() has returned that this credential is ready to log on.
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[in]  User               The user profile handle of the user profile currently being considered 
+                                 by the user identity manager. If NULL, then no user profile is currently 
+                                 under consideration.
+  @param[out] Identifier         On return, points to the user identifier. 
+ 
+  @retval EFI_SUCCESS            User identifier returned successfully.
+  @retval EFI_NOT_READY          No user identifier can be returned.
+  @retval EFI_ACCESS_DENIED      The user has been locked out of this user credential.
+  @retval EFI_NOT_FOUND          User is not NULL, and the specified user handle can't be found in user 
+                                 profile database 
+  @retval EFI_INVALID_PARAMETER  Identifier is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_USER)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE       User,
+  OUT      EFI_USER_INFO_IDENTIFIER      *Identifier
+  );
+
+/**
+  Indicate that user interface interaction has begun for the specified credential.
+
+  This function is called when a credential provider is selected by the user. If AutoLogon returns 
+  FALSE, then the user interface will be constructed by the User Identity Manager. 
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[out] AutoLogon          On return, points to the credential provider's capabilities after 
+                                 the credential provider has been selected by the user. 
+ 
+  @retval EFI_SUCCESS            Credential provider successfully selected.
+  @retval EFI_INVALID_PARAMETER  AutoLogon is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_SELECT)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  OUT      EFI_CREDENTIAL_LOGON_FLAGS    *AutoLogon
+  ); 
+
+/**
+  Indicate that user interface interaction has ended for the specified credential.
+
+  This function is called when a credential provider is deselected by the user.
+
+  @param[in] This        Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+ 
+  @retval EFI_SUCCESS    Credential provider successfully deselected.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_DESELECT)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This
+  );
+
+/**
+  Return the default logon behavior for this user credential.
+
+  This function reports the default login behavior regarding this credential provider.  
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[out] AutoLogon          On return, holds whether the credential provider should be 
+                                 used by default to automatically log on the user.  
+ 
+  @retval EFI_SUCCESS            Default information successfully returned.
+  @retval EFI_INVALID_PARAMETER  AutoLogon is NULL.
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_DEFAULT)(
+  IN  CONST EFI_USER_CREDENTIAL_PROTOCOL        *This,
+  OUT EFI_CREDENTIAL_LOGON_FLAGS                *AutoLogon
+  );
+
+/**
+  Return information attached to the credential provider.
+
+  This function returns user information. 
+
+  @param[in]     This           Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[in]     UserInfo       Handle of the user information data record. 
+  @param[out]    Info           On entry, points to a buffer of at least *InfoSize bytes. On exit, holds the user 
+                                information. If the buffer is too small to hold the information, then 
+                                EFI_BUFFER_TOO_SMALL is returned and InfoSize is updated to contain the 
+                                number of bytes actually required.
+  @param[in,out] InfoSize       On entry, points to the size of Info. On return, points to the size of the user 
+                                information. 
+ 
+  @retval EFI_SUCCESS           Information returned successfully.
+  @retval EFI_BUFFER_TOO_SMALL  The size specified by InfoSize is too small to hold all of the user 
+                                information. The size required is returned in *InfoSize.
+  @retval EFI_NOT_FOUND         The specified UserInfo does not refer to a valid user info handle.
+  @retval EFI_INVALID_PARAMETER Info is NULL or InfoSize is NULL.                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_GET_INFO)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  IN       EFI_USER_INFO_HANDLE          UserInfo,
+  OUT      EFI_USER_INFO                 *Info,
+  IN OUT   UINTN                         *InfoSize
+  );
+
+/**
+  Enumerate all of the user information records on the credential provider.
+
+  This function returns the next user information record. To retrieve the first user information record 
+  handle, point UserInfo at a NULL. Each subsequent call will retrieve another user information 
+  record handle until there are no more, at which point UserInfo will point to NULL. 
+
+  @param[in]     This            Points to this instance of the EFI_USER_CREDENTIAL_PROTOCOL.
+  @param[in,out] UserInfo        On entry, points to the previous user information handle or NULL to  
+                                 start enumeration. On exit, points to the next user information handle 
+                                 or NULL if there is no more user information.
+ 
+  @retval EFI_SUCCESS            User information returned.
+  @retval EFI_NOT_FOUND          No more user information found.
+  @retval EFI_INVALID_PARAMETER  UserInfo is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL_GET_NEXT_INFO)(
+  IN CONST EFI_USER_CREDENTIAL_PROTOCOL  *This,
+  IN OUT   EFI_USER_INFO_HANDLE          *UserInfo
+  );
+
+///
+/// This protocol provides support for a single class of credentials
+///
+struct _EFI_USER_CREDENTIAL_PROTOCOL {
+  EFI_GUID                      Identifier;  ///< Uniquely identifies this credential provider.
+  EFI_GUID                      Type;        ///< Identifies this class of User Credential Provider.
+  EFI_CREDENTIAL_ENROLL         Enroll;
+  EFI_CREDENTIAL_FORM           Form;
+  EFI_CREDENTIAL_TILE           Tile;
+  EFI_CREDENTIAL_TITLE          Title;
+  EFI_CREDENTIAL_USER           User;
+  EFI_CREDENTIAL_SELECT         Select;   
+  EFI_CREDENTIAL_DESELECT       Deselect;
+  EFI_CREDENTIAL_DEFAULT        Default;
+  EFI_CREDENTIAL_GET_INFO       GetInfo;
+  EFI_CREDENTIAL_GET_NEXT_INFO  GetNextInfo;
+  EFI_CREDENTIAL_CAPABILITIES   Capabilities;
+};
+
+extern EFI_GUID gEfiUserCredentialProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UserCredential2.h b/MdePkg/Include/Protocol/UserCredential2.h
new file mode 100644
index 000000000000..ed3423b47f6f
--- /dev/null
+++ b/MdePkg/Include/Protocol/UserCredential2.h
@@ -0,0 +1,314 @@
+/** @file
+  UEFI 2.3.1 User Credential Protocol definition.
+
+  Attached to a device handle, this protocol identifies a single means of identifying the user.
+
+  Copyright (c) 2009 - 2011, 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 __USER_CREDENTIAL2_H__
+#define __USER_CREDENTIAL2_H__
+
+#include <Protocol/UserManager.h>
+
+#define EFI_USER_CREDENTIAL2_PROTOCOL_GUID \
+  { \
+    0xe98adb03, 0xb8b9, 0x4af8, { 0xba, 0x20, 0x26, 0xe9, 0x11, 0x4c, 0xbc, 0xe5 } \
+  }
+
+typedef struct _EFI_USER_CREDENTIAL2_PROTOCOL  EFI_USER_CREDENTIAL2_PROTOCOL;
+
+/**
+  Enroll a user on a credential provider.
+
+  This function enrolls a user on this credential provider. If the user exists on this credential 
+  provider, update the user information on this credential provider; otherwise add the user information 
+  on credential provider.
+
+  @param[in] This                Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in] User                The user profile to enroll.
+ 
+  @retval EFI_SUCCESS            User profile was successfully enrolled.
+  @retval EFI_ACCESS_DENIED      Current user profile does not permit enrollment on the user profile 
+                                 handle. Either the user profile cannot enroll on any user profile or 
+                                 cannot enroll on a user profile other than the current user profile.
+  @retval EFI_UNSUPPORTED        This credential provider does not support enrollment in the pre-OS.
+  @retval EFI_DEVICE_ERROR       The new credential could not be created because of a device error.
+  @retval EFI_INVALID_PARAMETER  User does not refer to a valid user profile handle.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_ENROLL)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE        User
+  );
+
+/**
+  Returns the user interface information used during user identification.
+
+  This function returns information about the form used when interacting with the user during user 
+  identification. The form is the first enabled form in the form-set class 
+  EFI_HII_USER_CREDENTIAL_FORMSET_GUID installed on the HII handle HiiHandle. If 
+  the user credential provider does not require a form to identify the user, then this function should 
+  return EFI_NOT_FOUND.
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[out] Hii                On return, holds the HII database handle.
+  @param[out] FormSetId          On return, holds the identifier of the form set which contains
+                                 the form used during user identification.
+  @param[out] FormId             On return, holds the identifier of the form used during user 
+                                 identification.
+ 
+  @retval EFI_SUCCESS            Form returned successfully.
+  @retval EFI_NOT_FOUND          Form not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or FormSetId is NULL or FormId is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_FORM)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_GUID                      *FormSetId,
+  OUT      EFI_FORM_ID                   *FormId
+  );
+
+/**
+  Returns bitmap used to describe the credential provider type.
+
+  This optional function returns a bitmap which is less than or equal to the number of pixels specified 
+  by Width and Height. If no such bitmap exists, then EFI_NOT_FOUND is returned. 
+
+  @param[in]      This           Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in, out] Width          On entry, points to the desired bitmap width. If NULL then no bitmap
+                                 information will be returned. On exit, points to the width of the  
+                                 bitmap returned.
+  @param[in, out] Height         On entry, points to the desired bitmap height. If NULL then no bitmap 
+                                 information will be returned. On exit, points to the height of the  
+                                 bitmap returned
+  @param[out]     Hii            On return, holds the HII database handle. 
+  @param[out]     Image          On return, holds the HII image identifier. 
+ 
+  @retval EFI_SUCCESS            Image identifier returned successfully.
+  @retval EFI_NOT_FOUND          Image identifier not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or Image is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_TILE)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  IN OUT   UINTN                         *Width,
+  IN OUT   UINTN                         *Height,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_IMAGE_ID                  *Image
+  );
+
+/**
+  Returns string used to describe the credential provider type.
+
+  This function returns a string which describes the credential provider. If no such string exists, then 
+  EFI_NOT_FOUND is returned. 
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[out] Hii                On return, holds the HII database handle.
+  @param[out] String             On return, holds the HII string identifier.
+ 
+  @retval EFI_SUCCESS            String identifier returned successfully.
+  @retval EFI_NOT_FOUND          String identifier not returned.
+  @retval EFI_INVALID_PARAMETER  Hii is NULL or String is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_TITLE)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  OUT      EFI_HII_HANDLE                *Hii,
+  OUT      EFI_STRING_ID                 *String
+  );
+
+/**
+  Return the user identifier associated with the currently authenticated user.
+
+  This function returns the user identifier of the user authenticated by this credential provider. This 
+  function is called after the credential-related information has been submitted on a form OR after a 
+  call to Default() has returned that this credential is ready to log on.
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in]  User               The user profile handle of the user profile currently being considered 
+                                 by the user identity manager. If NULL, then no user profile is currently 
+                                 under consideration.
+  @param[out] Identifier         On return, points to the user identifier. 
+ 
+  @retval EFI_SUCCESS            User identifier returned successfully.
+  @retval EFI_NOT_READY          No user identifier can be returned.
+  @retval EFI_ACCESS_DENIED      The user has been locked out of this user credential.
+  @retval EFI_NOT_FOUND          User is not NULL, and the specified user handle can't be found in user 
+                                 profile database 
+  @retval EFI_INVALID_PARAMETER  Identifier is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_USER)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  IN       EFI_USER_PROFILE_HANDLE       User,
+  OUT      EFI_USER_INFO_IDENTIFIER      *Identifier
+  );
+
+/**
+  Indicate that user interface interaction has begun for the specified credential.
+
+  This function is called when a credential provider is selected by the user. If AutoLogon returns 
+  FALSE, then the user interface will be constructed by the User Identity Manager. 
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[out] AutoLogon          On return, points to the credential provider's capabilities after 
+                                 the credential provider has been selected by the user. 
+ 
+  @retval EFI_SUCCESS            Credential provider successfully selected.
+  @retval EFI_INVALID_PARAMETER  AutoLogon is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_SELECT)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  OUT      EFI_CREDENTIAL_LOGON_FLAGS    *AutoLogon
+  ); 
+
+/**
+  Indicate that user interface interaction has ended for the specified credential.
+
+  This function is called when a credential provider is deselected by the user.
+
+  @param[in] This        Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+ 
+  @retval EFI_SUCCESS    Credential provider successfully deselected.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_DESELECT)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This
+  );
+
+/**
+  Return the default logon behavior for this user credential.
+
+  This function reports the default login behavior regarding this credential provider.  
+
+  @param[in]  This               Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[out] AutoLogon          On return, holds whether the credential provider should be 
+                                 used by default to automatically log on the user.  
+ 
+  @retval EFI_SUCCESS            Default information successfully returned.
+  @retval EFI_INVALID_PARAMETER  AutoLogon is NULL.
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_DEFAULT)(
+  IN  CONST EFI_USER_CREDENTIAL2_PROTOCOL       *This,
+  OUT EFI_CREDENTIAL_LOGON_FLAGS                *AutoLogon
+  );
+
+/**
+  Return information attached to the credential provider.
+
+  This function returns user information. 
+
+  @param[in]     This           Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in]     UserInfo       Handle of the user information data record. 
+  @param[out]    Info           On entry, points to a buffer of at least *InfoSize bytes. On exit, holds the user 
+                                information. If the buffer is too small to hold the information, then 
+                                EFI_BUFFER_TOO_SMALL is returned and InfoSize is updated to contain the 
+                                number of bytes actually required.
+  @param[in,out] InfoSize       On entry, points to the size of Info. On return, points to the size of the user 
+                                information. 
+ 
+  @retval EFI_SUCCESS           Information returned successfully.
+  @retval EFI_BUFFER_TOO_SMALL  The size specified by InfoSize is too small to hold all of the user 
+                                information. The size required is returned in *InfoSize.
+  @retval EFI_NOT_FOUND         The specified UserInfo does not refer to a valid user info handle.
+  @retval EFI_INVALID_PARAMETER Info is NULL or InfoSize is NULL.                                
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_GET_INFO)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  IN       EFI_USER_INFO_HANDLE          UserInfo,
+  OUT      EFI_USER_INFO                 *Info,
+  IN OUT   UINTN                         *InfoSize
+  );
+
+/**
+  Enumerate all of the user information records on the credential provider.
+
+  This function returns the next user information record. To retrieve the first user information record 
+  handle, point UserInfo at a NULL. Each subsequent call will retrieve another user information 
+  record handle until there are no more, at which point UserInfo will point to NULL. 
+
+  @param[in]     This            Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in,out] UserInfo        On entry, points to the previous user information handle or NULL to  
+                                 start enumeration. On exit, points to the next user information handle 
+                                 or NULL if there is no more user information.
+ 
+  @retval EFI_SUCCESS            User information returned.
+  @retval EFI_NOT_FOUND          No more user information found.
+  @retval EFI_INVALID_PARAMETER  UserInfo is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREDENTIAL2_GET_NEXT_INFO)(
+  IN CONST EFI_USER_CREDENTIAL2_PROTOCOL *This,
+  IN OUT   EFI_USER_INFO_HANDLE          *UserInfo
+  );
+
+/**
+  Delete a user on this credential provider.
+
+  This function deletes a user on this credential provider. 
+
+  @param[in]     This            Points to this instance of the EFI_USER_CREDENTIAL2_PROTOCOL.
+  @param[in]     User            The user profile handle to delete.
+
+  @retval EFI_SUCCESS            User profile was successfully deleted.
+  @retval EFI_ACCESS_DENIED      Current user profile does not permit deletion on the user profile handle. 
+                                 Either the user profile cannot delete on any user profile or cannot delete 
+                                 on a user profile other than the current user profile. 
+  @retval EFI_UNSUPPORTED        This credential provider does not support deletion in the pre-OS.
+  @retval EFI_DEVICE_ERROR       The new credential could not be deleted because of a device error.
+  @retval EFI_INVALID_PARAMETER  User does not refer to a valid user profile handle.
+**/
+typedef 
+EFI_STATUS 
+(EFIAPI *EFI_CREDENTIAL2_DELETE)(
+ IN CONST EFI_USER_CREDENTIAL2_PROTOCOL  *This,
+ IN       EFI_USER_PROFILE_HANDLE        User
+);
+
+///
+/// This protocol provides support for a single class of credentials
+///
+struct _EFI_USER_CREDENTIAL2_PROTOCOL {
+  EFI_GUID                      Identifier;  ///< Uniquely identifies this credential provider.
+  EFI_GUID                      Type;        ///< Identifies this class of User Credential Provider.
+  EFI_CREDENTIAL2_ENROLL        Enroll;
+  EFI_CREDENTIAL2_FORM          Form;
+  EFI_CREDENTIAL2_TILE          Tile;
+  EFI_CREDENTIAL2_TITLE         Title;
+  EFI_CREDENTIAL2_USER          User;
+  EFI_CREDENTIAL2_SELECT        Select;   
+  EFI_CREDENTIAL2_DESELECT      Deselect;
+  EFI_CREDENTIAL2_DEFAULT       Default;
+  EFI_CREDENTIAL2_GET_INFO      GetInfo;
+  EFI_CREDENTIAL2_GET_NEXT_INFO GetNextInfo;
+  EFI_CREDENTIAL_CAPABILITIES   Capabilities;
+  EFI_CREDENTIAL2_DELETE        Delete; 
+};
+
+extern EFI_GUID gEfiUserCredential2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/UserManager.h b/MdePkg/Include/Protocol/UserManager.h
new file mode 100644
index 000000000000..73fa672a5915
--- /dev/null
+++ b/MdePkg/Include/Protocol/UserManager.h
@@ -0,0 +1,624 @@
+/** @file
+  UEFI User Manager Protocol definition.
+
+  This protocol manages user profiles.
+
+  Copyright (c) 2009 - 2011, 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 __USER_MANAGER_H__
+#define __USER_MANAGER_H__
+
+///
+/// Global ID for the User Manager Protocol
+///
+#define EFI_USER_MANAGER_PROTOCOL_GUID \
+  { \
+    0x6fd5b00c, 0xd426, 0x4283, { 0x98, 0x87, 0x6c, 0xf5, 0xcf, 0x1c, 0xb1, 0xfe } \
+  }
+
+#define EFI_EVENT_GROUP_USER_PROFILE_CHANGED \
+  { \
+    0xbaf1e6de, 0x209e, 0x4adb, { 0x8d, 0x96, 0xfd, 0x8b, 0x71, 0xf3, 0xf6, 0x83 } \
+  }
+
+typedef VOID *EFI_USER_PROFILE_HANDLE;
+typedef VOID *EFI_USER_INFO_HANDLE;
+
+///
+/// The attributes of the user profile information.
+///
+typedef UINT16 EFI_USER_INFO_ATTRIBS;
+#define EFI_USER_INFO_STORAGE                   0x000F
+#define EFI_USER_INFO_STORAGE_VOLATILE          0x0000
+#define EFI_USER_INFO_STORAGE_CREDENTIAL_NV     0x0001
+#define EFI_USER_INFO_STORAGE_PLATFORM_NV       0x0002
+
+#define EFI_USER_INFO_ACCESS                    0x0070
+#define EFI_USER_INFO_PUBLIC                    0x0010
+#define EFI_USER_INFO_PRIVATE                   0x0020
+#define EFI_USER_INFO_PROTECTED                 0x0030
+#define EFI_USER_INFO_EXCLUSIVE                 0x0080
+
+///
+/// User information structure
+///
+typedef struct {
+  ///
+  /// The user credential identifier associated with this user information or else Nil if the 
+  /// information is not associated with any specific credential.
+  ///
+  EFI_GUID               Credential;
+  ///
+  /// The type of user information.
+  ///
+  UINT8                  InfoType;
+  ///
+  /// Must be set to 0.
+  ///
+  UINT8                  Reserved1;
+  ///
+  /// The attributes of the user profile information.
+  ///
+  EFI_USER_INFO_ATTRIBS  InfoAttribs;
+  ///
+  /// The size of the user information, in bytes, including this header.
+  ///
+  UINT32                 InfoSize;
+} EFI_USER_INFO;
+
+///
+/// User credential class GUIDs
+///
+#define EFI_USER_CREDENTIAL_CLASS_UNKNOWN \
+  { 0x5cf32e68, 0x7660, 0x449b, { 0x80, 0xe6, 0x7e, 0xa3, 0x6e, 0x3, 0xf6, 0xa8 } }
+#define EFI_USER_CREDENTIAL_CLASS_PASSWORD \
+  { 0xf8e5058c, 0xccb6, 0x4714, { 0xb2, 0x20, 0x3f, 0x7e, 0x3a, 0x64, 0xb, 0xd1 } }
+#define EFI_USER_CREDENTIAL_CLASS_SMART_CARD \
+  { 0x5f03ba33, 0x8c6b, 0x4c24, { 0xaa, 0x2e, 0x14, 0xa2, 0x65, 0x7b, 0xd4, 0x54 } }
+#define EFI_USER_CREDENTIAL_CLASS_FINGERPRINT \
+  { 0x32cba21f, 0xf308, 0x4cbc, { 0x9a, 0xb5, 0xf5, 0xa3, 0x69, 0x9f, 0x4, 0x4a } }
+#define EFI_USER_CREDENTIAL_CLASS_HANDPRINT \
+  { 0x5917ef16, 0xf723, 0x4bb9, { 0xa6, 0x4b, 0xd8, 0xc5, 0x32, 0xf4, 0xd8, 0xb5 } }
+#define EFI_USER_CREDENTIAL_CLASS_SECURE_CARD \
+  { 0x8a6b4a83, 0x42fe, 0x45d2, { 0xa2, 0xef, 0x46, 0xf0, 0x6c, 0x7d, 0x98, 0x52 } }
+
+typedef UINT64   EFI_CREDENTIAL_CAPABILITIES;
+#define EFI_CREDENTIAL_CAPABILITIES_ENROLL  0x0000000000000001
+
+///
+/// Credential logon flags 
+///
+typedef UINT32 EFI_CREDENTIAL_LOGON_FLAGS;
+#define EFI_CREDENTIAL_LOGON_FLAG_AUTO                0x00000001
+#define EFI_CREDENTIAL_LOGON_FLAG_DEFAULT             0x00000002
+
+///
+/// User information record types
+///
+
+///
+/// No information.
+///
+#define EFI_USER_INFO_EMPTY_RECORD                    0x00
+///
+/// Provide the user's name for the enrolled user.
+///
+#define EFI_USER_INFO_NAME_RECORD                     0x01
+typedef CHAR16 *EFI_USER_INFO_NAME;
+///
+/// Provides the date and time when the user profile was created.
+///
+#define EFI_USER_INFO_CREATE_DATE_RECORD              0x02
+typedef EFI_TIME EFI_USER_INFO_CREATE_DATE;
+///
+/// Provides the date and time when the user profile was selected.
+///
+#define EFI_USER_INFO_USAGE_DATE_RECORD               0x03
+typedef EFI_TIME EFI_USER_INFO_USAGE_DATE;
+///
+/// Provides the number of times that the user profile has been selected.
+///
+#define EFI_USER_INFO_USAGE_COUNT_RECORD              0x04
+typedef UINT64 EFI_USER_INFO_USAGE_COUNT;
+///
+/// Provides a unique non-volatile user identifier for each enrolled user.
+///
+#define EFI_USER_INFO_IDENTIFIER_RECORD               0x05
+typedef UINT8 EFI_USER_INFO_IDENTIFIER[16];
+///
+/// Specifies the type of a particular credential associated with the user profile.
+///
+#define EFI_USER_INFO_CREDENTIAL_TYPE_RECORD          0x06
+typedef EFI_GUID EFI_USER_INFO_CREDENTIAL_TYPE;
+///
+/// Specifies the user-readable name of a particular credential type.
+///
+#define EFI_USER_INFO_CREDENTIAL_TYPE_NAME_RECORD     0x07
+typedef CHAR16 *EFI_USER_INFO_CREDENTIAL_TYPE_NAME;
+///
+/// Specifies the credential provider.
+///
+#define EFI_USER_INFO_CREDENTIAL_PROVIDER_RECORD      0x08
+typedef EFI_GUID EFI_USER_INFO_CREDENTIAL_PROVIDER;
+///
+/// Specifies the user-readable name of a particular credential's provider.
+///
+#define EFI_USER_INFO_CREDENTIAL_PROVIDER_NAME_RECORD 0x09
+typedef CHAR16 *EFI_USER_INFO_CREDENTIAL_PROVIDER_NAME;
+///
+/// Provides PKCS#11 credential information from a smart card.
+///
+#define EFI_USER_INFO_PKCS11_RECORD                   0x0A
+///
+/// Provides standard biometric information in the format specified by the ISO 19785 (Common 
+/// Biometric Exchange Formats Framework) specification.
+///
+#define EFI_USER_INFO_CBEFF_RECORD                    0x0B
+typedef VOID *EFI_USER_INFO_CBEFF;
+///
+/// Indicates how close of a match the fingerprint must be in order to be considered a match.
+///
+#define EFI_USER_INFO_FAR_RECORD                      0x0C
+typedef UINT8 EFI_USER_INFO_FAR;
+///
+/// Indicates how many attempts the user has to with a particular credential before the system prevents 
+/// further attempts.
+///
+#define EFI_USER_INFO_RETRY_RECORD                    0x0D
+typedef UINT8 EFI_USER_INFO_RETRY;
+///
+/// Provides the user's pre-OS access rights.
+///
+#define EFI_USER_INFO_ACCESS_POLICY_RECORD            0x0E
+
+typedef struct {
+  UINT32  Type;  ///< Specifies the type of user access control.
+  UINT32  Size;  ///< Specifies the size of the user access control record, in bytes, including this header.
+} EFI_USER_INFO_ACCESS_CONTROL;
+
+typedef EFI_USER_INFO_ACCESS_CONTROL EFI_USER_INFO_ACCESS_POLICY;
+
+///
+/// User Information access types
+///
+
+///
+/// Forbids the user from booting or loading executables from the specified device path or any child 
+/// device paths.
+///
+#define EFI_USER_INFO_ACCESS_FORBID_LOAD              0x00000001
+///
+/// Permits the user from booting or loading executables from the specified device path or any child 
+/// device paths.
+/// Note: in-consistency between code and the UEFI 2.3 specification here.
+/// The definition EFI_USER_INFO_ACCESS_PERMIT_BOOT in the specification should be typo and wait for
+/// spec update.
+///
+#define EFI_USER_INFO_ACCESS_PERMIT_LOAD              0x00000002
+///
+/// Presence of this record indicates that a user can update enrollment information.
+///
+#define EFI_USER_INFO_ACCESS_ENROLL_SELF              0x00000003
+///
+/// Presence of this record indicates that a user can enroll new users.
+///
+#define EFI_USER_INFO_ACCESS_ENROLL_OTHERS            0x00000004
+///
+/// Presence of this record indicates that a user can update the user information of any user.
+///
+#define EFI_USER_INFO_ACCESS_MANAGE                   0x00000005
+///
+/// Describes permissions usable when configuring the platform.
+///
+#define EFI_USER_INFO_ACCESS_SETUP                    0x00000006
+///
+/// Standard GUIDs for access to configure the platform.
+///
+#define EFI_USER_INFO_ACCESS_SETUP_ADMIN_GUID \
+  { 0x85b75607, 0xf7ce, 0x471e, { 0xb7, 0xe4, 0x2a, 0xea, 0x5f, 0x72, 0x32, 0xee } }
+#define EFI_USER_INFO_ACCESS_SETUP_NORMAL_GUID \
+  { 0x1db29ae0, 0x9dcb, 0x43bc, { 0x8d, 0x87, 0x5d, 0xa1, 0x49, 0x64, 0xdd, 0xe2 } }
+#define EFI_USER_INFO_ACCESS_SETUP_RESTRICTED_GUID \
+  { 0xbdb38125, 0x4d63, 0x49f4, { 0x82, 0x12, 0x61, 0xcf, 0x5a, 0x19, 0xa, 0xf8 } }
+
+///
+/// Forbids UEFI drivers from being started from the specified device path(s) or any child device paths.
+///
+#define EFI_USER_INFO_ACCESS_FORBID_CONNECT           0x00000007
+///
+/// Permits UEFI drivers to be started on the specified device path(s) or any child device paths.
+///
+#define EFI_USER_INFO_ACCESS_PERMIT_CONNECT           0x00000008
+///
+/// Modifies the boot order.
+///
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER               0x00000009
+typedef UINT32 EFI_USER_INFO_ACCESS_BOOT_ORDER_HDR;
+
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER_MASK          0x0000000F
+///
+/// Insert new boot options at the beginning of the boot order.
+///
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER_INSERT        0x00000000
+///
+/// Append new boot options to the end of the boot order.
+///
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER_APPEND        0x00000001
+///
+/// Replace the entire boot order.
+///
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER_REPLACE       0x00000002
+///
+/// The Boot Manager will not attempt find a default boot device 
+/// when the default boot order is does not lead to a bootable device.
+///
+#define EFI_USER_INFO_ACCESS_BOOT_ORDER_NODEFAULT     0x00000010
+
+///
+/// Provides the expression which determines which credentials are required to assert user identity.
+///
+#define EFI_USER_INFO_IDENTITY_POLICY_RECORD          0x0F
+
+typedef struct {
+  UINT32  Type;    ///< Specifies either an operator or a data item. 
+  UINT32  Length;  ///< The length of this block, in bytes, including this header.
+} EFI_USER_INFO_IDENTITY_POLICY;
+
+///
+/// User identity policy expression operators.
+///
+#define EFI_USER_INFO_IDENTITY_FALSE                  0x00
+#define EFI_USER_INFO_IDENTITY_TRUE                   0x01
+#define EFI_USER_INFO_IDENTITY_CREDENTIAL_TYPE        0x02
+#define EFI_USER_INFO_IDENTITY_CREDENTIAL_PROVIDER    0x03
+#define EFI_USER_INFO_IDENTITY_NOT                    0x10
+#define EFI_USER_INFO_IDENTITY_AND                    0x11
+#define EFI_USER_INFO_IDENTITY_OR                     0x12
+
+///
+/// Provides placeholder for additional user profile information identified by a GUID.
+///
+#define EFI_USER_INFO_GUID_RECORD                     0xFF
+typedef EFI_GUID EFI_USER_INFO_GUID;
+
+///
+/// User information table
+/// A collection of EFI_USER_INFO records, prefixed with this header.
+///
+typedef struct {
+  UINT64   Size;  ///< Total size of the user information table, in bytes.
+} EFI_USER_INFO_TABLE;
+
+typedef struct _EFI_USER_MANAGER_PROTOCOL  EFI_USER_MANAGER_PROTOCOL;
+
+/**
+  Create a new user profile.
+
+  This function creates a new user profile with only a new user identifier attached and returns its 
+  handle. The user profile is non-volatile, but the handle User can change across reboots.
+
+  @param[in]  This               Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[out] User               On return, points to the new user profile handle. 
+                                 The user profile handle is unique only during this boot.
+ 
+  @retval EFI_SUCCESS            User profile was successfully created.
+  @retval EFI_ACCESS_DENIED      Current user does not have sufficient permissions to create a user profile.
+  @retval EFI_UNSUPPORTED        Creation of new user profiles is not supported.
+  @retval EFI_INVALID_PARAMETER  The User parameter is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_CREATE)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  OUT      EFI_USER_PROFILE_HANDLE    *User
+  );
+
+/**
+  Delete an existing user profile.
+
+  @param[in] This                Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in] User                User profile handle. 
+
+  @retval EFI_SUCCESS            User profile was successfully deleted.
+  @retval EFI_ACCESS_DENIED      Current user does not have sufficient permissions to delete a user
+                                 profile or there is only one user profile.
+  @retval EFI_UNSUPPORTED        Deletion of new user profiles is not supported.
+  @retval EFI_INVALID_PARAMETER  User does not refer to a valid user profile.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_DELETE)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE    User
+  );
+
+/**
+  Enumerate all of the enrolled users on the platform.
+
+  This function returns the next enrolled user profile. To retrieve the first user profile handle, point 
+  User at a NULL. Each subsequent call will retrieve another user profile handle until there are no 
+  more, at which point User will point to NULL. 
+
+  @param[in]     This            Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in,out] User            On entry, points to the previous user profile handle or NULL to 
+                                 start enumeration. On exit, points to the next user profile handle
+                                 or NULL if there are no more user profiles.
+
+  @retval EFI_SUCCESS            Next enrolled user profile successfully returned. 
+  @retval EFI_ACCESS_DENIED      Next enrolled user profile was not successfully returned.
+  @retval EFI_INVALID_PARAMETER  The User parameter is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_GET_NEXT)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN OUT   EFI_USER_PROFILE_HANDLE    *User
+  );
+
+/**
+  Return the current user profile handle.
+
+  @param[in]  This               Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[out] CurrentUser        On return, points to the current user profile handle.
+
+  @retval EFI_SUCCESS            Current user profile handle returned successfully. 
+  @retval EFI_INVALID_PARAMETER  The CurrentUser parameter is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_CURRENT)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  OUT      EFI_USER_PROFILE_HANDLE    *CurrentUser
+  );
+
+/**
+  Identify a user.
+
+  Identify the user and, if authenticated, returns the user handle and changes the current user profile.
+  All user information marked as private in a previously selected profile is no longer available for 
+  inspection. 
+  Whenever the current user profile is changed then the an event with the GUID 
+  EFI_EVENT_GROUP_USER_PROFILE_CHANGED is signaled.
+
+  @param[in]  This               Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[out] User               On return, points to the user profile handle for the current user profile.
+
+  @retval EFI_SUCCESS            User was successfully identified.
+  @retval EFI_ACCESS_DENIED      User was not successfully identified.
+  @retval EFI_INVALID_PARAMETER  The User parameter is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_IDENTIFY)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  OUT      EFI_USER_PROFILE_HANDLE    *User
+  );
+
+/**
+  Find a user using a user information record.
+
+  This function searches all user profiles for the specified user information record. The search starts 
+  with the user information record handle following UserInfo and continues until either the 
+  information is found or there are no more user profiles.
+  A match occurs when the Info.InfoType field matches the user information record type and the 
+  user information record data matches the portion of Info.
+
+  @param[in]     This      Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in,out] User      On entry, points to the previously returned user profile handle or NULL to start 
+                           searching with the first user profile. On return, points to the user profile handle or 
+                           NULL if not found.
+  @param[in,out] UserInfo  On entry, points to the previously returned user information handle or NULL to start 
+                           searching with the first. On return, points to the user information handle of the user 
+                           information record or NULL if not found. Can be NULL, in which case only one user 
+                           information record per user can be returned. 
+  @param[in]     Info      Points to the buffer containing the user information to be compared to the user 
+                           information record. If the user information record data is empty, then only the user 
+                           information record type is compared. 
+                           If InfoSize is 0, then the user information record must be empty.
+
+  @param[in]     InfoSize  The size of Info, in bytes. 
+
+  @retval EFI_SUCCESS           User information was found. User points to the user profile handle and UserInfo
+                                points to the user information handle.
+  @retval EFI_NOT_FOUND         User information was not found. User points to NULL and UserInfo points to NULL.
+  @retval EFI_INVALID_PARAMETER User is NULL. Or Info is NULL.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_FIND)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN OUT   EFI_USER_PROFILE_HANDLE    *User,
+  IN OUT   EFI_USER_INFO_HANDLE       *UserInfo OPTIONAL,
+  IN CONST EFI_USER_INFO              *Info,
+  IN       UINTN                      InfoSize
+  );
+
+/**
+  Called by credential provider to notify of information change.
+
+  This function allows the credential provider to notify the User Identity Manager when user status  
+  has changed.
+  If the User Identity Manager doesn't support asynchronous changes in credentials, then this function 
+  should return EFI_UNSUPPORTED. 
+  If current user does not exist, and the credential provider can identify a user, then make the user 
+  to be current user and signal the EFI_EVENT_GROUP_USER_PROFILE_CHANGED event.
+  If current user already exists, and the credential provider can identify another user, then switch 
+  current user to the newly identified user, and signal the EFI_EVENT_GROUP_USER_PROFILE_CHANGED event.
+  If current user was identified by this credential provider and now the credential provider cannot identify 
+  current user, then logout current user and signal the EFI_EVENT_GROUP_USER_PROFILE_CHANGED event.
+
+  @param[in] This          Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in] Changed       Handle on which is installed an instance of the
+                           EFI_USER_CREDENTIAL_PROTOCOL where the user has changed.
+
+  @retval EFI_SUCCESS      The User Identity Manager has handled the notification.
+  @retval EFI_NOT_READY    The function was called while the specified credential provider was not selected.
+  @retval EFI_UNSUPPORTED  The User Identity Manager doesn't support asynchronous notifications.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_NOTIFY)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_HANDLE                 Changed
+  );
+
+/**
+  Return information attached to the user.
+
+  This function returns user information. The format of the information is described in User 
+  Information. The function may return EFI_ACCESS_DENIED if the information is marked private 
+  and the handle specified by User is not the current user profile. The function may return 
+  EFI_ACCESS_DENIED if the information is marked protected and the information is associated 
+  with a credential provider for which the user has not been authenticated.
+
+  @param[in]     This           Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in]     User           Handle of the user whose profile will be retrieved. 
+  @param[in]     UserInfo       Handle of the user information data record.   
+  @param[out]    Info           On entry, points to a buffer of at least *InfoSize bytes. On exit, holds the user 
+                                information. If the buffer is too small to hold the information, then 
+                                EFI_BUFFER_TOO_SMALL is returned and InfoSize is updated to contain the 
+                                number of bytes actually required. 
+  @param[in,out] InfoSize       On entry, points to the size of Info. On return, points to the size of the user 
+                                information. 
+
+  @retval EFI_SUCCESS           Information returned successfully.
+  @retval EFI_ACCESS_DENIED     The information about the specified user cannot be accessed by the current user.
+  @retval EFI_BUFFER_TOO_SMALL  The number of bytes specified by *InfoSize is too small to hold 
+                                the returned data. The actual size required is returned in *InfoSize.
+  @retval EFI_NOT_FOUND         User does not refer to a valid user profile or UserInfo does not refer to a valid
+                                user info handle.
+  @retval EFI_INVALID_PARAMETER Info is NULL or InfoSize is NULL.
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_GET_INFO)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE    User,
+  IN       EFI_USER_INFO_HANDLE       UserInfo,
+  OUT      EFI_USER_INFO              *Info,
+  IN OUT   UINTN                      *InfoSize
+  );
+
+/**
+  Add or update user information.
+
+  This function changes user information.  If NULL is pointed to by UserInfo, then a new user 
+  information record is created and its handle is returned in UserInfo. Otherwise, the existing one is 
+  replaced.
+  If EFI_USER_INFO_IDENTITY_POLICY_RECORD is changed, it is the caller's responsibility to keep it to 
+  be synced with the information on credential providers.
+  If EFI_USER_INFO_EXCLUSIVE is specified in Info and a user information record of the same 
+  type already exists in the user profile, then EFI_ACCESS_DENIED will be returned and 
+  UserInfo will point to the handle of the existing record.
+
+  @param[in]     This             Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in]     User             Handle of the user whose profile will be retrieved. 
+  @param[in,out] UserInfo         Handle of the user information data record.   
+  @param[in]     Info             On entry, points to a buffer of at least *InfoSize bytes. On exit, holds the user 
+                                  information. If the buffer is too small to hold the information, then 
+                                  EFI_BUFFER_TOO_SMALL is returned and InfoSize is updated to contain the 
+                                  number of bytes actually required. 
+  @param[in]     InfoSize         On entry, points to the size of Info. On return, points to the size of the user 
+                                  information. 
+
+  @retval EFI_SUCCESS             Information returned successfully.
+  @retval EFI_ACCESS_DENIED       The record is exclusive.
+  @retval EFI_SECURITY_VIOLATION  The current user does not have permission to change the specified 
+                                  user profile or user information record.
+  @retval EFI_NOT_FOUND           User does not refer to a valid user profile or UserInfo does not refer to a valid
+                                  user info handle.
+  @retval EFI_INVALID_PARAMETER   UserInfo is NULL or Info is NULL. 
+**/  
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_SET_INFO)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE    User,
+  IN OUT   EFI_USER_INFO_HANDLE       *UserInfo,
+  IN CONST EFI_USER_INFO              *Info,
+  IN       UINTN                      InfoSize
+  );
+
+/**
+  Delete user information.
+
+  Delete the user information attached to the user profile specified by the UserInfo.
+
+  @param[in] This            Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in] User            Handle of the user whose information will be deleted.
+  @param[in] UserInfo        Handle of the user information to remove.
+
+  @retval EFI_SUCCESS        User information deleted successfully.
+  @retval EFI_NOT_FOUND      User information record UserInfo does not exist in the user profile.
+  @retval EFI_ACCESS_DENIED  The current user does not have permission to delete this user information. 
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_DELETE_INFO)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE    User,
+  IN       EFI_USER_INFO_HANDLE       UserInfo
+  );
+
+/**
+  Enumerate user information of all the enrolled users on the platform.
+
+  This function returns the next user information record. To retrieve the first user information record 
+  handle, point UserInfo at a NULL. Each subsequent call will retrieve another user information 
+  record handle until there are no more, at which point UserInfo will point to NULL. 
+
+  @param[in]     This           Points to this instance of the EFI_USER_MANAGER_PROTOCOL.
+  @param[in]     User           Handle of the user whose information will be deleted.
+  @param[in,out] UserInfo       Handle of the user information to remove.
+
+  @retval EFI_SUCCESS           User information returned.
+  @retval EFI_NOT_FOUND         No more user information found.
+  @retval EFI_INVALID_PARAMETER UserInfo is NULL.
+**/ 
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USER_PROFILE_GET_NEXT_INFO)(
+  IN CONST EFI_USER_MANAGER_PROTOCOL  *This,
+  IN       EFI_USER_PROFILE_HANDLE    User,
+  IN OUT   EFI_USER_INFO_HANDLE       *UserInfo
+  );
+
+///
+/// This protocol provides the services used to manage user profiles.
+///
+struct _EFI_USER_MANAGER_PROTOCOL {
+  EFI_USER_PROFILE_CREATE         Create;
+  EFI_USER_PROFILE_DELETE         Delete;
+  EFI_USER_PROFILE_GET_NEXT       GetNext;
+  EFI_USER_PROFILE_CURRENT        Current;
+  EFI_USER_PROFILE_IDENTIFY       Identify;
+  EFI_USER_PROFILE_FIND           Find;
+  EFI_USER_PROFILE_NOTIFY         Notify;
+  EFI_USER_PROFILE_GET_INFO       GetInfo;
+  EFI_USER_PROFILE_SET_INFO       SetInfo;
+  EFI_USER_PROFILE_DELETE_INFO    DeleteInfo;
+  EFI_USER_PROFILE_GET_NEXT_INFO  GetNextInfo;
+};
+
+extern EFI_GUID gEfiUserManagerProtocolGuid;
+extern EFI_GUID gEfiEventUserProfileChangedGuid;
+extern EFI_GUID gEfiUserCredentialClassUnknownGuid;
+extern EFI_GUID gEfiUserCredentialClassPasswordGuid;
+extern EFI_GUID gEfiUserCredentialClassSmartCardGuid;
+extern EFI_GUID gEfiUserCredentialClassFingerprintGuid;
+extern EFI_GUID gEfiUserCredentialClassHandprintGuid;
+extern EFI_GUID gEfiUserCredentialClassSecureCardGuid;
+extern EFI_GUID gEfiUserInfoAccessSetupAdminGuid;
+extern EFI_GUID gEfiUserInfoAccessSetupNormalGuid;
+extern EFI_GUID gEfiUserInfoAccessSetupRestrictedGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/Variable.h b/MdePkg/Include/Protocol/Variable.h
new file mode 100644
index 000000000000..c9e86026f7ae
--- /dev/null
+++ b/MdePkg/Include/Protocol/Variable.h
@@ -0,0 +1,45 @@
+/** @file
+  Variable Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  This provides the services required to get and set environment variables. This 
+  protocol must be produced by a runtime DXE driver and may be consumed only by 
+  the DXE Foundation. The DXE driver that produces this protocol must be a runtime 
+  driver. This driver is responsible for initializing the GetVariable(), 
+  GetNextVariableName(), and SetVariable() fields of the UEFI Runtime Services Table.
+
+  After the three fields of the UEFI Runtime Services Table have been initialized, 
+  the driver must install the EFI_VARIABLE_ARCH_PROTOCOL_GUID on a new handle with 
+  a NULL interface pointer. The installation of this protocol informs the DXE Foundation 
+  that the read-only and the volatile environment variable related services are 
+  now available and that the DXE Foundation must update the 32-bit CRC of the UEFI 
+  Runtime Services Table. The full complement of environment variable services are 
+  not available until both this protocol and EFI_VARIABLE_WRITE_ARCH_PROTOCOL are 
+  installed. DXE drivers that require read-only access or read/write access to volatile 
+  environment variables must have this architectural protocol in their dependency 
+  expressions. DXE drivers that require write access to nonvolatile environment 
+  variables must have the EFI_VARIABLE_WRITE_ARCH_PROTOCOL in their dependency 
+  expressions.
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_VARIABLE_ARCH_H__
+#define __ARCH_PROTOCOL_VARIABLE_ARCH_H__
+
+///
+/// Global ID for the Variable Architectural Protocol
+///
+#define EFI_VARIABLE_ARCH_PROTOCOL_GUID \
+  { 0x1e5668e2, 0x8481, 0x11d4, {0xbc, 0xf1, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+extern EFI_GUID gEfiVariableArchProtocolGuid;
+
+#endif 
diff --git a/MdePkg/Include/Protocol/VariableWrite.h b/MdePkg/Include/Protocol/VariableWrite.h
new file mode 100644
index 000000000000..96971d9e8586
--- /dev/null
+++ b/MdePkg/Include/Protocol/VariableWrite.h
@@ -0,0 +1,45 @@
+/** @file
+  Variable Write Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  This provides the services required to set nonvolatile environment variables. 
+  This protocol must be produced by a runtime DXE driver and may be consumed only 
+  by the DXE Foundation.
+
+  The DXE driver that produces this protocol must be a runtime driver. This driver 
+  may update the SetVariable() field of the UEFI Runtime Services Table.
+  
+  After the UEFI Runtime Services Table has been initialized, the driver must 
+  install the EFI_VARIABLE_WRITE_ARCH_PROTOCOL_GUID on a new handle with a NULL 
+  interface pointer. The installation of this protocol informs the DXE Foundation 
+  that the write services for nonvolatile environment variables are now available 
+  and that the DXE Foundation must update the 32-bit CRC of the UEFI Runtime Services 
+  Table. The full complement of environment variable services are not available 
+  until both this protocol and EFI_VARIABLE_ARCH_PROTOCOL are installed. DXE drivers 
+  that require read-only access or read/write access to volatile environment variables
+  must have the EFI_VARIABLE_WRITE_ARCH_PROTOCOL in their dependency expressions.
+  DXE drivers that require write access to nonvolatile environment variables must 
+  have this architectural protocol in their dependency expressions.  
+  
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_VARIABLE_WRITE_ARCH_H__
+#define __ARCH_PROTOCOL_VARIABLE_WRITE_ARCH_H__
+
+///
+/// Global ID for the Variable Write Architectural Protocol
+///
+#define EFI_VARIABLE_WRITE_ARCH_PROTOCOL_GUID \
+  { 0x6441f818, 0x6362, 0x4e44, {0xb5, 0x70, 0x7d, 0xba, 0x31, 0xdd, 0x24, 0x53 } }
+
+extern EFI_GUID gEfiVariableWriteArchProtocolGuid;
+
+#endif 
diff --git a/MdePkg/Include/Protocol/VlanConfig.h b/MdePkg/Include/Protocol/VlanConfig.h
new file mode 100644
index 000000000000..5d980a642134
--- /dev/null
+++ b/MdePkg/Include/Protocol/VlanConfig.h
@@ -0,0 +1,143 @@
+/** @file
+  EFI VLAN Config protocol is to provide manageability interface for VLAN configuration.
+
+  Copyright (c) 2009, 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.
+
+  @par Revision Reference:          
+  This Protocol is introduced in UEFI Specification 2.2
+
+**/
+
+#ifndef __EFI_VLANCONFIG_PROTOCOL_H__
+#define __EFI_VLANCONFIG_PROTOCOL_H__
+
+
+#define EFI_VLAN_CONFIG_PROTOCOL_GUID \
+  { \
+    0x9e23d768, 0xd2f3, 0x4366, {0x9f, 0xc3, 0x3a, 0x7a, 0xba, 0x86, 0x43, 0x74 } \
+  }
+
+typedef struct _EFI_VLAN_CONFIG_PROTOCOL EFI_VLAN_CONFIG_PROTOCOL;
+
+
+///
+/// EFI_VLAN_FIND_DATA
+///
+typedef struct {
+  UINT16          VlanId;     ///< Vlan Identifier.
+  UINT8           Priority;   ///< Priority of this VLAN.
+} EFI_VLAN_FIND_DATA;
+
+
+/**
+  Create a VLAN device or modify the configuration parameter of an 
+  already-configured VLAN.
+
+  The Set() function is used to create a new VLAN device or change the VLAN
+  configuration parameters. If the VlanId hasn't been configured in the 
+  physical Ethernet device, a new VLAN device will be created. If a VLAN with
+  this VlanId is already configured, then related configuration will be updated
+  as the input parameters. 
+ 
+  If VlanId is zero, the VLAN device will send and receive untagged frames.
+  Otherwise, the VLAN device will send and receive VLAN-tagged frames containing the VlanId.
+  If VlanId is out of scope of (0-4094), EFI_INVALID_PARAMETER is returned.
+  If Priority is out of the scope of (0-7), then EFI_INVALID_PARAMETER is returned. 
+  If there is not enough system memory to perform the registration, then 
+  EFI_OUT_OF_RESOURCES is returned.
+
+  @param[in] This                Points to the EFI_VLAN_CONFIG_PROTOCOL.
+  @param[in] VlanId              A unique identifier (1-4094) of the VLAN which is being created 
+                                 or modified, or zero (0).
+  @param[in] Priority            3 bit priority in VLAN header. Priority 0 is default value. If 
+                                 VlanId is zero (0), Priority is ignored.
+                                 
+  @retval EFI_SUCCESS            The VLAN is successfully configured.
+  @retval EFI_INVALID_PARAMETER  One or more of following conditions is TRUE:
+                                 - This is NULL.
+                                 - VlanId is an invalid VLAN Identifier.
+                                 - Priority is invalid.
+  @retval EFI_OUT_OF_RESOURCES   There is not enough system memory to perform the registration.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_VLAN_CONFIG_SET)(
+  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
+  IN  UINT16                       VlanId,
+  IN  UINT8                        Priority
+  );
+
+/**
+  Find configuration information for specified VLAN or all configured VLANs.
+
+  The Find() function is used to find the configuration information for matching
+  VLAN and allocate a buffer into which those entries are copied. 
+
+  @param[in]  This               Points to the EFI_VLAN_CONFIG_PROTOCOL.
+  @param[in]  VlanId             Pointer to VLAN identifier. Set to NULL to find all
+                                 configured VLANs.
+  @param[out] NumberOfVlan       The number of VLANs which is found by the specified criteria.
+  @param[out] Entries            The buffer which receive the VLAN configuration.
+                                 
+  @retval EFI_SUCCESS            The VLAN is successfully found.
+  @retval EFI_INVALID_PARAMETER  One or more of following conditions is TRUE:
+                                 - This is NULL.
+                                 - Specified VlanId is invalid.
+  @retval EFI_NOT_FOUND          No matching VLAN is found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_VLAN_CONFIG_FIND)(
+  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
+  IN  UINT16                       *VlanId  OPTIONAL,
+  OUT UINT16                       *NumberOfVlan,
+  OUT EFI_VLAN_FIND_DATA           **Entries
+  );
+
+/**
+  Remove the configured VLAN device.
+
+  The Remove() function is used to remove the specified VLAN device. 
+  If the VlanId is out of the scope of (0-4094), EFI_INVALID_PARAMETER is returned.
+  If specified VLAN hasn't been previously configured, EFI_NOT_FOUND is returned.   
+
+  @param[in] This                Points to the EFI_VLAN_CONFIG_PROTOCOL.
+  @param[in] VlanId              Identifier (0-4094) of the VLAN to be removed.
+                                 
+  @retval EFI_SUCCESS            The VLAN is successfully removed.
+  @retval EFI_INVALID_PARAMETER  One or more of following conditions is TRUE:
+                                 - This is NULL.
+                                 - VlanId  is an invalid parameter.
+  @retval EFI_NOT_FOUND          The to-be-removed VLAN does not exist.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_VLAN_CONFIG_REMOVE)(
+  IN  EFI_VLAN_CONFIG_PROTOCOL     *This,
+  IN  UINT16                       VlanId
+  );
+
+///
+/// EFI_VLAN_CONFIG_PROTOCOL
+/// provide manageability interface for VLAN setting. The intended 
+/// VLAN tagging implementation is IEEE802.1Q.
+///
+struct _EFI_VLAN_CONFIG_PROTOCOL {
+  EFI_VLAN_CONFIG_SET              Set;
+  EFI_VLAN_CONFIG_FIND             Find;
+  EFI_VLAN_CONFIG_REMOVE           Remove;
+};
+
+extern EFI_GUID gEfiVlanConfigProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/WatchdogTimer.h b/MdePkg/Include/Protocol/WatchdogTimer.h
new file mode 100644
index 000000000000..b48f943db2d1
--- /dev/null
+++ b/MdePkg/Include/Protocol/WatchdogTimer.h
@@ -0,0 +1,144 @@
+/** @file
+  Watchdog Timer Architectural Protocol as defined in PI Specification VOLUME 2 DXE
+
+  Used to provide system watchdog timer services
+
+  Copyright (c) 2006 - 2008, 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 __ARCH_PROTOCOL_WATCHDOG_TIMER_H__
+#define __ARCH_PROTOCOL_WATCHDOG_TIMER_H__
+
+///
+/// Global ID for the Watchdog Timer Architectural Protocol
+///
+#define EFI_WATCHDOG_TIMER_ARCH_PROTOCOL_GUID \
+  { 0x665E3FF5, 0x46CC, 0x11d4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D } }
+
+///
+/// Declare forward reference for the Timer Architectural Protocol
+///
+typedef struct _EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  EFI_WATCHDOG_TIMER_ARCH_PROTOCOL;
+
+/**
+  A function of this type is called when the watchdog timer fires if a 
+  handler has been registered.
+
+  @param  Time             The time in 100 ns units that has passed since the watchdog
+                           timer was armed. For the notify function to be called, this
+                           must be greater than TimerPeriod.
+
+  @return None.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_WATCHDOG_TIMER_NOTIFY)(
+  IN UINT64  Time
+  );
+
+/**
+  This function registers a handler that is to be invoked when the watchdog 
+  timer fires.  By default, the EFI_WATCHDOG_TIMER protocol will call the 
+  Runtime Service ResetSystem() when the watchdog timer fires.  If a 
+  NotifyFunction is registered, then the NotifyFunction will be called before 
+  the Runtime Service ResetSystem() is called.  If NotifyFunction is NULL, then 
+  the watchdog handler is unregistered.  If a watchdog handler is registered, 
+  then EFI_SUCCESS is returned.  If an attempt is made to register a handler 
+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
+  If an attempt is made to uninstall a handler when a handler is not installed, 
+  then return EFI_INVALID_PARAMETER.
+
+  @param  This             The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
+  @param  NotifyFunction   The function to call when the watchdog timer fires. If this
+                           is NULL, then the handler will be unregistered.
+
+  @retval EFI_SUCCESS           The watchdog timer handler was registered or
+                                unregistered.
+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
+                                registered.
+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
+                                previously registered.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_WATCHDOG_TIMER_REGISTER_HANDLER)(
+  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
+  IN EFI_WATCHDOG_TIMER_NOTIFY         NotifyFunction
+  );
+
+/**
+  This function sets the amount of time to wait before firing the watchdog 
+  timer to TimerPeriod 100 nS units.  If TimerPeriod is 0, then the watchdog 
+  timer is disabled.
+
+  @param  This             The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
+  @param  TimerPeriod      The amount of time in 100 nS units to wait before the watchdog
+                           timer is fired. If TimerPeriod is zero, then the watchdog
+                           timer is disabled.
+
+  @retval EFI_SUCCESS           The watchdog timer has been programmed to fire in Time
+                                100 nS units.
+  @retval EFI_DEVICE_ERROR      A watchdog timer could not be programmed due to a device
+                                error.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD)(
+  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
+  IN UINT64                            TimerPeriod
+  );
+
+/**
+  This function retrieves the amount of time the system will wait before firing 
+  the watchdog timer.  This period is returned in TimerPeriod, and EFI_SUCCESS 
+  is returned.  If TimerPeriod is NULL, then EFI_INVALID_PARAMETER is returned.
+
+  @param  This             The EFI_WATCHDOG_TIMER_ARCH_PROTOCOL instance.
+  @param  TimerPeriod      A pointer to the amount of time in 100 nS units that the system
+                           will wait before the watchdog timer is fired. If TimerPeriod of
+                           zero is returned, then the watchdog timer is disabled.
+
+  @retval EFI_SUCCESS           The amount of time that the system will wait before
+                                firing the watchdog timer was returned in TimerPeriod.
+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
+
+**/
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD)(
+  IN  EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
+  OUT UINT64                            *TimerPeriod
+  );
+
+
+///
+/// This protocol provides the services required to implement the Boot Service 
+/// SetWatchdogTimer().  It provides a service to set the amount of time to wait 
+/// before firing the watchdog timer, and it also provides a service to register 
+/// a handler that is invoked when the watchdog timer fires.  This protocol can 
+/// implement the watchdog timer by using the event and timer Boot Services, or 
+/// it can make use of custom hardware.  When the watchdog timer fires, control 
+/// will be passed to a handler if one has been registered.  If no handler has 
+/// been registered, or the registered handler returns, then the system will be 
+/// reset by calling the Runtime Service ResetSystem().
+///
+struct _EFI_WATCHDOG_TIMER_ARCH_PROTOCOL {
+  EFI_WATCHDOG_TIMER_REGISTER_HANDLER  RegisterHandler;
+  EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD  SetTimerPeriod;
+  EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD  GetTimerPeriod;
+};
+
+extern EFI_GUID gEfiWatchdogTimerArchProtocolGuid;
+
+#endif
+
diff --git a/MdePkg/Include/Protocol/WiFi.h b/MdePkg/Include/Protocol/WiFi.h
new file mode 100644
index 000000000000..cbc1a17bc6f6
--- /dev/null
+++ b/MdePkg/Include/Protocol/WiFi.h
@@ -0,0 +1,1129 @@
+/** @file
+  This file provides management service interfaces of 802.11 MAC layer. It is used by
+  network applications (and drivers) to establish wireless connection with an access
+  point (AP).
+
+  Copyright (c) 2015 - 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.5
+
+**/
+
+#ifndef __EFI_WIFI_PROTOCOL_H__
+#define __EFI_WIFI_PROTOCOL_H__
+
+#include <Protocol/WiFi2.h>
+
+#define EFI_WIRELESS_MAC_CONNECTION_PROTOCOL_GUID \
+  { \
+    0xda55bc9, 0x45f8, 0x4bb4, {0x87, 0x19, 0x52, 0x24, 0xf1, 0x8a, 0x4d, 0x45 } \
+  }
+
+typedef struct _EFI_WIRELESS_MAC_CONNECTION_PROTOCOL EFI_WIRELESS_MAC_CONNECTION_PROTOCOL;
+
+///
+/// EFI_80211_ACC_NET_TYPE
+///
+typedef enum {
+  IeeePrivate           = 0,
+  IeeePrivatewithGuest  = 1,
+  IeeeChargeablePublic  = 2,
+  IeeeFreePublic        = 3,
+  IeeePersonal          = 4,
+  IeeeEmergencyServOnly = 5,
+  IeeeTestOrExp         = 14,
+  IeeeWildcard          = 15
+} EFI_80211_ACC_NET_TYPE;
+
+///
+/// EFI_80211_ASSOCIATE_RESULT_CODE
+///
+typedef enum {
+  AssociateSuccess,
+  AssociateRefusedReasonUnspecified,
+  AssociateRefusedCapsMismatch,
+  AssociateRefusedExtReason,
+  AssociateRefusedAPOutOfMemory,
+  AssociateRefusedBasicRatesMismatch,
+  AssociateRejectedEmergencyServicesNotSupported,
+  AssociateRefusedTemporarily
+} EFI_80211_ASSOCIATE_RESULT_CODE;
+
+///
+/// EFI_80211_SCAN_RESULT_CODE
+///
+typedef enum {
+  ///
+  /// The scan operation finished successfully.
+  ///
+  ScanSuccess,
+  ///
+  /// The scan operation is not supported in current implementation.
+  ///
+  ScanNotSupported
+} EFI_80211_SCAN_RESULT_CODE;
+
+///
+/// EFI_80211_REASON_CODE
+///
+typedef enum {
+  Ieee80211UnspecifiedReason           = 1,
+  Ieee80211PreviousAuthenticateInvalid = 2,
+  Ieee80211DeauthenticatedSinceLeaving = 3,
+  Ieee80211DisassociatedDueToInactive  = 4,
+  Ieee80211DisassociatedSinceApUnable  = 5,
+  Ieee80211Class2FrameNonauthenticated = 6,
+  Ieee80211Class3FrameNonassociated    = 7,
+  Ieee80211DisassociatedSinceLeaving   = 8,
+  // ...
+} EFI_80211_REASON_CODE;
+
+///
+/// EFI_80211_DISASSOCIATE_RESULT_CODE
+///
+typedef enum {
+  ///
+  /// Disassociation process completed successfully.
+  ///
+  DisassociateSuccess,
+  ///
+  /// Disassociation failed due to any input parameter is invalid.
+  ///
+  DisassociateInvalidParameters
+} EFI_80211_DISASSOCIATE_RESULT_CODE;
+
+///
+/// EFI_80211_AUTHENTICATION_TYPE
+///
+typedef enum {
+  ///
+  /// Open system authentication, admits any STA to the DS.
+  ///
+  OpenSystem,
+  ///
+  /// Shared Key authentication relies on WEP to demonstrate knowledge of a WEP
+  /// encryption key.
+  ///
+  SharedKey,
+  ///
+  /// FT authentication relies on keys derived during the initial mobility domain
+  /// association to authenticate the stations.
+  ///
+  FastBSSTransition,
+  ///
+  /// SAE authentication uses finite field cryptography to prove knowledge of a shared
+  /// password.
+  ///
+  SAE
+} EFI_80211_AUTHENTICATION_TYPE;
+
+///
+/// EFI_80211_AUTHENTICATION_RESULT_CODE
+///
+typedef enum {
+  AuthenticateSuccess,
+  AuthenticateRefused,
+  AuthenticateAnticLoggingTokenRequired,
+  AuthenticateFiniteCyclicGroupNotSupported,
+  AuthenticationRejected,
+  AuthenticateInvalidParameter
+} EFI_80211_AUTHENTICATE_RESULT_CODE;
+
+///
+/// EFI_80211_ELEMENT_HEADER
+///
+typedef struct {
+  ///
+  /// A unique element ID defined in IEEE 802.11 specification.
+  ///
+  UINT8                              ElementID;
+  ///
+  /// Specifies the number of octets in the element body.
+  ///
+  UINT8                              Length;
+} EFI_80211_ELEMENT_HEADER;
+
+///
+/// EFI_80211_ELEMENT_REQ
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Start of elements that are requested to be included in the Probe Response frame.
+  /// The elements are listed in order of increasing element ID.
+  ///
+  UINT8                              RequestIDs[1];
+} EFI_80211_ELEMENT_REQ;
+
+///
+/// EFI_80211_ELEMENT_SSID
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Service set identifier. If Hdr.Length is zero, this field is ignored.
+  ///
+  UINT8                              SSId[32];
+} EFI_80211_ELEMENT_SSID;
+
+///
+/// EFI_80211_SCAN_DATA
+///
+typedef struct {
+  ///
+  /// Determines whether infrastructure BSS, IBSS, MBSS, or all, are included in the
+  /// scan.
+  ///
+  EFI_80211_BSS_TYPE                 BSSType;
+  ///
+  /// Indicates a specific or wildcard BSSID. Use all binary 1s to represent all SSIDs.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Length in bytes of the SSId. If zero, ignore SSId field.
+  ///
+  UINT8                              SSIdLen;
+  ///
+  /// Specifies the desired SSID or the wildcard SSID. Use NULL to represent all SSIDs.
+  ///
+  UINT8                              *SSId;
+  ///
+  /// Indicates passive scanning if TRUE.
+  ///
+  BOOLEAN                            PassiveMode;
+  ///
+  /// The delay in microseconds to be used prior to transmitting a Probe frame during
+  /// active scanning. If zero, the value can be overridden by an
+  /// implementation-dependent default value.
+  ///
+  UINT32                             ProbeDelay;
+  ///
+  /// Specifies a list of channels that are examined when scanning for a BSS. If set to
+  /// NULL, all valid channels will be scanned.
+  ///
+  UINT32                             *ChannelList;
+  ///
+  /// Indicates the minimum time in TU to spend on each channel when scanning. If zero,
+  /// the value can be overridden by an implementation-dependent default value.
+  ///
+  UINT32                             MinChannelTime;
+  ///
+  /// Indicates the maximum time in TU to spend on each channel when scanning. If zero,
+  /// the value can be overridden by an implementation-dependent default value.
+  ///
+  UINT32                             MaxChannelTime;
+  ///
+  /// Points to an optionally present element. This is an optional parameter and may be
+  /// NULL.
+  ///
+  EFI_80211_ELEMENT_REQ              *RequestInformation;
+  ///
+  /// Indicates one or more SSID elements that are optionally present. This is an
+  /// optional parameter and may be NULL.
+  ///
+  EFI_80211_ELEMENT_SSID             *SSIDList;
+  ///
+  /// Specifies a desired specific access network type or the wildcard access network
+  /// type. Use 15 as wildcard access network type.
+  ///
+  EFI_80211_ACC_NET_TYPE             AccessNetworkType;
+  ///
+  ///  Specifies zero or more elements. This is an optional parameter and may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_SCAN_DATA;
+
+///
+/// EFI_80211_COUNTRY_TRIPLET_SUBBAND
+///
+typedef struct {
+  ///
+  /// Indicates the lowest channel number in the subband. It has a positive integer
+  /// value less than 201.
+  ///
+  UINT8                              FirstChannelNum;
+  ///
+  /// Indicates the number of channels in the subband.
+  ///
+  UINT8                              NumOfChannels;
+  ///
+  /// Indicates the maximum power in dBm allowed to be transmitted.
+  ///
+  UINT8                              MaxTxPowerLevel;
+} EFI_80211_COUNTRY_TRIPLET_SUBBAND;
+
+///
+/// EFI_80211_COUNTRY_TRIPLET_OPERATE
+///
+typedef struct {
+  ///
+  /// Indicates the operating extension identifier. It has a positive integer value of
+  /// 201 or greater.
+  ///
+  UINT8                              OperatingExtId;
+  ///
+  /// Index into a set of values for radio equipment set of rules.
+  ///
+  UINT8                              OperatingClass;
+  ///
+  /// Specifies aAirPropagationTime characteristics used in BSS operation. Refer the
+  /// definition of aAirPropagationTime in IEEE 802.11 specification.
+  ///
+  UINT8                              CoverageClass;
+} EFI_80211_COUNTRY_TRIPLET_OPERATE;
+
+///
+/// EFI_80211_COUNTRY_TRIPLET
+///
+typedef union {
+  ///
+  /// The subband triplet.
+  ///
+  EFI_80211_COUNTRY_TRIPLET_SUBBAND  Subband;
+  ///
+  /// The operating triplet.
+  ///
+  EFI_80211_COUNTRY_TRIPLET_OPERATE  Operating;
+} EFI_80211_COUNTRY_TRIPLET;
+
+///
+/// EFI_80211_ELEMENT_COUNTRY
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Specifies country strings in 3 octets.
+  ///
+  UINT8                              CountryStr[3];
+  ///
+  /// Indicates a triplet that repeated in country element. The number of triplets is
+  /// determined by the Hdr.Length field.
+  ///
+  EFI_80211_COUNTRY_TRIPLET          CountryTriplet[1];
+} EFI_80211_ELEMENT_COUNTRY;
+
+///
+/// EFI_80211_ELEMENT_DATA_RSN
+///
+typedef struct {
+  ///
+  /// Indicates the version number of the RSNA protocol. Value 1 is defined in current
+  /// IEEE 802.11 specification.
+  ///
+  UINT16                             Version;
+  ///
+  /// Specifies the cipher suite selector used by the BSS to protect group address frames.
+  ///
+  UINT32                             GroupDataCipherSuite;
+  ///
+  /// Indicates the number of pairwise cipher suite selectors that are contained in
+  /// PairwiseCipherSuiteList.
+  ///
+//UINT16                             PairwiseCipherSuiteCount;
+  ///
+  /// Contains a series of cipher suite selectors that indicate the pairwise cipher
+  /// suites contained in this element.
+  ///
+//UINT32                             PairwiseCipherSuiteList[PairwiseCipherSuiteCount];
+  ///
+  /// Indicates the number of AKM suite selectors that are contained in AKMSuiteList.
+  ///
+//UINT16                             AKMSuiteCount;
+  ///
+  /// Contains a series of AKM suite selectors that indicate the AKM suites contained in
+  /// this element.
+  ///
+//UINT32                             AKMSuiteList[AKMSuiteCount];
+  ///
+  /// Indicates requested or advertised capabilities.
+  ///
+//UINT16                             RSNCapabilities;
+  ///
+  /// Indicates the number of PKMIDs in the PMKIDList.
+  ///
+//UINT16                             PMKIDCount;
+  ///
+  /// Contains zero or more PKMIDs that the STA believes to be valid for the destination
+  /// AP.
+//UINT8                              PMKIDList[PMKIDCount][16];
+  ///
+  /// Specifies the cipher suite selector used by the BSS to protect group addressed
+  /// robust management frames.
+  ///
+//UINT32                             GroupManagementCipherSuite;
+} EFI_80211_ELEMENT_DATA_RSN;
+
+///
+/// EFI_80211_ELEMENT_RSN
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Points to RSN element. The size of a RSN element is limited to 255 octets.
+  ///
+  EFI_80211_ELEMENT_DATA_RSN         *Data;
+} EFI_80211_ELEMENT_RSN;
+
+///
+/// EFI_80211_ELEMENT_EXT_CAP
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Indicates the capabilities being advertised by the STA transmitting the element.
+  /// This is a bit field with variable length. Refer to IEEE 802.11 specification for
+  /// bit value.
+  ///
+  UINT8                              Capabilities[1];
+} EFI_80211_ELEMENT_EXT_CAP;
+
+///
+/// EFI_80211_BSS_DESCRIPTION
+///
+typedef struct {
+  ///
+  /// Indicates a specific BSSID of the found BSS.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the SSID of the found BSS. If NULL, ignore SSIdLen field.
+  ///
+  UINT8                              *SSId;
+  ///
+  /// Specifies the SSID of the found BSS. If NULL, ignore SSIdLen field.
+  ///
+  UINT8                              SSIdLen;
+  ///
+  /// Specifies the type of the found BSS.
+  ///
+  EFI_80211_BSS_TYPE                 BSSType;
+  ///
+  /// The beacon period in TU of the found BSS.
+  ///
+  UINT16                             BeaconPeriod;
+  ///
+  /// The timestamp of the received frame from the found BSS.
+  ///
+  UINT64                             Timestamp;
+  ///
+  /// The advertised capabilities of the BSS.
+  ///
+  UINT16                             CapabilityInfo;
+  ///
+  /// The set of data rates that shall be supported by all STAs that desire to join this
+  /// BSS.
+  ///
+  UINT8                              *BSSBasicRateSet;
+  ///
+  /// The set of data rates that the peer STA desires to use for communication within
+  /// the BSS.
+  ///
+  UINT8                              *OperationalRateSet;
+  ///
+  /// The information required to identify the regulatory domain in which the peer STA
+  /// is located.
+  ///
+  EFI_80211_ELEMENT_COUNTRY          *Country;
+  ///
+  /// The cipher suites and AKM suites supported in the BSS.
+  ///
+  EFI_80211_ELEMENT_RSN              RSN;
+  ///
+  /// Specifies the RSSI of the received frame.
+  ///
+  UINT8                              RSSI;
+  ///
+  /// Specifies the RCPI of the received frame.
+  ///
+  UINT8                              RCPIMeasurement;
+  ///
+  /// Specifies the RSNI of the received frame.
+  ///
+  UINT8                              RSNIMeasurement;
+  ///
+  /// Specifies the elements requested by the request element of the Probe Request frame.
+  /// This is an optional parameter and may be NULL.
+  ///
+  UINT8                              *RequestedElements;
+  ///
+  /// Specifies the BSS membership selectors that represent the set of features that
+  /// shall be supported by all STAs to join this BSS.
+  ///
+  UINT8                              *BSSMembershipSelectorSet;
+  ///
+  /// Specifies the parameters within the Extended Capabilities element that are
+  /// supported by the MAC entity. This is an optional parameter and may be NULL.
+  ///
+  EFI_80211_ELEMENT_EXT_CAP          *ExtCapElement;
+} EFI_80211_BSS_DESCRIPTION;
+
+///
+/// EFI_80211_SUBELEMENT_INFO
+///
+typedef struct {
+  ///
+  /// Indicates the unique identifier within the containing element or sub-element.
+  ///
+  UINT8                              SubElementID;
+  ///
+  /// Specifies the number of octets in the Data field.
+  ///
+  UINT8                              Length;
+  ///
+  /// A variable length data buffer.
+  ///
+  UINT8                              Data[1];
+} EFI_80211_SUBELEMENT_INFO;
+
+///
+/// EFI_80211_MULTIPLE_BSSID
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Indicates the maximum number of BSSIDs in the multiple BSSID set. When Indicator
+  /// is set to n, 2n is the maximum number.
+  ///
+  UINT8                              Indicator;
+  ///
+  /// Contains zero or more sub-elements.
+  ///
+  EFI_80211_SUBELEMENT_INFO          SubElement[1];
+} EFI_80211_MULTIPLE_BSSID;
+
+///
+/// EFI_80211_BSS_DESP_PILOT
+///
+typedef struct {
+  ///
+  /// Indicates a specific BSSID of the found BSS.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the type of the found BSS.
+  ///
+  EFI_80211_BSS_TYPE                 BSSType;
+  ///
+  /// One octet field to report condensed capability information.
+  ///
+  UINT8                              ConCapInfo;
+  ///
+  /// Two octet's field to report condensed country string.
+  ///
+  UINT8                              ConCountryStr[2];
+  ///
+  /// Indicates the operating class value for the operating channel.
+  ///
+  UINT8                              OperatingClass;
+  ///
+  /// Indicates the operating channel.
+  ///
+  UINT8                              Channel;
+  ///
+  /// Indicates the measurement pilot interval in TU.
+  ///
+  UINT8                              Interval;
+  ///
+  /// Indicates that the BSS is within a multiple BSSID set.
+  ///
+  EFI_80211_MULTIPLE_BSSID           *MultipleBSSID;
+  ///
+  /// Specifies the RCPI of the received frame.
+  ///
+  UINT8                              RCPIMeasurement;
+  ///
+  /// Specifies the RSNI of the received frame.
+  ///
+  UINT8                              RSNIMeasurement;
+} EFI_80211_BSS_DESP_PILOT;
+
+///
+/// EFI_80211_SCAN_RESULT
+///
+typedef struct {
+  ///
+  /// The number of EFI_80211_BSS_DESCRIPTION in BSSDespSet. If zero, BSSDespSet should
+  /// be ignored.
+  ///
+  UINTN                              NumOfBSSDesp;
+  ///
+  /// Points to zero or more instances of EFI_80211_BSS_DESCRIPTION.
+  ///
+  EFI_80211_BSS_DESCRIPTION          **BSSDespSet;
+  ///
+  /// The number of EFI_80211_BSS_DESP_PILOT in BSSDespFromPilotSet. If zero,
+  /// BSSDespFromPilotSet should be ignored.
+  ///
+  UINTN                              NumofBSSDespFromPilot;
+  ///
+  /// Points to zero or more instances of EFI_80211_BSS_DESP_PILOT.
+  ///
+  EFI_80211_BSS_DESP_PILOT           **BSSDespFromPilotSet;
+  ///
+  /// Specifies zero or more elements. This is an optional parameter and may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_SCAN_RESULT;
+
+///
+/// EFI_80211_SCAN_DATA_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI Wireless
+  /// MAC Connection Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                          Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:       Scan operation completed successfully.
+  ///   EFI_NOT_FOUND:     Failed to find available BSS.
+  ///   EFI_DEVICE_ERROR:  An unexpected network or system error occurred.
+  ///   EFI_ACCESS_DENIED: The scan operation is not completed due to some underlying
+  ///                      hardware or software state.
+  ///   EFI_NOT_READY:     The scan operation is started but not yet completed.
+  EFI_STATUS                         Status;
+  ///
+  /// Pointer to the scan data.
+  ///
+  EFI_80211_SCAN_DATA                *Data;
+  ///
+  /// Indicates the scan state.
+  ///
+  EFI_80211_SCAN_RESULT_CODE         ResultCode;
+  ///
+  /// Indicates the scan result. It is caller's responsibility to free this buffer.
+  ///
+  EFI_80211_SCAN_RESULT              *Result;
+} EFI_80211_SCAN_DATA_TOKEN;
+
+///
+/// EFI_80211_ELEMENT_SUPP_CHANNEL_TUPLE
+///
+typedef struct {
+  ///
+  /// The first channel number in a subband of supported channels.
+  ///
+  UINT8                              FirstChannelNumber;
+  ///
+  /// The number of channels in a subband of supported channels.
+  ///
+  UINT8                              NumberOfChannels;
+} EFI_80211_ELEMENT_SUPP_CHANNEL_TUPLE;
+
+///
+/// EFI_80211_ELEMENT_SUPP_CHANNEL
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER                Hdr;
+  ///
+  /// Indicates one or more tuples of (first channel, number of channels).
+  ///
+  EFI_80211_ELEMENT_SUPP_CHANNEL_TUPLE    Subband[1];
+} EFI_80211_ELEMENT_SUPP_CHANNEL;
+
+///
+/// EFI_80211_ASSOCIATE_DATA
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity to associate with.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the requested operational capabilities to the AP in 2 octets.
+  ///
+  UINT16                             CapabilityInfo;
+  ///
+  /// Specifies a time limit in TU, after which the associate procedure is terminated.
+  ///
+  UINT32                             FailureTimeout;
+  ///
+  /// Specifies if in power save mode, how often the STA awakes and listens for the next
+  /// beacon frame in TU.
+  ///
+  UINT32                             ListenInterval;
+  ///
+  /// Indicates a list of channels in which the STA is capable of operating.
+  ///
+  EFI_80211_ELEMENT_SUPP_CHANNEL     *Channels;
+  ///
+  /// The cipher suites and AKM suites selected by the STA.
+  ///
+  EFI_80211_ELEMENT_RSN              RSN;
+  ///
+  /// Specifies the parameters within the Extended Capabilities element that are
+  /// supported by the MAC entity.  This is an optional parameter and may be NULL.
+  ///
+  EFI_80211_ELEMENT_EXT_CAP          *ExtCapElement;
+  ///
+  /// Specifies zero or more elements. This is an optional parameter and may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_ASSOCIATE_DATA;
+
+///
+/// EFI_80211_ELEMENT_TIMEOUT_VAL
+///
+typedef struct {
+  ///
+  /// Common header of an element.
+  ///
+  EFI_80211_ELEMENT_HEADER           Hdr;
+  ///
+  /// Specifies the timeout interval type.
+  ///
+  UINT8                              Type;
+  ///
+  /// Specifies the timeout interval value.
+  ///
+  UINT32                             Value;
+} EFI_80211_ELEMENT_TIMEOUT_VAL;
+
+///
+/// EFI_80211_ASSOCIATE_RESULT
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity from which the association request
+  /// was received.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the operational capabilities advertised by the AP.
+  ///
+  UINT16                             CapabilityInfo;
+  ///
+  /// Specifies the association ID value assigned by the AP.
+  ///
+  UINT16                             AssociationID;
+  ///
+  /// Indicates the measured RCPI of the corresponding association request frame. It is
+  /// an optional parameter and is set to zero if unavailable.
+  ///
+  UINT8                              RCPIValue;
+  ///
+  /// Indicates the measured RSNI at the time the corresponding association request
+  /// frame was received. It is an optional parameter and is set to zero if unavailable.
+  ///
+  UINT8                              RSNIValue;
+  ///
+  /// Specifies the parameters within the Extended Capabilities element that are
+  /// supported by the MAC entity.  This is an optional parameter and may be NULL.
+  ///
+  EFI_80211_ELEMENT_EXT_CAP          *ExtCapElement;
+  ///
+  /// Specifies the timeout interval when the result code is AssociateRefusedTemporarily.
+  ///
+  EFI_80211_ELEMENT_TIMEOUT_VAL      TimeoutInterval;
+  ///
+  /// Specifies zero or more elements. This is an optional parameter and may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_ASSOCIATE_RESULT;
+
+///
+/// EFI_80211_ASSOCIATE_DATA_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI Wireless
+  /// MAC Connection Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                          Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:      Association operation completed successfully.
+  ///   EFI_DEVICE_ERROR: An unexpected network or system error occurred.
+  ///
+  EFI_STATUS                         Status;
+  ///
+  /// Pointer to the association data.
+  ///
+  EFI_80211_ASSOCIATE_DATA           *Data;
+  ///
+  /// Indicates the association state.
+  ///
+  EFI_80211_ASSOCIATE_RESULT_CODE    ResultCode;
+  ///
+  /// Indicates the association result. It is caller's responsibility to free this
+  /// buffer.
+  ///
+  EFI_80211_ASSOCIATE_RESULT         *Result;
+} EFI_80211_ASSOCIATE_DATA_TOKEN;
+
+///
+/// EFI_80211_DISASSOCIATE_DATA
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity with which to perform the
+  /// disassociation process.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the reason for initiating the disassociation process.
+  ///
+  EFI_80211_REASON_CODE              ReasonCode;
+  ///
+  /// Zero or more elements, may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_DISASSOCIATE_DATA;
+
+///
+/// EFI_80211_DISASSOCIATE_DATA_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI Wireless
+  /// MAC Connection Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                          Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:       Disassociation operation completed successfully.
+  ///   EFI_DEVICE_ERROR:  An unexpected network or system error occurred.
+  ///   EFI_ACCESS_DENIED: The disassociation operation is not completed due to some
+  ///                      underlying hardware or software state.
+  ///   EFI_NOT_READY:     The disassociation operation is started but not yet completed.
+  ///
+  EFI_STATUS                         Status;
+  ///
+  /// Pointer to the disassociation data.
+  ///
+  EFI_80211_DISASSOCIATE_DATA        *Data;
+  ///
+  /// Indicates the disassociation state.
+  ///
+  EFI_80211_DISASSOCIATE_RESULT_CODE ResultCode;
+} EFI_80211_DISASSOCIATE_DATA_TOKEN;
+
+///
+/// EFI_80211_AUTHENTICATION_DATA
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity with which to perform the
+  /// authentication process.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the type of authentication algorithm to use during the authentication
+  /// process.
+  ///
+  EFI_80211_AUTHENTICATION_TYPE      AuthType;
+  ///
+  /// Specifies a time limit in TU after which the authentication procedure is
+  /// terminated.
+  ///
+  UINT32                             FailureTimeout;
+  ///
+  /// Specifies the set of elements to be included in the first message of the FT
+  /// authentication sequence, may be NULL.
+  ///
+  UINT8                              *FTContent;
+  ///
+  /// Specifies the set of elements to be included in the SAE Commit Message or SAE
+  /// Confirm Message, may be NULL.
+  ///
+  UINT8                              *SAEContent;
+  ///
+  /// Zero or more elements, may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_AUTHENTICATE_DATA;
+
+///
+/// EFI_80211_AUTHENTICATION_RESULT
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity from which the authentication request
+  /// was received.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the set of elements to be included in the second message of the FT
+  /// authentication sequence, may be NULL.
+  ///
+  UINT8                              *FTContent;
+  ///
+  /// Specifies the set of elements to be included in the SAE Commit Message or SAE
+  /// Confirm Message, may be NULL.
+  ///
+  UINT8                              *SAEContent;
+  ///
+  /// Zero or more elements, may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_AUTHENTICATE_RESULT;
+
+///
+/// EFI_80211_AUTHENTICATE_DATA_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI Wireless
+  /// MAC Connection Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                          Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS: Authentication operation completed successfully.
+  ///   EFI_PROTOCOL_ERROR: Peer MAC entity rejects the authentication.
+  ///   EFI_NO_RESPONSE:    Peer MAC entity does not response the authentication request.
+  ///   EFI_DEVICE_ERROR:   An unexpected network or system error occurred.
+  ///   EFI_ACCESS_DENIED:  The authentication operation is not completed due to some
+  ///                       underlying hardware or software state.
+  ///   EFI_NOT_READY:      The authentication operation is started but not yet completed.
+  ///
+  EFI_STATUS                         Status;
+  ///
+  /// Pointer to the authentication data.
+  ///
+  EFI_80211_AUTHENTICATE_DATA        *Data;
+  ///
+  /// Indicates the association state.
+  ///
+  EFI_80211_AUTHENTICATE_RESULT_CODE ResultCode;
+  ///
+  /// Indicates the association result. It is caller's responsibility to free this
+  /// buffer.
+  ///
+  EFI_80211_AUTHENTICATE_RESULT      *Result;
+} EFI_80211_AUTHENTICATE_DATA_TOKEN;
+
+///
+/// EFI_80211_DEAUTHENTICATE_DATA
+///
+typedef struct {
+  ///
+  /// Specifies the address of the peer MAC entity with which to perform the
+  /// deauthentication process.
+  ///
+  EFI_80211_MAC_ADDRESS              BSSId;
+  ///
+  /// Specifies the reason for initiating the deauthentication process.
+  ///
+  EFI_80211_REASON_CODE              ReasonCode;
+  ///
+  /// Zero or more elements, may be NULL.
+  ///
+  UINT8                              *VendorSpecificInfo;
+} EFI_80211_DEAUTHENTICATE_DATA;
+
+///
+/// EFI_80211_DEAUTHENTICATE_DATA_TOKEN
+///
+typedef struct {
+  ///
+  /// This Event will be signaled after the Status field is updated by the EFI Wireless
+  /// MAC Connection Protocol driver. The type of Event must be EFI_NOTIFY_SIGNAL.
+  ///
+  EFI_EVENT                          Event;
+  ///
+  /// Will be set to one of the following values:
+  ///   EFI_SUCCESS:       Deauthentication operation completed successfully.
+  ///   EFI_DEVICE_ERROR:  An unexpected network or system error occurred.
+  ///   EFI_ACCESS_DENIED: The deauthentication operation is not completed due to some
+  ///                      underlying hardware or software state.
+  ///   EFI_NOT_READY:     The deauthentication operation is started but not yet
+  ///                      completed.
+  ///
+  EFI_STATUS                         Status;
+  ///
+  /// Pointer to the deauthentication data.
+  ///
+  EFI_80211_DEAUTHENTICATE_DATA      *Data;
+} EFI_80211_DEAUTHENTICATE_DATA_TOKEN;
+
+/**
+  Request a survey of potential BSSs that administrator can later elect to try to join.
+
+  The Scan() function returns the description of the set of BSSs detected by the scan
+  process. Passive scan operation is performed by default.
+
+  @param[in]  This                Pointer to the EFI_WIRELESS_MAC_CONNECTION_PROTOCOL
+                                  instance.
+  @param[in]  Data                Pointer to the scan token.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  Data->Data is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters are not supported
+                                  by this implementation.
+  @retval EFI_ALREADY_STARTED     The scan operation is already started.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_SCAN)(
+  IN EFI_WIRELESS_MAC_CONNECTION_PROTOCOL        *This,
+  IN EFI_80211_SCAN_DATA_TOKEN                   *Data
+  );
+
+/**
+  Request an association with a specified peer MAC entity that is within an AP.
+
+  The Associate() function provides the capability for MAC layer to become associated
+  with an AP.
+
+  @param[in]  This                Pointer to the EFI_WIRELESS_MAC_CONNECTION_PROTOCOL
+                                  instance.
+  @param[in]  Data                Pointer to the association token.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  Data->Data is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters are not supported
+                                  by this implementation.
+  @retval EFI_ALREADY_STARTED     The association process is already started.
+  @retval EFI_NOT_READY           Authentication is not performed before this association
+                                  process.
+  @retval EFI_NOT_FOUND           The specified peer MAC entity is not found.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_ASSOCIATE)(
+  IN EFI_WIRELESS_MAC_CONNECTION_PROTOCOL        *This,
+  IN EFI_80211_ASSOCIATE_DATA_TOKEN              *Data
+  );
+
+/**
+  Request a disassociation with a specified peer MAC entity.
+
+  The Disassociate() function is invoked to terminate an existing association.
+  Disassociation is a notification and cannot be refused by the receiving peer except
+  when management frame protection is negotiated and the message integrity check fails.
+
+  @param[in]  This                Pointer to the EFI_WIRELESS_MAC_CONNECTION_PROTOCOL
+                                  instance.
+  @param[in]  Data                Pointer to the disassociation token.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+  @retval EFI_ALREADY_STARTED     The disassociation process is already started.
+  @retval EFI_NOT_READY           The disassociation service is invoked to a
+                                  nonexistent association relationship.
+  @retval EFI_NOT_FOUND           The specified peer MAC entity is not found.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_DISASSOCIATE)(
+  IN EFI_WIRELESS_MAC_CONNECTION_PROTOCOL        *This,
+  IN EFI_80211_DISASSOCIATE_DATA_TOKEN           *Data
+  );
+
+/**
+  Request the process of establishing an authentication relationship with a peer MAC
+  entity.
+
+  The Authenticate() function requests authentication with a specified peer MAC entity.
+  This service might be time-consuming thus is designed to be invoked independently of
+  the association service.
+
+  @param[in]  This                Pointer to the EFI_WIRELESS_MAC_CONNECTION_PROTOCOL
+                                  instance.
+  @param[in]  Data                Pointer to the authentication token.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  Data.Data is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters are not supported
+                                  by this implementation.
+  @retval EFI_ALREADY_STARTED     The authentication process is already started.
+  @retval EFI_NOT_FOUND           The specified peer MAC entity is not found.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_AUTHENTICATE)(
+  IN EFI_WIRELESS_MAC_CONNECTION_PROTOCOL        *This,
+  IN EFI_80211_AUTHENTICATE_DATA_TOKEN           *Data
+  );
+
+/**
+  Invalidate the authentication relationship with a peer MAC entity.
+
+  The Deauthenticate() function requests that the authentication relationship with a
+  specified peer MAC entity be invalidated. Deauthentication is a notification and when
+  it is sent out the association at the transmitting station is terminated.
+
+  @param[in]  This                Pointer to the EFI_WIRELESS_MAC_CONNECTION_PROTOCOL
+                                  instance.
+  @param[in]  Data                Pointer to the deauthentication token.
+
+  @retval EFI_SUCCESS             The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is TRUE:
+                                  This is NULL.
+                                  Data is NULL.
+                                  Data.Data is NULL.
+  @retval EFI_ALREADY_STARTED     The deauthentication process is already started.
+  @retval EFI_NOT_READY           The deauthentication service is invoked to a
+                                  nonexistent association or authentication relationship.
+  @retval EFI_NOT_FOUND           The specified peer MAC entity is not found.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be allocated.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_DEAUTHENTICATE)(
+  IN EFI_WIRELESS_MAC_CONNECTION_PROTOCOL        *This,
+  IN EFI_80211_DEAUTHENTICATE_DATA_TOKEN         *Data
+  );
+
+///
+/// The EFI_WIRELESS_MAC_CONNECTION_PROTOCOL is designed to provide management service
+/// interfaces for the EFI wireless network stack to establish wireless connection with
+/// AP. An EFI Wireless MAC Connection Protocol instance will be installed on each
+/// communication device that the EFI wireless network stack runs on.
+///
+struct _EFI_WIRELESS_MAC_CONNECTION_PROTOCOL {
+  EFI_WIRELESS_MAC_CONNECTION_SCAN               Scan;
+  EFI_WIRELESS_MAC_CONNECTION_ASSOCIATE          Associate;
+  EFI_WIRELESS_MAC_CONNECTION_DISASSOCIATE       Disassociate;
+  EFI_WIRELESS_MAC_CONNECTION_AUTHENTICATE       Authenticate;
+  EFI_WIRELESS_MAC_CONNECTION_DEAUTHENTICATE     Deauthenticate;
+};
+
+extern EFI_GUID gEfiWiFiProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Protocol/WiFi2.h b/MdePkg/Include/Protocol/WiFi2.h
new file mode 100644
index 000000000000..c28f9fc492c8
--- /dev/null
+++ b/MdePkg/Include/Protocol/WiFi2.h
@@ -0,0 +1,413 @@
+/** @file
+  This file defines the EFI Wireless MAC Connection II Protocol.
+
+  Copyright (c) 2016, 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.
+
+  @par Revision Reference:
+  This Protocol is introduced in UEFI Specification 2.6
+
+**/
+
+#ifndef __EFI_WIFI2_PROTOCOL_H__
+#define __EFI_WIFI2_PROTOCOL_H__
+
+#define EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL_GUID \
+  { \
+    0x1b0fb9bf, 0x699d, 0x4fdd, { 0xa7, 0xc3, 0x25, 0x46, 0x68, 0x1b, 0xf6, 0x3b } \
+  }
+
+typedef struct _EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL;
+
+///
+/// EFI_80211_BSS_TYPE
+///
+typedef enum {
+  IeeeInfrastructureBSS,
+  IeeeIndependentBSS,
+  IeeeMeshBSS,
+  IeeeAnyBss
+} EFI_80211_BSS_TYPE;
+
+///
+/// EFI_80211_CONNECT_NETWORK_RESULT_CODE
+///
+typedef enum {
+  //
+  // The connection establishment operation finished successfully.
+  //
+  ConnectSuccess,
+  //
+  // The connection was refused by the Network.
+  //
+  ConnectRefused,
+  //
+  // The connection establishment operation failed (i.e, Network is not
+  // detected).
+  //
+  ConnectFailed,
+  //
+  // The connection establishment operation was terminated on timeout.
+  //
+  ConnectFailureTimeout,
+  //
+  // The connection establishment operation failed on other reason.
+  //
+  ConnectFailedReasonUnspecified
+} EFI_80211_CONNECT_NETWORK_RESULT_CODE;
+
+///
+/// EFI_80211_MAC_ADDRESS
+///
+typedef struct {
+  UINT8                              Addr[6];
+} EFI_80211_MAC_ADDRESS;
+
+#define EFI_MAX_SSID_LEN 32
+
+///
+/// EFI_80211_SSID
+///
+typedef struct {
+  //
+  // Length in bytes of the SSId. If zero, ignore SSId field.
+  //
+  UINT8                                     SSIdLen;
+  //
+  // Specifies the service set identifier.
+  //
+  UINT8                                     SSId[EFI_MAX_SSID_LEN];
+} EFI_80211_SSID;
+
+///
+/// EFI_80211_GET_NETWORKS_DATA
+///
+typedef struct {
+  //
+  // The number of EFI_80211_SSID in SSIDList. If zero, SSIDList should be
+  // ignored.
+  //
+  UINT32                                    NumOfSSID;
+  //
+  // The SSIDList is a pointer to an array of EFI_80211_SSID instances. The
+  // number of entries is specified by NumOfSSID. The array should only include
+  // SSIDs of hidden networks. It is suggested that the caller inputs less than
+  // 10 elements in the SSIDList. It is the caller's responsibility to free
+  // this buffer.
+  //
+  EFI_80211_SSID                            SSIDList[1];
+} EFI_80211_GET_NETWORKS_DATA;
+
+///
+/// EFI_80211_SUITE_SELECTOR
+///
+typedef struct {
+  //
+  // Organization Unique Identifier, as defined in IEEE 802.11 standard,
+  // usually set to 00-0F-AC.
+  //
+  UINT8                                     Oui[3];
+  //
+  // Suites types, as defined in IEEE 802.11 standard.
+  //
+  UINT8                                     SuiteType;
+} EFI_80211_SUITE_SELECTOR;
+
+///
+/// EFI_80211_AKM_SUITE_SELECTOR
+///
+typedef struct {
+  //
+  // Indicates the number of AKM suite selectors that are contained in
+  // AKMSuiteList. If zero, the AKMSuiteList is ignored.
+  //
+  UINT16                                    AKMSuiteCount;
+  //
+  // A variable-length array of AKM suites, as defined in IEEE 802.11 standard,
+  // Table 8-101. The number of entries is specified by AKMSuiteCount.
+  //
+  EFI_80211_SUITE_SELECTOR                  AKMSuiteList[1];
+} EFI_80211_AKM_SUITE_SELECTOR;
+
+///
+/// EFI_80211_CIPHER_SUITE_SELECTOR
+///
+typedef struct {
+  //
+  // Indicates the number of cipher suites that are contained in
+  // CipherSuiteList. If zero, the CipherSuiteList is ignored.
+  //
+  UINT16                                    CipherSuiteCount;
+  //
+  // A variable-length array of cipher suites, as defined in IEEE 802.11
+  // standard, Table 8-99. The number of entries is specified by
+  // CipherSuiteCount.
+  //
+  EFI_80211_SUITE_SELECTOR                  CipherSuiteList[1];
+} EFI_80211_CIPHER_SUITE_SELECTOR;
+
+///
+/// EFI_80211_NETWORK
+///
+typedef struct {
+  //
+  // Specifies the type of the BSS.
+  //
+  EFI_80211_BSS_TYPE                        BSSType;
+  //
+  // Specifies the SSID of the BSS.
+  //
+  EFI_80211_SSID                            SSId;
+  //
+  // Pointer to the AKM suites supported in the wireless network.
+  //
+  EFI_80211_AKM_SUITE_SELECTOR              *AKMSuite;
+  //
+  // Pointer to the cipher suites supported in the wireless network.
+  //
+  EFI_80211_CIPHER_SUITE_SELECTOR           *CipherSuite;
+} EFI_80211_NETWORK;
+
+///
+/// EFI_80211_NETWORK_DESCRIPTION
+///
+typedef struct {
+  //
+  // Specifies the found wireless network.
+  //
+  EFI_80211_NETWORK                         Network;
+  //
+  // Indicates the network quality as a value between 0 to 100, where 100
+  // indicates the highest network quality.
+  //
+  UINT8                                     NetworkQuality;
+} EFI_80211_NETWORK_DESCRIPTION;
+
+///
+/// EFI_80211_GET_NETWORKS_RESULT
+///
+typedef struct {
+  //
+  // The number of EFI_80211_NETWORK_DESCRIPTION in NetworkDesc. If zero,
+  // NetworkDesc should be ignored.
+  //
+  UINT8                                     NumOfNetworkDesc;
+  //
+  // The NetworkDesc is a pointer to an array of EFI_80211_NETWORK_DESCRIPTION
+  // instances. It is caller's responsibility to free this buffer.
+  //
+  EFI_80211_NETWORK_DESCRIPTION             **NetworkDesc;
+} EFI_80211_GET_NETWORKS_RESULT;
+
+///
+/// EFI_80211_GET_NETWORKS_TOKEN
+///
+typedef struct {
+  //
+  // If the status code returned by GetNetworks() is EFI_SUCCESS, then this
+  // Event will be signaled after the Status field is updated by the EFI
+  // Wireless MAC Connection Protocol II driver. The type of Event must be
+  // EFI_NOTIFY_SIGNAL.
+  //
+  EFI_EVENT                                 Event;
+  //
+  // Will be set to one of the following values:
+  // EFI_SUCCESS: The operation completed successfully.
+  // EFI_NOT_FOUND: Failed to find available wireless networks.
+  // EFI_DEVICE_ERROR: An unexpected network or system error occurred.
+  // EFI_ACCESS_DENIED: The operation is not completed due to some underlying
+  // hardware or software state.
+  // EFI_NOT_READY: The operation is started but not yet completed.
+  //
+  EFI_STATUS                                Status;
+  //
+  // Pointer to the input data for getting networks.
+  //
+  EFI_80211_GET_NETWORKS_DATA               *Data;
+  //
+  // Indicates the scan result. It is caller's responsibility to free this
+  // buffer.
+  //
+  EFI_80211_GET_NETWORKS_RESULT             *Result;
+} EFI_80211_GET_NETWORKS_TOKEN;
+
+///
+/// EFI_80211_CONNECT_NETWORK_DATA
+///
+typedef struct {
+  //
+  // Specifies the wireless network to connect to.
+  //
+  EFI_80211_NETWORK                         *Network;
+  //
+  // Specifies a time limit in seconds that is optionally present, after which
+  // the connection establishment procedure is terminated by the UNDI driver.
+  // This is an optional parameter and may be 0. Values of 5 seconds or higher
+  // are recommended.
+  //
+  UINT32                                    FailureTimeout;
+} EFI_80211_CONNECT_NETWORK_DATA;
+
+///
+/// EFI_80211_CONNECT_NETWORK_TOKEN
+///
+typedef struct {
+  //
+  // If the status code returned by ConnectNetwork() is EFI_SUCCESS, then this
+  // Event will be signaled after the Status field is updated by the EFI
+  // Wireless MAC Connection Protocol II driver. The type of Event must be
+  // EFI_NOTIFY_SIGNAL.
+  //
+  EFI_EVENT                                 Event;
+  //
+  // Will be set to one of the following values:
+  // EFI_SUCCESS: The operation completed successfully.
+  // EFI_DEVICE_ERROR: An unexpected network or system error occurred.
+  // EFI_ACCESS_DENIED: The operation is not completed due to some underlying
+  // hardware or software state.
+  // EFI_NOT_READY: The operation is started but not yet completed.
+  //
+  EFI_STATUS                                Status;
+  //
+  // Pointer to the connection data.
+  //
+  EFI_80211_CONNECT_NETWORK_DATA            *Data;
+  //
+  // Indicates the connection state.
+  //
+  EFI_80211_CONNECT_NETWORK_RESULT_CODE     ResultCode;
+} EFI_80211_CONNECT_NETWORK_TOKEN;
+
+///
+/// EFI_80211_DISCONNECT_NETWORK_TOKEN
+///
+typedef struct {
+  //
+  // If the status code returned by DisconnectNetwork() is EFI_SUCCESS, then
+  // this Event will be signaled after the Status field is updated by the EFI
+  // Wireless MAC Connection Protocol II driver. The type of Event must be
+  // EFI_NOTIFY_SIGNAL.
+  //
+  EFI_EVENT                                 Event;
+  //
+  // Will be set to one of the following values:
+  // EFI_SUCCESS: The operation completed successfully
+  // EFI_DEVICE_ERROR: An unexpected network or system error occurred.
+  // EFI_ACCESS_DENIED: The operation is not completed due to some underlying
+  // hardware or software state.
+  //
+  EFI_STATUS                                Status;
+} EFI_80211_DISCONNECT_NETWORK_TOKEN;
+
+/**
+  Request a survey of potential wireless networks that administrator can later
+  elect to try to join.
+
+  @param[in]  This                Pointer to the
+                                  EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL
+                                  instance.
+  @param[in]  Token               Pointer to the token for getting wireless
+                                  network.
+
+  @retval EFI_SUCCESS             The operation started, and an event will
+                                  eventually be raised for the caller.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters is not
+                                  supported by this implementation.
+  @retval EFI_ALREADY_STARTED     The operation of getting wireless network is
+                                  already started.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be
+                                  allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_II_GET_NETWORKS) (
+  IN EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL          *This,
+  IN EFI_80211_GET_NETWORKS_TOKEN                     *Token
+  );
+
+/**
+  Connect a wireless network specified by a particular SSID, BSS type and
+  Security type.
+
+  @param[in]  This                Pointer to the
+                                  EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL
+                                  instance.
+  @param[in]  Token               Pointer to the token for connecting wireless
+                                  network.
+
+  @retval EFI_SUCCESS             The operation started successfully. Results
+                                  will be notified eventually.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters are not
+                                  supported by this implementation.
+  @retval EFI_ALREADY_STARTED     The connection process is already started.
+  @retval EFI_NOT_FOUND           The specified wireless network is not found.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be
+                                  allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_II_CONNECT_NETWORK) (
+  IN EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL          *This,
+  IN EFI_80211_CONNECT_NETWORK_TOKEN                  *Token
+  );
+
+/**
+  Request a disconnection with current connected wireless network.
+
+  @param[in]  This                Pointer to the
+                                  EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL
+                                  instance.
+  @param[in]  Token               Pointer to the token for disconnecting
+                                  wireless network.
+
+  @retval EFI_SUCCESS             The operation started successfully. Results
+                                  will be notified eventually.
+  @retval EFI_INVALID_PARAMETER   One or more of the following conditions is
+                                  TRUE:
+                                  This is NULL.
+                                  Token is NULL.
+  @retval EFI_UNSUPPORTED         One or more of the input parameters are not
+                                  supported by this implementation.
+  @retval EFI_NOT_FOUND           Not connected to a wireless network.
+  @retval EFI_OUT_OF_RESOURCES    Required system resources could not be
+                                  allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WIRELESS_MAC_CONNECTION_II_DISCONNECT_NETWORK) (
+  IN EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL          *This,
+  IN EFI_80211_DISCONNECT_NETWORK_TOKEN               *Token
+  );
+
+///
+/// The EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL provides network management
+/// service interfaces for 802.11 network stack. It is used by network
+/// applications (and drivers) to establish wireless connection with a wireless
+/// network.
+///
+struct _EFI_WIRELESS_MAC_CONNECTION_II_PROTOCOL {
+  EFI_WIRELESS_MAC_CONNECTION_II_GET_NETWORKS         GetNetworks;
+  EFI_WIRELESS_MAC_CONNECTION_II_CONNECT_NETWORK      ConnectNetwork;
+  EFI_WIRELESS_MAC_CONNECTION_II_DISCONNECT_NETWORK   DisconnectNetwork;
+};
+
+extern EFI_GUID gEfiWiFi2ProtocolGuid;
+
+#endif
diff --git a/MdePkg/Include/Uefi.h b/MdePkg/Include/Uefi.h
new file mode 100644
index 000000000000..4b210131778f
--- /dev/null
+++ b/MdePkg/Include/Uefi.h
@@ -0,0 +1,27 @@
+/** @file
+
+  Root include file for Mde Package UEFI, UEFI_APPLICATION type modules.
+
+  This is the include file for any module of type UEFI and UEFI_APPLICATION. Uefi modules only use 
+  types defined via this include file and can be ported easily to any 
+  environment. 
+
+Copyright (c) 2006 - 2010, 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 __PI_UEFI_H__
+#define __PI_UEFI_H__
+
+#include <Uefi/UefiBaseType.h>
+#include <Uefi/UefiSpec.h>
+
+#endif
+
diff --git a/MdePkg/Include/Uefi/UefiAcpiDataTable.h b/MdePkg/Include/Uefi/UefiAcpiDataTable.h
new file mode 100644
index 000000000000..92999de11c48
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiAcpiDataTable.h
@@ -0,0 +1,60 @@
+/** @file
+  UEFI ACPI Data Table Definition.
+
+Copyright (c) 2011 - 2016, 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 __UEFI_ACPI_DATA_TABLE_H__
+#define __UEFI_ACPI_DATA_TABLE_H__
+
+#include <IndustryStandard/Acpi.h>
+
+#pragma pack(1)
+typedef struct {
+  EFI_ACPI_DESCRIPTION_HEADER   Header;
+  GUID                          Identifier;
+  UINT16                        DataOffset;
+} EFI_ACPI_DATA_TABLE;
+
+typedef struct {
+  EFI_ACPI_DATA_TABLE  UefiAcpiDataTable;
+  UINT32               SwSmiNumber;
+  UINT64               BufferPtrAddress;
+} EFI_SMM_COMMUNICATION_ACPI_TABLE;
+
+typedef struct {
+  EFI_SMM_COMMUNICATION_ACPI_TABLE        UefiSmmCommunicationAcpiTable;
+  EFI_ACPI_6_0_GENERIC_ADDRESS_STRUCTURE  InvocationRegister;
+} EFI_SMM_COMMUNICATION_ACPI_TABLE_2;
+
+///
+/// To avoid confusion in interpreting frames, the communication buffer should always 
+/// begin with EFI_SMM_COMMUNICATE_HEADER
+///
+typedef struct {
+  ///
+  /// Allows for disambiguation of the message format.
+  ///
+  EFI_GUID  HeaderGuid;
+  ///
+  /// Describes the size of Data (in bytes) and does not include the size of the header.
+  ///
+  UINTN     MessageLength;
+  ///
+  /// Designates an array of bytes that is MessageLength in size.
+  ///
+  UINT8     Data[1];
+} EFI_SMM_COMMUNICATE_HEADER;
+
+#pragma pack()
+
+#endif
+
diff --git a/MdePkg/Include/Uefi/UefiBaseType.h b/MdePkg/Include/Uefi/UefiBaseType.h
new file mode 100644
index 000000000000..32b39c9fed17
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiBaseType.h
@@ -0,0 +1,299 @@
+/** @file
+  Defines data types and constants introduced in UEFI.
+
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011 - 2016, ARM Ltd. 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 __UEFI_BASETYPE_H__
+#define __UEFI_BASETYPE_H__
+
+#include <Base.h>
+
+//
+// Basic data type definitions introduced in UEFI.
+//
+
+///
+/// 128-bit buffer containing a unique identifier value.
+///
+typedef GUID                      EFI_GUID;
+///
+/// Function return status for EFI API.
+///
+typedef RETURN_STATUS             EFI_STATUS;
+///
+/// A collection of related interfaces.
+///
+typedef VOID                      *EFI_HANDLE;
+///
+/// Handle to an event structure.
+///
+typedef VOID                      *EFI_EVENT;
+///
+/// Task priority level.
+///
+typedef UINTN                     EFI_TPL;
+///
+/// Logical block address.
+///
+typedef UINT64                    EFI_LBA;
+
+///
+/// 64-bit physical memory address.
+///
+typedef UINT64                    EFI_PHYSICAL_ADDRESS;
+
+///
+/// 64-bit virtual memory address.
+///
+typedef UINT64                    EFI_VIRTUAL_ADDRESS;
+
+///
+/// EFI Time Abstraction:
+///  Year:       1900 - 9999
+///  Month:      1 - 12
+///  Day:        1 - 31
+///  Hour:       0 - 23
+///  Minute:     0 - 59
+///  Second:     0 - 59
+///  Nanosecond: 0 - 999,999,999
+///  TimeZone:   -1440 to 1440 or 2047
+///
+typedef struct {
+  UINT16  Year;
+  UINT8   Month;
+  UINT8   Day;
+  UINT8   Hour;
+  UINT8   Minute;
+  UINT8   Second;
+  UINT8   Pad1;
+  UINT32  Nanosecond;
+  INT16   TimeZone;
+  UINT8   Daylight;
+  UINT8   Pad2;
+} EFI_TIME;
+
+
+///
+/// 4-byte buffer. An IPv4 internet protocol address.
+///
+typedef IPv4_ADDRESS EFI_IPv4_ADDRESS;
+
+///
+/// 16-byte buffer. An IPv6 internet protocol address.
+///
+typedef IPv6_ADDRESS EFI_IPv6_ADDRESS;
+
+///
+/// 32-byte buffer containing a network Media Access Control address.
+///
+typedef struct {
+  UINT8 Addr[32];
+} EFI_MAC_ADDRESS;
+
+///
+/// 16-byte buffer aligned on a 4-byte boundary.
+/// An IPv4 or IPv6 internet protocol address.
+///
+typedef union {
+  UINT32            Addr[4];
+  EFI_IPv4_ADDRESS  v4;
+  EFI_IPv6_ADDRESS  v6;
+} EFI_IP_ADDRESS;
+
+
+///
+/// Enumeration of EFI_STATUS.
+///@{ 
+#define EFI_SUCCESS               RETURN_SUCCESS              
+#define EFI_LOAD_ERROR            RETURN_LOAD_ERROR           
+#define EFI_INVALID_PARAMETER     RETURN_INVALID_PARAMETER    
+#define EFI_UNSUPPORTED           RETURN_UNSUPPORTED          
+#define EFI_BAD_BUFFER_SIZE       RETURN_BAD_BUFFER_SIZE      
+#define EFI_BUFFER_TOO_SMALL      RETURN_BUFFER_TOO_SMALL     
+#define EFI_NOT_READY             RETURN_NOT_READY            
+#define EFI_DEVICE_ERROR          RETURN_DEVICE_ERROR         
+#define EFI_WRITE_PROTECTED       RETURN_WRITE_PROTECTED      
+#define EFI_OUT_OF_RESOURCES      RETURN_OUT_OF_RESOURCES     
+#define EFI_VOLUME_CORRUPTED      RETURN_VOLUME_CORRUPTED     
+#define EFI_VOLUME_FULL           RETURN_VOLUME_FULL          
+#define EFI_NO_MEDIA              RETURN_NO_MEDIA             
+#define EFI_MEDIA_CHANGED         RETURN_MEDIA_CHANGED        
+#define EFI_NOT_FOUND             RETURN_NOT_FOUND            
+#define EFI_ACCESS_DENIED         RETURN_ACCESS_DENIED        
+#define EFI_NO_RESPONSE           RETURN_NO_RESPONSE          
+#define EFI_NO_MAPPING            RETURN_NO_MAPPING           
+#define EFI_TIMEOUT               RETURN_TIMEOUT              
+#define EFI_NOT_STARTED           RETURN_NOT_STARTED          
+#define EFI_ALREADY_STARTED       RETURN_ALREADY_STARTED      
+#define EFI_ABORTED               RETURN_ABORTED              
+#define EFI_ICMP_ERROR            RETURN_ICMP_ERROR           
+#define EFI_TFTP_ERROR            RETURN_TFTP_ERROR           
+#define EFI_PROTOCOL_ERROR        RETURN_PROTOCOL_ERROR       
+#define EFI_INCOMPATIBLE_VERSION  RETURN_INCOMPATIBLE_VERSION 
+#define EFI_SECURITY_VIOLATION    RETURN_SECURITY_VIOLATION   
+#define EFI_CRC_ERROR             RETURN_CRC_ERROR   
+#define EFI_END_OF_MEDIA          RETURN_END_OF_MEDIA
+#define EFI_END_OF_FILE           RETURN_END_OF_FILE
+#define EFI_INVALID_LANGUAGE      RETURN_INVALID_LANGUAGE
+#define EFI_COMPROMISED_DATA      RETURN_COMPROMISED_DATA
+#define EFI_HTTP_ERROR            RETURN_HTTP_ERROR
+
+#define EFI_WARN_UNKNOWN_GLYPH    RETURN_WARN_UNKNOWN_GLYPH   
+#define EFI_WARN_DELETE_FAILURE   RETURN_WARN_DELETE_FAILURE  
+#define EFI_WARN_WRITE_FAILURE    RETURN_WARN_WRITE_FAILURE   
+#define EFI_WARN_BUFFER_TOO_SMALL RETURN_WARN_BUFFER_TOO_SMALL
+#define EFI_WARN_STALE_DATA       RETURN_WARN_STALE_DATA
+#define EFI_WARN_FILE_SYSTEM      RETURN_WARN_FILE_SYSTEM
+///@}
+
+///
+/// Define macro to encode the status code.
+/// 
+#define EFIERR(_a)                ENCODE_ERROR(_a)
+
+#define EFI_ERROR(A)              RETURN_ERROR(A)
+
+///
+/// ICMP error definitions
+///@{
+#define EFI_NETWORK_UNREACHABLE   EFIERR(100)
+#define EFI_HOST_UNREACHABLE      EFIERR(101) 
+#define EFI_PROTOCOL_UNREACHABLE  EFIERR(102)
+#define EFI_PORT_UNREACHABLE      EFIERR(103)
+///@}
+
+///
+/// Tcp connection status definitions
+///@{
+#define EFI_CONNECTION_FIN        EFIERR(104)
+#define EFI_CONNECTION_RESET      EFIERR(105)
+#define EFI_CONNECTION_REFUSED    EFIERR(106)
+///@}
+
+//
+// The EFI memory allocation functions work in units of EFI_PAGEs that are
+// 4KB. This should in no way be confused with the page size of the processor.
+// An EFI_PAGE is just the quanta of memory in EFI.
+//
+#define EFI_PAGE_SIZE             SIZE_4KB
+#define EFI_PAGE_MASK             0xFFF
+#define EFI_PAGE_SHIFT            12
+
+/**
+  Macro that converts a size, in bytes, to a number of EFI_PAGESs.
+
+  @param  Size      A size in bytes.  This parameter is assumed to be type UINTN.  
+                    Passing in a parameter that is larger than UINTN may produce 
+                    unexpected results.
+
+  @return  The number of EFI_PAGESs associated with the number of bytes specified
+           by Size.
+
+**/
+#define EFI_SIZE_TO_PAGES(Size)  (((Size) >> EFI_PAGE_SHIFT) + (((Size) & EFI_PAGE_MASK) ? 1 : 0))
+
+/**
+  Macro that converts a number of EFI_PAGEs to a size in bytes.
+
+  @param  Pages     The number of EFI_PAGES.  This parameter is assumed to be 
+                    type UINTN.  Passing in a parameter that is larger than 
+                    UINTN may produce unexpected results.
+
+  @return  The number of bytes associated with the number of EFI_PAGEs specified 
+           by Pages.
+  
+**/
+#define EFI_PAGES_TO_SIZE(Pages)  ((Pages) << EFI_PAGE_SHIFT)
+
+///
+/// PE32+ Machine type for IA32 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_IA32            0x014C
+
+///
+/// PE32+ Machine type for IA64 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_IA64            0x0200
+
+///
+/// PE32+ Machine type for EBC UEFI images.
+///
+#define EFI_IMAGE_MACHINE_EBC             0x0EBC
+
+///
+/// PE32+ Machine type for X64 UEFI images.
+///
+#define EFI_IMAGE_MACHINE_X64             0x8664
+
+///
+/// PE32+ Machine type for ARM mixed ARM and Thumb/Thumb2 images.
+///
+#define EFI_IMAGE_MACHINE_ARMTHUMB_MIXED  0x01C2
+
+///
+/// PE32+ Machine type for AARCH64 A64 images.
+///
+#define EFI_IMAGE_MACHINE_AARCH64  0xAA64
+
+
+#if   defined (MDE_CPU_IA32)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_IA32) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_X64) 
+
+#elif defined (MDE_CPU_IPF)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_IA64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE) 
+
+#elif defined (MDE_CPU_X64)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_X64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_IA32) 
+
+#elif defined (MDE_CPU_ARM)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_ARMTHUMB_MIXED) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_ARMTHUMB_MIXED) 
+
+#elif defined (MDE_CPU_AARCH64)
+
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
+  (((Machine) == EFI_IMAGE_MACHINE_AARCH64) || ((Machine) == EFI_IMAGE_MACHINE_EBC))
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE)
+
+#elif defined (MDE_CPU_EBC)
+
+///
+/// This is just to make sure you can cross compile with the EBC compiler.
+/// It does not make sense to have a PE loader coded in EBC. 
+///
+#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) ((Machine) == EFI_IMAGE_MACHINE_EBC)
+
+#define EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED(Machine) (FALSE) 
+
+#else
+#error Unknown Processor Type
+#endif
+
+#endif
diff --git a/MdePkg/Include/Uefi/UefiGpt.h b/MdePkg/Include/Uefi/UefiGpt.h
new file mode 100644
index 000000000000..aa3c9bec0b5c
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiGpt.h
@@ -0,0 +1,141 @@
+/** @file
+  EFI Guid Partition Table Format Definition.
+
+Copyright (c) 2006 - 2011, 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 __UEFI_GPT_H__
+#define __UEFI_GPT_H__
+
+///
+/// The primary GUID Partition Table Header must be
+/// located in LBA 1 (i.e., the second logical block).
+///
+#define PRIMARY_PART_HEADER_LBA 1
+///
+/// EFI Partition Table Signature: "EFI PART".
+/// 
+#define EFI_PTAB_HEADER_ID      SIGNATURE_64 ('E','F','I',' ','P','A','R','T')
+
+#pragma pack(1)
+
+///
+/// GPT Partition Table Header.
+///
+typedef struct {
+  ///
+  /// The table header for the GPT partition Table.
+  /// This header contains EFI_PTAB_HEADER_ID.
+  ///
+  EFI_TABLE_HEADER  Header;
+  ///
+  /// The LBA that contains this data structure.
+  ///
+  EFI_LBA           MyLBA;
+  ///
+  /// LBA address of the alternate GUID Partition Table Header.
+  ///
+  EFI_LBA           AlternateLBA;
+  ///
+  /// The first usable logical block that may be used
+  /// by a partition described by a GUID Partition Entry.
+  ///
+  EFI_LBA           FirstUsableLBA;
+  ///
+  /// The last usable logical block that may be used
+  /// by a partition described by a GUID Partition Entry.
+  ///
+  EFI_LBA           LastUsableLBA;
+  ///
+  /// GUID that can be used to uniquely identify the disk.
+  ///
+  EFI_GUID          DiskGUID;
+  ///
+  /// The starting LBA of the GUID Partition Entry array.
+  ///
+  EFI_LBA           PartitionEntryLBA;
+  ///
+  /// The number of Partition Entries in the GUID Partition Entry array.
+  ///
+  UINT32            NumberOfPartitionEntries;
+  ///
+  /// The size, in bytes, of each the GUID Partition
+  /// Entry structures in the GUID Partition Entry
+  /// array. This field shall be set to a value of 128 x 2^n where n is
+  /// an integer greater than or equal to zero (e.g., 128, 256, 512, etc.).
+  ///
+  UINT32            SizeOfPartitionEntry;
+  ///
+  /// The CRC32 of the GUID Partition Entry array.
+  /// Starts at PartitionEntryLBA and is
+  /// computed over a byte length of
+  /// NumberOfPartitionEntries * SizeOfPartitionEntry.
+  ///
+  UINT32            PartitionEntryArrayCRC32;
+} EFI_PARTITION_TABLE_HEADER;
+
+///
+/// GPT Partition Entry.
+///
+typedef struct {
+  ///
+  /// Unique ID that defines the purpose and type of this Partition. A value of
+  /// zero defines that this partition entry is not being used.
+  ///
+  EFI_GUID  PartitionTypeGUID;
+  ///
+  /// GUID that is unique for every partition entry. Every partition ever
+  /// created will have a unique GUID.
+  /// This GUID must be assigned when the GUID Partition Entry is created.
+  ///
+  EFI_GUID  UniquePartitionGUID;
+  ///
+  /// Starting LBA of the partition defined by this entry
+  ///
+  EFI_LBA   StartingLBA;
+  ///
+  /// Ending LBA of the partition defined by this entry.
+  ///
+  EFI_LBA   EndingLBA;
+  ///
+  /// Attribute bits, all bits reserved by UEFI
+  /// Bit 0:      If this bit is set, the partition is required for the platform to function. The owner/creator of the
+  ///             partition indicates that deletion or modification of the contents can result in loss of platform
+  ///             features or failure for the platform to boot or operate. The system cannot function normally if
+  ///             this partition is removed, and it should be considered part of the hardware of the system.
+  ///             Actions such as running diagnostics, system recovery, or even OS install or boot, could
+  ///             potentially stop working if this partition is removed. Unless OS software or firmware
+  ///             recognizes this partition, it should never be removed or modified as the UEFI firmware or
+  ///             platform hardware may become non-functional.
+  /// Bit 1:      If this bit is set, then firmware must not produce an EFI_BLOCK_IO_PROTOCOL device for
+  ///             this partition. By not producing an EFI_BLOCK_IO_PROTOCOL partition, file system
+  ///             mappings will not be created for this partition in UEFI.
+  /// Bit 2:      This bit is set aside to let systems with traditional PC-AT BIOS firmware implementations
+  ///             inform certain limited, special-purpose software running on these systems that a GPT 
+  ///             partition may be bootable. The UEFI boot manager must ignore this bit when selecting
+  ///             a UEFI-compliant application, e.g., an OS loader.
+  /// Bits 3-47:  Undefined and must be zero. Reserved for expansion by future versions of the UEFI
+  ///             specification.
+  /// Bits 48-63: Reserved for GUID specific use. The use of these bits will vary depending on the
+  ///             PartitionTypeGUID. Only the owner of the PartitionTypeGUID is allowed
+  ///             to modify these bits. They must be preserved if Bits 0-47 are modified..
+  ///
+  UINT64    Attributes;
+  ///
+  /// Null-terminated name of the partition.
+  ///
+  CHAR16    PartitionName[36];
+} EFI_PARTITION_ENTRY;
+
+#pragma pack()
+#endif
+
+
diff --git a/MdePkg/Include/Uefi/UefiInternalFormRepresentation.h b/MdePkg/Include/Uefi/UefiInternalFormRepresentation.h
new file mode 100644
index 000000000000..389c12c1f040
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiInternalFormRepresentation.h
@@ -0,0 +1,2135 @@
+/** @file
+  This file defines the encoding for the VFR (Visual Form Representation) language.
+  IFR is primarily consumed by the EFI presentation engine, and produced by EFI
+  internal application and drivers as well as all add-in card option-ROM drivers
+
+Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+(C) Copyright 2016 Hewlett Packard Enterprise Development LP<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.             
+
+  @par Revision Reference:
+  These definitions are from UEFI 2.1 and 2.2.
+
+**/
+
+#ifndef __UEFI_INTERNAL_FORMREPRESENTATION_H__
+#define __UEFI_INTERNAL_FORMREPRESENTATION_H__
+
+#include <Guid/HiiFormMapMethodGuid.h>
+
+///
+/// The following types are currently defined:
+///
+typedef VOID*   EFI_HII_HANDLE;
+typedef CHAR16* EFI_STRING;
+typedef UINT16  EFI_IMAGE_ID;
+typedef UINT16  EFI_QUESTION_ID;
+typedef UINT16  EFI_STRING_ID;
+typedef UINT16  EFI_FORM_ID;
+typedef UINT16  EFI_VARSTORE_ID;
+typedef UINT16  EFI_ANIMATION_ID;
+
+typedef UINT16  EFI_DEFAULT_ID;
+
+typedef UINT32  EFI_HII_FONT_STYLE;
+
+
+
+#pragma pack(1)
+
+//
+// Definitions for Package Lists and Package Headers
+// Section 27.3.1
+//
+
+///
+/// The header found at the start of each package list.
+///
+typedef struct {
+  EFI_GUID               PackageListGuid;
+  UINT32                 PackageLength;
+} EFI_HII_PACKAGE_LIST_HEADER;
+
+///
+/// The header found at the start of each package.
+///
+typedef struct {
+  UINT32  Length:24;
+  UINT32  Type:8;
+  // UINT8  Data[...];
+} EFI_HII_PACKAGE_HEADER;
+
+//
+// Value of HII package type
+// 
+#define EFI_HII_PACKAGE_TYPE_ALL             0x00
+#define EFI_HII_PACKAGE_TYPE_GUID            0x01
+#define EFI_HII_PACKAGE_FORMS                0x02
+#define EFI_HII_PACKAGE_STRINGS              0x04
+#define EFI_HII_PACKAGE_FONTS                0x05
+#define EFI_HII_PACKAGE_IMAGES               0x06
+#define EFI_HII_PACKAGE_SIMPLE_FONTS         0x07
+#define EFI_HII_PACKAGE_DEVICE_PATH          0x08
+#define EFI_HII_PACKAGE_KEYBOARD_LAYOUT      0x09
+#define EFI_HII_PACKAGE_ANIMATIONS           0x0A
+#define EFI_HII_PACKAGE_END                  0xDF
+#define EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN    0xE0
+#define EFI_HII_PACKAGE_TYPE_SYSTEM_END      0xFF
+
+//
+// Definitions for Simplified Font Package
+//
+
+///
+/// Contents of EFI_NARROW_GLYPH.Attributes.
+///@{
+#define EFI_GLYPH_NON_SPACING                0x01
+#define EFI_GLYPH_WIDE                       0x02
+#define EFI_GLYPH_HEIGHT                     19
+#define EFI_GLYPH_WIDTH                      8
+///@}
+
+///
+/// The EFI_NARROW_GLYPH has a preferred dimension (w x h) of 8 x 19 pixels.
+///
+typedef struct {
+  ///
+  /// The Unicode representation of the glyph. The term weight is the 
+  /// technical term for a character code.
+  ///
+  CHAR16                 UnicodeWeight;
+  ///
+  /// The data element containing the glyph definitions.
+  ///
+  UINT8                  Attributes;
+  ///
+  /// The column major glyph representation of the character. Bits 
+  /// with values of one indicate that the corresponding pixel is to be
+  /// on when normally displayed; those with zero are off.
+  ///
+  UINT8                  GlyphCol1[EFI_GLYPH_HEIGHT];
+} EFI_NARROW_GLYPH;
+
+///
+/// The EFI_WIDE_GLYPH has a preferred dimension (w x h) of 16 x 19 pixels, which is large enough 
+/// to accommodate logographic characters.
+///
+typedef struct {
+  ///
+  /// The Unicode representation of the glyph. The term weight is the 
+  /// technical term for a character code.
+  ///
+  CHAR16                 UnicodeWeight;
+  ///
+  /// The data element containing the glyph definitions.
+  ///
+  UINT8                  Attributes;
+  ///
+  /// The column major glyph representation of the character. Bits 
+  /// with values of one indicate that the corresponding pixel is to be 
+  /// on when normally displayed; those with zero are off.
+  ///
+  UINT8                  GlyphCol1[EFI_GLYPH_HEIGHT];
+  ///
+  /// The column major glyph representation of the character. Bits 
+  /// with values of one indicate that the corresponding pixel is to be 
+  /// on when normally displayed; those with zero are off.
+  ///
+  UINT8                  GlyphCol2[EFI_GLYPH_HEIGHT];
+  ///
+  /// Ensures that sizeof (EFI_WIDE_GLYPH) is twice the 
+  /// sizeof (EFI_NARROW_GLYPH). The contents of Pad must 
+  /// be zero.
+  ///
+  UINT8                  Pad[3];
+} EFI_WIDE_GLYPH;
+
+///
+/// A simplified font package consists of a font header
+/// followed by a series of glyph structures.
+///
+typedef struct _EFI_HII_SIMPLE_FONT_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER Header;
+  UINT16                 NumberOfNarrowGlyphs;
+  UINT16                 NumberOfWideGlyphs;
+  // EFI_NARROW_GLYPH       NarrowGlyphs[];
+  // EFI_WIDE_GLYPH         WideGlyphs[];
+} EFI_HII_SIMPLE_FONT_PACKAGE_HDR;
+
+//
+// Definitions for Font Package
+// Section 27.3.3
+//
+
+//
+// Value for font style
+//
+#define EFI_HII_FONT_STYLE_NORMAL            0x00000000
+#define EFI_HII_FONT_STYLE_BOLD              0x00000001
+#define EFI_HII_FONT_STYLE_ITALIC            0x00000002
+#define EFI_HII_FONT_STYLE_EMBOSS            0x00010000
+#define EFI_HII_FONT_STYLE_OUTLINE           0x00020000
+#define EFI_HII_FONT_STYLE_SHADOW            0x00040000
+#define EFI_HII_FONT_STYLE_UNDERLINE         0x00080000
+#define EFI_HII_FONT_STYLE_DBL_UNDER         0x00100000
+
+typedef struct _EFI_HII_GLYPH_INFO {
+  UINT16                 Width;
+  UINT16                 Height;
+  INT16                  OffsetX;
+  INT16                  OffsetY;
+  INT16                  AdvanceX;
+} EFI_HII_GLYPH_INFO;
+
+///
+/// The fixed header consists of a standard record header,
+/// then the character values in this section, the flags
+/// (including the encoding method) and the offsets of the glyph
+/// information, the glyph bitmaps and the character map.
+///
+typedef struct _EFI_HII_FONT_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER Header;
+  UINT32                 HdrSize;
+  UINT32                 GlyphBlockOffset;
+  EFI_HII_GLYPH_INFO     Cell;
+  EFI_HII_FONT_STYLE     FontStyle;
+  CHAR16                 FontFamily[1];
+} EFI_HII_FONT_PACKAGE_HDR;
+
+//
+// Value of different glyph info block types
+//
+#define EFI_HII_GIBT_END                  0x00
+#define EFI_HII_GIBT_GLYPH                0x10
+#define EFI_HII_GIBT_GLYPHS               0x11
+#define EFI_HII_GIBT_GLYPH_DEFAULT        0x12
+#define EFI_HII_GIBT_GLYPHS_DEFAULT       0x13
+#define EFI_HII_GIBT_GLYPH_VARIABILITY    0x14
+#define EFI_HII_GIBT_DUPLICATE            0x20
+#define EFI_HII_GIBT_SKIP2                0x21
+#define EFI_HII_GIBT_SKIP1                0x22
+#define EFI_HII_GIBT_DEFAULTS             0x23
+#define EFI_HII_GIBT_EXT1                 0x30
+#define EFI_HII_GIBT_EXT2                 0x31
+#define EFI_HII_GIBT_EXT4                 0x32
+
+typedef struct _EFI_HII_GLYPH_BLOCK {
+  UINT8                  BlockType;
+} EFI_HII_GLYPH_BLOCK;
+
+//
+// Definition of different glyph info block types
+//
+
+typedef struct _EFI_HII_GIBT_DEFAULTS_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  EFI_HII_GLYPH_INFO     Cell;
+} EFI_HII_GIBT_DEFAULTS_BLOCK;
+
+typedef struct _EFI_HII_GIBT_DUPLICATE_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  CHAR16                 CharValue;
+} EFI_HII_GIBT_DUPLICATE_BLOCK;
+
+typedef struct _EFI_GLYPH_GIBT_END_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+} EFI_GLYPH_GIBT_END_BLOCK;
+
+typedef struct _EFI_HII_GIBT_EXT1_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT8                  BlockType2;
+  UINT8                  Length;
+} EFI_HII_GIBT_EXT1_BLOCK;
+
+typedef struct _EFI_HII_GIBT_EXT2_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT8                  BlockType2;
+  UINT16                 Length;
+} EFI_HII_GIBT_EXT2_BLOCK;
+
+typedef struct _EFI_HII_GIBT_EXT4_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT8                  BlockType2;
+  UINT32                 Length;
+} EFI_HII_GIBT_EXT4_BLOCK;
+
+typedef struct _EFI_HII_GIBT_GLYPH_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  EFI_HII_GLYPH_INFO     Cell;
+  UINT8                  BitmapData[1];
+} EFI_HII_GIBT_GLYPH_BLOCK;
+
+typedef struct _EFI_HII_GIBT_GLYPHS_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  EFI_HII_GLYPH_INFO     Cell;
+  UINT16                 Count;  
+  UINT8                  BitmapData[1];
+} EFI_HII_GIBT_GLYPHS_BLOCK;
+
+typedef struct _EFI_HII_GIBT_GLYPH_DEFAULT_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT8                  BitmapData[1];
+} EFI_HII_GIBT_GLYPH_DEFAULT_BLOCK;
+
+typedef struct _EFI_HII_GIBT_GLYPHS_DEFAULT_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT16                 Count;
+  UINT8                  BitmapData[1];
+} EFI_HII_GIBT_GLYPHS_DEFAULT_BLOCK;
+
+typedef struct _EFI_HII_GIBT_VARIABILITY_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  EFI_HII_GLYPH_INFO     Cell;
+  UINT8                  GlyphPackInBits;
+  UINT8                  BitmapData [1];
+} EFI_HII_GIBT_VARIABILITY_BLOCK;
+
+typedef struct _EFI_HII_GIBT_SKIP1_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT8                  SkipCount;
+} EFI_HII_GIBT_SKIP1_BLOCK;
+
+typedef struct _EFI_HII_GIBT_SKIP2_BLOCK {
+  EFI_HII_GLYPH_BLOCK    Header;
+  UINT16                 SkipCount;
+} EFI_HII_GIBT_SKIP2_BLOCK;
+
+//
+// Definitions for Device Path Package
+// Section 27.3.4
+//
+
+///
+/// The device path package is used to carry a device path
+/// associated with the package list.
+///
+typedef struct _EFI_HII_DEVICE_PATH_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER   Header;
+  // EFI_DEVICE_PATH_PROTOCOL DevicePath[];
+} EFI_HII_DEVICE_PATH_PACKAGE_HDR;
+
+//
+// Definitions for GUID Package
+// Section 27.3.5
+//
+
+///
+/// The GUID package is used to carry data where the format is defined by a GUID.
+///
+typedef struct _EFI_HII_GUID_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER  Header;
+  EFI_GUID                Guid;
+  // Data per GUID definition may follow
+} EFI_HII_GUID_PACKAGE_HDR;
+
+//
+// Definitions for String Package
+// Section 27.3.6
+//
+
+#define UEFI_CONFIG_LANG   "x-UEFI"
+#define UEFI_CONFIG_LANG_2 "x-i-UEFI"
+
+///
+/// The fixed header consists of a standard record header and then the string identifiers
+/// contained in this section and the offsets of the string and language information.
+///
+typedef struct _EFI_HII_STRING_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER  Header;
+  UINT32                  HdrSize;
+  UINT32                  StringInfoOffset;
+  CHAR16                  LanguageWindow[16];
+  EFI_STRING_ID           LanguageName;
+  CHAR8                   Language[1];
+} EFI_HII_STRING_PACKAGE_HDR;
+
+typedef struct {
+  UINT8                   BlockType;
+} EFI_HII_STRING_BLOCK;
+
+//
+// Value of different string information block types
+//
+#define EFI_HII_SIBT_END                     0x00
+#define EFI_HII_SIBT_STRING_SCSU             0x10
+#define EFI_HII_SIBT_STRING_SCSU_FONT        0x11
+#define EFI_HII_SIBT_STRINGS_SCSU            0x12
+#define EFI_HII_SIBT_STRINGS_SCSU_FONT       0x13
+#define EFI_HII_SIBT_STRING_UCS2             0x14
+#define EFI_HII_SIBT_STRING_UCS2_FONT        0x15
+#define EFI_HII_SIBT_STRINGS_UCS2            0x16
+#define EFI_HII_SIBT_STRINGS_UCS2_FONT       0x17
+#define EFI_HII_SIBT_DUPLICATE               0x20
+#define EFI_HII_SIBT_SKIP2                   0x21
+#define EFI_HII_SIBT_SKIP1                   0x22
+#define EFI_HII_SIBT_EXT1                    0x30
+#define EFI_HII_SIBT_EXT2                    0x31
+#define EFI_HII_SIBT_EXT4                    0x32
+#define EFI_HII_SIBT_FONT                    0x40
+
+//
+// Definition of different string information block types
+//
+
+typedef struct _EFI_HII_SIBT_DUPLICATE_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  EFI_STRING_ID           StringId;
+} EFI_HII_SIBT_DUPLICATE_BLOCK;
+
+typedef struct _EFI_HII_SIBT_END_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+} EFI_HII_SIBT_END_BLOCK;
+
+typedef struct _EFI_HII_SIBT_EXT1_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   BlockType2;
+  UINT8                   Length;
+} EFI_HII_SIBT_EXT1_BLOCK;
+
+typedef struct _EFI_HII_SIBT_EXT2_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   BlockType2;
+  UINT16                  Length;
+} EFI_HII_SIBT_EXT2_BLOCK;
+
+typedef struct _EFI_HII_SIBT_EXT4_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   BlockType2;
+  UINT32                  Length;
+} EFI_HII_SIBT_EXT4_BLOCK;
+
+typedef struct _EFI_HII_SIBT_FONT_BLOCK {
+  EFI_HII_SIBT_EXT2_BLOCK Header;
+  UINT8                   FontId;
+  UINT16                  FontSize;
+  EFI_HII_FONT_STYLE      FontStyle;
+  CHAR16                  FontName[1];
+} EFI_HII_SIBT_FONT_BLOCK;
+
+typedef struct _EFI_HII_SIBT_SKIP1_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   SkipCount;
+} EFI_HII_SIBT_SKIP1_BLOCK;
+
+typedef struct _EFI_HII_SIBT_SKIP2_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT16                  SkipCount;
+} EFI_HII_SIBT_SKIP2_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRING_SCSU_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   StringText[1];
+} EFI_HII_SIBT_STRING_SCSU_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   FontIdentifier;
+  UINT8                   StringText[1];
+} EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRINGS_SCSU_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT16                  StringCount;
+  UINT8                   StringText[1];
+} EFI_HII_SIBT_STRINGS_SCSU_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   FontIdentifier;
+  UINT16                  StringCount;
+  UINT8                   StringText[1];
+} EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRING_UCS2_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  CHAR16                  StringText[1];
+} EFI_HII_SIBT_STRING_UCS2_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   FontIdentifier;
+  CHAR16                  StringText[1];
+} EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRINGS_UCS2_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT16                  StringCount;
+  CHAR16                  StringText[1];
+} EFI_HII_SIBT_STRINGS_UCS2_BLOCK;
+
+typedef struct _EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK {
+  EFI_HII_STRING_BLOCK    Header;
+  UINT8                   FontIdentifier;
+  UINT16                  StringCount;
+  CHAR16                  StringText[1];
+} EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK;
+
+//
+// Definitions for Image Package
+// Section 27.3.7
+//
+
+typedef struct _EFI_HII_IMAGE_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER  Header;
+  UINT32                  ImageInfoOffset;
+  UINT32                  PaletteInfoOffset;
+} EFI_HII_IMAGE_PACKAGE_HDR;
+
+typedef struct _EFI_HII_IMAGE_BLOCK {
+  UINT8                   BlockType;
+} EFI_HII_IMAGE_BLOCK;
+
+//
+// Value of different image information block types
+//
+#define EFI_HII_IIBT_END               0x00
+#define EFI_HII_IIBT_IMAGE_1BIT        0x10
+#define EFI_HII_IIBT_IMAGE_1BIT_TRANS  0x11
+#define EFI_HII_IIBT_IMAGE_4BIT        0x12
+#define EFI_HII_IIBT_IMAGE_4BIT_TRANS  0x13
+#define EFI_HII_IIBT_IMAGE_8BIT        0x14
+#define EFI_HII_IIBT_IMAGE_8BIT_TRANS  0x15
+#define EFI_HII_IIBT_IMAGE_24BIT       0x16
+#define EFI_HII_IIBT_IMAGE_24BIT_TRANS 0x17
+#define EFI_HII_IIBT_IMAGE_JPEG        0x18
+#define EFI_HII_IIBT_IMAGE_PNG         0x19
+#define EFI_HII_IIBT_DUPLICATE         0x20
+#define EFI_HII_IIBT_SKIP2             0x21
+#define EFI_HII_IIBT_SKIP1             0x22
+#define EFI_HII_IIBT_EXT1              0x30
+#define EFI_HII_IIBT_EXT2              0x31
+#define EFI_HII_IIBT_EXT4              0x32
+
+//
+// Definition of different image information block types
+//
+
+typedef struct _EFI_HII_IIBT_END_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+} EFI_HII_IIBT_END_BLOCK;
+
+typedef struct _EFI_HII_IIBT_EXT1_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        BlockType2;
+  UINT8                        Length;
+} EFI_HII_IIBT_EXT1_BLOCK;
+
+typedef struct _EFI_HII_IIBT_EXT2_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        BlockType2;
+  UINT16                       Length;
+} EFI_HII_IIBT_EXT2_BLOCK;
+
+typedef struct _EFI_HII_IIBT_EXT4_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        BlockType2;
+  UINT32                       Length;
+} EFI_HII_IIBT_EXT4_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_1BIT_BASE {
+  UINT16                       Width;
+  UINT16                       Height;
+  UINT8                        Data[1];
+} EFI_HII_IIBT_IMAGE_1BIT_BASE;
+
+typedef struct _EFI_HII_IIBT_IMAGE_1BIT_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_1BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_1BIT_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_1BIT_TRANS_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_1BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_1BIT_TRANS_BLOCK;
+
+typedef struct _EFI_HII_RGB_PIXEL {
+  UINT8                        b;
+  UINT8                        g;
+  UINT8                        r;
+} EFI_HII_RGB_PIXEL;
+
+typedef struct _EFI_HII_IIBT_IMAGE_24BIT_BASE {
+  UINT16                       Width;
+  UINT16                       Height;
+  EFI_HII_RGB_PIXEL            Bitmap[1];
+} EFI_HII_IIBT_IMAGE_24BIT_BASE;
+
+typedef struct _EFI_HII_IIBT_IMAGE_24BIT_BLOCK {
+  EFI_HII_IMAGE_BLOCK           Header;
+  EFI_HII_IIBT_IMAGE_24BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_24BIT_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_24BIT_TRANS_BLOCK {
+  EFI_HII_IMAGE_BLOCK           Header;
+  EFI_HII_IIBT_IMAGE_24BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_24BIT_TRANS_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_4BIT_BASE {
+  UINT16                       Width;
+  UINT16                       Height;
+  UINT8                        Data[1];
+} EFI_HII_IIBT_IMAGE_4BIT_BASE;
+
+typedef struct _EFI_HII_IIBT_IMAGE_4BIT_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_4BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_4BIT_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_4BIT_TRANS_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_4BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_4BIT_TRANS_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_8BIT_BASE {
+  UINT16                       Width;
+  UINT16                       Height;
+  UINT8                        Data[1];
+} EFI_HII_IIBT_IMAGE_8BIT_BASE;
+
+typedef struct _EFI_HII_IIBT_IMAGE_8BIT_PALETTE_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_8BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_8BIT_BLOCK;
+
+typedef struct _EFI_HII_IIBT_IMAGE_8BIT_TRANS_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        PaletteIndex;
+  EFI_HII_IIBT_IMAGE_8BIT_BASE Bitmap;
+} EFI_HII_IIBT_IMAGE_8BIT_TRAN_BLOCK;
+
+typedef struct _EFI_HII_IIBT_DUPLICATE_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  EFI_IMAGE_ID                 ImageId;
+} EFI_HII_IIBT_DUPLICATE_BLOCK;
+
+typedef struct _EFI_HII_IIBT_JPEG_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT32                       Size;
+  UINT8                        Data[1];
+} EFI_HII_IIBT_JPEG_BLOCK;
+
+typedef struct _EFI_HII_IIBT_PNG_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT32                       Size;
+  UINT8                        Data[1];
+} EFI_HII_IIBT_PNG_BLOCK;
+
+typedef struct _EFI_HII_IIBT_SKIP1_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT8                        SkipCount;
+} EFI_HII_IIBT_SKIP1_BLOCK;
+
+typedef struct _EFI_HII_IIBT_SKIP2_BLOCK {
+  EFI_HII_IMAGE_BLOCK          Header;
+  UINT16                       SkipCount;
+} EFI_HII_IIBT_SKIP2_BLOCK;
+
+//
+// Definitions for Palette Information
+//
+
+typedef struct _EFI_HII_IMAGE_PALETTE_INFO_HEADER {
+  UINT16                       PaletteCount;
+} EFI_HII_IMAGE_PALETTE_INFO_HEADER;
+
+typedef struct _EFI_HII_IMAGE_PALETTE_INFO {
+  UINT16                       PaletteSize;
+  EFI_HII_RGB_PIXEL            PaletteValue[1];
+} EFI_HII_IMAGE_PALETTE_INFO;
+
+//
+// Definitions for Forms Package
+// Section 27.3.8
+//
+
+///
+/// The Form package is used to carry form-based encoding data.
+///
+typedef struct _EFI_HII_FORM_PACKAGE_HDR {
+  EFI_HII_PACKAGE_HEADER       Header;
+  // EFI_IFR_OP_HEADER         OpCodeHeader;
+  // More op-codes follow
+} EFI_HII_FORM_PACKAGE_HDR;
+
+typedef struct {
+  UINT8 Hour;
+  UINT8 Minute;
+  UINT8 Second;
+} EFI_HII_TIME;
+
+typedef struct {
+  UINT16 Year;
+  UINT8  Month;
+  UINT8  Day;
+} EFI_HII_DATE;
+
+typedef struct {
+  EFI_QUESTION_ID QuestionId;
+  EFI_FORM_ID     FormId;
+  EFI_GUID        FormSetGuid;
+  EFI_STRING_ID   DevicePath;
+} EFI_HII_REF;
+
+typedef union {
+  UINT8           u8;
+  UINT16          u16;
+  UINT32          u32;
+  UINT64          u64;
+  BOOLEAN         b;
+  EFI_HII_TIME    time;
+  EFI_HII_DATE    date;
+  EFI_STRING_ID   string; ///< EFI_IFR_TYPE_STRING, EFI_IFR_TYPE_ACTION
+  EFI_HII_REF     ref;    ///< EFI_IFR_TYPE_REF
+  // UINT8 buffer[];      ///< EFI_IFR_TYPE_BUFFER
+} EFI_IFR_TYPE_VALUE;
+
+//
+// IFR Opcodes
+//
+#define EFI_IFR_FORM_OP                0x01
+#define EFI_IFR_SUBTITLE_OP            0x02
+#define EFI_IFR_TEXT_OP                0x03
+#define EFI_IFR_IMAGE_OP               0x04
+#define EFI_IFR_ONE_OF_OP              0x05
+#define EFI_IFR_CHECKBOX_OP            0x06
+#define EFI_IFR_NUMERIC_OP             0x07
+#define EFI_IFR_PASSWORD_OP            0x08
+#define EFI_IFR_ONE_OF_OPTION_OP       0x09
+#define EFI_IFR_SUPPRESS_IF_OP         0x0A
+#define EFI_IFR_LOCKED_OP              0x0B
+#define EFI_IFR_ACTION_OP              0x0C
+#define EFI_IFR_RESET_BUTTON_OP        0x0D
+#define EFI_IFR_FORM_SET_OP            0x0E
+#define EFI_IFR_REF_OP                 0x0F
+#define EFI_IFR_NO_SUBMIT_IF_OP        0x10
+#define EFI_IFR_INCONSISTENT_IF_OP     0x11
+#define EFI_IFR_EQ_ID_VAL_OP           0x12
+#define EFI_IFR_EQ_ID_ID_OP            0x13
+#define EFI_IFR_EQ_ID_VAL_LIST_OP      0x14
+#define EFI_IFR_AND_OP                 0x15
+#define EFI_IFR_OR_OP                  0x16
+#define EFI_IFR_NOT_OP                 0x17
+#define EFI_IFR_RULE_OP                0x18
+#define EFI_IFR_GRAY_OUT_IF_OP         0x19
+#define EFI_IFR_DATE_OP                0x1A
+#define EFI_IFR_TIME_OP                0x1B
+#define EFI_IFR_STRING_OP              0x1C
+#define EFI_IFR_REFRESH_OP             0x1D
+#define EFI_IFR_DISABLE_IF_OP          0x1E
+#define EFI_IFR_ANIMATION_OP           0x1F
+#define EFI_IFR_TO_LOWER_OP            0x20
+#define EFI_IFR_TO_UPPER_OP            0x21
+#define EFI_IFR_MAP_OP                 0x22
+#define EFI_IFR_ORDERED_LIST_OP        0x23
+#define EFI_IFR_VARSTORE_OP            0x24
+#define EFI_IFR_VARSTORE_NAME_VALUE_OP 0x25
+#define EFI_IFR_VARSTORE_EFI_OP        0x26
+#define EFI_IFR_VARSTORE_DEVICE_OP     0x27
+#define EFI_IFR_VERSION_OP             0x28
+#define EFI_IFR_END_OP                 0x29
+#define EFI_IFR_MATCH_OP               0x2A
+#define EFI_IFR_GET_OP                 0x2B
+#define EFI_IFR_SET_OP                 0x2C
+#define EFI_IFR_READ_OP                0x2D
+#define EFI_IFR_WRITE_OP               0x2E
+#define EFI_IFR_EQUAL_OP               0x2F
+#define EFI_IFR_NOT_EQUAL_OP           0x30
+#define EFI_IFR_GREATER_THAN_OP        0x31
+#define EFI_IFR_GREATER_EQUAL_OP       0x32
+#define EFI_IFR_LESS_THAN_OP           0x33
+#define EFI_IFR_LESS_EQUAL_OP          0x34
+#define EFI_IFR_BITWISE_AND_OP         0x35
+#define EFI_IFR_BITWISE_OR_OP          0x36
+#define EFI_IFR_BITWISE_NOT_OP         0x37
+#define EFI_IFR_SHIFT_LEFT_OP          0x38
+#define EFI_IFR_SHIFT_RIGHT_OP         0x39
+#define EFI_IFR_ADD_OP                 0x3A
+#define EFI_IFR_SUBTRACT_OP            0x3B
+#define EFI_IFR_MULTIPLY_OP            0x3C
+#define EFI_IFR_DIVIDE_OP              0x3D
+#define EFI_IFR_MODULO_OP              0x3E
+#define EFI_IFR_RULE_REF_OP            0x3F
+#define EFI_IFR_QUESTION_REF1_OP       0x40
+#define EFI_IFR_QUESTION_REF2_OP       0x41
+#define EFI_IFR_UINT8_OP               0x42
+#define EFI_IFR_UINT16_OP              0x43
+#define EFI_IFR_UINT32_OP              0x44
+#define EFI_IFR_UINT64_OP              0x45
+#define EFI_IFR_TRUE_OP                0x46
+#define EFI_IFR_FALSE_OP               0x47
+#define EFI_IFR_TO_UINT_OP             0x48
+#define EFI_IFR_TO_STRING_OP           0x49
+#define EFI_IFR_TO_BOOLEAN_OP          0x4A
+#define EFI_IFR_MID_OP                 0x4B
+#define EFI_IFR_FIND_OP                0x4C
+#define EFI_IFR_TOKEN_OP               0x4D
+#define EFI_IFR_STRING_REF1_OP         0x4E
+#define EFI_IFR_STRING_REF2_OP         0x4F
+#define EFI_IFR_CONDITIONAL_OP         0x50
+#define EFI_IFR_QUESTION_REF3_OP       0x51
+#define EFI_IFR_ZERO_OP                0x52
+#define EFI_IFR_ONE_OP                 0x53
+#define EFI_IFR_ONES_OP                0x54
+#define EFI_IFR_UNDEFINED_OP           0x55
+#define EFI_IFR_LENGTH_OP              0x56
+#define EFI_IFR_DUP_OP                 0x57
+#define EFI_IFR_THIS_OP                0x58
+#define EFI_IFR_SPAN_OP                0x59
+#define EFI_IFR_VALUE_OP               0x5A
+#define EFI_IFR_DEFAULT_OP             0x5B
+#define EFI_IFR_DEFAULTSTORE_OP        0x5C
+#define EFI_IFR_FORM_MAP_OP            0x5D
+#define EFI_IFR_CATENATE_OP            0x5E
+#define EFI_IFR_GUID_OP                0x5F
+#define EFI_IFR_SECURITY_OP            0x60
+#define EFI_IFR_MODAL_TAG_OP           0x61
+#define EFI_IFR_REFRESH_ID_OP          0x62
+#define EFI_IFR_WARNING_IF_OP          0x63
+#define EFI_IFR_MATCH2_OP              0x64
+
+//
+// Definitions of IFR Standard Headers
+// Section 27.3.8.2
+//
+
+typedef struct _EFI_IFR_OP_HEADER {
+  UINT8                    OpCode;
+  UINT8                    Length:7;
+  UINT8                    Scope:1;
+} EFI_IFR_OP_HEADER;
+
+typedef struct _EFI_IFR_STATEMENT_HEADER {
+  EFI_STRING_ID            Prompt;
+  EFI_STRING_ID            Help;
+} EFI_IFR_STATEMENT_HEADER;
+
+typedef struct _EFI_IFR_QUESTION_HEADER {
+  EFI_IFR_STATEMENT_HEADER Header;
+  EFI_QUESTION_ID          QuestionId;
+  EFI_VARSTORE_ID          VarStoreId;
+  union {
+    EFI_STRING_ID          VarName;
+    UINT16                 VarOffset;
+  }                        VarStoreInfo;
+  UINT8                    Flags;
+} EFI_IFR_QUESTION_HEADER;
+
+//
+// Flag values of EFI_IFR_QUESTION_HEADER
+//
+#define EFI_IFR_FLAG_READ_ONLY          0x01
+#define EFI_IFR_FLAG_CALLBACK           0x04
+#define EFI_IFR_FLAG_RESET_REQUIRED     0x10
+#define EFI_IFR_FLAG_RECONNECT_REQUIRED 0x40
+#define EFI_IFR_FLAG_OPTIONS_ONLY       0x80
+
+//
+// Definition for Opcode Reference
+// Section 27.3.8.3
+//
+typedef struct _EFI_IFR_DEFAULTSTORE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            DefaultName;
+  UINT16                   DefaultId;
+} EFI_IFR_DEFAULTSTORE;
+
+//
+// Default Identifier of default store 
+//
+#define EFI_HII_DEFAULT_CLASS_STANDARD       0x0000
+#define EFI_HII_DEFAULT_CLASS_MANUFACTURING  0x0001
+#define EFI_HII_DEFAULT_CLASS_SAFE           0x0002
+#define EFI_HII_DEFAULT_CLASS_PLATFORM_BEGIN 0x4000
+#define EFI_HII_DEFAULT_CLASS_PLATFORM_END   0x7fff
+#define EFI_HII_DEFAULT_CLASS_HARDWARE_BEGIN 0x8000
+#define EFI_HII_DEFAULT_CLASS_HARDWARE_END   0xbfff
+#define EFI_HII_DEFAULT_CLASS_FIRMWARE_BEGIN 0xc000
+#define EFI_HII_DEFAULT_CLASS_FIRMWARE_END   0xffff
+
+typedef struct _EFI_IFR_VARSTORE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_GUID                 Guid;
+  EFI_VARSTORE_ID          VarStoreId;
+  UINT16                   Size;
+  UINT8                    Name[1];
+} EFI_IFR_VARSTORE;
+
+typedef struct _EFI_IFR_VARSTORE_EFI {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_VARSTORE_ID          VarStoreId;
+  EFI_GUID                 Guid;
+  UINT32                   Attributes;
+  UINT16                   Size;
+  UINT8                    Name[1];
+} EFI_IFR_VARSTORE_EFI;
+
+typedef struct _EFI_IFR_VARSTORE_NAME_VALUE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_VARSTORE_ID          VarStoreId;
+  EFI_GUID                 Guid;
+} EFI_IFR_VARSTORE_NAME_VALUE;
+
+typedef struct _EFI_IFR_FORM_SET {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_GUID                 Guid;
+  EFI_STRING_ID            FormSetTitle;
+  EFI_STRING_ID            Help;
+  UINT8                    Flags;
+  // EFI_GUID              ClassGuid[];
+} EFI_IFR_FORM_SET;
+
+typedef struct _EFI_IFR_END {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_END;
+
+typedef struct _EFI_IFR_FORM {
+  EFI_IFR_OP_HEADER        Header;
+  UINT16                   FormId;
+  EFI_STRING_ID            FormTitle;
+} EFI_IFR_FORM;
+
+typedef struct _EFI_IFR_IMAGE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IMAGE_ID             Id;
+} EFI_IFR_IMAGE;
+
+typedef struct _EFI_IFR_MODAL_TAG {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_MODAL_TAG;
+
+typedef struct _EFI_IFR_LOCKED {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_LOCKED;
+
+typedef struct _EFI_IFR_RULE {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    RuleId;
+} EFI_IFR_RULE;
+
+typedef struct _EFI_IFR_DEFAULT {
+  EFI_IFR_OP_HEADER        Header;
+  UINT16                   DefaultId;
+  UINT8                    Type;
+  EFI_IFR_TYPE_VALUE       Value;
+} EFI_IFR_DEFAULT;
+
+typedef struct _EFI_IFR_DEFAULT_2 {
+  EFI_IFR_OP_HEADER        Header;
+  UINT16                   DefaultId;
+  UINT8                    Type;
+} EFI_IFR_DEFAULT_2;
+
+typedef struct _EFI_IFR_VALUE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_VALUE;
+
+typedef struct _EFI_IFR_SUBTITLE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_STATEMENT_HEADER Statement;
+  UINT8                    Flags;
+} EFI_IFR_SUBTITLE;
+
+#define EFI_IFR_FLAGS_HORIZONTAL       0x01
+
+typedef struct _EFI_IFR_CHECKBOX {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    Flags;
+} EFI_IFR_CHECKBOX;
+
+#define EFI_IFR_CHECKBOX_DEFAULT       0x01
+#define EFI_IFR_CHECKBOX_DEFAULT_MFG   0x02
+
+typedef struct _EFI_IFR_TEXT {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_STATEMENT_HEADER Statement;
+  EFI_STRING_ID            TextTwo;
+} EFI_IFR_TEXT;
+
+typedef struct _EFI_IFR_REF {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  EFI_FORM_ID              FormId;
+} EFI_IFR_REF;
+
+typedef struct _EFI_IFR_REF2 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  EFI_FORM_ID              FormId;
+  EFI_QUESTION_ID          QuestionId;
+} EFI_IFR_REF2;
+
+typedef struct _EFI_IFR_REF3 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  EFI_FORM_ID              FormId;
+  EFI_QUESTION_ID          QuestionId;
+  EFI_GUID                 FormSetId;
+} EFI_IFR_REF3;
+
+typedef struct _EFI_IFR_REF4 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  EFI_FORM_ID              FormId;
+  EFI_QUESTION_ID          QuestionId;
+  EFI_GUID                 FormSetId;
+  EFI_STRING_ID            DevicePath;
+} EFI_IFR_REF4;
+
+typedef struct _EFI_IFR_REF5 {
+  EFI_IFR_OP_HEADER Header;
+  EFI_IFR_QUESTION_HEADER Question;
+} EFI_IFR_REF5;
+
+typedef struct _EFI_IFR_RESET_BUTTON {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_STATEMENT_HEADER Statement;
+  EFI_DEFAULT_ID           DefaultId;
+} EFI_IFR_RESET_BUTTON;
+
+typedef struct _EFI_IFR_ACTION {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  EFI_STRING_ID            QuestionConfig;
+} EFI_IFR_ACTION;
+
+typedef struct _EFI_IFR_ACTION_1 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+} EFI_IFR_ACTION_1;
+
+typedef struct _EFI_IFR_DATE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    Flags;
+} EFI_IFR_DATE;
+
+//
+// Flags that describe the behavior of the question.
+//
+#define EFI_QF_DATE_YEAR_SUPPRESS      0x01
+#define EFI_QF_DATE_MONTH_SUPPRESS     0x02
+#define EFI_QF_DATE_DAY_SUPPRESS       0x04
+
+#define EFI_QF_DATE_STORAGE            0x30
+#define     QF_DATE_STORAGE_NORMAL     0x00
+#define     QF_DATE_STORAGE_TIME       0x10
+#define     QF_DATE_STORAGE_WAKEUP     0x20
+
+typedef union {
+  struct {
+    UINT8 MinValue;
+    UINT8 MaxValue;
+    UINT8 Step;
+  } u8;
+  struct {
+    UINT16 MinValue;
+    UINT16 MaxValue;
+    UINT16 Step;
+  } u16;
+  struct {
+    UINT32 MinValue;
+    UINT32 MaxValue;
+    UINT32 Step;
+  } u32;
+  struct {
+    UINT64 MinValue;
+    UINT64 MaxValue;
+    UINT64 Step;
+  } u64;
+} MINMAXSTEP_DATA;
+
+typedef struct _EFI_IFR_NUMERIC {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    Flags;
+  MINMAXSTEP_DATA          data;
+} EFI_IFR_NUMERIC;
+
+//
+// Flags related to the numeric question
+//
+#define EFI_IFR_NUMERIC_SIZE           0x03
+#define   EFI_IFR_NUMERIC_SIZE_1       0x00
+#define   EFI_IFR_NUMERIC_SIZE_2       0x01
+#define   EFI_IFR_NUMERIC_SIZE_4       0x02
+#define   EFI_IFR_NUMERIC_SIZE_8       0x03
+
+#define EFI_IFR_DISPLAY                0x30
+#define   EFI_IFR_DISPLAY_INT_DEC      0x00
+#define   EFI_IFR_DISPLAY_UINT_DEC     0x10
+#define   EFI_IFR_DISPLAY_UINT_HEX     0x20
+
+typedef struct _EFI_IFR_ONE_OF {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    Flags;
+  MINMAXSTEP_DATA          data;
+} EFI_IFR_ONE_OF;
+
+typedef struct _EFI_IFR_STRING {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    MinSize;
+  UINT8                    MaxSize;
+  UINT8                    Flags;
+} EFI_IFR_STRING;
+
+#define EFI_IFR_STRING_MULTI_LINE      0x01
+
+typedef struct _EFI_IFR_PASSWORD {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT16                   MinSize;
+  UINT16                   MaxSize;
+} EFI_IFR_PASSWORD;
+
+typedef struct _EFI_IFR_ORDERED_LIST {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    MaxContainers;
+  UINT8                    Flags;
+} EFI_IFR_ORDERED_LIST;
+
+#define EFI_IFR_UNIQUE_SET             0x01
+#define EFI_IFR_NO_EMPTY_SET           0x02
+
+typedef struct _EFI_IFR_TIME {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_IFR_QUESTION_HEADER  Question;
+  UINT8                    Flags;
+} EFI_IFR_TIME;
+
+//
+// A bit-mask that determines which unique settings are active for this opcode.
+//
+#define QF_TIME_HOUR_SUPPRESS          0x01
+#define QF_TIME_MINUTE_SUPPRESS        0x02
+#define QF_TIME_SECOND_SUPPRESS        0x04
+
+#define QF_TIME_STORAGE                0x30
+#define   QF_TIME_STORAGE_NORMAL       0x00
+#define   QF_TIME_STORAGE_TIME         0x10
+#define   QF_TIME_STORAGE_WAKEUP       0x20
+
+typedef struct _EFI_IFR_DISABLE_IF {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_DISABLE_IF;
+
+typedef struct _EFI_IFR_SUPPRESS_IF {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_SUPPRESS_IF;
+
+typedef struct _EFI_IFR_GRAY_OUT_IF {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_GRAY_OUT_IF;
+
+typedef struct _EFI_IFR_INCONSISTENT_IF {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            Error;
+} EFI_IFR_INCONSISTENT_IF;
+
+typedef struct _EFI_IFR_NO_SUBMIT_IF {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            Error;
+} EFI_IFR_NO_SUBMIT_IF;
+
+typedef struct _EFI_IFR_WARNING_IF {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            Warning;
+  UINT8                    TimeOut;
+} EFI_IFR_WARNING_IF;
+
+typedef struct _EFI_IFR_REFRESH {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    RefreshInterval;
+} EFI_IFR_REFRESH;
+
+typedef struct _EFI_IFR_VARSTORE_DEVICE {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            DevicePath;
+} EFI_IFR_VARSTORE_DEVICE;
+
+typedef struct _EFI_IFR_ONE_OF_OPTION {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            Option;
+  UINT8                    Flags;
+  UINT8                    Type;
+  EFI_IFR_TYPE_VALUE       Value;
+} EFI_IFR_ONE_OF_OPTION;
+
+//
+// Types of the option's value.
+//
+#define EFI_IFR_TYPE_NUM_SIZE_8        0x00
+#define EFI_IFR_TYPE_NUM_SIZE_16       0x01
+#define EFI_IFR_TYPE_NUM_SIZE_32       0x02
+#define EFI_IFR_TYPE_NUM_SIZE_64       0x03
+#define EFI_IFR_TYPE_BOOLEAN           0x04
+#define EFI_IFR_TYPE_TIME              0x05
+#define EFI_IFR_TYPE_DATE              0x06
+#define EFI_IFR_TYPE_STRING            0x07
+#define EFI_IFR_TYPE_OTHER             0x08
+#define EFI_IFR_TYPE_UNDEFINED         0x09
+#define EFI_IFR_TYPE_ACTION            0x0A
+#define EFI_IFR_TYPE_BUFFER            0x0B
+#define EFI_IFR_TYPE_REF               0x0C
+
+#define EFI_IFR_OPTION_DEFAULT         0x10
+#define EFI_IFR_OPTION_DEFAULT_MFG     0x20
+
+typedef struct _EFI_IFR_GUID {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_GUID                 Guid;
+  //Optional Data Follows
+} EFI_IFR_GUID;
+
+typedef struct _EFI_IFR_REFRESH_ID {
+  EFI_IFR_OP_HEADER Header;
+  EFI_GUID          RefreshEventGroupId;
+} EFI_IFR_REFRESH_ID;
+
+typedef struct _EFI_IFR_DUP {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_DUP;
+
+typedef struct _EFI_IFR_EQ_ID_ID {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_QUESTION_ID          QuestionId1;
+  EFI_QUESTION_ID          QuestionId2;
+} EFI_IFR_EQ_ID_ID;
+
+typedef struct _EFI_IFR_EQ_ID_VAL {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_QUESTION_ID          QuestionId;
+  UINT16                   Value;
+} EFI_IFR_EQ_ID_VAL;
+
+typedef struct _EFI_IFR_EQ_ID_VAL_LIST {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_QUESTION_ID          QuestionId;
+  UINT16                   ListLength;
+  UINT16                   ValueList[1];
+} EFI_IFR_EQ_ID_VAL_LIST;
+
+typedef struct _EFI_IFR_UINT8 {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8 Value;
+} EFI_IFR_UINT8;
+
+typedef struct _EFI_IFR_UINT16 {
+  EFI_IFR_OP_HEADER        Header;
+  UINT16                   Value;
+} EFI_IFR_UINT16;
+
+typedef struct _EFI_IFR_UINT32 {
+  EFI_IFR_OP_HEADER        Header;
+  UINT32                   Value;
+} EFI_IFR_UINT32;
+
+typedef struct _EFI_IFR_UINT64 {
+  EFI_IFR_OP_HEADER        Header;
+  UINT64 Value;
+} EFI_IFR_UINT64;
+
+typedef struct _EFI_IFR_QUESTION_REF1 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_QUESTION_ID          QuestionId;
+} EFI_IFR_QUESTION_REF1;
+
+typedef struct _EFI_IFR_QUESTION_REF2 {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_QUESTION_REF2;
+
+typedef struct _EFI_IFR_QUESTION_REF3 {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_QUESTION_REF3;
+
+typedef struct _EFI_IFR_QUESTION_REF3_2 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            DevicePath;
+} EFI_IFR_QUESTION_REF3_2;
+
+typedef struct _EFI_IFR_QUESTION_REF3_3 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            DevicePath;
+  EFI_GUID                 Guid;
+} EFI_IFR_QUESTION_REF3_3;
+
+typedef struct _EFI_IFR_RULE_REF {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    RuleId;
+} EFI_IFR_RULE_REF;
+
+typedef struct _EFI_IFR_STRING_REF1 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_STRING_ID            StringId;
+} EFI_IFR_STRING_REF1;
+
+typedef struct _EFI_IFR_STRING_REF2 {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_STRING_REF2;
+
+typedef struct _EFI_IFR_THIS {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_THIS;
+
+typedef struct _EFI_IFR_TRUE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TRUE;
+
+typedef struct _EFI_IFR_FALSE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_FALSE;
+
+typedef struct _EFI_IFR_ONE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_ONE;
+
+typedef struct _EFI_IFR_ONES {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_ONES;
+
+typedef struct _EFI_IFR_ZERO {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_ZERO;
+
+typedef struct _EFI_IFR_UNDEFINED {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_UNDEFINED;
+
+typedef struct _EFI_IFR_VERSION {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_VERSION;
+
+typedef struct _EFI_IFR_LENGTH {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_LENGTH;
+
+typedef struct _EFI_IFR_NOT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_NOT;
+
+typedef struct _EFI_IFR_BITWISE_NOT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_BITWISE_NOT;
+
+typedef struct _EFI_IFR_TO_BOOLEAN {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TO_BOOLEAN;
+
+///
+/// For EFI_IFR_TO_STRING, when converting from
+/// unsigned integers, these flags control the format:
+/// 0 = unsigned decimal.
+/// 1 = signed decimal.
+/// 2 = hexadecimal (lower-case alpha).
+/// 3 = hexadecimal (upper-case alpha).
+///@{
+#define EFI_IFR_STRING_UNSIGNED_DEC      0
+#define EFI_IFR_STRING_SIGNED_DEC        1
+#define EFI_IFR_STRING_LOWERCASE_HEX     2
+#define EFI_IFR_STRING_UPPERCASE_HEX     3
+///@}
+
+///
+/// When converting from a buffer, these flags control the format:
+/// 0 = ASCII.
+/// 8 = Unicode.
+///@{
+#define EFI_IFR_STRING_ASCII             0
+#define EFI_IFR_STRING_UNICODE           8
+///@}
+
+typedef struct _EFI_IFR_TO_STRING {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    Format;
+} EFI_IFR_TO_STRING;
+
+typedef struct _EFI_IFR_TO_UINT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TO_UINT;
+
+typedef struct _EFI_IFR_TO_UPPER {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TO_UPPER;
+
+typedef struct _EFI_IFR_TO_LOWER {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TO_LOWER;
+
+typedef struct _EFI_IFR_ADD {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_ADD;
+
+typedef struct _EFI_IFR_AND {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_AND;
+
+typedef struct _EFI_IFR_BITWISE_AND {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_BITWISE_AND;
+
+typedef struct _EFI_IFR_BITWISE_OR {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_BITWISE_OR;
+
+typedef struct _EFI_IFR_CATENATE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_CATENATE;
+
+typedef struct _EFI_IFR_DIVIDE {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_DIVIDE;
+
+typedef struct _EFI_IFR_EQUAL {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_EQUAL;
+
+typedef struct _EFI_IFR_GREATER_EQUAL {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_GREATER_EQUAL;
+
+typedef struct _EFI_IFR_GREATER_THAN {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_GREATER_THAN;
+
+typedef struct _EFI_IFR_LESS_EQUAL {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_LESS_EQUAL;
+
+typedef struct _EFI_IFR_LESS_THAN {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_LESS_THAN;
+
+typedef struct _EFI_IFR_MATCH {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_MATCH;
+
+typedef struct _EFI_IFR_MATCH2 {
+  EFI_IFR_OP_HEADER        Header;
+  EFI_GUID                 SyntaxType;
+} EFI_IFR_MATCH2;
+
+typedef struct _EFI_IFR_MULTIPLY {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_MULTIPLY;
+
+typedef struct _EFI_IFR_MODULO {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_MODULO;
+
+typedef struct _EFI_IFR_NOT_EQUAL {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_NOT_EQUAL;
+
+typedef struct _EFI_IFR_OR {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_OR;
+
+typedef struct _EFI_IFR_SHIFT_LEFT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_SHIFT_LEFT;
+
+typedef struct _EFI_IFR_SHIFT_RIGHT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_SHIFT_RIGHT;
+
+typedef struct _EFI_IFR_SUBTRACT {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_SUBTRACT;
+
+typedef struct _EFI_IFR_CONDITIONAL {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_CONDITIONAL;
+
+//
+// Flags governing the matching criteria of EFI_IFR_FIND
+//
+#define EFI_IFR_FF_CASE_SENSITIVE    0x00
+#define EFI_IFR_FF_CASE_INSENSITIVE  0x01
+
+typedef struct _EFI_IFR_FIND {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    Format;
+} EFI_IFR_FIND;
+
+typedef struct _EFI_IFR_MID {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_MID;
+
+typedef struct _EFI_IFR_TOKEN {
+  EFI_IFR_OP_HEADER        Header;
+} EFI_IFR_TOKEN;
+
+//
+// Flags specifying whether to find the first matching string
+// or the first non-matching string.
+//
+#define EFI_IFR_FLAGS_FIRST_MATCHING     0x00
+#define EFI_IFR_FLAGS_FIRST_NON_MATCHING 0x01
+
+typedef struct _EFI_IFR_SPAN {
+  EFI_IFR_OP_HEADER        Header;
+  UINT8                    Flags;
+} EFI_IFR_SPAN;
+
+typedef struct _EFI_IFR_SECURITY {
+  ///
+  /// Standard opcode header, where Header.Op = EFI_IFR_SECURITY_OP.
+  ///
+  EFI_IFR_OP_HEADER        Header;
+  ///
+  /// Security permission level.
+  ///
+  EFI_GUID                 Permissions;
+} EFI_IFR_SECURITY;
+
+typedef struct _EFI_IFR_FORM_MAP_METHOD {
+  ///
+  /// The string identifier which provides the human-readable name of 
+  /// the configuration method for this standards map form.
+  ///
+  EFI_STRING_ID            MethodTitle;
+  ///
+  /// Identifier which uniquely specifies the configuration methods 
+  /// associated with this standards map form.
+  ///
+  EFI_GUID                 MethodIdentifier;
+} EFI_IFR_FORM_MAP_METHOD;
+
+typedef struct _EFI_IFR_FORM_MAP {
+  ///
+  /// The sequence that defines the type of opcode as well as the length 
+  /// of the opcode being defined. Header.OpCode = EFI_IFR_FORM_MAP_OP. 
+  ///
+  EFI_IFR_OP_HEADER        Header;
+  ///
+  /// The unique identifier for this particular form.
+  ///
+  EFI_FORM_ID              FormId;
+  ///
+  /// One or more configuration method's name and unique identifier.
+  ///
+  // EFI_IFR_FORM_MAP_METHOD  Methods[];
+} EFI_IFR_FORM_MAP;
+
+typedef struct _EFI_IFR_SET {
+  ///
+  /// The sequence that defines the type of opcode as well as the length 
+  /// of the opcode being defined. Header.OpCode = EFI_IFR_SET_OP. 
+  ///
+  EFI_IFR_OP_HEADER  Header;
+  ///
+  /// Specifies the identifier of a previously declared variable store to 
+  /// use when storing the question's value. 
+  ///
+  EFI_VARSTORE_ID    VarStoreId;
+  union {
+    ///
+    /// A 16-bit Buffer Storage offset.
+    ///
+    EFI_STRING_ID    VarName;
+    ///
+    /// A Name Value or EFI Variable name (VarName).
+    ///
+    UINT16           VarOffset;
+  }                  VarStoreInfo;
+  ///
+  /// Specifies the type used for storage. 
+  ///
+  UINT8              VarStoreType;
+} EFI_IFR_SET;
+
+typedef struct _EFI_IFR_GET {
+  ///
+  /// The sequence that defines the type of opcode as well as the length 
+  /// of the opcode being defined. Header.OpCode = EFI_IFR_GET_OP. 
+  ///
+  EFI_IFR_OP_HEADER  Header;
+  ///
+  /// Specifies the identifier of a previously declared variable store to 
+  /// use when retrieving the value. 
+  ///
+  EFI_VARSTORE_ID    VarStoreId;
+  union {
+    ///
+    /// A 16-bit Buffer Storage offset.
+    ///
+    EFI_STRING_ID    VarName;
+    ///
+    /// A Name Value or EFI Variable name (VarName).
+    ///
+    UINT16           VarOffset;
+  }                  VarStoreInfo;
+  ///
+  /// Specifies the type used for storage. 
+  ///
+  UINT8              VarStoreType;
+} EFI_IFR_GET;
+
+typedef struct _EFI_IFR_READ {
+  EFI_IFR_OP_HEADER       Header;
+} EFI_IFR_READ;
+
+typedef struct _EFI_IFR_WRITE {
+  EFI_IFR_OP_HEADER      Header;
+} EFI_IFR_WRITE;
+
+typedef struct _EFI_IFR_MAP {
+  EFI_IFR_OP_HEADER      Header;
+} EFI_IFR_MAP;
+//
+// Definitions for Keyboard Package
+// Releated definitions are in Section of EFI_HII_DATABASE_PROTOCOL
+//
+
+///
+/// Each enumeration values maps a physical key on a keyboard.
+///
+typedef enum {    
+  EfiKeyLCtrl,
+  EfiKeyA0, 
+  EfiKeyLAlt,
+  EfiKeySpaceBar,
+  EfiKeyA2,
+  EfiKeyA3,
+  EfiKeyA4,
+  EfiKeyRCtrl,
+  EfiKeyLeftArrow,
+  EfiKeyDownArrow,
+  EfiKeyRightArrow,
+  EfiKeyZero,
+  EfiKeyPeriod,
+  EfiKeyEnter,
+  EfiKeyLShift,
+  EfiKeyB0,
+  EfiKeyB1,
+  EfiKeyB2,
+  EfiKeyB3,
+  EfiKeyB4,
+  EfiKeyB5,
+  EfiKeyB6,
+  EfiKeyB7,
+  EfiKeyB8,
+  EfiKeyB9,
+  EfiKeyB10,
+  EfiKeyRShift,
+  EfiKeyUpArrow,
+  EfiKeyOne,
+  EfiKeyTwo,
+  EfiKeyThree,
+  EfiKeyCapsLock,
+  EfiKeyC1,
+  EfiKeyC2,
+  EfiKeyC3,
+  EfiKeyC4,
+  EfiKeyC5,
+  EfiKeyC6,
+  EfiKeyC7,
+  EfiKeyC8,
+  EfiKeyC9,
+  EfiKeyC10,
+  EfiKeyC11,
+  EfiKeyC12,
+  EfiKeyFour,
+  EfiKeyFive,
+  EfiKeySix,
+  EfiKeyPlus,
+  EfiKeyTab,
+  EfiKeyD1,
+  EfiKeyD2,
+  EfiKeyD3,
+  EfiKeyD4,
+  EfiKeyD5,
+  EfiKeyD6,
+  EfiKeyD7,
+  EfiKeyD8,
+  EfiKeyD9,
+  EfiKeyD10,
+  EfiKeyD11,
+  EfiKeyD12,
+  EfiKeyD13,
+  EfiKeyDel,
+  EfiKeyEnd,
+  EfiKeyPgDn,
+  EfiKeySeven,
+  EfiKeyEight,
+  EfiKeyNine,
+  EfiKeyE0,
+  EfiKeyE1,
+  EfiKeyE2,
+  EfiKeyE3,
+  EfiKeyE4,
+  EfiKeyE5,
+  EfiKeyE6,
+  EfiKeyE7,
+  EfiKeyE8,
+  EfiKeyE9,
+  EfiKeyE10,
+  EfiKeyE11,
+  EfiKeyE12,
+  EfiKeyBackSpace,
+  EfiKeyIns,
+  EfiKeyHome,
+  EfiKeyPgUp,
+  EfiKeyNLck,
+  EfiKeySlash,
+  EfiKeyAsterisk,
+  EfiKeyMinus,
+  EfiKeyEsc,
+  EfiKeyF1,
+  EfiKeyF2,
+  EfiKeyF3,
+  EfiKeyF4,
+  EfiKeyF5,
+  EfiKeyF6,
+  EfiKeyF7,
+  EfiKeyF8,
+  EfiKeyF9,
+  EfiKeyF10,
+  EfiKeyF11,
+  EfiKeyF12,
+  EfiKeyPrint,
+  EfiKeySLck,
+  EfiKeyPause
+} EFI_KEY;
+
+typedef struct {
+  ///
+  /// Used to describe a physical key on a keyboard.
+  ///
+  EFI_KEY                 Key;
+  ///
+  /// Unicode character code for the Key.
+  ///
+  CHAR16                  Unicode;
+  ///
+  /// Unicode character code for the key with the shift key being held down.
+  ///
+  CHAR16                  ShiftedUnicode;
+  ///
+  /// Unicode character code for the key with the Alt-GR being held down.
+  ///
+  CHAR16                  AltGrUnicode;
+  ///
+  /// Unicode character code for the key with the Alt-GR and shift keys being held down.
+  ///
+  CHAR16                  ShiftedAltGrUnicode;
+  ///
+  /// Modifier keys are defined to allow for special functionality that is not necessarily 
+  /// accomplished by a printable character. Many of these modifier keys are flags to toggle 
+  /// certain state bits on and off inside of a keyboard driver.
+  ///
+  UINT16                  Modifier;
+  UINT16                  AffectedAttribute;
+} EFI_KEY_DESCRIPTOR;
+
+///
+/// A key which is affected by all the standard shift modifiers.  
+/// Most keys would be expected to have this bit active.
+///
+#define EFI_AFFECTED_BY_STANDARD_SHIFT       0x0001
+
+///
+/// This key is affected by the caps lock so that if a keyboard driver
+/// would need to disambiguate between a key which had a "1" defined
+/// versus an "a" character.  Having this bit turned on would tell
+/// the keyboard driver to use the appropriate shifted state or not.
+///
+#define EFI_AFFECTED_BY_CAPS_LOCK            0x0002
+
+///
+/// Similar to the case of CAPS lock, if this bit is active, the key
+/// is affected by the num lock being turned on.
+///
+#define EFI_AFFECTED_BY_NUM_LOCK             0x0004
+
+typedef struct {
+  UINT16                  LayoutLength;
+  EFI_GUID                Guid;
+  UINT32                  LayoutDescriptorStringOffset;
+  UINT8                   DescriptorCount;
+  // EFI_KEY_DESCRIPTOR    Descriptors[];
+} EFI_HII_KEYBOARD_LAYOUT;
+
+typedef struct {
+  EFI_HII_PACKAGE_HEADER  Header;
+  UINT16                  LayoutCount;
+  // EFI_HII_KEYBOARD_LAYOUT Layout[];
+} EFI_HII_KEYBOARD_PACKAGE_HDR;
+
+//
+// Modifier values
+//
+#define EFI_NULL_MODIFIER                0x0000
+#define EFI_LEFT_CONTROL_MODIFIER        0x0001
+#define EFI_RIGHT_CONTROL_MODIFIER       0x0002
+#define EFI_LEFT_ALT_MODIFIER            0x0003
+#define EFI_RIGHT_ALT_MODIFIER           0x0004
+#define EFI_ALT_GR_MODIFIER              0x0005
+#define EFI_INSERT_MODIFIER              0x0006
+#define EFI_DELETE_MODIFIER              0x0007
+#define EFI_PAGE_DOWN_MODIFIER           0x0008
+#define EFI_PAGE_UP_MODIFIER             0x0009
+#define EFI_HOME_MODIFIER                0x000A
+#define EFI_END_MODIFIER                 0x000B
+#define EFI_LEFT_SHIFT_MODIFIER          0x000C
+#define EFI_RIGHT_SHIFT_MODIFIER         0x000D
+#define EFI_CAPS_LOCK_MODIFIER           0x000E
+#define EFI_NUM_LOCK_MODIFIER            0x000F
+#define EFI_LEFT_ARROW_MODIFIER          0x0010
+#define EFI_RIGHT_ARROW_MODIFIER         0x0011
+#define EFI_DOWN_ARROW_MODIFIER          0x0012
+#define EFI_UP_ARROW_MODIFIER            0x0013
+#define EFI_NS_KEY_MODIFIER              0x0014
+#define EFI_NS_KEY_DEPENDENCY_MODIFIER   0x0015
+#define EFI_FUNCTION_KEY_ONE_MODIFIER    0x0016
+#define EFI_FUNCTION_KEY_TWO_MODIFIER    0x0017
+#define EFI_FUNCTION_KEY_THREE_MODIFIER  0x0018
+#define EFI_FUNCTION_KEY_FOUR_MODIFIER   0x0019
+#define EFI_FUNCTION_KEY_FIVE_MODIFIER   0x001A
+#define EFI_FUNCTION_KEY_SIX_MODIFIER    0x001B
+#define EFI_FUNCTION_KEY_SEVEN_MODIFIER  0x001C
+#define EFI_FUNCTION_KEY_EIGHT_MODIFIER  0x001D
+#define EFI_FUNCTION_KEY_NINE_MODIFIER   0x001E
+#define EFI_FUNCTION_KEY_TEN_MODIFIER    0x001F
+#define EFI_FUNCTION_KEY_ELEVEN_MODIFIER 0x0020
+#define EFI_FUNCTION_KEY_TWELVE_MODIFIER 0x0021
+
+//
+// Keys that have multiple control functions based on modifier
+// settings are handled in the keyboard driver implementation.
+// For instance, PRINT_KEY might have a modifier held down and
+// is still a nonprinting character, but might have an alternate
+// control function like SYSREQUEST
+//
+#define EFI_PRINT_MODIFIER               0x0022
+#define EFI_SYS_REQUEST_MODIFIER         0x0023
+#define EFI_SCROLL_LOCK_MODIFIER         0x0024
+#define EFI_PAUSE_MODIFIER               0x0025
+#define EFI_BREAK_MODIFIER               0x0026
+
+#define EFI_LEFT_LOGO_MODIFIER           0x0027
+#define EFI_RIGHT_LOGO_MODIFIER          0x0028
+#define EFI_MENU_MODIFIER                0x0029
+
+///
+/// Animation IFR opcode
+///
+typedef struct _EFI_IFR_ANIMATION {
+  ///
+  /// Standard opcode header, where Header.OpCode is 
+  /// EFI_IFR_ANIMATION_OP.
+  ///
+  EFI_IFR_OP_HEADER        Header;
+  ///
+  /// Animation identifier in the HII database.
+  ///
+  EFI_ANIMATION_ID         Id;
+} EFI_IFR_ANIMATION;
+
+///
+/// HII animation package header.
+///
+typedef struct _EFI_HII_ANIMATION_PACKAGE_HDR {
+  ///
+  /// Standard package header, where Header.Type = EFI_HII_PACKAGE_ANIMATIONS.
+  ///
+  EFI_HII_PACKAGE_HEADER  Header;
+  ///
+  /// Offset, relative to this header, of the animation information. If 
+  /// this is zero, then there are no animation sequences in the package.
+  ///
+  UINT32                  AnimationInfoOffset;
+} EFI_HII_ANIMATION_PACKAGE_HDR;
+
+///
+/// Animation information is encoded as a series of blocks,
+/// with each block prefixed by a single byte header EFI_HII_ANIMATION_BLOCK.
+///
+typedef struct _EFI_HII_ANIMATION_BLOCK {
+  UINT8  BlockType;
+  //UINT8  BlockBody[];
+} EFI_HII_ANIMATION_BLOCK;
+
+///
+/// Animation block types.
+///
+#define EFI_HII_AIBT_END                 0x00
+#define EFI_HII_AIBT_OVERLAY_IMAGES      0x10
+#define EFI_HII_AIBT_CLEAR_IMAGES        0x11
+#define EFI_HII_AIBT_RESTORE_SCRN        0x12
+#define EFI_HII_AIBT_OVERLAY_IMAGES_LOOP 0x18
+#define EFI_HII_AIBT_CLEAR_IMAGES_LOOP   0x19
+#define EFI_HII_AIBT_RESTORE_SCRN_LOOP   0x1A
+#define EFI_HII_AIBT_DUPLICATE           0x20
+#define EFI_HII_AIBT_SKIP2               0x21
+#define EFI_HII_AIBT_SKIP1               0x22
+#define EFI_HII_AIBT_EXT1                0x30
+#define EFI_HII_AIBT_EXT2                0x31
+#define EFI_HII_AIBT_EXT4                0x32
+
+///
+/// Extended block headers used for variable sized animation records
+/// which need an explicit length.
+///
+
+typedef struct _EFI_HII_AIBT_EXT1_BLOCK  {
+  ///
+  /// Standard animation header, where Header.BlockType = EFI_HII_AIBT_EXT1.
+  ///
+  EFI_HII_ANIMATION_BLOCK  Header;
+  ///
+  /// The block type.
+  ///
+  UINT8                    BlockType2;
+  ///
+  /// Size of the animation block, in bytes, including the animation block header.
+  ///
+  UINT8                    Length;
+} EFI_HII_AIBT_EXT1_BLOCK;
+
+typedef struct _EFI_HII_AIBT_EXT2_BLOCK {
+  ///
+  /// Standard animation header, where Header.BlockType = EFI_HII_AIBT_EXT2.
+  ///
+  EFI_HII_ANIMATION_BLOCK  Header;
+  ///
+  /// The block type
+  ///
+  UINT8                    BlockType2;
+  ///
+  /// Size of the animation block, in bytes, including the animation block header.
+  ///
+  UINT16                   Length;
+} EFI_HII_AIBT_EXT2_BLOCK;
+
+typedef struct _EFI_HII_AIBT_EXT4_BLOCK {
+  ///
+  /// Standard animation header, where Header.BlockType = EFI_HII_AIBT_EXT4.
+  ///
+  EFI_HII_ANIMATION_BLOCK  Header;
+  ///
+  /// The block type
+  ///
+  UINT8                    BlockType2;
+  ///
+  /// Size of the animation block, in bytes, including the animation block header.
+  ///
+  UINT32                   Length;
+} EFI_HII_AIBT_EXT4_BLOCK;
+
+typedef struct _EFI_HII_ANIMATION_CELL {
+  ///
+  /// The X offset from the upper left hand corner of the logical 
+  /// window to position the indexed image.
+  ///
+  UINT16                    OffsetX;
+  ///
+  /// The Y offset from the upper left hand corner of the logical 
+  /// window to position the indexed image.
+  ///
+  UINT16                    OffsetY;
+  ///
+  /// The image to display at the specified offset from the upper left 
+  /// hand corner of the logical window.
+  ///
+  EFI_IMAGE_ID              ImageId;
+  ///
+  /// The number of milliseconds to delay after displaying the indexed 
+  /// image and before continuing on to the next linked image.  If value 
+  /// is zero, no delay.
+  ///
+  UINT16                    Delay;
+} EFI_HII_ANIMATION_CELL;
+
+///
+/// An animation block to describe an animation sequence that does not cycle, and
+/// where one image is simply displayed over the previous image.
+///
+typedef struct _EFI_HII_AIBT_OVERLAY_IMAGES_BLOCK {
+  ///
+  /// This is image that is to be reference by the image protocols, if the 
+  /// animation function is not supported or disabled. This image can 
+  /// be one particular image from the animation sequence (if any one 
+  /// of the animation frames has a complete image) or an alternate 
+  /// image that can be displayed alone. If the value is zero, no image 
+  /// is displayed.
+  ///
+  EFI_IMAGE_ID            DftImageId;
+  ///
+  /// The overall width of the set of images (logical window width).
+  ///
+  UINT16                  Width;
+  ///
+  /// The overall height of the set of images (logical window height).
+  ///
+  UINT16                  Height;
+  ///
+  /// The number of EFI_HII_ANIMATION_CELL contained in the 
+  /// animation sequence.
+  ///
+  UINT16                  CellCount;
+  ///
+  /// An array of CellCount animation cells.
+  ///
+  EFI_HII_ANIMATION_CELL  AnimationCell[1];
+} EFI_HII_AIBT_OVERLAY_IMAGES_BLOCK;
+
+///
+/// An animation block to describe an animation sequence that does not cycle,
+/// and where the logical window is cleared to the specified color before 
+/// the next image is displayed.
+///
+typedef struct _EFI_HII_AIBT_CLEAR_IMAGES_BLOCK {
+  ///
+  /// This is image that is to be reference by the image protocols, if the 
+  /// animation function is not supported or disabled. This image can 
+  /// be one particular image from the animation sequence (if any one 
+  /// of the animation frames has a complete image) or an alternate 
+  /// image that can be displayed alone. If the value is zero, no image 
+  /// is displayed.
+  ///
+  EFI_IMAGE_ID       DftImageId;
+  ///
+  /// The overall width of the set of images (logical window width).
+  ///
+  UINT16             Width;
+  ///
+  /// The overall height of the set of images (logical window height).
+  ///
+  UINT16             Height;
+  ///
+  /// The number of EFI_HII_ANIMATION_CELL contained in the 
+  /// animation sequence.
+  ///
+  UINT16             CellCount;
+  ///
+  /// The color to clear the logical window to before displaying the 
+  /// indexed image.
+  ///
+  EFI_HII_RGB_PIXEL  BackgndColor;
+  ///
+  /// An array of CellCount animation cells.
+  ///
+  EFI_HII_ANIMATION_CELL AnimationCell[1];
+} EFI_HII_AIBT_CLEAR_IMAGES_BLOCK;
+
+///
+/// An animation block to describe an animation sequence that does not cycle,
+/// and where the screen is restored to the original state before the next 
+/// image is displayed.
+///
+typedef struct _EFI_HII_AIBT_RESTORE_SCRN_BLOCK {
+  ///
+  /// This is image that is to be reference by the image protocols, if the 
+  /// animation function is not supported or disabled. This image can 
+  /// be one particular image from the animation sequence (if any one 
+  /// of the animation frames has a complete image) or an alternate 
+  /// image that can be displayed alone. If the value is zero, no image 
+  /// is displayed.
+  ///
+  EFI_IMAGE_ID            DftImageId;
+  ///
+  /// The overall width of the set of images (logical window width).
+  ///
+  UINT16                  Width;
+  ///
+  /// The overall height of the set of images (logical window height).
+  ///
+  UINT16                  Height;
+  ///
+  /// The number of EFI_HII_ANIMATION_CELL contained in the 
+  /// animation sequence.
+  ///
+  UINT16                  CellCount;
+  ///
+  /// An array of CellCount animation cells.
+  ///
+  EFI_HII_ANIMATION_CELL  AnimationCell[1];
+} EFI_HII_AIBT_RESTORE_SCRN_BLOCK;
+
+///
+/// An animation block to describe an animation sequence that continuously cycles,
+/// and where one image is simply displayed over the previous image.
+///
+typedef EFI_HII_AIBT_OVERLAY_IMAGES_BLOCK  EFI_HII_AIBT_OVERLAY_IMAGES_LOOP_BLOCK;
+
+///
+/// An animation block to describe an animation sequence that continuously cycles,
+/// and where the logical window is cleared to the specified color before 
+/// the next image is displayed.
+///
+typedef EFI_HII_AIBT_CLEAR_IMAGES_BLOCK    EFI_HII_AIBT_CLEAR_IMAGES_LOOP_BLOCK;
+
+///
+/// An animation block to describe an animation sequence that continuously cycles,
+/// and where the screen is restored to the original state before 
+/// the next image is displayed.
+///
+typedef EFI_HII_AIBT_RESTORE_SCRN_BLOCK    EFI_HII_AIBT_RESTORE_SCRN_LOOP_BLOCK;
+
+///
+/// Assigns a new character value to a previously defined animation sequence.
+///
+typedef struct _EFI_HII_AIBT_DUPLICATE_BLOCK {
+  ///
+  /// The previously defined animation ID with the exact same 
+  /// animation information.
+  ///
+  EFI_ANIMATION_ID  AnimationId;
+} EFI_HII_AIBT_DUPLICATE_BLOCK;
+
+///
+/// Skips animation IDs.
+///
+typedef struct _EFI_HII_AIBT_SKIP1_BLOCK {
+  ///
+  /// The unsigned 8-bit value to add to AnimationIdCurrent.
+  ///
+  UINT8  SkipCount;
+} EFI_HII_AIBT_SKIP1_BLOCK;
+
+///
+/// Skips animation IDs.
+///
+typedef struct _EFI_HII_AIBT_SKIP2_BLOCK {
+  ///
+  /// The unsigned 16-bit value to add to AnimationIdCurrent.
+  ///
+  UINT16  SkipCount;
+} EFI_HII_AIBT_SKIP2_BLOCK;
+
+#pragma pack()
+
+
+
+///
+/// References to string tokens must use this macro to enable scanning for
+/// token usages.
+///
+///
+/// STRING_TOKEN is not defined in UEFI specification. But it is placed 
+/// here for the easy access by C files and VFR source files.
+///
+#define STRING_TOKEN(t) t
+
+///
+/// IMAGE_TOKEN is not defined in UEFI specification. But it is placed
+/// here for the easy access by C files and VFR source files.
+///
+#define IMAGE_TOKEN(t) t
+
+#endif
diff --git a/MdePkg/Include/Uefi/UefiMultiPhase.h b/MdePkg/Include/Uefi/UefiMultiPhase.h
new file mode 100644
index 000000000000..30352587ad22
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiMultiPhase.h
@@ -0,0 +1,231 @@
+/** @file
+  This includes some definitions introduced in UEFI that will be used in both PEI and DXE phases.
+
+Copyright (c) 2006 - 2015, 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 __UEFI_MULTIPHASE_H__
+#define __UEFI_MULTIPHASE_H__
+
+#include <Guid/WinCertificate.h>
+///
+/// Enumeration of memory types introduced in UEFI.
+///
+typedef enum {
+  ///
+  /// Not used.
+  ///
+  EfiReservedMemoryType,
+  ///
+  /// The code portions of a loaded application.
+  /// (Note that UEFI OS loaders are UEFI applications.)
+  ///
+  EfiLoaderCode,
+  ///
+  /// The data portions of a loaded application and the default data allocation
+  /// type used by an application to allocate pool memory.
+  ///
+  EfiLoaderData,
+  ///
+  /// The code portions of a loaded Boot Services Driver.
+  ///
+  EfiBootServicesCode,
+  ///
+  /// The data portions of a loaded Boot Serves Driver, and the default data
+  /// allocation type used by a Boot Services Driver to allocate pool memory.
+  ///
+  EfiBootServicesData,
+  ///
+  /// The code portions of a loaded Runtime Services Driver.
+  ///
+  EfiRuntimeServicesCode,
+  ///
+  /// The data portions of a loaded Runtime Services Driver and the default
+  /// data allocation type used by a Runtime Services Driver to allocate pool memory.
+  ///
+  EfiRuntimeServicesData,
+  ///
+  /// Free (unallocated) memory.
+  ///
+  EfiConventionalMemory,
+  ///
+  /// Memory in which errors have been detected.
+  ///
+  EfiUnusableMemory,
+  ///
+  /// Memory that holds the ACPI tables.
+  ///
+  EfiACPIReclaimMemory,
+  ///
+  /// Address space reserved for use by the firmware.
+  ///
+  EfiACPIMemoryNVS,
+  ///
+  /// Used by system firmware to request that a memory-mapped IO region
+  /// be mapped by the OS to a virtual address so it can be accessed by EFI runtime services.
+  ///
+  EfiMemoryMappedIO,
+  ///
+  /// System memory-mapped IO region that is used to translate memory
+  /// cycles to IO cycles by the processor.
+  ///
+  EfiMemoryMappedIOPortSpace,
+  ///
+  /// Address space reserved by the firmware for code that is part of the processor.
+  ///
+  EfiPalCode,
+  ///
+  /// A memory region that operates as EfiConventionalMemory, 
+  /// however it happens to also support byte-addressable non-volatility.
+  ///
+  EfiPersistentMemory,
+  EfiMaxMemoryType
+} EFI_MEMORY_TYPE;
+
+///
+/// Enumeration of reset types.
+///
+typedef enum {
+  ///
+  /// Used to induce a system-wide reset. This sets all circuitry within the
+  /// system to its initial state.  This type of reset is asynchronous to system
+  /// operation and operates withgout regard to cycle boundaries.  EfiColdReset
+  /// is tantamount to a system power cycle.
+  ///
+  EfiResetCold,
+  ///
+  /// Used to induce a system-wide initialization. The processors are set to their
+  /// initial state, and pending cycles are not corrupted.  If the system does
+  /// not support this reset type, then an EfiResetCold must be performed.
+  ///
+  EfiResetWarm,
+  ///
+  /// Used to induce an entry into a power state equivalent to the ACPI G2/S5 or G3
+  /// state.  If the system does not support this reset type, then when the system
+  /// is rebooted, it should exhibit the EfiResetCold attributes.
+  ///
+  EfiResetShutdown,
+  ///
+  /// Used to induce a system-wide reset. The exact type of the reset is defined by
+  /// the EFI_GUID that follows the Null-terminated Unicode string passed into
+  /// ResetData. If the platform does not recognize the EFI_GUID in ResetData the
+  /// platform must pick a supported reset type to perform. The platform may
+  /// optionally log the parameters from any non-normal reset that occurs.
+  ///
+  EfiResetPlatformSpecific
+} EFI_RESET_TYPE;
+
+///
+/// Data structure that precedes all of the standard EFI table types.
+///
+typedef struct {
+  ///
+  /// A 64-bit signature that identifies the type of table that follows.
+  /// Unique signatures have been generated for the EFI System Table,
+  /// the EFI Boot Services Table, and the EFI Runtime Services Table.
+  ///
+  UINT64  Signature;
+  ///
+  /// The revision of the EFI Specification to which this table
+  /// conforms. The upper 16 bits of this field contain the major
+  /// revision value, and the lower 16 bits contain the minor revision
+  /// value. The minor revision values are limited to the range of 00..99.
+  ///
+  UINT32  Revision;
+  ///
+  /// The size, in bytes, of the entire table including the EFI_TABLE_HEADER.
+  ///
+  UINT32  HeaderSize;
+  ///
+  /// The 32-bit CRC for the entire table. This value is computed by
+  /// setting this field to 0, and computing the 32-bit CRC for HeaderSize bytes.
+  ///
+  UINT32  CRC32;
+  ///
+  /// Reserved field that must be set to 0.
+  ///
+  UINT32  Reserved;
+} EFI_TABLE_HEADER;
+
+///
+/// Attributes of variable.
+///
+#define EFI_VARIABLE_NON_VOLATILE                            0x00000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS                      0x00000002
+#define EFI_VARIABLE_RUNTIME_ACCESS                          0x00000004
+///
+/// This attribute is identified by the mnemonic 'HR'
+/// elsewhere in this specification.
+///
+#define EFI_VARIABLE_HARDWARE_ERROR_RECORD                   0x00000008
+///
+/// Attributes of Authenticated Variable
+///
+#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS              0x00000010
+#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS   0x00000020
+#define EFI_VARIABLE_APPEND_WRITE                            0x00000040
+
+
+///
+/// AuthInfo is a WIN_CERTIFICATE using the wCertificateType
+/// WIN_CERTIFICATE_UEFI_GUID and the CertType
+/// EFI_CERT_TYPE_RSA2048_SHA256_GUID. If the attribute specifies
+/// authenticated access, then the Data buffer should begin with an
+/// authentication descriptor prior to the data payload and DataSize
+/// should reflect the the data.and descriptor size. The caller
+/// shall digest the Monotonic Count value and the associated data
+/// for the variable update using the SHA-256 1-way hash algorithm.
+/// The ensuing the 32-byte digest will be signed using the private
+/// key associated w/ the public/private 2048-bit RSA key-pair. The
+/// WIN_CERTIFICATE shall be used to describe the signature of the
+/// Variable data *Data. In addition, the signature will also
+/// include the MonotonicCount value to guard against replay attacks.
+///
+typedef struct {
+  ///
+  /// Included in the signature of
+  /// AuthInfo.Used to ensure freshness/no
+  /// replay. Incremented during each
+  /// "Write" access.
+  ///
+  UINT64                      MonotonicCount;
+  ///
+  /// Provides the authorization for the variable
+  /// access. It is a signature across the
+  /// variable data and the  Monotonic Count
+  /// value. Caller uses Private key that is
+  /// associated with a public key that has been
+  /// provisioned via the key exchange.
+  ///
+  WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
+} EFI_VARIABLE_AUTHENTICATION;
+
+///
+/// When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is
+/// set, then the Data buffer shall begin with an instance of a complete (and serialized)
+/// EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new
+/// variable value and DataSize shall reflect the combined size of the descriptor and the new
+/// variable value. The authentication descriptor is not part of the variable data and is not
+/// returned by subsequent calls to GetVariable().
+///
+typedef struct {
+  ///
+  /// For the TimeStamp value, components Pad1, Nanosecond, TimeZone, Daylight and
+  /// Pad2 shall be set to 0. This means that the time shall always be expressed in GMT.
+  ///
+  EFI_TIME                    TimeStamp;
+  ///
+  /// Only a CertType of  EFI_CERT_TYPE_PKCS7_GUID is accepted.
+  ///
+  WIN_CERTIFICATE_UEFI_GUID   AuthInfo;
+ } EFI_VARIABLE_AUTHENTICATION_2;
+
+#endif
diff --git a/MdePkg/Include/Uefi/UefiPxe.h b/MdePkg/Include/Uefi/UefiPxe.h
new file mode 100644
index 000000000000..aad1d3577dd9
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiPxe.h
@@ -0,0 +1,1792 @@
+/** @file
+  This header file contains all of the PXE type definitions,
+  structure prototypes, global variables and constants that
+  are needed for porting PXE to EFI.
+
+Copyright (c) 2006 - 2016, 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.
+
+  @par Revision Reference:
+  32/64-bit PXE specification:
+  alpha-4, 99-Dec-17.
+
+**/
+
+#ifndef __EFI_PXE_H__
+#define __EFI_PXE_H__
+
+#pragma pack(1)
+
+#define PXE_BUSTYPE(a, b, c, d) \
+    ( \
+      (((PXE_UINT32) (d) & 0xFF) << 24) | (((PXE_UINT32) (c) & 0xFF) << 16) | (((PXE_UINT32) (b) & 0xFF) << 8) | \
+        ((PXE_UINT32) (a) & 0xFF) \
+    )
+
+///
+/// UNDI ROM ID and devive ID signature.
+///
+#define PXE_BUSTYPE_PXE PXE_BUSTYPE ('!', 'P', 'X', 'E')
+
+///
+/// BUS ROM ID signatures.
+///
+#define PXE_BUSTYPE_PCI     PXE_BUSTYPE ('P', 'C', 'I', 'R')
+#define PXE_BUSTYPE_PC_CARD PXE_BUSTYPE ('P', 'C', 'C', 'R')
+#define PXE_BUSTYPE_USB     PXE_BUSTYPE ('U', 'S', 'B', 'R')
+#define PXE_BUSTYPE_1394    PXE_BUSTYPE ('1', '3', '9', '4')
+
+#define PXE_SWAP_UINT16(n)  ((((PXE_UINT16) (n) & 0x00FF) << 8) | (((PXE_UINT16) (n) & 0xFF00) >> 8))
+
+#define PXE_SWAP_UINT32(n) \
+  ((((PXE_UINT32)(n) & 0x000000FF) << 24) | \
+   (((PXE_UINT32)(n) & 0x0000FF00) << 8)  | \
+   (((PXE_UINT32)(n) & 0x00FF0000) >> 8)  | \
+   (((PXE_UINT32)(n) & 0xFF000000) >> 24))
+
+#define PXE_SWAP_UINT64(n) \
+  ((((PXE_UINT64)(n) & 0x00000000000000FFULL) << 56) | \
+   (((PXE_UINT64)(n) & 0x000000000000FF00ULL) << 40) | \
+   (((PXE_UINT64)(n) & 0x0000000000FF0000ULL) << 24) | \
+   (((PXE_UINT64)(n) & 0x00000000FF000000ULL) << 8)  | \
+   (((PXE_UINT64)(n) & 0x000000FF00000000ULL) >> 8)  | \
+   (((PXE_UINT64)(n) & 0x0000FF0000000000ULL) >> 24) | \
+   (((PXE_UINT64)(n) & 0x00FF000000000000ULL) >> 40) | \
+   (((PXE_UINT64)(n) & 0xFF00000000000000ULL) >> 56))
+
+
+#define PXE_CPBSIZE_NOT_USED  0               ///< zero
+#define PXE_DBSIZE_NOT_USED   0               ///< zero
+#define PXE_CPBADDR_NOT_USED  (PXE_UINT64) 0  ///< zero
+#define PXE_DBADDR_NOT_USED   (PXE_UINT64) 0  ///< zero
+#define PXE_CONST             CONST
+
+#define PXE_VOLATILE          volatile
+
+typedef VOID           PXE_VOID;
+typedef UINT8          PXE_UINT8;
+typedef UINT16         PXE_UINT16;
+typedef UINT32         PXE_UINT32;
+typedef UINTN          PXE_UINTN;
+
+///
+/// Typedef unsigned long PXE_UINT64.
+///
+typedef UINT64      PXE_UINT64;
+
+typedef PXE_UINT8 PXE_BOOL;
+#define PXE_FALSE 0            ///< zero
+#define PXE_TRUE  (!PXE_FALSE)
+
+typedef PXE_UINT16      PXE_OPCODE;
+
+///
+/// Return UNDI operational state.
+///
+#define PXE_OPCODE_GET_STATE  0x0000
+
+///
+/// Change UNDI operational state from Stopped to Started.
+///
+#define PXE_OPCODE_START  0x0001
+
+///
+/// Change UNDI operational state from Started to Stopped.
+///
+#define PXE_OPCODE_STOP 0x0002
+
+///
+/// Get UNDI initialization information.
+///
+#define PXE_OPCODE_GET_INIT_INFO  0x0003
+
+///
+/// Get NIC configuration information.
+///
+#define PXE_OPCODE_GET_CONFIG_INFO  0x0004
+
+///
+/// Changed UNDI operational state from Started to Initialized.
+///
+#define PXE_OPCODE_INITIALIZE 0x0005
+
+///
+/// Re-initialize the NIC H/W.
+///
+#define PXE_OPCODE_RESET  0x0006
+
+///
+/// Change the UNDI operational state from Initialized to Started.
+///
+#define PXE_OPCODE_SHUTDOWN 0x0007
+
+///
+/// Read & change state of external interrupt enables.
+///
+#define PXE_OPCODE_INTERRUPT_ENABLES  0x0008
+
+///
+/// Read & change state of packet receive filters.
+///
+#define PXE_OPCODE_RECEIVE_FILTERS  0x0009
+
+///
+/// Read & change station MAC address.
+///
+#define PXE_OPCODE_STATION_ADDRESS  0x000A
+
+///
+/// Read traffic statistics.
+///
+#define PXE_OPCODE_STATISTICS 0x000B
+
+///
+/// Convert multicast IP address to multicast MAC address.
+///
+#define PXE_OPCODE_MCAST_IP_TO_MAC  0x000C
+
+///
+/// Read or change non-volatile storage on the NIC.
+///
+#define PXE_OPCODE_NVDATA 0x000D
+
+///
+/// Get & clear interrupt status.
+///
+#define PXE_OPCODE_GET_STATUS 0x000E
+
+///
+/// Fill media header in packet for transmit.
+///
+#define PXE_OPCODE_FILL_HEADER  0x000F
+
+///
+/// Transmit packet(s).
+///
+#define PXE_OPCODE_TRANSMIT 0x0010
+
+///
+/// Receive packet.
+///
+#define PXE_OPCODE_RECEIVE  0x0011
+
+///
+/// Last valid PXE UNDI OpCode number.
+///
+#define PXE_OPCODE_LAST_VALID 0x0011
+
+typedef PXE_UINT16  PXE_OPFLAGS;
+
+#define PXE_OPFLAGS_NOT_USED  0x0000
+
+//
+// //////////////////////////////////////
+// UNDI Get State
+//
+// No OpFlags
+
+////////////////////////////////////////
+// UNDI Start
+//
+// No OpFlags
+
+////////////////////////////////////////
+// UNDI Stop
+//
+// No OpFlags
+
+////////////////////////////////////////
+// UNDI Get Init Info
+//
+// No Opflags
+
+////////////////////////////////////////
+// UNDI Get Config Info
+//
+// No Opflags
+
+///
+/// UNDI Initialize
+///
+#define PXE_OPFLAGS_INITIALIZE_CABLE_DETECT_MASK    0x0001
+#define PXE_OPFLAGS_INITIALIZE_DETECT_CABLE         0x0000
+#define PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE  0x0001
+
+///
+///
+/// UNDI Reset
+///
+#define PXE_OPFLAGS_RESET_DISABLE_INTERRUPTS  0x0001
+#define PXE_OPFLAGS_RESET_DISABLE_FILTERS     0x0002
+
+///
+/// UNDI Shutdown.
+///
+/// No OpFlags.
+
+///
+/// UNDI Interrupt Enables.
+///
+///
+/// Select whether to enable or disable external interrupt signals.
+/// Setting both enable and disable will return PXE_STATCODE_INVALID_OPFLAGS.
+///
+#define PXE_OPFLAGS_INTERRUPT_OPMASK  0xC000
+#define PXE_OPFLAGS_INTERRUPT_ENABLE  0x8000
+#define PXE_OPFLAGS_INTERRUPT_DISABLE 0x4000
+#define PXE_OPFLAGS_INTERRUPT_READ    0x0000
+
+///
+/// Enable receive interrupts.  An external interrupt will be generated
+/// after a complete non-error packet has been received.
+///
+#define PXE_OPFLAGS_INTERRUPT_RECEIVE 0x0001
+
+///
+/// Enable transmit interrupts.  An external interrupt will be generated
+/// after a complete non-error packet has been transmitted.
+///
+#define PXE_OPFLAGS_INTERRUPT_TRANSMIT  0x0002
+
+///
+/// Enable command interrupts.  An external interrupt will be generated
+/// when command execution stops.
+///
+#define PXE_OPFLAGS_INTERRUPT_COMMAND 0x0004
+
+///
+/// Generate software interrupt.  Setting this bit generates an external
+/// interrupt, if it is supported by the hardware.
+///
+#define PXE_OPFLAGS_INTERRUPT_SOFTWARE  0x0008
+
+///
+/// UNDI Receive Filters.
+///
+///
+/// Select whether to enable or disable receive filters.
+/// Setting both enable and disable will return PXE_STATCODE_INVALID_OPCODE.
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_OPMASK   0xC000
+#define PXE_OPFLAGS_RECEIVE_FILTER_ENABLE   0x8000
+#define PXE_OPFLAGS_RECEIVE_FILTER_DISABLE  0x4000
+#define PXE_OPFLAGS_RECEIVE_FILTER_READ     0x0000
+
+///
+/// To reset the contents of the multicast MAC address filter list,
+/// set this OpFlag:
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST 0x2000
+
+///
+/// Enable unicast packet receiving.  Packets sent to the current station
+/// MAC address will be received.
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_UNICAST  0x0001
+
+///
+/// Enable broadcast packet receiving.  Packets sent to the broadcast
+/// MAC address will be received.
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST  0x0002
+
+///
+/// Enable filtered multicast packet receiving.  Packets sent to any
+/// of the multicast MAC addresses in the multicast MAC address filter
+/// list will be received.  If the filter list is empty, no multicast
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004
+
+///
+/// Enable promiscuous packet receiving.  All packets will be received.
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS  0x0008
+
+///
+/// Enable promiscuous multicast packet receiving.  All multicast
+/// packets will be received.
+///
+#define PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST  0x0010
+
+///
+/// UNDI Station Address.
+///
+#define PXE_OPFLAGS_STATION_ADDRESS_READ   0x0000
+#define PXE_OPFLAGS_STATION_ADDRESS_WRITE  0x0000
+#define PXE_OPFLAGS_STATION_ADDRESS_RESET  0x0001
+
+///
+/// UNDI Statistics.
+///
+#define PXE_OPFLAGS_STATISTICS_READ   0x0000
+#define PXE_OPFLAGS_STATISTICS_RESET  0x0001
+
+///
+/// UNDI MCast IP to MAC.
+///
+///
+/// Identify the type of IP address in the CPB.
+///
+#define PXE_OPFLAGS_MCAST_IP_TO_MAC_OPMASK  0x0003
+#define PXE_OPFLAGS_MCAST_IPV4_TO_MAC       0x0000
+#define PXE_OPFLAGS_MCAST_IPV6_TO_MAC       0x0001
+
+///
+/// UNDI NvData.
+///
+///
+/// Select the type of non-volatile data operation.
+///
+#define PXE_OPFLAGS_NVDATA_OPMASK 0x0001
+#define PXE_OPFLAGS_NVDATA_READ   0x0000
+#define PXE_OPFLAGS_NVDATA_WRITE  0x0001
+
+///
+/// UNDI Get Status.
+///
+///
+/// Return current interrupt status.  This will also clear any interrupts
+/// that are currently set.  This can be used in a polling routine.  The
+/// interrupt flags are still set and cleared even when the interrupts
+/// are disabled.
+///
+#define PXE_OPFLAGS_GET_INTERRUPT_STATUS  0x0001
+
+///
+/// Return list of transmitted buffers for recycling.  Transmit buffers
+/// must not be changed or unallocated until they have recycled.  After
+/// issuing a transmit command, wait for a transmit complete interrupt.
+/// When a transmit complete interrupt is received, read the transmitted
+/// buffers.  Do not plan on getting one buffer per interrupt.  Some
+/// NICs and UNDIs may transmit multiple buffers per interrupt.
+///
+#define PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS 0x0002
+
+///
+/// Return current media status.
+///
+#define PXE_OPFLAGS_GET_MEDIA_STATUS    0x0004
+
+///
+/// UNDI Fill Header.
+///
+#define PXE_OPFLAGS_FILL_HEADER_OPMASK      0x0001
+#define PXE_OPFLAGS_FILL_HEADER_FRAGMENTED  0x0001
+#define PXE_OPFLAGS_FILL_HEADER_WHOLE       0x0000
+
+///
+/// UNDI Transmit.
+///
+///
+/// S/W UNDI only.  Return after the packet has been transmitted.  A
+/// transmit complete interrupt will still be generated and the transmit
+/// buffer will have to be recycled.
+///
+#define PXE_OPFLAGS_SWUNDI_TRANSMIT_OPMASK  0x0001
+#define PXE_OPFLAGS_TRANSMIT_BLOCK          0x0001
+#define PXE_OPFLAGS_TRANSMIT_DONT_BLOCK     0x0000
+
+#define PXE_OPFLAGS_TRANSMIT_OPMASK     0x0002
+#define PXE_OPFLAGS_TRANSMIT_FRAGMENTED 0x0002
+#define PXE_OPFLAGS_TRANSMIT_WHOLE      0x0000
+
+///
+/// UNDI Receive.
+///
+/// No OpFlags.
+///
+
+///
+/// PXE STATFLAGS.
+///
+typedef PXE_UINT16  PXE_STATFLAGS;
+
+#define PXE_STATFLAGS_INITIALIZE  0x0000
+
+///
+/// Common StatFlags that can be returned by all commands.
+///
+///
+/// The COMMAND_COMPLETE and COMMAND_FAILED status flags must be
+/// implemented by all UNDIs.  COMMAND_QUEUED is only needed by UNDIs
+/// that support command queuing.
+///
+#define PXE_STATFLAGS_STATUS_MASK       0xC000
+#define PXE_STATFLAGS_COMMAND_COMPLETE  0xC000
+#define PXE_STATFLAGS_COMMAND_FAILED    0x8000
+#define PXE_STATFLAGS_COMMAND_QUEUED    0x4000
+
+///
+/// UNDI Get State.
+///
+#define PXE_STATFLAGS_GET_STATE_MASK        0x0003
+#define PXE_STATFLAGS_GET_STATE_INITIALIZED 0x0002
+#define PXE_STATFLAGS_GET_STATE_STARTED     0x0001
+#define PXE_STATFLAGS_GET_STATE_STOPPED     0x0000
+
+///
+/// UNDI Start.
+///
+/// No additional StatFlags.
+///
+
+///
+/// UNDI Get Init Info.
+///
+#define PXE_STATFLAGS_CABLE_DETECT_MASK           0x0001
+#define PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED  0x0000
+#define PXE_STATFLAGS_CABLE_DETECT_SUPPORTED      0x0001
+
+#define PXE_STATFLAGS_GET_STATUS_NO_MEDIA_MASK           0x0002
+#define PXE_STATFLAGS_GET_STATUS_NO_MEDIA_NOT_SUPPORTED  0x0000
+#define PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED      0x0002
+
+///
+/// UNDI Initialize.
+///
+#define PXE_STATFLAGS_INITIALIZED_NO_MEDIA  0x0001
+
+///
+/// UNDI Reset.
+///
+#define PXE_STATFLAGS_RESET_NO_MEDIA  0x0001
+
+///
+/// UNDI Shutdown.
+///
+/// No additional StatFlags.
+
+///
+/// UNDI Interrupt Enables.
+///
+///
+/// If set, receive interrupts are enabled.
+///
+#define PXE_STATFLAGS_INTERRUPT_RECEIVE 0x0001
+
+///
+/// If set, transmit interrupts are enabled.
+///
+#define PXE_STATFLAGS_INTERRUPT_TRANSMIT  0x0002
+
+///
+/// If set, command interrupts are enabled.
+///
+#define PXE_STATFLAGS_INTERRUPT_COMMAND 0x0004
+
+///
+/// UNDI Receive Filters.
+///
+
+///
+/// If set, unicast packets will be received.
+///
+#define PXE_STATFLAGS_RECEIVE_FILTER_UNICAST  0x0001
+
+///
+/// If set, broadcast packets will be received.
+///
+#define PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST  0x0002
+
+///
+/// If set, multicast packets that match up with the multicast address
+/// filter list will be received.
+///
+#define PXE_STATFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST 0x0004
+
+///
+/// If set, all packets will be received.
+///
+#define PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS  0x0008
+
+///
+/// If set, all multicast packets will be received.
+///
+#define PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST  0x0010
+
+///
+/// UNDI Station Address.
+///
+/// No additional StatFlags.
+///
+
+///
+/// UNDI Statistics.
+///
+/// No additional StatFlags.
+///
+
+///
+//// UNDI MCast IP to MAC.
+////
+//// No additional StatFlags.
+
+///
+/// UNDI NvData.
+///
+/// No additional StatFlags.
+///
+
+///
+/// UNDI Get Status.
+///
+
+///
+/// Use to determine if an interrupt has occurred.
+///
+#define PXE_STATFLAGS_GET_STATUS_INTERRUPT_MASK 0x000F
+#define PXE_STATFLAGS_GET_STATUS_NO_INTERRUPTS  0x0000
+
+///
+/// If set, at least one receive interrupt occurred.
+///
+#define PXE_STATFLAGS_GET_STATUS_RECEIVE  0x0001
+
+///
+/// If set, at least one transmit interrupt occurred.
+///
+#define PXE_STATFLAGS_GET_STATUS_TRANSMIT 0x0002
+
+///
+/// If set, at least one command interrupt occurred.
+///
+#define PXE_STATFLAGS_GET_STATUS_COMMAND  0x0004
+
+///
+/// If set, at least one software interrupt occurred.
+///
+#define PXE_STATFLAGS_GET_STATUS_SOFTWARE 0x0008
+
+///
+/// This flag is set if the transmitted buffer queue is empty.  This flag
+/// will be set if all transmitted buffer addresses get written into the DB.
+///
+#define PXE_STATFLAGS_GET_STATUS_TXBUF_QUEUE_EMPTY  0x0010
+
+///
+/// This flag is set if no transmitted buffer addresses were written
+/// into the DB.  (This could be because DBsize was too small.)
+///
+#define PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN  0x0020
+
+///
+/// This flag is set if there is no media detected.
+///
+#define PXE_STATFLAGS_GET_STATUS_NO_MEDIA  0x0040
+
+///
+/// UNDI Fill Header.
+///
+/// No additional StatFlags.
+///
+
+///
+/// UNDI Transmit.
+///
+/// No additional StatFlags.
+
+///
+/// UNDI Receive
+///.
+
+///
+/// No additional StatFlags.
+///
+typedef PXE_UINT16  PXE_STATCODE;
+
+#define PXE_STATCODE_INITIALIZE 0x0000
+
+///
+/// Common StatCodes returned by all UNDI commands, UNDI protocol functions
+/// and BC protocol functions.
+///
+#define PXE_STATCODE_SUCCESS              0x0000
+
+#define PXE_STATCODE_INVALID_CDB          0x0001
+#define PXE_STATCODE_INVALID_CPB          0x0002
+#define PXE_STATCODE_BUSY                 0x0003
+#define PXE_STATCODE_QUEUE_FULL           0x0004
+#define PXE_STATCODE_ALREADY_STARTED      0x0005
+#define PXE_STATCODE_NOT_STARTED          0x0006
+#define PXE_STATCODE_NOT_SHUTDOWN         0x0007
+#define PXE_STATCODE_ALREADY_INITIALIZED  0x0008
+#define PXE_STATCODE_NOT_INITIALIZED      0x0009
+#define PXE_STATCODE_DEVICE_FAILURE       0x000A
+#define PXE_STATCODE_NVDATA_FAILURE       0x000B
+#define PXE_STATCODE_UNSUPPORTED          0x000C
+#define PXE_STATCODE_BUFFER_FULL          0x000D
+#define PXE_STATCODE_INVALID_PARAMETER    0x000E
+#define PXE_STATCODE_INVALID_UNDI         0x000F
+#define PXE_STATCODE_IPV4_NOT_SUPPORTED   0x0010
+#define PXE_STATCODE_IPV6_NOT_SUPPORTED   0x0011
+#define PXE_STATCODE_NOT_ENOUGH_MEMORY    0x0012
+#define PXE_STATCODE_NO_DATA              0x0013
+
+typedef PXE_UINT16  PXE_IFNUM;
+
+///
+/// This interface number must be passed to the S/W UNDI Start command.
+///
+#define PXE_IFNUM_START 0x0000
+
+///
+/// This interface number is returned by the S/W UNDI Get State and
+/// Start commands if information in the CDB, CPB or DB is invalid.
+///
+#define PXE_IFNUM_INVALID 0x0000
+
+typedef PXE_UINT16  PXE_CONTROL;
+
+///
+/// Setting this flag directs the UNDI to queue this command for later
+/// execution if the UNDI is busy and it supports command queuing.
+/// If queuing is not supported, a PXE_STATCODE_INVALID_CONTROL error
+/// is returned.  If the queue is full, a PXE_STATCODE_CDB_QUEUE_FULL
+/// error is returned.
+///
+#define PXE_CONTROL_QUEUE_IF_BUSY 0x0002
+
+///
+/// These two bit values are used to determine if there are more UNDI
+/// CDB structures following this one.  If the link bit is set, there
+/// must be a CDB structure following this one.  Execution will start
+/// on the next CDB structure as soon as this one completes successfully.
+/// If an error is generated by this command, execution will stop.
+///
+#define PXE_CONTROL_LINK              0x0001
+#define PXE_CONTROL_LAST_CDB_IN_LIST  0x0000
+
+typedef PXE_UINT8   PXE_FRAME_TYPE;
+
+#define PXE_FRAME_TYPE_NONE                     0x00
+#define PXE_FRAME_TYPE_UNICAST                  0x01
+#define PXE_FRAME_TYPE_BROADCAST                0x02
+#define PXE_FRAME_TYPE_FILTERED_MULTICAST       0x03
+#define PXE_FRAME_TYPE_PROMISCUOUS              0x04
+#define PXE_FRAME_TYPE_PROMISCUOUS_MULTICAST    0x05
+
+#define PXE_FRAME_TYPE_MULTICAST                PXE_FRAME_TYPE_FILTERED_MULTICAST
+
+typedef PXE_UINT32  PXE_IPV4;
+
+typedef PXE_UINT32  PXE_IPV6[4];
+#define PXE_MAC_LENGTH  32
+
+typedef PXE_UINT8   PXE_MAC_ADDR[PXE_MAC_LENGTH];
+
+typedef PXE_UINT8   PXE_IFTYPE;
+typedef UINT16      PXE_MEDIA_PROTOCOL;
+
+///
+/// This information is from the ARP section of RFC 1700.
+///
+///     1 Ethernet (10Mb)                                    [JBP]
+///     2 Experimental Ethernet (3Mb)                        [JBP]
+///     3 Amateur Radio AX.25                                [PXK]
+///     4 Proteon ProNET Token Ring                          [JBP]
+///     5 Chaos                                              [GXP]
+///     6 IEEE 802 Networks                                  [JBP]
+///     7 ARCNET                                             [JBP]
+///     8 Hyperchannel                                       [JBP]
+///     9 Lanstar                                             [TU]
+///    10 Autonet Short Address                             [MXB1]
+///    11 LocalTalk                                         [JKR1]
+///    12 LocalNet (IBM* PCNet or SYTEK* LocalNET)           [JXM]
+///    13 Ultra link                                        [RXD2]
+///    14 SMDS                                              [GXC1]
+///    15 Frame Relay                                        [AGM]
+///    16 Asynchronous Transmission Mode (ATM)              [JXB2]
+///    17 HDLC                                               [JBP]
+///    18 Fibre Channel                            [Yakov Rekhter]
+///    19 Asynchronous Transmission Mode (ATM)      [Mark Laubach]
+///    20 Serial Line                                        [JBP]
+///    21 Asynchronous Transmission Mode (ATM)              [MXB1]
+///
+/// * Other names and brands may be claimed as the property of others.
+///
+#define PXE_IFTYPE_ETHERNET       0x01
+#define PXE_IFTYPE_TOKENRING      0x04
+#define PXE_IFTYPE_FIBRE_CHANNEL  0x12
+
+typedef struct s_pxe_hw_undi {
+  PXE_UINT32  Signature;      ///< PXE_ROMID_SIGNATURE.
+  PXE_UINT8   Len;            ///< sizeof(PXE_HW_UNDI).
+  PXE_UINT8   Fudge;          ///< makes 8-bit cksum equal zero.
+  PXE_UINT8   Rev;            ///< PXE_ROMID_REV.
+  PXE_UINT8   IFcnt;          ///< physical connector count lower byte.
+  PXE_UINT8   MajorVer;       ///< PXE_ROMID_MAJORVER.
+  PXE_UINT8   MinorVer;       ///< PXE_ROMID_MINORVER.
+  PXE_UINT8   IFcntExt;       ///< physical connector count upper byte.
+  PXE_UINT8   reserved;       ///< zero, not used.
+  PXE_UINT32  Implementation; ///< implementation flags.
+  ///< reserved             ///< vendor use.
+  ///< UINT32 Status;       ///< status port.
+  ///< UINT32 Command;      ///< command port.
+  ///< UINT64 CDBaddr;      ///< CDB address port.
+  ///<
+} PXE_HW_UNDI;
+
+///
+/// Status port bit definitions.
+///
+
+///
+/// UNDI operation state.
+///
+#define PXE_HWSTAT_STATE_MASK   0xC0000000
+#define PXE_HWSTAT_BUSY         0xC0000000
+#define PXE_HWSTAT_INITIALIZED  0x80000000
+#define PXE_HWSTAT_STARTED      0x40000000
+#define PXE_HWSTAT_STOPPED      0x00000000
+
+///
+/// If set, last command failed.
+///
+#define PXE_HWSTAT_COMMAND_FAILED 0x20000000
+
+///
+/// If set, identifies enabled receive filters.
+///
+#define PXE_HWSTAT_PROMISCUOUS_MULTICAST_RX_ENABLED 0x00001000
+#define PXE_HWSTAT_PROMISCUOUS_RX_ENABLED           0x00000800
+#define PXE_HWSTAT_BROADCAST_RX_ENABLED             0x00000400
+#define PXE_HWSTAT_MULTICAST_RX_ENABLED             0x00000200
+#define PXE_HWSTAT_UNICAST_RX_ENABLED               0x00000100
+
+///
+/// If set, identifies enabled external interrupts.
+///
+#define PXE_HWSTAT_SOFTWARE_INT_ENABLED     0x00000080
+#define PXE_HWSTAT_TX_COMPLETE_INT_ENABLED  0x00000040
+#define PXE_HWSTAT_PACKET_RX_INT_ENABLED    0x00000020
+#define PXE_HWSTAT_CMD_COMPLETE_INT_ENABLED 0x00000010
+
+///
+/// If set, identifies pending interrupts.
+///
+#define PXE_HWSTAT_SOFTWARE_INT_PENDING     0x00000008
+#define PXE_HWSTAT_TX_COMPLETE_INT_PENDING  0x00000004
+#define PXE_HWSTAT_PACKET_RX_INT_PENDING    0x00000002
+#define PXE_HWSTAT_CMD_COMPLETE_INT_PENDING 0x00000001
+
+///
+/// Command port definitions.
+///
+
+///
+/// If set, CDB identified in CDBaddr port is given to UNDI.
+/// If not set, other bits in this word will be processed.
+///
+#define PXE_HWCMD_ISSUE_COMMAND   0x80000000
+#define PXE_HWCMD_INTS_AND_FILTS  0x00000000
+
+///
+/// Use these to enable/disable receive filters.
+///
+#define PXE_HWCMD_PROMISCUOUS_MULTICAST_RX_ENABLE 0x00001000
+#define PXE_HWCMD_PROMISCUOUS_RX_ENABLE           0x00000800
+#define PXE_HWCMD_BROADCAST_RX_ENABLE             0x00000400
+#define PXE_HWCMD_MULTICAST_RX_ENABLE             0x00000200
+#define PXE_HWCMD_UNICAST_RX_ENABLE               0x00000100
+
+///
+/// Use these to enable/disable external interrupts.
+///
+#define PXE_HWCMD_SOFTWARE_INT_ENABLE     0x00000080
+#define PXE_HWCMD_TX_COMPLETE_INT_ENABLE  0x00000040
+#define PXE_HWCMD_PACKET_RX_INT_ENABLE    0x00000020
+#define PXE_HWCMD_CMD_COMPLETE_INT_ENABLE 0x00000010
+
+///
+/// Use these to clear pending external interrupts.
+///
+#define PXE_HWCMD_CLEAR_SOFTWARE_INT      0x00000008
+#define PXE_HWCMD_CLEAR_TX_COMPLETE_INT   0x00000004
+#define PXE_HWCMD_CLEAR_PACKET_RX_INT     0x00000002
+#define PXE_HWCMD_CLEAR_CMD_COMPLETE_INT  0x00000001
+
+typedef struct s_pxe_sw_undi {
+  PXE_UINT32  Signature;      ///< PXE_ROMID_SIGNATURE.
+  PXE_UINT8   Len;            ///< sizeof(PXE_SW_UNDI).
+  PXE_UINT8   Fudge;          ///< makes 8-bit cksum zero.
+  PXE_UINT8   Rev;            ///< PXE_ROMID_REV.
+  PXE_UINT8   IFcnt;          ///< physical connector count lower byte.
+  PXE_UINT8   MajorVer;       ///< PXE_ROMID_MAJORVER.
+  PXE_UINT8   MinorVer;       ///< PXE_ROMID_MINORVER.
+  PXE_UINT8   IFcntExt;       ///< physical connector count upper byte.
+  PXE_UINT8   reserved1;      ///< zero, not used.
+  PXE_UINT32  Implementation; ///< Implementation flags.
+  PXE_UINT64  EntryPoint;     ///< API entry point.
+  PXE_UINT8   reserved2[3];   ///< zero, not used.
+  PXE_UINT8   BusCnt;         ///< number of bustypes supported.
+  PXE_UINT32  BusType[1];     ///< list of supported bustypes.
+} PXE_SW_UNDI;
+
+typedef union u_pxe_undi {
+  PXE_HW_UNDI hw;
+  PXE_SW_UNDI sw;
+} PXE_UNDI;
+
+///
+/// Signature of !PXE structure.
+///
+#define PXE_ROMID_SIGNATURE PXE_BUSTYPE ('!', 'P', 'X', 'E')
+
+///
+/// !PXE structure format revision
+///.
+#define PXE_ROMID_REV 0x02
+
+///
+/// UNDI command interface revision.  These are the values that get sent
+/// in option 94 (Client Network Interface Identifier) in the DHCP Discover
+/// and PXE Boot Server Request packets.
+///
+#define PXE_ROMID_MAJORVER    0x03
+#define PXE_ROMID_MINORVER    0x01
+
+///
+/// Implementation flags.
+///
+#define PXE_ROMID_IMP_HW_UNDI                             0x80000000
+#define PXE_ROMID_IMP_SW_VIRT_ADDR                        0x40000000
+#define PXE_ROMID_IMP_64BIT_DEVICE                        0x00010000
+#define PXE_ROMID_IMP_FRAG_SUPPORTED                      0x00008000
+#define PXE_ROMID_IMP_CMD_LINK_SUPPORTED                  0x00004000
+#define PXE_ROMID_IMP_CMD_QUEUE_SUPPORTED                 0x00002000
+#define PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED               0x00001000
+#define PXE_ROMID_IMP_NVDATA_SUPPORT_MASK                 0x00000C00
+#define PXE_ROMID_IMP_NVDATA_BULK_WRITABLE                0x00000C00
+#define PXE_ROMID_IMP_NVDATA_SPARSE_WRITABLE              0x00000800
+#define PXE_ROMID_IMP_NVDATA_READ_ONLY                    0x00000400
+#define PXE_ROMID_IMP_NVDATA_NOT_AVAILABLE                0x00000000
+#define PXE_ROMID_IMP_STATISTICS_SUPPORTED                0x00000200
+#define PXE_ROMID_IMP_STATION_ADDR_SETTABLE               0x00000100
+#define PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED  0x00000080
+#define PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED            0x00000040
+#define PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED              0x00000020
+#define PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED     0x00000010
+#define PXE_ROMID_IMP_SOFTWARE_INT_SUPPORTED              0x00000008
+#define PXE_ROMID_IMP_TX_COMPLETE_INT_SUPPORTED           0x00000004
+#define PXE_ROMID_IMP_PACKET_RX_INT_SUPPORTED             0x00000002
+#define PXE_ROMID_IMP_CMD_COMPLETE_INT_SUPPORTED          0x00000001
+
+typedef struct s_pxe_cdb {
+  PXE_OPCODE    OpCode;
+  PXE_OPFLAGS   OpFlags;
+  PXE_UINT16    CPBsize;
+  PXE_UINT16    DBsize;
+  PXE_UINT64    CPBaddr;
+  PXE_UINT64    DBaddr;
+  PXE_STATCODE  StatCode;
+  PXE_STATFLAGS StatFlags;
+  PXE_UINT16    IFnum;
+  PXE_CONTROL   Control;
+} PXE_CDB;
+
+typedef union u_pxe_ip_addr {
+  PXE_IPV6  IPv6;
+  PXE_IPV4  IPv4;
+} PXE_IP_ADDR;
+
+typedef union pxe_device {
+  ///
+  /// PCI and PC Card NICs are both identified using bus, device
+  /// and function numbers.  For PC Card, this may require PC
+  /// Card services to be loaded in the BIOS or preboot
+  /// environment.
+  ///
+  struct {
+    ///
+    /// See S/W UNDI ROMID structure definition for PCI and
+    /// PCC BusType definitions.
+    ///
+    PXE_UINT32  BusType;
+
+    ///
+    /// Bus, device & function numbers that locate this device.
+    ///
+    PXE_UINT16  Bus;
+    PXE_UINT8   Device;
+    PXE_UINT8   Function;
+  }
+  PCI, PCC;
+
+} PXE_DEVICE;
+
+///
+/// cpb and db definitions
+///
+#define MAX_PCI_CONFIG_LEN    64  ///< # of dwords.
+#define MAX_EEPROM_LEN        128 ///< # of dwords.
+#define MAX_XMIT_BUFFERS      32  ///< recycling Q length for xmit_done.
+#define MAX_MCAST_ADDRESS_CNT 8
+
+typedef struct s_pxe_cpb_start_30 {
+  ///
+  /// PXE_VOID Delay(UINTN microseconds);
+  ///
+  /// UNDI will never request a delay smaller than 10 microseconds
+  /// and will always request delays in increments of 10 microseconds.
+  /// The Delay() CallBack routine must delay between n and n + 10
+  /// microseconds before returning control to the UNDI.
+  ///
+  /// This field cannot be set to zero.
+  ///
+  UINT64  Delay;
+
+  ///
+  /// PXE_VOID Block(UINT32 enable);
+  ///
+  /// UNDI may need to block multi-threaded/multi-processor access to
+  /// critical code sections when programming or accessing the network
+  /// device.  To this end, a blocking service is needed by the UNDI.
+  /// When UNDI needs a block, it will call Block() passing a non-zero
+  /// value.  When UNDI no longer needs a block, it will call Block()
+  /// with a zero value.  When called, if the Block() is already enabled,
+  /// do not return control to the UNDI until the previous Block() is
+  /// disabled.
+  ///
+  /// This field cannot be set to zero.
+  ///
+  UINT64  Block;
+
+  ///
+  /// PXE_VOID Virt2Phys(UINT64 virtual, UINT64 physical_ptr);
+  ///
+  /// UNDI will pass the virtual address of a buffer and the virtual
+  /// address of a 64-bit physical buffer.  Convert the virtual address
+  /// to a physical address and write the result to the physical address
+  /// buffer.  If virtual and physical addresses are the same, just
+  /// copy the virtual address to the physical address buffer.
+  ///
+  /// This field can be set to zero if virtual and physical addresses
+  /// are equal.
+  ///
+  UINT64  Virt2Phys;
+  ///
+  /// PXE_VOID Mem_IO(UINT8 read_write, UINT8 len, UINT64 port,
+  ///              UINT64 buf_addr);
+  ///
+  /// UNDI will read or write the device io space using this call back
+  /// function. It passes the number of bytes as the len parameter and it
+  /// will be either 1,2,4 or 8.
+  ///
+  /// This field can not be set to zero.
+  ///
+  UINT64  Mem_IO;
+} PXE_CPB_START_30;
+
+typedef struct s_pxe_cpb_start_31 {
+  ///
+  /// PXE_VOID Delay(UINT64 UnqId, UINTN microseconds);
+  ///
+  /// UNDI will never request a delay smaller than 10 microseconds
+  /// and will always request delays in increments of 10 microseconds.
+  /// The Delay() CallBack routine must delay between n and n + 10
+  /// microseconds before returning control to the UNDI.
+  ///
+  /// This field cannot be set to zero.
+  ///
+  UINT64  Delay;
+
+  ///
+  /// PXE_VOID Block(UINT64 unq_id, UINT32 enable);
+  ///
+  /// UNDI may need to block multi-threaded/multi-processor access to
+  /// critical code sections when programming or accessing the network
+  /// device.  To this end, a blocking service is needed by the UNDI.
+  /// When UNDI needs a block, it will call Block() passing a non-zero
+  /// value.  When UNDI no longer needs a block, it will call Block()
+  /// with a zero value.  When called, if the Block() is already enabled,
+  /// do not return control to the UNDI until the previous Block() is
+  /// disabled.
+  ///
+  /// This field cannot be set to zero.
+  ///
+  UINT64  Block;
+
+  ///
+  /// PXE_VOID Virt2Phys(UINT64 UnqId, UINT64 virtual, UINT64 physical_ptr);
+  ///
+  /// UNDI will pass the virtual address of a buffer and the virtual
+  /// address of a 64-bit physical buffer.  Convert the virtual address
+  /// to a physical address and write the result to the physical address
+  /// buffer.  If virtual and physical addresses are the same, just
+  /// copy the virtual address to the physical address buffer.
+  ///
+  /// This field can be set to zero if virtual and physical addresses
+  /// are equal.
+  ///
+  UINT64  Virt2Phys;
+  ///
+  /// PXE_VOID Mem_IO(UINT64 UnqId, UINT8 read_write, UINT8 len, UINT64 port,
+  ///              UINT64 buf_addr);
+  ///
+  /// UNDI will read or write the device io space using this call back
+  /// function. It passes the number of bytes as the len parameter and it
+  /// will be either 1,2,4 or 8.
+  ///
+  /// This field can not be set to zero.
+  ///
+  UINT64  Mem_IO;
+  ///
+  /// PXE_VOID Map_Mem(UINT64 unq_id, UINT64 virtual_addr, UINT32 size,
+  ///                 UINT32 Direction, UINT64 mapped_addr);
+  ///
+  /// UNDI will pass the virtual address of a buffer, direction of the data
+  /// flow from/to the mapped buffer (the constants are defined below)
+  /// and a place holder (pointer) for the mapped address.
+  /// This call will Map the given address to a physical DMA address and write
+  /// the result to the mapped_addr pointer.  If there is no need to
+  /// map the given address to a lower address (i.e. the given address is
+  /// associated with a physical address that is already compatible to be
+  /// used with the DMA, it converts the given virtual address to it's
+  /// physical address and write that in the mapped address pointer.
+  ///
+  /// This field can be set to zero if there is no mapping service available.
+  ///
+  UINT64  Map_Mem;
+
+  ///
+  /// PXE_VOID UnMap_Mem(UINT64 unq_id, UINT64 virtual_addr, UINT32 size,
+  ///            UINT32 Direction, UINT64 mapped_addr);
+  ///
+  /// UNDI will pass the virtual and mapped addresses of a buffer.
+  /// This call will un map the given address.
+  ///
+  /// This field can be set to zero if there is no unmapping service available.
+  ///
+  UINT64  UnMap_Mem;
+
+  ///
+  /// PXE_VOID Sync_Mem(UINT64 unq_id, UINT64 virtual,
+  ///            UINT32 size, UINT32 Direction, UINT64 mapped_addr);
+  ///
+  /// UNDI will pass the virtual and mapped addresses of a buffer.
+  /// This call will synchronize the contents of both the virtual and mapped.
+  /// buffers for the given Direction.
+  ///
+  /// This field can be set to zero if there is no service available.
+  ///
+  UINT64  Sync_Mem;
+
+  ///
+  /// protocol driver can provide anything for this Unique_ID, UNDI remembers
+  /// that as just a 64bit value associated to the interface specified by
+  /// the ifnum and gives it back as a parameter to all the call-back routines
+  /// when calling for that interface!
+  ///
+  UINT64  Unique_ID;
+} PXE_CPB_START_31;
+
+#define TO_AND_FROM_DEVICE    0
+#define FROM_DEVICE           1
+#define TO_DEVICE             2
+
+#define PXE_DELAY_MILLISECOND 1000
+#define PXE_DELAY_SECOND      1000000
+#define PXE_IO_READ           0
+#define PXE_IO_WRITE          1
+#define PXE_MEM_READ          2
+#define PXE_MEM_WRITE         4
+
+typedef struct s_pxe_db_get_init_info {
+  ///
+  /// Minimum length of locked memory buffer that must be given to
+  /// the Initialize command. Giving UNDI more memory will generally
+  /// give better performance.
+  ///
+  /// If MemoryRequired is zero, the UNDI does not need and will not
+  /// use system memory to receive and transmit packets.
+  ///
+  PXE_UINT32  MemoryRequired;
+
+  ///
+  /// Maximum frame data length for Tx/Rx excluding the media header.
+  ///
+  PXE_UINT32  FrameDataLen;
+
+  ///
+  /// Supported link speeds are in units of mega bits.  Common ethernet
+  /// values are 10, 100 and 1000.  Unused LinkSpeeds[] entries are zero
+  /// filled.
+  ///
+  PXE_UINT32  LinkSpeeds[4];
+
+  ///
+  /// Number of non-volatile storage items.
+  ///
+  PXE_UINT32  NvCount;
+
+  ///
+  /// Width of non-volatile storage item in bytes.  0, 1, 2 or 4
+  ///
+  PXE_UINT16  NvWidth;
+
+  ///
+  /// Media header length.  This is the typical media header length for
+  /// this UNDI.  This information is needed when allocating receive
+  /// and transmit buffers.
+  ///
+  PXE_UINT16  MediaHeaderLen;
+
+  ///
+  /// Number of bytes in the NIC hardware (MAC) address.
+  ///
+  PXE_UINT16  HWaddrLen;
+
+  ///
+  /// Maximum number of multicast MAC addresses in the multicast
+  /// MAC address filter list.
+  ///
+  PXE_UINT16  MCastFilterCnt;
+
+  ///
+  /// Default number and size of transmit and receive buffers that will
+  /// be allocated by the UNDI.  If MemoryRequired is non-zero, this
+  /// allocation will come out of the memory buffer given to the Initialize
+  /// command.  If MemoryRequired is zero, this allocation will come out of
+  /// memory on the NIC.
+  ///
+  PXE_UINT16  TxBufCnt;
+  PXE_UINT16  TxBufSize;
+  PXE_UINT16  RxBufCnt;
+  PXE_UINT16  RxBufSize;
+
+  ///
+  /// Hardware interface types defined in the Assigned Numbers RFC
+  /// and used in DHCP and ARP packets.
+  /// See the PXE_IFTYPE typedef and PXE_IFTYPE_xxx macros.
+  ///
+  PXE_UINT8   IFtype;
+
+  ///
+  /// Supported duplex.  See PXE_DUPLEX_xxxxx #defines below.
+  ///
+  PXE_UINT8   SupportedDuplexModes;
+
+  ///
+  /// Supported loopback options.  See PXE_LOOPBACK_xxxxx #defines below.
+  ///
+  PXE_UINT8   SupportedLoopBackModes;
+} PXE_DB_GET_INIT_INFO;
+
+#define PXE_MAX_TXRX_UNIT_ETHER           1500
+
+#define PXE_HWADDR_LEN_ETHER              0x0006
+#define PXE_MAC_HEADER_LEN_ETHER          0x000E
+
+#define PXE_DUPLEX_ENABLE_FULL_SUPPORTED  1
+#define PXE_DUPLEX_FORCE_FULL_SUPPORTED   2
+
+#define PXE_LOOPBACK_INTERNAL_SUPPORTED   1
+#define PXE_LOOPBACK_EXTERNAL_SUPPORTED   2
+
+typedef struct s_pxe_pci_config_info {
+  ///
+  /// This is the flag field for the PXE_DB_GET_CONFIG_INFO union.
+  /// For PCI bus devices, this field is set to PXE_BUSTYPE_PCI.
+  ///
+  UINT32  BusType;
+
+  ///
+  /// This identifies the PCI network device that this UNDI interface.
+  /// is bound to.
+  ///
+  UINT16  Bus;
+  UINT8   Device;
+  UINT8   Function;
+
+  ///
+  /// This is a copy of the PCI configuration space for this
+  /// network device.
+  ///
+  union {
+    UINT8   Byte[256];
+    UINT16  Word[128];
+    UINT32  Dword[64];
+  } Config;
+} PXE_PCI_CONFIG_INFO;
+
+typedef struct s_pxe_pcc_config_info {
+  ///
+  /// This is the flag field for the PXE_DB_GET_CONFIG_INFO union.
+  /// For PCC bus devices, this field is set to PXE_BUSTYPE_PCC.
+  ///
+  PXE_UINT32  BusType;
+
+  ///
+  /// This identifies the PCC network device that this UNDI interface
+  /// is bound to.
+  ///
+  PXE_UINT16  Bus;
+  PXE_UINT8   Device;
+  PXE_UINT8   Function;
+
+  ///
+  /// This is a copy of the PCC configuration space for this
+  /// network device.
+  ///
+  union {
+    PXE_UINT8   Byte[256];
+    PXE_UINT16  Word[128];
+    PXE_UINT32  Dword[64];
+  } Config;
+} PXE_PCC_CONFIG_INFO;
+
+typedef union u_pxe_db_get_config_info {
+  PXE_PCI_CONFIG_INFO   pci;
+  PXE_PCC_CONFIG_INFO   pcc;
+} PXE_DB_GET_CONFIG_INFO;
+
+typedef struct s_pxe_cpb_initialize {
+  ///
+  /// Address of first (lowest) byte of the memory buffer.  This buffer must
+  /// be in contiguous physical memory and cannot be swapped out.  The UNDI
+  /// will be using this for transmit and receive buffering.
+  ///
+  PXE_UINT64  MemoryAddr;
+
+  ///
+  /// MemoryLength must be greater than or equal to MemoryRequired
+  /// returned by the Get Init Info command.
+  ///
+  PXE_UINT32  MemoryLength;
+
+  ///
+  /// Desired link speed in Mbit/sec.  Common ethernet values are 10, 100
+  /// and 1000.  Setting a value of zero will auto-detect and/or use the
+  /// default link speed (operation depends on UNDI/NIC functionality).
+  ///
+  PXE_UINT32  LinkSpeed;
+
+  ///
+  /// Suggested number and size of receive and transmit buffers to
+  /// allocate.  If MemoryAddr and MemoryLength are non-zero, this
+  /// allocation comes out of the supplied memory buffer.  If MemoryAddr
+  /// and MemoryLength are zero, this allocation comes out of memory
+  /// on the NIC.
+  ///
+  /// If these fields are set to zero, the UNDI will allocate buffer
+  /// counts and sizes as it sees fit.
+  ///
+  PXE_UINT16  TxBufCnt;
+  PXE_UINT16  TxBufSize;
+  PXE_UINT16  RxBufCnt;
+  PXE_UINT16  RxBufSize;
+
+  ///
+  /// The following configuration parameters are optional and must be zero
+  /// to use the default values.
+  ///
+  PXE_UINT8   DuplexMode;
+
+  PXE_UINT8   LoopBackMode;
+} PXE_CPB_INITIALIZE;
+
+#define PXE_DUPLEX_DEFAULT      0x00
+#define PXE_FORCE_FULL_DUPLEX   0x01
+#define PXE_ENABLE_FULL_DUPLEX  0x02
+#define PXE_FORCE_HALF_DUPLEX   0x04
+#define PXE_DISABLE_FULL_DUPLEX 0x08
+
+#define LOOPBACK_NORMAL         0
+#define LOOPBACK_INTERNAL       1
+#define LOOPBACK_EXTERNAL       2
+
+typedef struct s_pxe_db_initialize {
+  ///
+  /// Actual amount of memory used from the supplied memory buffer.  This
+  /// may be less that the amount of memory suppllied and may be zero if
+  /// the UNDI and network device do not use external memory buffers.
+  ///
+  /// Memory used by the UNDI and network device is allocated from the
+  /// lowest memory buffer address.
+  ///
+  PXE_UINT32  MemoryUsed;
+
+  ///
+  /// Actual number and size of receive and transmit buffers that were
+  /// allocated.
+  ///
+  PXE_UINT16  TxBufCnt;
+  PXE_UINT16  TxBufSize;
+  PXE_UINT16  RxBufCnt;
+  PXE_UINT16  RxBufSize;
+} PXE_DB_INITIALIZE;
+
+typedef struct s_pxe_cpb_receive_filters {
+  ///
+  /// List of multicast MAC addresses.  This list, if present, will
+  /// replace the existing multicast MAC address filter list.
+  ///
+  PXE_MAC_ADDR  MCastList[MAX_MCAST_ADDRESS_CNT];
+} PXE_CPB_RECEIVE_FILTERS;
+
+typedef struct s_pxe_db_receive_filters {
+  ///
+  /// Filtered multicast MAC address list.
+  ///
+  PXE_MAC_ADDR  MCastList[MAX_MCAST_ADDRESS_CNT];
+} PXE_DB_RECEIVE_FILTERS;
+
+typedef struct s_pxe_cpb_station_address {
+  ///
+  /// If supplied and supported, the current station MAC address
+  /// will be changed.
+  ///
+  PXE_MAC_ADDR  StationAddr;
+} PXE_CPB_STATION_ADDRESS;
+
+typedef struct s_pxe_dpb_station_address {
+  ///
+  /// Current station MAC address.
+  ///
+  PXE_MAC_ADDR  StationAddr;
+
+  ///
+  /// Station broadcast MAC address.
+  ///
+  PXE_MAC_ADDR  BroadcastAddr;
+
+  ///
+  /// Permanent station MAC address.
+  ///
+  PXE_MAC_ADDR  PermanentAddr;
+} PXE_DB_STATION_ADDRESS;
+
+typedef struct s_pxe_db_statistics {
+  ///
+  /// Bit field identifying what statistic data is collected by the
+  /// UNDI/NIC.
+  /// If bit 0x00 is set, Data[0x00] is collected.
+  /// If bit 0x01 is set, Data[0x01] is collected.
+  /// If bit 0x20 is set, Data[0x20] is collected.
+  /// If bit 0x21 is set, Data[0x21] is collected.
+  /// Etc.
+  ///
+  PXE_UINT64  Supported;
+
+  ///
+  /// Statistic data.
+  ///
+  PXE_UINT64  Data[64];
+} PXE_DB_STATISTICS;
+
+///
+/// Total number of frames received.  Includes frames with errors and
+/// dropped frames.
+///
+#define PXE_STATISTICS_RX_TOTAL_FRAMES  0x00
+
+///
+/// Number of valid frames received and copied into receive buffers.
+///
+#define PXE_STATISTICS_RX_GOOD_FRAMES 0x01
+
+///
+/// Number of frames below the minimum length for the media.
+/// This would be <64 for ethernet.
+///
+#define PXE_STATISTICS_RX_UNDERSIZE_FRAMES  0x02
+
+///
+/// Number of frames longer than the maxminum length for the
+/// media.  This would be >1500 for ethernet.
+///
+#define PXE_STATISTICS_RX_OVERSIZE_FRAMES 0x03
+
+///
+/// Valid frames that were dropped because receive buffers were full.
+///
+#define PXE_STATISTICS_RX_DROPPED_FRAMES  0x04
+
+///
+/// Number of valid unicast frames received and not dropped.
+///
+#define PXE_STATISTICS_RX_UNICAST_FRAMES  0x05
+
+///
+/// Number of valid broadcast frames received and not dropped.
+///
+#define PXE_STATISTICS_RX_BROADCAST_FRAMES  0x06
+
+///
+/// Number of valid mutlicast frames received and not dropped.
+///
+#define PXE_STATISTICS_RX_MULTICAST_FRAMES  0x07
+
+///
+/// Number of frames w/ CRC or alignment errors.
+///
+#define PXE_STATISTICS_RX_CRC_ERROR_FRAMES  0x08
+
+///
+/// Total number of bytes received.  Includes frames with errors
+/// and dropped frames.
+///
+#define PXE_STATISTICS_RX_TOTAL_BYTES 0x09
+
+///
+/// Transmit statistics.
+///
+#define PXE_STATISTICS_TX_TOTAL_FRAMES      0x0A
+#define PXE_STATISTICS_TX_GOOD_FRAMES       0x0B
+#define PXE_STATISTICS_TX_UNDERSIZE_FRAMES  0x0C
+#define PXE_STATISTICS_TX_OVERSIZE_FRAMES   0x0D
+#define PXE_STATISTICS_TX_DROPPED_FRAMES    0x0E
+#define PXE_STATISTICS_TX_UNICAST_FRAMES    0x0F
+#define PXE_STATISTICS_TX_BROADCAST_FRAMES  0x10
+#define PXE_STATISTICS_TX_MULTICAST_FRAMES  0x11
+#define PXE_STATISTICS_TX_CRC_ERROR_FRAMES  0x12
+#define PXE_STATISTICS_TX_TOTAL_BYTES       0x13
+
+///
+/// Number of collisions detection on this subnet.
+///
+#define PXE_STATISTICS_COLLISIONS 0x14
+
+///
+/// Number of frames destined for unsupported protocol.
+///
+#define PXE_STATISTICS_UNSUPPORTED_PROTOCOL 0x15
+
+///
+/// Number of valid frames received that were duplicated.
+///
+#define PXE_STATISTICS_RX_DUPLICATED_FRAMES 0x16
+
+///
+/// Number of encrypted frames received that failed to decrypt.
+///
+#define PXE_STATISTICS_RX_DECRYPT_ERROR_FRAMES 0x17
+
+///
+/// Number of frames that failed to transmit after exceeding the retry limit.
+///
+#define PXE_STATISTICS_TX_ERROR_FRAMES 0x18
+
+///
+/// Number of frames transmitted successfully after more than one attempt.
+///
+#define PXE_STATISTICS_TX_RETRY_FRAMES 0x19
+
+typedef struct s_pxe_cpb_mcast_ip_to_mac {
+  ///
+  /// Multicast IP address to be converted to multicast MAC address.
+  ///
+  PXE_IP_ADDR IP;
+} PXE_CPB_MCAST_IP_TO_MAC;
+
+typedef struct s_pxe_db_mcast_ip_to_mac {
+  ///
+  /// Multicast MAC address.
+  ///
+  PXE_MAC_ADDR  MAC;
+} PXE_DB_MCAST_IP_TO_MAC;
+
+typedef struct s_pxe_cpb_nvdata_sparse {
+  ///
+  /// NvData item list.  Only items in this list will be updated.
+  ///
+  struct {
+    ///
+    ///  Non-volatile storage address to be changed.
+    ///
+    PXE_UINT32  Addr;
+
+    ///
+    /// Data item to write into above storage address.
+    ///
+    union {
+      PXE_UINT8   Byte;
+      PXE_UINT16  Word;
+      PXE_UINT32  Dword;
+    } Data;
+  } Item[MAX_EEPROM_LEN];
+} PXE_CPB_NVDATA_SPARSE;
+
+///
+/// When using bulk update, the size of the CPB structure must be
+/// the same size as the non-volatile NIC storage.
+///
+typedef union u_pxe_cpb_nvdata_bulk {
+  ///
+  /// Array of byte-wide data items.
+  ///
+  PXE_UINT8   Byte[MAX_EEPROM_LEN << 2];
+
+  ///
+  /// Array of word-wide data items.
+  ///
+  PXE_UINT16  Word[MAX_EEPROM_LEN << 1];
+
+  ///
+  /// Array of dword-wide data items.
+  ///
+  PXE_UINT32  Dword[MAX_EEPROM_LEN];
+} PXE_CPB_NVDATA_BULK;
+
+typedef struct s_pxe_db_nvdata {
+  ///
+  /// Arrays of data items from non-volatile storage.
+  ///
+  union {
+    ///
+    /// Array of byte-wide data items.
+    ///
+    PXE_UINT8   Byte[MAX_EEPROM_LEN << 2];
+
+    ///
+    /// Array of word-wide data items.
+    ///
+    PXE_UINT16  Word[MAX_EEPROM_LEN << 1];
+
+    ///
+    /// Array of dword-wide data items.
+    ///
+    PXE_UINT32  Dword[MAX_EEPROM_LEN];
+  } Data;
+} PXE_DB_NVDATA;
+
+typedef struct s_pxe_db_get_status {
+  ///
+  /// Length of next receive frame (header + data).  If this is zero,
+  /// there is no next receive frame available.
+  ///
+  PXE_UINT32  RxFrameLen;
+
+  ///
+  /// Reserved, set to zero.
+  ///
+  PXE_UINT32  reserved;
+
+  ///
+  ///  Addresses of transmitted buffers that need to be recycled.
+  ///
+  PXE_UINT64  TxBuffer[MAX_XMIT_BUFFERS];
+} PXE_DB_GET_STATUS;
+
+typedef struct s_pxe_cpb_fill_header {
+  ///
+  /// Source and destination MAC addresses.  These will be copied into
+  /// the media header without doing byte swapping.
+  ///
+  PXE_MAC_ADDR  SrcAddr;
+  PXE_MAC_ADDR  DestAddr;
+
+  ///
+  /// Address of first byte of media header.  The first byte of packet data
+  /// follows the last byte of the media header.
+  ///
+  PXE_UINT64        MediaHeader;
+
+  ///
+  /// Length of packet data in bytes (not including the media header).
+  ///
+  PXE_UINT32        PacketLen;
+
+  ///
+  /// Protocol type.  This will be copied into the media header without
+  /// doing byte swapping.  Protocol type numbers can be obtained from
+  /// the Assigned Numbers RFC 1700.
+  ///
+  PXE_UINT16        Protocol;
+
+  ///
+  /// Length of the media header in bytes.
+  ///
+  PXE_UINT16        MediaHeaderLen;
+} PXE_CPB_FILL_HEADER;
+
+#define PXE_PROTOCOL_ETHERNET_IP  0x0800
+#define PXE_PROTOCOL_ETHERNET_ARP 0x0806
+#define MAX_XMIT_FRAGMENTS        16
+
+typedef struct s_pxe_cpb_fill_header_fragmented {
+  ///
+  /// Source and destination MAC addresses.  These will be copied into
+  /// the media header without doing byte swapping.
+  ///
+  PXE_MAC_ADDR        SrcAddr;
+  PXE_MAC_ADDR        DestAddr;
+
+  ///
+  /// Length of packet data in bytes (not including the media header).
+  ///
+  PXE_UINT32          PacketLen;
+
+  ///
+  /// Protocol type.  This will be copied into the media header without
+  /// doing byte swapping.  Protocol type numbers can be obtained from
+  /// the Assigned Numbers RFC 1700.
+  ///
+  PXE_MEDIA_PROTOCOL  Protocol;
+
+  ///
+  /// Length of the media header in bytes.
+  ///
+  PXE_UINT16          MediaHeaderLen;
+
+  ///
+  /// Number of packet fragment descriptors.
+  ///
+  PXE_UINT16          FragCnt;
+
+  ///
+  /// Reserved, must be set to zero.
+  ///
+  PXE_UINT16          reserved;
+
+  ///
+  /// Array of packet fragment descriptors.  The first byte of the media
+  /// header is the first byte of the first fragment.
+  ///
+  struct {
+    ///
+    /// Address of this packet fragment.
+    ///
+    PXE_UINT64  FragAddr;
+
+    ///
+    /// Length of this packet fragment.
+    ///
+    PXE_UINT32  FragLen;
+
+    ///
+    /// Reserved, must be set to zero.
+    ///
+    PXE_UINT32  reserved;
+  } FragDesc[MAX_XMIT_FRAGMENTS];
+}
+PXE_CPB_FILL_HEADER_FRAGMENTED;
+
+typedef struct s_pxe_cpb_transmit {
+  ///
+  /// Address of first byte of frame buffer.  This is also the first byte
+  /// of the media header.
+  ///
+  PXE_UINT64  FrameAddr;
+
+  ///
+  /// Length of the data portion of the frame buffer in bytes.  Do not
+  /// include the length of the media header.
+  ///
+  PXE_UINT32  DataLen;
+
+  ///
+  /// Length of the media header in bytes.
+  ///
+  PXE_UINT16  MediaheaderLen;
+
+  ///
+  /// Reserved, must be zero.
+  ///
+  PXE_UINT16  reserved;
+} PXE_CPB_TRANSMIT;
+
+typedef struct s_pxe_cpb_transmit_fragments {
+  ///
+  /// Length of packet data in bytes (not including the media header).
+  ///
+  PXE_UINT32  FrameLen;
+
+  ///
+  /// Length of the media header in bytes.
+  ///
+  PXE_UINT16  MediaheaderLen;
+
+  ///
+  /// Number of packet fragment descriptors.
+  ///
+  PXE_UINT16  FragCnt;
+
+  ///
+  /// Array of frame fragment descriptors.  The first byte of the first
+  /// fragment is also the first byte of the media header.
+  ///
+  struct {
+    ///
+    /// Address of this frame fragment.
+    ///
+    PXE_UINT64  FragAddr;
+
+    ///
+    /// Length of this frame fragment.
+    ///
+    PXE_UINT32  FragLen;
+
+    ///
+    /// Reserved, must be set to zero.
+    ///
+    PXE_UINT32  reserved;
+  } FragDesc[MAX_XMIT_FRAGMENTS];
+}
+PXE_CPB_TRANSMIT_FRAGMENTS;
+
+typedef struct s_pxe_cpb_receive {
+  ///
+  /// Address of first byte of receive buffer.  This is also the first byte
+  /// of the frame header.
+  ///
+  PXE_UINT64  BufferAddr;
+
+  ///
+  /// Length of receive buffer.  This must be large enough to hold the
+  /// received frame (media header + data).  If the length of smaller than
+  /// the received frame, data will be lost.
+  ///
+  PXE_UINT32  BufferLen;
+
+  ///
+  /// Reserved, must be set to zero.
+  ///
+  PXE_UINT32  reserved;
+} PXE_CPB_RECEIVE;
+
+typedef struct s_pxe_db_receive {
+  ///
+  /// Source and destination MAC addresses from media header.
+  ///
+  PXE_MAC_ADDR        SrcAddr;
+  PXE_MAC_ADDR        DestAddr;
+
+  ///
+  /// Length of received frame.  May be larger than receive buffer size.
+  /// The receive buffer will not be overwritten.  This is how to tell
+  /// if data was lost because the receive buffer was too small.
+  ///
+  PXE_UINT32          FrameLen;
+
+  ///
+  /// Protocol type from media header.
+  ///
+  PXE_MEDIA_PROTOCOL  Protocol;
+
+  ///
+  /// Length of media header in received frame.
+  ///
+  PXE_UINT16          MediaHeaderLen;
+
+  ///
+  /// Type of receive frame.
+  ///
+  PXE_FRAME_TYPE      Type;
+
+  ///
+  /// Reserved, must be zero.
+  ///
+  PXE_UINT8           reserved[7];
+
+} PXE_DB_RECEIVE;
+
+#pragma pack()
+
+#endif
diff --git a/MdePkg/Include/Uefi/UefiSpec.h b/MdePkg/Include/Uefi/UefiSpec.h
new file mode 100644
index 000000000000..bea32b7f5e1b
--- /dev/null
+++ b/MdePkg/Include/Uefi/UefiSpec.h
@@ -0,0 +1,2194 @@
+/** @file
+  Include file that supports UEFI.
+
+  This include file must contain things defined in the UEFI 2.6 specification.
+  If a code construct is defined in the UEFI 2.6 specification it must be included
+  by this include file.
+
+Copyright (c) 2006 - 2016, 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 __UEFI_SPEC_H__
+#define __UEFI_SPEC_H__
+
+#include <Uefi/UefiMultiPhase.h>
+
+#include <Protocol/DevicePath.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Protocol/SimpleTextOut.h>
+
+///
+/// Enumeration of EFI memory allocation types.
+///
+typedef enum {
+  ///
+  /// Allocate any available range of pages that satisfies the request.
+  ///
+  AllocateAnyPages,
+  ///
+  /// Allocate any available range of pages whose uppermost address is less than 
+  /// or equal to a specified maximum address.
+  ///
+  AllocateMaxAddress,
+  ///
+  /// Allocate pages at a specified address.
+  ///
+  AllocateAddress,
+  ///
+  /// Maximum enumeration value that may be used for bounds checking.
+  ///
+  MaxAllocateType
+} EFI_ALLOCATE_TYPE;
+
+//
+// Bit definitions for EFI_TIME.Daylight
+//
+#define EFI_TIME_ADJUST_DAYLIGHT  0x01
+#define EFI_TIME_IN_DAYLIGHT      0x02
+
+///
+/// Value definition for EFI_TIME.TimeZone.
+///
+#define EFI_UNSPECIFIED_TIMEZONE  0x07FF
+
+//
+// Memory cacheability attributes
+//
+#define EFI_MEMORY_UC               0x0000000000000001ULL
+#define EFI_MEMORY_WC               0x0000000000000002ULL
+#define EFI_MEMORY_WT               0x0000000000000004ULL
+#define EFI_MEMORY_WB               0x0000000000000008ULL
+#define EFI_MEMORY_UCE              0x0000000000000010ULL
+//
+// Physical memory protection attributes
+//
+// Note: UEFI spec 2.5 and following: use EFI_MEMORY_RO as write-protected physical memory
+// protection attribute. Also, EFI_MEMORY_WP means cacheability attribute.
+//
+#define EFI_MEMORY_WP               0x0000000000001000ULL
+#define EFI_MEMORY_RP               0x0000000000002000ULL
+#define EFI_MEMORY_XP               0x0000000000004000ULL
+#define EFI_MEMORY_RO               0x0000000000020000ULL
+//
+// Physical memory persistence attribute. 
+// The memory region supports byte-addressable non-volatility.
+//
+#define EFI_MEMORY_NV               0x0000000000008000ULL
+//
+// The memory region provides higher reliability relative to other memory in the system.
+// If all memory has the same reliability, then this bit is not used.
+//
+#define EFI_MEMORY_MORE_RELIABLE    0x0000000000010000ULL
+//
+// Runtime memory attribute
+//
+#define EFI_MEMORY_RUNTIME          0x8000000000000000ULL
+
+///
+/// Memory descriptor version number.
+///
+#define EFI_MEMORY_DESCRIPTOR_VERSION 1
+
+///
+/// Definition of an EFI memory descriptor.
+///
+typedef struct {
+  ///
+  /// Type of the memory region.  See EFI_MEMORY_TYPE.
+  ///
+  UINT32                Type;
+  ///
+  /// Physical address of the first byte of the memory region.  Must aligned 
+  /// on a 4 KB boundary.
+  ///
+  EFI_PHYSICAL_ADDRESS  PhysicalStart;
+  ///
+  /// Virtual address of the first byte of the memory region.  Must aligned 
+  /// on a 4 KB boundary.
+  ///
+  EFI_VIRTUAL_ADDRESS   VirtualStart;
+  ///
+  /// Number of 4KB pages in the memory region.
+  ///
+  UINT64                NumberOfPages;
+  ///
+  /// Attributes of the memory region that describe the bit mask of capabilities
+  /// for that memory region, and not necessarily the current settings for that 
+  /// memory region.
+  ///
+  UINT64                Attribute;
+} EFI_MEMORY_DESCRIPTOR;
+
+/**
+  Allocates memory pages from the system.
+
+  @param[in]       Type         The type of allocation to perform.
+  @param[in]       MemoryType   The type of memory to allocate.
+                                MemoryType values in the range 0x70000000..0x7FFFFFFF
+                                are reserved for OEM use. MemoryType values in the range
+                                0x80000000..0xFFFFFFFF are reserved for use by UEFI OS loaders
+                                that are provided by operating system vendors.
+  @param[in]       Pages        The number of contiguous 4 KB pages to allocate.
+  @param[in, out]  Memory       The pointer to a physical address. On input, the way in which the address is
+                                used depends on the value of Type.
+
+  @retval EFI_SUCCESS           The requested pages were allocated.
+  @retval EFI_INVALID_PARAMETER 1) Type is not AllocateAnyPages or
+                                AllocateMaxAddress or AllocateAddress.
+                                2) MemoryType is in the range
+                                EfiMaxMemoryType..0x6FFFFFFF.
+                                3) Memory is NULL.
+                                4) MemoryType is EfiPersistentMemory.
+  @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
+  @retval EFI_NOT_FOUND         The requested pages could not be found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_PAGES)(
+  IN     EFI_ALLOCATE_TYPE            Type,
+  IN     EFI_MEMORY_TYPE              MemoryType,
+  IN     UINTN                        Pages,
+  IN OUT EFI_PHYSICAL_ADDRESS         *Memory
+  );
+
+/**
+  Frees memory pages.
+
+  @param[in]  Memory      The base physical address of the pages to be freed.
+  @param[in]  Pages       The number of contiguous 4 KB pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_PAGES)(
+  IN  EFI_PHYSICAL_ADDRESS         Memory,
+  IN  UINTN                        Pages
+  );
+
+/**
+  Returns the current memory map.
+
+  @param[in, out]  MemoryMapSize         A pointer to the size, in bytes, of the MemoryMap buffer.
+                                         On input, this is the size of the buffer allocated by the caller.
+                                         On output, it is the size of the buffer returned by the firmware if
+                                         the buffer was large enough, or the size of the buffer needed to contain
+                                         the map if the buffer was too small.
+  @param[in, out]  MemoryMap             A pointer to the buffer in which firmware places the current memory
+                                         map.
+  @param[out]      MapKey                A pointer to the location in which firmware returns the key for the
+                                         current memory map.
+  @param[out]      DescriptorSize        A pointer to the location in which firmware returns the size, in bytes, of
+                                         an individual EFI_MEMORY_DESCRIPTOR.
+  @param[out]      DescriptorVersion     A pointer to the location in which firmware returns the version number
+                                         associated with the EFI_MEMORY_DESCRIPTOR.
+
+  @retval EFI_SUCCESS           The memory map was returned in the MemoryMap buffer.
+  @retval EFI_BUFFER_TOO_SMALL  The MemoryMap buffer was too small. The current buffer size
+                                needed to hold the memory map is returned in MemoryMapSize.
+  @retval EFI_INVALID_PARAMETER 1) MemoryMapSize is NULL.
+                                2) The MemoryMap buffer is not too small and MemoryMap is
+                                   NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MEMORY_MAP)(
+  IN OUT UINTN                       *MemoryMapSize,
+  IN OUT EFI_MEMORY_DESCRIPTOR       *MemoryMap,
+  OUT    UINTN                       *MapKey,
+  OUT    UINTN                       *DescriptorSize,
+  OUT    UINT32                      *DescriptorVersion
+  );
+
+/**
+  Allocates pool memory.
+
+  @param[in]   PoolType         The type of pool to allocate.
+                                MemoryType values in the range 0x70000000..0x7FFFFFFF
+                                are reserved for OEM use. MemoryType values in the range
+                                0x80000000..0xFFFFFFFF are reserved for use by UEFI OS loaders
+                                that are provided by operating system vendors.
+  @param[in]   Size             The number of bytes to allocate from the pool.
+  @param[out]  Buffer           A pointer to a pointer to the allocated buffer if the call succeeds;
+                                undefined otherwise.
+
+  @retval EFI_SUCCESS           The requested number of bytes was allocated.
+  @retval EFI_OUT_OF_RESOURCES  The pool requested could not be allocated.
+  @retval EFI_INVALID_PARAMETER Buffer is NULL.
+                                PoolType is in the range EfiMaxMemoryType..0x6FFFFFFF.
+                                PoolType is EfiPersistentMemory.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_POOL)(
+  IN  EFI_MEMORY_TYPE              PoolType,
+  IN  UINTN                        Size,
+  OUT VOID                         **Buffer
+  );
+
+/**
+  Returns pool memory to the system.
+
+  @param[in]  Buffer            The pointer to the buffer to free.
+
+  @retval EFI_SUCCESS           The memory was returned to the system.
+  @retval EFI_INVALID_PARAMETER Buffer was invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_POOL)(
+  IN  VOID                         *Buffer
+  );
+
+/**
+  Changes the runtime addressing mode of EFI firmware from physical to virtual.
+
+  @param[in]  MemoryMapSize     The size in bytes of VirtualMap.
+  @param[in]  DescriptorSize    The size in bytes of an entry in the VirtualMap.
+  @param[in]  DescriptorVersion The version of the structure entries in VirtualMap.
+  @param[in]  VirtualMap        An array of memory descriptors which contain new virtual
+                                address mapping information for all runtime ranges.
+
+  @retval EFI_SUCCESS           The virtual address map has been applied.
+  @retval EFI_UNSUPPORTED       EFI firmware is not at runtime, or the EFI firmware is already in
+                                virtual address mapped mode.
+  @retval EFI_INVALID_PARAMETER DescriptorSize or DescriptorVersion is invalid.
+  @retval EFI_NO_MAPPING        A virtual address was not supplied for a range in the memory
+                                map that requires a mapping.
+  @retval EFI_NOT_FOUND         A virtual address was supplied for an address that is not found
+                                in the memory map.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP)(
+  IN  UINTN                        MemoryMapSize,
+  IN  UINTN                        DescriptorSize,
+  IN  UINT32                       DescriptorVersion,
+  IN  EFI_MEMORY_DESCRIPTOR        *VirtualMap
+  );
+
+/**
+  Connects one or more drivers to a controller.
+
+  @param[in]  ControllerHandle      The handle of the controller to which driver(s) are to be connected.
+  @param[in]  DriverImageHandle     A pointer to an ordered list handles that support the
+                                    EFI_DRIVER_BINDING_PROTOCOL.
+  @param[in]  RemainingDevicePath   A pointer to the device path that specifies a child of the
+                                    controller specified by ControllerHandle.
+  @param[in]  Recursive             If TRUE, then ConnectController() is called recursively
+                                    until the entire tree of controllers below the controller specified
+                                    by ControllerHandle have been created. If FALSE, then
+                                    the tree of controllers is only expanded one level.
+
+  @retval EFI_SUCCESS           1) One or more drivers were connected to ControllerHandle.
+                                2) No drivers were connected to ControllerHandle, but
+                                RemainingDevicePath is not NULL, and it is an End Device
+                                Path Node.
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+  @retval EFI_NOT_FOUND         1) There are no EFI_DRIVER_BINDING_PROTOCOL instances
+                                present in the system.
+                                2) No drivers were connected to ControllerHandle.
+  @retval EFI_SECURITY_VIOLATION 
+                                The user has no permission to start UEFI device drivers on the device path 
+                                associated with the ControllerHandle or specified by the RemainingDevicePath.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CONNECT_CONTROLLER)(
+  IN  EFI_HANDLE                    ControllerHandle,
+  IN  EFI_HANDLE                    *DriverImageHandle,   OPTIONAL
+  IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath, OPTIONAL
+  IN  BOOLEAN                       Recursive
+  );
+
+/**
+  Disconnects one or more drivers from a controller.
+
+  @param[in]  ControllerHandle      The handle of the controller from which driver(s) are to be disconnected.
+  @param[in]  DriverImageHandle     The driver to disconnect from ControllerHandle.
+                                    If DriverImageHandle is NULL, then all the drivers currently managing
+                                    ControllerHandle are disconnected from ControllerHandle.
+  @param[in]  ChildHandle           The handle of the child to destroy.
+                                    If ChildHandle is NULL, then all the children of ControllerHandle are
+                                    destroyed before the drivers are disconnected from ControllerHandle.
+
+  @retval EFI_SUCCESS           1) One or more drivers were disconnected from the controller.
+                                2) On entry, no drivers are managing ControllerHandle.
+                                3) DriverImageHandle is not NULL, and on entry
+                                   DriverImageHandle is not managing ControllerHandle.
+  @retval EFI_INVALID_PARAMETER 1) ControllerHandle is NULL.
+                                2) DriverImageHandle is not NULL, and it is not a valid EFI_HANDLE.
+                                3) ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
+                                4) DriverImageHandle does not support the EFI_DRIVER_BINDING_PROTOCOL.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to disconnect any drivers from
+                                ControllerHandle.
+  @retval EFI_DEVICE_ERROR      The controller could not be disconnected because of a device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISCONNECT_CONTROLLER)(
+  IN  EFI_HANDLE                     ControllerHandle,
+  IN  EFI_HANDLE                     DriverImageHandle, OPTIONAL
+  IN  EFI_HANDLE                     ChildHandle        OPTIONAL
+  );
+
+
+
+//
+// ConvertPointer DebugDisposition type.
+//
+#define EFI_OPTIONAL_PTR     0x00000001
+
+/**
+  Determines the new virtual address that is to be used on subsequent memory accesses.
+
+  @param[in]       DebugDisposition  Supplies type information for the pointer being converted.
+  @param[in, out]  Address           A pointer to a pointer that is to be fixed to be the value needed
+                                     for the new virtual address mappings being applied.
+
+  @retval EFI_SUCCESS           The pointer pointed to by Address was modified.
+  @retval EFI_INVALID_PARAMETER 1) Address is NULL.
+                                2) *Address is NULL and DebugDisposition does
+                                not have the EFI_OPTIONAL_PTR bit set.
+  @retval EFI_NOT_FOUND         The pointer pointed to by Address was not found to be part
+                                of the current memory map. This is normally fatal.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CONVERT_POINTER)(
+  IN     UINTN                      DebugDisposition,
+  IN OUT VOID                       **Address
+  );
+
+
+//
+// These types can be ORed together as needed - for example,
+// EVT_TIMER might be Ored with EVT_NOTIFY_WAIT or
+// EVT_NOTIFY_SIGNAL.
+//
+#define EVT_TIMER                         0x80000000
+#define EVT_RUNTIME                       0x40000000
+#define EVT_NOTIFY_WAIT                   0x00000100
+#define EVT_NOTIFY_SIGNAL                 0x00000200
+
+#define EVT_SIGNAL_EXIT_BOOT_SERVICES     0x00000201
+#define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE 0x60000202
+
+//
+// The event's NotifyContext pointer points to a runtime memory
+// address.
+// The event is deprecated in UEFI2.0 and later specifications.
+//
+#define EVT_RUNTIME_CONTEXT               0x20000000
+
+
+/**
+  Invoke a notification event
+
+  @param[in]  Event                 Event whose notification function is being invoked.
+  @param[in]  Context               The pointer to the notification function's context,
+                                    which is implementation-dependent.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_EVENT_NOTIFY)(
+  IN  EFI_EVENT                Event,
+  IN  VOID                     *Context
+  );
+
+/**
+  Creates an event.
+
+  @param[in]   Type             The type of event to create and its mode and attributes.
+  @param[in]   NotifyTpl        The task priority level of event notifications, if needed.
+  @param[in]   NotifyFunction   The pointer to the event's notification function, if any.
+  @param[in]   NotifyContext    The pointer to the notification function's context; corresponds to parameter
+                                Context in the notification function.
+  @param[out]  Event            The pointer to the newly created event if the call succeeds; undefined
+                                otherwise.
+
+  @retval EFI_SUCCESS           The event structure was created.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The event could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREATE_EVENT)(
+  IN  UINT32                       Type,
+  IN  EFI_TPL                      NotifyTpl,
+  IN  EFI_EVENT_NOTIFY             NotifyFunction,
+  IN  VOID                         *NotifyContext,
+  OUT EFI_EVENT                    *Event
+  );
+
+/**
+  Creates an event in a group.
+
+  @param[in]   Type             The type of event to create and its mode and attributes.
+  @param[in]   NotifyTpl        The task priority level of event notifications,if needed.
+  @param[in]   NotifyFunction   The pointer to the event's notification function, if any.
+  @param[in]   NotifyContext    The pointer to the notification function's context; corresponds to parameter
+                                Context in the notification function.
+  @param[in]   EventGroup       The pointer to the unique identifier of the group to which this event belongs.
+                                If this is NULL, then the function behaves as if the parameters were passed
+                                to CreateEvent.
+  @param[out]  Event            The pointer to the newly created event if the call succeeds; undefined
+                                otherwise.
+
+  @retval EFI_SUCCESS           The event structure was created.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The event could not be allocated.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREATE_EVENT_EX)(
+  IN       UINT32                 Type,
+  IN       EFI_TPL                NotifyTpl,
+  IN       EFI_EVENT_NOTIFY       NotifyFunction OPTIONAL,
+  IN CONST VOID                   *NotifyContext OPTIONAL,
+  IN CONST EFI_GUID               *EventGroup    OPTIONAL,
+  OUT      EFI_EVENT              *Event
+  );
+
+///
+/// Timer delay types
+///
+typedef enum {
+  ///
+  /// An event's timer settings is to be cancelled and not trigger time is to be set/
+  ///
+  TimerCancel,
+  ///
+  /// An event is to be signaled periodically at a specified interval from the current time.
+  ///
+  TimerPeriodic,
+  ///
+  /// An event is to be signaled once at a specified interval from the current time.
+  ///
+  TimerRelative
+} EFI_TIMER_DELAY;
+
+/**
+  Sets the type of timer and the trigger time for a timer event.
+
+  @param[in]  Event             The timer event that is to be signaled at the specified time.
+  @param[in]  Type              The type of time that is specified in TriggerTime.
+  @param[in]  TriggerTime       The number of 100ns units until the timer expires.
+                                A TriggerTime of 0 is legal.
+                                If Type is TimerRelative and TriggerTime is 0, then the timer
+                                event will be signaled on the next timer tick.
+                                If Type is TimerPeriodic and TriggerTime is 0, then the timer
+                                event will be signaled on every timer tick.
+
+  @retval EFI_SUCCESS           The event has been set to be signaled at the requested time.
+  @retval EFI_INVALID_PARAMETER Event or Type is not valid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_TIMER)(
+  IN  EFI_EVENT                Event,
+  IN  EFI_TIMER_DELAY          Type,
+  IN  UINT64                   TriggerTime
+  );
+
+/**
+  Signals an event.
+
+  @param[in]  Event             The event to signal.
+
+  @retval EFI_SUCCESS           The event has been signaled.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIGNAL_EVENT)(
+  IN  EFI_EVENT                Event
+  );
+
+/**
+  Stops execution until an event is signaled.
+
+  @param[in]   NumberOfEvents   The number of events in the Event array.
+  @param[in]   Event            An array of EFI_EVENT.
+  @param[out]  Index            The pointer to the index of the event which satisfied the wait condition.
+
+  @retval EFI_SUCCESS           The event indicated by Index was signaled.
+  @retval EFI_INVALID_PARAMETER 1) NumberOfEvents is 0.
+                                2) The event indicated by Index is of type
+                                   EVT_NOTIFY_SIGNAL.
+  @retval EFI_UNSUPPORTED       The current TPL is not TPL_APPLICATION.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_WAIT_FOR_EVENT)(
+  IN  UINTN                    NumberOfEvents,
+  IN  EFI_EVENT                *Event,
+  OUT UINTN                    *Index
+  );
+
+/**
+  Closes an event.
+
+  @param[in]  Event             The event to close.
+
+  @retval EFI_SUCCESS           The event has been closed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CLOSE_EVENT)(
+  IN EFI_EVENT                Event
+  );
+
+/**
+  Checks whether an event is in the signaled state.
+
+  @param[in]  Event             The event to check.
+
+  @retval EFI_SUCCESS           The event is in the signaled state.
+  @retval EFI_NOT_READY         The event is not in the signaled state.
+  @retval EFI_INVALID_PARAMETER Event is of type EVT_NOTIFY_SIGNAL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CHECK_EVENT)(
+  IN EFI_EVENT                Event
+  );
+
+
+//
+// Task priority level
+//
+#define TPL_APPLICATION       4
+#define TPL_CALLBACK          8
+#define TPL_NOTIFY            16
+#define TPL_HIGH_LEVEL        31
+
+
+/**
+  Raises a task's priority level and returns its previous level.
+
+  @param[in]  NewTpl          The new task priority level.
+
+  @return Previous task priority level
+
+**/
+typedef
+EFI_TPL
+(EFIAPI *EFI_RAISE_TPL)(
+  IN EFI_TPL      NewTpl
+  );
+
+/**
+  Restores a task's priority level to its previous value.
+
+  @param[in]  OldTpl          The previous task priority level to restore.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_RESTORE_TPL)(
+  IN EFI_TPL      OldTpl
+  );
+
+/**
+  Returns the value of a variable.
+
+  @param[in]       VariableName  A Null-terminated string that is the name of the vendor's
+                                 variable.
+  @param[in]       VendorGuid    A unique identifier for the vendor.
+  @param[out]      Attributes    If not NULL, a pointer to the memory location to return the
+                                 attributes bitmask for the variable.
+  @param[in, out]  DataSize      On input, the size in bytes of the return Data buffer.
+                                 On output the size of data returned in Data.
+  @param[out]      Data          The buffer to return the contents of the variable. May be NULL
+                                 with a zero DataSize in order to determine the size buffer needed.
+
+  @retval EFI_SUCCESS            The function completed successfully.
+  @retval EFI_NOT_FOUND          The variable was not found.
+  @retval EFI_BUFFER_TOO_SMALL   The DataSize is too small for the result.
+  @retval EFI_INVALID_PARAMETER  VariableName is NULL.
+  @retval EFI_INVALID_PARAMETER  VendorGuid is NULL.
+  @retval EFI_INVALID_PARAMETER  DataSize is NULL.
+  @retval EFI_INVALID_PARAMETER  The DataSize is not too small and Data is NULL.
+  @retval EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval EFI_SECURITY_VIOLATION The variable could not be retrieved due to an authentication failure.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_VARIABLE)(
+  IN     CHAR16                      *VariableName,
+  IN     EFI_GUID                    *VendorGuid,
+  OUT    UINT32                      *Attributes,    OPTIONAL
+  IN OUT UINTN                       *DataSize,
+  OUT    VOID                        *Data           OPTIONAL
+  );
+
+/**
+  Enumerates the current variable names.
+
+  @param[in, out]  VariableNameSize The size of the VariableName buffer.
+  @param[in, out]  VariableName     On input, supplies the last VariableName that was returned
+                                    by GetNextVariableName(). On output, returns the Nullterminated
+                                    string of the current variable.
+  @param[in, out]  VendorGuid       On input, supplies the last VendorGuid that was returned by
+                                    GetNextVariableName(). On output, returns the
+                                    VendorGuid of the current variable.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_NOT_FOUND         The next variable was not found.
+  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the result.
+  @retval EFI_INVALID_PARAMETER VariableNameSize is NULL.
+  @retval EFI_INVALID_PARAMETER VariableName is NULL.
+  @retval EFI_INVALID_PARAMETER VendorGuid is NULL.
+  @retval EFI_DEVICE_ERROR      The variable could not be retrieved due to a hardware error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_VARIABLE_NAME)(
+  IN OUT UINTN                    *VariableNameSize,
+  IN OUT CHAR16                   *VariableName,
+  IN OUT EFI_GUID                 *VendorGuid
+  );
+
+/**
+  Sets the value of a variable.
+
+  @param[in]  VariableName       A Null-terminated string that is the name of the vendor's variable.
+                                 Each VariableName is unique for each VendorGuid. VariableName must
+                                 contain 1 or more characters. If VariableName is an empty string,
+                                 then EFI_INVALID_PARAMETER is returned.
+  @param[in]  VendorGuid         A unique identifier for the vendor.
+  @param[in]  Attributes         Attributes bitmask to set for the variable.
+  @param[in]  DataSize           The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE, 
+                                 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, or 
+                                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero 
+                                 causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is 
+                                 set, then a SetVariable() call with a DataSize of zero will not cause any change to 
+                                 the variable value (the timestamp associated with the variable may be updated however 
+                                 even if no new data value is provided,see the description of the 
+                                 EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not 
+                                 be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated). 
+  @param[in]  Data               The contents for the variable.
+
+  @retval EFI_SUCCESS            The firmware has successfully stored the variable and its data as
+                                 defined by the Attributes.
+  @retval EFI_INVALID_PARAMETER  An invalid combination of attribute bits, name, and GUID was supplied, or the
+                                 DataSize exceeds the maximum allowed.
+  @retval EFI_INVALID_PARAMETER  VariableName is an empty string.
+  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.
+  @retval EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval EFI_WRITE_PROTECTED    The variable in question is read-only.
+  @retval EFI_WRITE_PROTECTED    The variable in question cannot be deleted.
+  @retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 
+                                 or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS being set, but the AuthInfo 
+                                 does NOT pass the validation check carried out by the firmware.
+  
+  @retval EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_VARIABLE)(
+  IN  CHAR16                       *VariableName,
+  IN  EFI_GUID                     *VendorGuid,
+  IN  UINT32                       Attributes,
+  IN  UINTN                        DataSize,
+  IN  VOID                         *Data
+  );
+
+
+///
+/// This provides the capabilities of the
+/// real time clock device as exposed through the EFI interfaces.
+///
+typedef struct {
+  ///
+  /// Provides the reporting resolution of the real-time clock device in
+  /// counts per second. For a normal PC-AT CMOS RTC device, this
+  /// value would be 1 Hz, or 1, to indicate that the device only reports
+  /// the time to the resolution of 1 second.
+  ///
+  UINT32    Resolution;
+  ///
+  /// Provides the timekeeping accuracy of the real-time clock in an
+  /// error rate of 1E-6 parts per million. For a clock with an accuracy
+  /// of 50 parts per million, the value in this field would be
+  /// 50,000,000.
+  ///
+  UINT32    Accuracy;
+  ///
+  /// A TRUE indicates that a time set operation clears the device's
+  /// time below the Resolution reporting level. A FALSE
+  /// indicates that the state below the Resolution level of the
+  /// device is not cleared when the time is set. Normal PC-AT CMOS
+  /// RTC devices set this value to FALSE.
+  ///
+  BOOLEAN   SetsToZero;
+} EFI_TIME_CAPABILITIES;
+
+/**
+  Returns the current time and date information, and the time-keeping capabilities
+  of the hardware platform.
+
+  @param[out]  Time             A pointer to storage to receive a snapshot of the current time.
+  @param[out]  Capabilities     An optional pointer to a buffer to receive the real time clock
+                                device's capabilities.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER Time is NULL.
+  @retval EFI_DEVICE_ERROR      The time could not be retrieved due to hardware error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_TIME)(
+  OUT  EFI_TIME                    *Time,
+  OUT  EFI_TIME_CAPABILITIES       *Capabilities OPTIONAL
+  );
+
+/**
+  Sets the current local time and date information.
+
+  @param[in]  Time              A pointer to the current time.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_INVALID_PARAMETER A time field is out of range.
+  @retval EFI_DEVICE_ERROR      The time could not be set due due to hardware error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_TIME)(
+  IN  EFI_TIME                     *Time
+  );
+
+/**
+  Returns the current wakeup alarm clock setting.
+
+  @param[out]  Enabled          Indicates if the alarm is currently enabled or disabled.
+  @param[out]  Pending          Indicates if the alarm signal is pending and requires acknowledgement.
+  @param[out]  Time             The current alarm setting.
+
+  @retval EFI_SUCCESS           The alarm settings were returned.
+  @retval EFI_INVALID_PARAMETER Enabled is NULL.
+  @retval EFI_INVALID_PARAMETER Pending is NULL.
+  @retval EFI_INVALID_PARAMETER Time is NULL.
+  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.
+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_WAKEUP_TIME)(
+  OUT BOOLEAN                     *Enabled,
+  OUT BOOLEAN                     *Pending,
+  OUT EFI_TIME                    *Time
+  );
+
+/**
+  Sets the system wakeup alarm clock time.
+
+  @param[in]  Enable            Enable or disable the wakeup alarm.
+  @param[in]  Time              If Enable is TRUE, the time to set the wakeup alarm for.
+                                If Enable is FALSE, then this parameter is optional, and may be NULL.
+
+  @retval EFI_SUCCESS           If Enable is TRUE, then the wakeup alarm was enabled. If
+                                Enable is FALSE, then the wakeup alarm was disabled.
+  @retval EFI_INVALID_PARAMETER A time field is out of range.
+  @retval EFI_DEVICE_ERROR      The wakeup time could not be set due to a hardware error.
+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_WAKEUP_TIME)(
+  IN  BOOLEAN                      Enable,
+  IN  EFI_TIME                     *Time   OPTIONAL
+  );
+
+/**
+  Loads an EFI image into memory.
+
+  @param[in]   BootPolicy        If TRUE, indicates that the request originates from the boot
+                                 manager, and that the boot manager is attempting to load
+                                 FilePath as a boot selection. Ignored if SourceBuffer is
+                                 not NULL.
+  @param[in]   ParentImageHandle The caller's image handle.
+  @param[in]   DevicePath        The DeviceHandle specific file path from which the image is
+                                 loaded.
+  @param[in]   SourceBuffer      If not NULL, a pointer to the memory location containing a copy
+                                 of the image to be loaded.
+  @param[in]   SourceSize        The size in bytes of SourceBuffer. Ignored if SourceBuffer is NULL.
+  @param[out]  ImageHandle       The pointer to the returned image handle that is created when the
+                                 image is successfully loaded.
+
+  @retval EFI_SUCCESS            Image was loaded into memory correctly.
+  @retval EFI_NOT_FOUND          Both SourceBuffer and DevicePath are NULL.
+  @retval EFI_INVALID_PARAMETER  One or more parametes are invalid.
+  @retval EFI_UNSUPPORTED        The image type is not supported.
+  @retval EFI_OUT_OF_RESOURCES   Image was not loaded due to insufficient resources.
+  @retval EFI_LOAD_ERROR         Image was not loaded because the image format was corrupt or not
+                                 understood.
+  @retval EFI_DEVICE_ERROR       Image was not loaded because the device returned a read error.
+  @retval EFI_ACCESS_DENIED      Image was not loaded because the platform policy prohibits the 
+                                 image from being loaded. NULL is returned in *ImageHandle.
+  @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a 
+                                 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current 
+                                 platform policy specifies that the image should not be started.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_LOAD)(
+  IN  BOOLEAN                      BootPolicy,
+  IN  EFI_HANDLE                   ParentImageHandle,
+  IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath,
+  IN  VOID                         *SourceBuffer OPTIONAL,
+  IN  UINTN                        SourceSize,
+  OUT EFI_HANDLE                   *ImageHandle
+  );
+
+/**
+  Transfers control to a loaded image's entry point.
+
+  @param[in]   ImageHandle       Handle of image to be started.
+  @param[out]  ExitDataSize      The pointer to the size, in bytes, of ExitData.
+  @param[out]  ExitData          The pointer to a pointer to a data buffer that includes a Null-terminated
+                                 string, optionally followed by additional binary data.
+
+  @retval EFI_INVALID_PARAMETER  ImageHandle is either an invalid image handle or the image
+                                 has already been initialized with StartImage.
+  @retval EFI_SECURITY_VIOLATION The current platform policy specifies that the image should not be started.
+  @return Exit code from image
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_START)(
+  IN  EFI_HANDLE                  ImageHandle,
+  OUT UINTN                       *ExitDataSize,
+  OUT CHAR16                      **ExitData    OPTIONAL
+  );
+
+/**
+  Terminates a loaded EFI image and returns control to boot services.
+
+  @param[in]  ImageHandle       Handle that identifies the image. This parameter is passed to the 
+                                image on entry.
+  @param[in]  ExitStatus        The image's exit code.
+  @param[in]  ExitDataSize      The size, in bytes, of ExitData. Ignored if ExitStatus is EFI_SUCCESS.
+  @param[in]  ExitData          The pointer to a data buffer that includes a Null-terminated string,
+                                optionally followed by additional binary data. The string is a 
+                                description that the caller may use to further indicate the reason 
+                                for the image's exit. ExitData is only valid if ExitStatus 
+                                is something other than EFI_SUCCESS. The ExitData buffer 
+                                must be allocated by calling AllocatePool().
+
+  @retval EFI_SUCCESS           The image specified by ImageHandle was unloaded.
+  @retval EFI_INVALID_PARAMETER The image specified by ImageHandle has been loaded and
+                                started with LoadImage() and StartImage(), but the
+                                image is not the currently executing image.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXIT)(
+  IN  EFI_HANDLE                   ImageHandle,
+  IN  EFI_STATUS                   ExitStatus,
+  IN  UINTN                        ExitDataSize,
+  IN  CHAR16                       *ExitData     OPTIONAL
+  );
+
+/**
+  Unloads an image.
+
+  @param[in]  ImageHandle       Handle that identifies the image to be unloaded.
+
+  @retval EFI_SUCCESS           The image has been unloaded.
+  @retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_UNLOAD)(
+  IN  EFI_HANDLE                   ImageHandle
+  );
+
+/**
+  Terminates all boot services.
+
+  @param[in]  ImageHandle       Handle that identifies the exiting image.
+  @param[in]  MapKey            Key to the latest memory map.
+
+  @retval EFI_SUCCESS           Boot services have been terminated.
+  @retval EFI_INVALID_PARAMETER MapKey is incorrect.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXIT_BOOT_SERVICES)(
+  IN  EFI_HANDLE                   ImageHandle,
+  IN  UINTN                        MapKey
+  );
+
+/**
+  Induces a fine-grained stall.
+
+  @param[in]  Microseconds      The number of microseconds to stall execution.
+
+  @retval EFI_SUCCESS           Execution was stalled at least the requested number of
+                                Microseconds.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STALL)(
+  IN  UINTN                    Microseconds
+  );
+
+/**
+  Sets the system's watchdog timer.
+
+  @param[in]  Timeout           The number of seconds to set the watchdog timer to.
+  @param[in]  WatchdogCode      The numeric code to log on a watchdog timer timeout event.
+  @param[in]  DataSize          The size, in bytes, of WatchdogData.
+  @param[in]  WatchdogData      A data buffer that includes a Null-terminated string, optionally
+                                followed by additional binary data.
+
+  @retval EFI_SUCCESS           The timeout has been set.
+  @retval EFI_INVALID_PARAMETER The supplied WatchdogCode is invalid.
+  @retval EFI_UNSUPPORTED       The system does not have a watchdog timer.
+  @retval EFI_DEVICE_ERROR      The watchdog timer could not be programmed due to a hardware
+                                error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_WATCHDOG_TIMER)(
+  IN UINTN                    Timeout,
+  IN UINT64                   WatchdogCode,
+  IN UINTN                    DataSize,
+  IN CHAR16                   *WatchdogData OPTIONAL
+  );
+
+/**
+  Resets the entire platform.
+
+  @param[in]  ResetType         The type of reset to perform.
+  @param[in]  ResetStatus       The status code for the reset.
+  @param[in]  DataSize          The size, in bytes, of ResetData.
+  @param[in]  ResetData         For a ResetType of EfiResetCold, EfiResetWarm, or
+                                EfiResetShutdown the data buffer starts with a Null-terminated
+                                string, optionally followed by additional binary data.
+                                The string is a description that the caller may use to further
+                                indicate the reason for the system reset. ResetData is only
+                                valid if ResetStatus is something other than EFI_SUCCESS
+                                unless the ResetType is EfiResetPlatformSpecific
+                                where a minimum amount of ResetData is always required.
+**/
+typedef
+VOID
+(EFIAPI *EFI_RESET_SYSTEM)(
+  IN EFI_RESET_TYPE           ResetType,
+  IN EFI_STATUS               ResetStatus,
+  IN UINTN                    DataSize,
+  IN VOID                     *ResetData OPTIONAL
+  );
+
+/**
+  Returns a monotonically increasing count for the platform.
+
+  @param[out]  Count            The pointer to returned value.
+
+  @retval EFI_SUCCESS           The next monotonic count was returned.
+  @retval EFI_INVALID_PARAMETER Count is NULL.
+  @retval EFI_DEVICE_ERROR      The device is not functioning properly.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_MONOTONIC_COUNT)(
+  OUT UINT64                  *Count
+  );
+
+/**
+  Returns the next high 32 bits of the platform's monotonic counter.
+
+  @param[out]  HighCount        The pointer to returned value.
+
+  @retval EFI_SUCCESS           The next high monotonic count was returned.
+  @retval EFI_INVALID_PARAMETER HighCount is NULL.
+  @retval EFI_DEVICE_ERROR      The device is not functioning properly.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT)(
+  OUT UINT32                  *HighCount
+  );
+
+/**
+  Computes and returns a 32-bit CRC for a data buffer.
+
+  @param[in]   Data             A pointer to the buffer on which the 32-bit CRC is to be computed.
+  @param[in]   DataSize         The number of bytes in the buffer Data.
+  @param[out]  Crc32            The 32-bit CRC that was computed for the data buffer specified by Data
+                                and DataSize.
+
+  @retval EFI_SUCCESS           The 32-bit CRC was computed for the data buffer and returned in
+                                Crc32.
+  @retval EFI_INVALID_PARAMETER Data is NULL.
+  @retval EFI_INVALID_PARAMETER Crc32 is NULL.
+  @retval EFI_INVALID_PARAMETER DataSize is 0.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CALCULATE_CRC32)(
+  IN  VOID                              *Data,
+  IN  UINTN                             DataSize,
+  OUT UINT32                            *Crc32
+  );
+
+/**
+  Copies the contents of one buffer to another buffer.
+
+  @param[in]  Destination       The pointer to the destination buffer of the memory copy.
+  @param[in]  Source            The pointer to the source buffer of the memory copy.
+  @param[in]  Length            Number of bytes to copy from Source to Destination.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_COPY_MEM)(
+  IN VOID     *Destination,
+  IN VOID     *Source,
+  IN UINTN    Length
+  );
+
+/**
+  The SetMem() function fills a buffer with a specified value.
+
+  @param[in]  Buffer            The pointer to the buffer to fill.
+  @param[in]  Size              Number of bytes in Buffer to fill.
+  @param[in]  Value             Value to fill Buffer with.
+
+**/
+typedef
+VOID
+(EFIAPI *EFI_SET_MEM)(
+  IN VOID     *Buffer,
+  IN UINTN    Size,
+  IN UINT8    Value
+  );
+
+///
+/// Enumeration of EFI Interface Types
+///
+typedef enum {
+  ///
+  /// Indicates that the supplied protocol interface is supplied in native form.
+  ///
+  EFI_NATIVE_INTERFACE
+} EFI_INTERFACE_TYPE;
+
+/**
+  Installs a protocol interface on a device handle. If the handle does not exist, it is created and added
+  to the list of handles in the system. InstallMultipleProtocolInterfaces() performs
+  more error checking than InstallProtocolInterface(), so it is recommended that
+  InstallMultipleProtocolInterfaces() be used in place of
+  InstallProtocolInterface()
+
+  @param[in, out]  Handle         A pointer to the EFI_HANDLE on which the interface is to be installed.
+  @param[in]       Protocol       The numeric ID of the protocol interface.
+  @param[in]       InterfaceType  Indicates whether Interface is supplied in native form.
+  @param[in]       Interface      A pointer to the protocol interface.
+
+  @retval EFI_SUCCESS           The protocol interface was installed.
+  @retval EFI_OUT_OF_RESOURCES  Space for a new handle could not be allocated.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+  @retval EFI_INVALID_PARAMETER InterfaceType is not EFI_NATIVE_INTERFACE.
+  @retval EFI_INVALID_PARAMETER Protocol is already installed on the handle specified by Handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE)(
+  IN OUT EFI_HANDLE               *Handle,
+  IN     EFI_GUID                 *Protocol,
+  IN     EFI_INTERFACE_TYPE       InterfaceType,
+  IN     VOID                     *Interface
+  );
+
+/**
+  Installs one or more protocol interfaces into the boot services environment.
+
+  @param[in, out]  Handle       The pointer to a handle to install the new protocol interfaces on,
+                                or a pointer to NULL if a new handle is to be allocated.
+  @param  ...                   A variable argument list containing pairs of protocol GUIDs and protocol
+                                interfaces.
+
+  @retval EFI_SUCCESS           All the protocol interface was installed.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+  @retval EFI_ALREADY_STARTED   A Device Path Protocol instance was passed in that is already present in
+                                the handle database.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Protocol is already installed on the handle specified by Handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES)(
+  IN OUT EFI_HANDLE           *Handle,
+  ...
+  );
+
+/**
+  Reinstalls a protocol interface on a device handle.
+
+  @param[in]  Handle            Handle on which the interface is to be reinstalled.
+  @param[in]  Protocol          The numeric ID of the interface.
+  @param[in]  OldInterface      A pointer to the old interface. NULL can be used if a structure is not
+                                associated with Protocol.
+  @param[in]  NewInterface      A pointer to the new interface.
+
+  @retval EFI_SUCCESS           The protocol interface was reinstalled.
+  @retval EFI_NOT_FOUND         The OldInterface on the handle was not found.
+  @retval EFI_ACCESS_DENIED     The protocol interface could not be reinstalled,
+                                because OldInterface is still being used by a
+                                driver that will not release it.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE)(
+  IN EFI_HANDLE               Handle,
+  IN EFI_GUID                 *Protocol,
+  IN VOID                     *OldInterface,
+  IN VOID                     *NewInterface
+  );
+
+/**
+  Removes a protocol interface from a device handle. It is recommended that
+  UninstallMultipleProtocolInterfaces() be used in place of
+  UninstallProtocolInterface().
+
+  @param[in]  Handle            The handle on which the interface was installed.
+  @param[in]  Protocol          The numeric ID of the interface.
+  @param[in]  Interface         A pointer to the interface.
+
+  @retval EFI_SUCCESS           The interface was removed.
+  @retval EFI_NOT_FOUND         The interface was not found.
+  @retval EFI_ACCESS_DENIED     The interface was not removed because the interface
+                                is still being used by a driver.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE)(
+  IN EFI_HANDLE               Handle,
+  IN EFI_GUID                 *Protocol,
+  IN VOID                     *Interface
+  );
+
+/**
+  Removes one or more protocol interfaces into the boot services environment.
+
+  @param[in]  Handle            The handle to remove the protocol interfaces from.
+  @param  ...                   A variable argument list containing pairs of protocol GUIDs and
+                                protocol interfaces.
+
+  @retval EFI_SUCCESS           All the protocol interfaces were removed.
+  @retval EFI_INVALID_PARAMETER One of the protocol interfaces was not previously installed on Handle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES)(
+  IN EFI_HANDLE           Handle,
+  ...
+  );
+
+/**
+  Queries a handle to determine if it supports a specified protocol.
+
+  @param[in]   Handle           The handle being queried.
+  @param[in]   Protocol         The published unique identifier of the protocol.
+  @param[out]  Interface        Supplies the address where a pointer to the corresponding Protocol
+                                Interface is returned.
+
+  @retval EFI_SUCCESS           The interface information for the specified protocol was returned.
+  @retval EFI_UNSUPPORTED       The device does not support the specified protocol.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+  @retval EFI_INVALID_PARAMETER Interface is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HANDLE_PROTOCOL)(
+  IN  EFI_HANDLE               Handle,
+  IN  EFI_GUID                 *Protocol,
+  OUT VOID                     **Interface
+  );
+
+#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
+#define EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
+#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
+#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
+#define EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
+#define EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
+
+/**
+  Queries a handle to determine if it supports a specified protocol. If the protocol is supported by the
+  handle, it opens the protocol on behalf of the calling agent.
+
+  @param[in]   Handle           The handle for the protocol interface that is being opened.
+  @param[in]   Protocol         The published unique identifier of the protocol.
+  @param[out]  Interface        Supplies the address where a pointer to the corresponding Protocol
+                                Interface is returned.
+  @param[in]   AgentHandle      The handle of the agent that is opening the protocol interface
+                                specified by Protocol and Interface.
+  @param[in]   ControllerHandle If the agent that is opening a protocol is a driver that follows the
+                                UEFI Driver Model, then this parameter is the controller handle
+                                that requires the protocol interface. If the agent does not follow
+                                the UEFI Driver Model, then this parameter is optional and may
+                                be NULL.
+  @param[in]   Attributes       The open mode of the protocol interface specified by Handle
+                                and Protocol.
+
+  @retval EFI_SUCCESS           An item was added to the open list for the protocol interface, and the
+                                protocol interface was returned in Interface.
+  @retval EFI_UNSUPPORTED       Handle does not support Protocol.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_ACCESS_DENIED     Required attributes can't be supported in current environment.
+  @retval EFI_ALREADY_STARTED   Item on the open list already has requierd attributes whose agent
+                                handle is the same as AgentHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_OPEN_PROTOCOL)(
+  IN  EFI_HANDLE                Handle,
+  IN  EFI_GUID                  *Protocol,
+  OUT VOID                      **Interface, OPTIONAL
+  IN  EFI_HANDLE                AgentHandle,
+  IN  EFI_HANDLE                ControllerHandle,
+  IN  UINT32                    Attributes
+  );
+
+
+/**
+  Closes a protocol on a handle that was opened using OpenProtocol().
+
+  @param[in]  Handle            The handle for the protocol interface that was previously opened
+                                with OpenProtocol(), and is now being closed.
+  @param[in]  Protocol          The published unique identifier of the protocol.
+  @param[in]  AgentHandle       The handle of the agent that is closing the protocol interface.
+  @param[in]  ControllerHandle  If the agent that opened a protocol is a driver that follows the
+                                UEFI Driver Model, then this parameter is the controller handle
+                                that required the protocol interface.
+
+  @retval EFI_SUCCESS           The protocol instance was closed.
+  @retval EFI_INVALID_PARAMETER 1) Handle is NULL.
+                                2) AgentHandle is NULL.
+                                3) ControllerHandle is not NULL and ControllerHandle is not a valid EFI_HANDLE.
+                                4) Protocol is NULL.
+  @retval EFI_NOT_FOUND         1) Handle does not support the protocol specified by Protocol.
+                                2) The protocol interface specified by Handle and Protocol is not
+                                   currently open by AgentHandle and ControllerHandle.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CLOSE_PROTOCOL)(
+  IN EFI_HANDLE               Handle,
+  IN EFI_GUID                 *Protocol,
+  IN EFI_HANDLE               AgentHandle,
+  IN EFI_HANDLE               ControllerHandle
+  );
+
+///
+/// EFI Oprn Protocol Information Entry
+///
+typedef struct {
+  EFI_HANDLE  AgentHandle;
+  EFI_HANDLE  ControllerHandle;
+  UINT32      Attributes;
+  UINT32      OpenCount;
+} EFI_OPEN_PROTOCOL_INFORMATION_ENTRY;
+
+/**
+  Retrieves the list of agents that currently have a protocol interface opened.
+
+  @param[in]   Handle           The handle for the protocol interface that is being queried.
+  @param[in]   Protocol         The published unique identifier of the protocol.
+  @param[out]  EntryBuffer      A pointer to a buffer of open protocol information in the form of
+                                EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures.
+  @param[out]  EntryCount       A pointer to the number of entries in EntryBuffer.
+
+  @retval EFI_SUCCESS           The open protocol information was returned in EntryBuffer, and the
+                                number of entries was returned EntryCount.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resources available to allocate EntryBuffer.
+  @retval EFI_NOT_FOUND         Handle does not support the protocol specified by Protocol.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION)(
+  IN  EFI_HANDLE                          Handle,
+  IN  EFI_GUID                            *Protocol,
+  OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
+  OUT UINTN                               *EntryCount
+  );
+
+/**
+  Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated
+  from pool.
+
+  @param[in]   Handle              The handle from which to retrieve the list of protocol interface
+                                   GUIDs.
+  @param[out]  ProtocolBuffer      A pointer to the list of protocol interface GUID pointers that are
+                                   installed on Handle.
+  @param[out]  ProtocolBufferCount A pointer to the number of GUID pointers present in
+                                   ProtocolBuffer.
+
+  @retval EFI_SUCCESS           The list of protocol interface GUIDs installed on Handle was returned in
+                                ProtocolBuffer. The number of protocol interface GUIDs was
+                                returned in ProtocolBufferCount.
+  @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the results.
+  @retval EFI_INVALID_PARAMETER Handle is NULL.
+  @retval EFI_INVALID_PARAMETER Handle is not a valid EFI_HANDLE.
+  @retval EFI_INVALID_PARAMETER ProtocolBuffer is NULL.
+  @retval EFI_INVALID_PARAMETER ProtocolBufferCount is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PROTOCOLS_PER_HANDLE)(
+  IN  EFI_HANDLE      Handle,
+  OUT EFI_GUID        ***ProtocolBuffer,
+  OUT UINTN           *ProtocolBufferCount
+  );
+
+/**
+  Creates an event that is to be signaled whenever an interface is installed for a specified protocol.
+
+  @param[in]   Protocol         The numeric ID of the protocol for which the event is to be registered.
+  @param[in]   Event            Event that is to be signaled whenever a protocol interface is registered
+                                for Protocol.
+  @param[out]  Registration     A pointer to a memory location to receive the registration value.
+
+  @retval EFI_SUCCESS           The notification event has been registered.
+  @retval EFI_OUT_OF_RESOURCES  Space for the notification event could not be allocated.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+  @retval EFI_INVALID_PARAMETER Event is NULL.
+  @retval EFI_INVALID_PARAMETER Registration is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY)(
+  IN  EFI_GUID                 *Protocol,
+  IN  EFI_EVENT                Event,
+  OUT VOID                     **Registration
+  );
+
+///
+/// Enumeration of EFI Locate Search Types
+///
+typedef enum {
+  ///
+  /// Retrieve all the handles in the handle database.
+  ///
+  AllHandles,
+  ///
+  /// Retrieve the next handle fron a RegisterProtocolNotify() event.
+  ///
+  ByRegisterNotify,
+  ///
+  /// Retrieve the set of handles from the handle database that support a 
+  /// specified protocol.
+  ///
+  ByProtocol
+} EFI_LOCATE_SEARCH_TYPE;
+
+/**
+  Returns an array of handles that support a specified protocol.
+
+  @param[in]       SearchType   Specifies which handle(s) are to be returned.
+  @param[in]       Protocol     Specifies the protocol to search by.
+  @param[in]       SearchKey    Specifies the search key.
+  @param[in, out]  BufferSize   On input, the size in bytes of Buffer. On output, the size in bytes of
+                                the array returned in Buffer (if the buffer was large enough) or the
+                                size, in bytes, of the buffer needed to obtain the array (if the buffer was
+                                not large enough).
+  @param[out]      Buffer       The buffer in which the array is returned.
+
+  @retval EFI_SUCCESS           The array of handles was returned.
+  @retval EFI_NOT_FOUND         No handles match the search.
+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small for the result.
+  @retval EFI_INVALID_PARAMETER SearchType is not a member of EFI_LOCATE_SEARCH_TYPE.
+  @retval EFI_INVALID_PARAMETER SearchType is ByRegisterNotify and SearchKey is NULL.
+  @retval EFI_INVALID_PARAMETER SearchType is ByProtocol and Protocol is NULL.
+  @retval EFI_INVALID_PARAMETER One or more matches are found and BufferSize is NULL.
+  @retval EFI_INVALID_PARAMETER BufferSize is large enough for the result and Buffer is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_HANDLE)(
+  IN     EFI_LOCATE_SEARCH_TYPE   SearchType,
+  IN     EFI_GUID                 *Protocol,    OPTIONAL
+  IN     VOID                     *SearchKey,   OPTIONAL
+  IN OUT UINTN                    *BufferSize,
+  OUT    EFI_HANDLE               *Buffer
+  );
+
+/**
+  Locates the handle to a device on the device path that supports the specified protocol.
+
+  @param[in]       Protocol     Specifies the protocol to search for.
+  @param[in, out]  DevicePath   On input, a pointer to a pointer to the device path. On output, the device
+                                path pointer is modified to point to the remaining part of the device
+                                path.
+  @param[out]      Device       A pointer to the returned device handle.
+
+  @retval EFI_SUCCESS           The resulting handle was returned.
+  @retval EFI_NOT_FOUND         No handles match the search.
+  @retval EFI_INVALID_PARAMETER Protocol is NULL.
+  @retval EFI_INVALID_PARAMETER DevicePath is NULL.
+  @retval EFI_INVALID_PARAMETER A handle matched the search and Device is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_DEVICE_PATH)(
+  IN     EFI_GUID                         *Protocol,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL         **DevicePath,
+  OUT    EFI_HANDLE                       *Device
+  );
+
+/**
+  Adds, updates, or removes a configuration table entry from the EFI System Table.
+
+  @param[in]  Guid              A pointer to the GUID for the entry to add, update, or remove.
+  @param[in]  Table             A pointer to the configuration table for the entry to add, update, or
+                                remove. May be NULL.
+
+  @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.
+  @retval EFI_NOT_FOUND         An attempt was made to delete a nonexistent entry.
+  @retval EFI_INVALID_PARAMETER Guid is NULL.
+  @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE)(
+  IN EFI_GUID                 *Guid,
+  IN VOID                     *Table
+  );
+
+/**
+  Returns an array of handles that support the requested protocol in a buffer allocated from pool.
+
+  @param[in]       SearchType   Specifies which handle(s) are to be returned.
+  @param[in]       Protocol     Provides the protocol to search by.
+                                This parameter is only valid for a SearchType of ByProtocol.
+  @param[in]       SearchKey    Supplies the search key depending on the SearchType.
+  @param[in, out]  NoHandles    The number of handles returned in Buffer.
+  @param[out]      Buffer       A pointer to the buffer to return the requested array of handles that
+                                support Protocol.
+
+  @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of
+                                handles in Buffer was returned in NoHandles.
+  @retval EFI_NOT_FOUND         No handles match the search.
+  @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.
+  @retval EFI_INVALID_PARAMETER NoHandles is NULL.
+  @retval EFI_INVALID_PARAMETER Buffer is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_HANDLE_BUFFER)(
+  IN     EFI_LOCATE_SEARCH_TYPE       SearchType,
+  IN     EFI_GUID                     *Protocol,      OPTIONAL
+  IN     VOID                         *SearchKey,     OPTIONAL
+  IN OUT UINTN                        *NoHandles,
+  OUT    EFI_HANDLE                   **Buffer
+  );
+
+/**
+  Returns the first protocol instance that matches the given protocol.
+
+  @param[in]  Protocol          Provides the protocol to search for.
+  @param[in]  Registration      Optional registration key returned from
+                                RegisterProtocolNotify().
+  @param[out]  Interface        On return, a pointer to the first interface that matches Protocol and
+                                Registration.
+
+  @retval EFI_SUCCESS           A protocol instance matching Protocol was found and returned in
+                                Interface.
+  @retval EFI_NOT_FOUND         No protocol instances were found that match Protocol and
+                                Registration.
+  @retval EFI_INVALID_PARAMETER Interface is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_PROTOCOL)(
+  IN  EFI_GUID  *Protocol,
+  IN  VOID      *Registration, OPTIONAL
+  OUT VOID      **Interface
+  );
+
+///
+/// EFI Capsule Block Descriptor
+///
+typedef struct {
+  ///
+  /// Length in bytes of the data pointed to by DataBlock/ContinuationPointer.
+  ///
+  UINT64                  Length;
+  union {
+    ///
+    /// Physical address of the data block. This member of the union is
+    /// used if Length is not equal to zero.
+    ///
+    EFI_PHYSICAL_ADDRESS  DataBlock;
+    ///
+    /// Physical address of another block of
+    /// EFI_CAPSULE_BLOCK_DESCRIPTOR structures. This
+    /// member of the union is used if Length is equal to zero. If
+    /// ContinuationPointer is zero this entry represents the end of the list.
+    ///
+    EFI_PHYSICAL_ADDRESS  ContinuationPointer;
+  } Union;
+} EFI_CAPSULE_BLOCK_DESCRIPTOR;
+
+///
+/// EFI Capsule Header.
+///
+typedef struct {
+  ///
+  /// A GUID that defines the contents of a capsule.
+  ///
+  EFI_GUID          CapsuleGuid;
+  ///
+  /// The size of the capsule header. This may be larger than the size of
+  /// the EFI_CAPSULE_HEADER since CapsuleGuid may imply
+  /// extended header entries
+  ///
+  UINT32            HeaderSize;
+  ///
+  /// Bit-mapped list describing the capsule attributes. The Flag values
+  /// of 0x0000 - 0xFFFF are defined by CapsuleGuid. Flag values
+  /// of 0x10000 - 0xFFFFFFFF are defined by this specification
+  ///
+  UINT32            Flags;
+  ///
+  /// Size in bytes of the capsule.
+  ///
+  UINT32            CapsuleImageSize;
+} EFI_CAPSULE_HEADER;
+
+///
+/// The EFI System Table entry must point to an array of capsules
+/// that contain the same CapsuleGuid value. The array must be
+/// prefixed by a UINT32 that represents the size of the array of capsules.
+///
+typedef struct {
+  ///
+  /// the size of the array of capsules.
+  ///
+  UINT32   CapsuleArrayNumber;
+  ///
+  /// Point to an array of capsules that contain the same CapsuleGuid value.
+  ///
+  VOID*    CapsulePtr[1];
+} EFI_CAPSULE_TABLE;
+
+#define CAPSULE_FLAGS_PERSIST_ACROSS_RESET          0x00010000
+#define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE         0x00020000
+#define CAPSULE_FLAGS_INITIATE_RESET                0x00040000
+
+/**
+  Passes capsules to the firmware with both virtual and physical mapping. Depending on the intended
+  consumption, the firmware may process the capsule immediately. If the payload should persist
+  across a system reset, the reset value returned from EFI_QueryCapsuleCapabilities must
+  be passed into ResetSystem() and will cause the capsule to be processed by the firmware as
+  part of the reset process.
+
+  @param[in]  CapsuleHeaderArray Virtual pointer to an array of virtual pointers to the capsules
+                                 being passed into update capsule.
+  @param[in]  CapsuleCount       Number of pointers to EFI_CAPSULE_HEADER in
+                                 CaspuleHeaderArray.
+  @param[in]  ScatterGatherList  Physical pointer to a set of
+                                 EFI_CAPSULE_BLOCK_DESCRIPTOR that describes the
+                                 location in physical memory of a set of capsules.
+
+  @retval EFI_SUCCESS           Valid capsule was passed. If
+                                CAPSULE_FLAGS_PERSIT_ACROSS_RESET is not set, the
+                                capsule has been successfully processed by the firmware.
+  @retval EFI_INVALID_PARAMETER CapsuleSize is NULL, or an incompatible set of flags were
+                                set in the capsule header.
+  @retval EFI_INVALID_PARAMETER CapsuleCount is 0.
+  @retval EFI_DEVICE_ERROR      The capsule update was started, but failed due to a device error.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform.
+  @retval EFI_OUT_OF_RESOURCES  When ExitBootServices() has been previously called this error indicates the capsule 
+                                is compatible with this platform but is not capable of being submitted or processed 
+                                in runtime. The caller may resubmit the capsule prior to ExitBootServices().
+  @retval EFI_OUT_OF_RESOURCES  When ExitBootServices() has not been previously called then this error indicates 
+                                the capsule is compatible with this platform but there are insufficient resources to process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UPDATE_CAPSULE)(
+  IN EFI_CAPSULE_HEADER     **CapsuleHeaderArray,
+  IN UINTN                  CapsuleCount,
+  IN EFI_PHYSICAL_ADDRESS   ScatterGatherList   OPTIONAL
+  );
+
+/**
+  Returns if the capsule can be supported via UpdateCapsule().
+
+  @param[in]   CapsuleHeaderArray  Virtual pointer to an array of virtual pointers to the capsules
+                                   being passed into update capsule.
+  @param[in]   CapsuleCount        Number of pointers to EFI_CAPSULE_HEADER in
+                                   CaspuleHeaderArray.
+  @param[out]  MaxiumCapsuleSize   On output the maximum size that UpdateCapsule() can
+                                   support as an argument to UpdateCapsule() via
+                                   CapsuleHeaderArray and ScatterGatherList.
+  @param[out]  ResetType           Returns the type of reset required for the capsule update.
+
+  @retval EFI_SUCCESS           Valid answer returned.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform, and
+                                MaximumCapsuleSize and ResetType are undefined.
+  @retval EFI_INVALID_PARAMETER MaximumCapsuleSize is NULL.
+  @retval EFI_OUT_OF_RESOURCES  When ExitBootServices() has been previously called this error indicates the capsule 
+                                is compatible with this platform but is not capable of being submitted or processed 
+                                in runtime. The caller may resubmit the capsule prior to ExitBootServices().
+  @retval EFI_OUT_OF_RESOURCES  When ExitBootServices() has not been previously called then this error indicates 
+                                the capsule is compatible with this platform but there are insufficient resources to process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_QUERY_CAPSULE_CAPABILITIES)(
+  IN  EFI_CAPSULE_HEADER     **CapsuleHeaderArray,
+  IN  UINTN                  CapsuleCount,
+  OUT UINT64                 *MaximumCapsuleSize,
+  OUT EFI_RESET_TYPE         *ResetType
+  );
+
+/**
+  Returns information about the EFI variables.
+
+  @param[in]   Attributes                   Attributes bitmask to specify the type of variables on
+                                            which to return information.
+  @param[out]  MaximumVariableStorageSize   On output the maximum size of the storage space
+                                            available for the EFI variables associated with the
+                                            attributes specified.
+  @param[out]  RemainingVariableStorageSize Returns the remaining size of the storage space
+                                            available for the EFI variables associated with the
+                                            attributes specified.
+  @param[out]  MaximumVariableSize          Returns the maximum size of the individual EFI
+                                            variables associated with the attributes specified.
+
+  @retval EFI_SUCCESS                  Valid answer returned.
+  @retval EFI_INVALID_PARAMETER        An invalid combination of attribute bits was supplied
+  @retval EFI_UNSUPPORTED              The attribute is not supported on this platform, and the
+                                       MaximumVariableStorageSize,
+                                       RemainingVariableStorageSize, MaximumVariableSize
+                                       are undefined.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_QUERY_VARIABLE_INFO)(
+  IN  UINT32            Attributes,
+  OUT UINT64            *MaximumVariableStorageSize,
+  OUT UINT64            *RemainingVariableStorageSize,
+  OUT UINT64            *MaximumVariableSize
+  );
+
+//
+// Firmware should stop at a firmware user interface on next boot
+//
+#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI                    0x0000000000000001
+#define EFI_OS_INDICATIONS_TIMESTAMP_REVOCATION             0x0000000000000002
+#define EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED  0x0000000000000004
+#define EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED            0x0000000000000008
+#define EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED     0x0000000000000010
+#define EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY          0x0000000000000040
+
+//
+// EFI Runtime Services Table
+//
+#define EFI_SYSTEM_TABLE_SIGNATURE      SIGNATURE_64 ('I','B','I',' ','S','Y','S','T')
+#define EFI_2_60_SYSTEM_TABLE_REVISION  ((2 << 16) | (60))
+#define EFI_2_50_SYSTEM_TABLE_REVISION  ((2 << 16) | (50))
+#define EFI_2_40_SYSTEM_TABLE_REVISION  ((2 << 16) | (40))
+#define EFI_2_31_SYSTEM_TABLE_REVISION  ((2 << 16) | (31))
+#define EFI_2_30_SYSTEM_TABLE_REVISION  ((2 << 16) | (30))
+#define EFI_2_20_SYSTEM_TABLE_REVISION  ((2 << 16) | (20))
+#define EFI_2_10_SYSTEM_TABLE_REVISION  ((2 << 16) | (10))
+#define EFI_2_00_SYSTEM_TABLE_REVISION  ((2 << 16) | (00))
+#define EFI_1_10_SYSTEM_TABLE_REVISION  ((1 << 16) | (10))
+#define EFI_1_02_SYSTEM_TABLE_REVISION  ((1 << 16) | (02))
+#define EFI_SYSTEM_TABLE_REVISION       EFI_2_60_SYSTEM_TABLE_REVISION
+#define EFI_SPECIFICATION_VERSION       EFI_SYSTEM_TABLE_REVISION
+
+#define EFI_RUNTIME_SERVICES_SIGNATURE  SIGNATURE_64 ('R','U','N','T','S','E','R','V')
+#define EFI_RUNTIME_SERVICES_REVISION   EFI_SPECIFICATION_VERSION
+
+///
+/// EFI Runtime Services Table.
+///
+typedef struct {
+  ///
+  /// The table header for the EFI Runtime Services Table.
+  ///
+  EFI_TABLE_HEADER                Hdr;
+
+  //
+  // Time Services
+  //
+  EFI_GET_TIME                    GetTime;
+  EFI_SET_TIME                    SetTime;
+  EFI_GET_WAKEUP_TIME             GetWakeupTime;
+  EFI_SET_WAKEUP_TIME             SetWakeupTime;
+
+  //
+  // Virtual Memory Services
+  //
+  EFI_SET_VIRTUAL_ADDRESS_MAP     SetVirtualAddressMap;
+  EFI_CONVERT_POINTER             ConvertPointer;
+
+  //
+  // Variable Services
+  //
+  EFI_GET_VARIABLE                GetVariable;
+  EFI_GET_NEXT_VARIABLE_NAME      GetNextVariableName;
+  EFI_SET_VARIABLE                SetVariable;
+
+  //
+  // Miscellaneous Services
+  //
+  EFI_GET_NEXT_HIGH_MONO_COUNT    GetNextHighMonotonicCount;
+  EFI_RESET_SYSTEM                ResetSystem;
+
+  //
+  // UEFI 2.0 Capsule Services
+  //
+  EFI_UPDATE_CAPSULE              UpdateCapsule;
+  EFI_QUERY_CAPSULE_CAPABILITIES  QueryCapsuleCapabilities;
+
+  //
+  // Miscellaneous UEFI 2.0 Service
+  //
+  EFI_QUERY_VARIABLE_INFO         QueryVariableInfo;
+} EFI_RUNTIME_SERVICES;
+
+
+#define EFI_BOOT_SERVICES_SIGNATURE   SIGNATURE_64 ('B','O','O','T','S','E','R','V')
+#define EFI_BOOT_SERVICES_REVISION    EFI_SPECIFICATION_VERSION
+
+///
+/// EFI Boot Services Table.
+///
+typedef struct {
+  ///
+  /// The table header for the EFI Boot Services Table.
+  ///
+  EFI_TABLE_HEADER                Hdr;
+
+  //
+  // Task Priority Services
+  //
+  EFI_RAISE_TPL                   RaiseTPL;
+  EFI_RESTORE_TPL                 RestoreTPL;
+
+  //
+  // Memory Services
+  //
+  EFI_ALLOCATE_PAGES              AllocatePages;
+  EFI_FREE_PAGES                  FreePages;
+  EFI_GET_MEMORY_MAP              GetMemoryMap;
+  EFI_ALLOCATE_POOL               AllocatePool;
+  EFI_FREE_POOL                   FreePool;
+
+  //
+  // Event & Timer Services
+  //
+  EFI_CREATE_EVENT                  CreateEvent;
+  EFI_SET_TIMER                     SetTimer;
+  EFI_WAIT_FOR_EVENT                WaitForEvent;
+  EFI_SIGNAL_EVENT                  SignalEvent;
+  EFI_CLOSE_EVENT                   CloseEvent;
+  EFI_CHECK_EVENT                   CheckEvent;
+
+  //
+  // Protocol Handler Services
+  //
+  EFI_INSTALL_PROTOCOL_INTERFACE    InstallProtocolInterface;
+  EFI_REINSTALL_PROTOCOL_INTERFACE  ReinstallProtocolInterface;
+  EFI_UNINSTALL_PROTOCOL_INTERFACE  UninstallProtocolInterface;
+  EFI_HANDLE_PROTOCOL               HandleProtocol;
+  VOID                              *Reserved;
+  EFI_REGISTER_PROTOCOL_NOTIFY      RegisterProtocolNotify;
+  EFI_LOCATE_HANDLE                 LocateHandle;
+  EFI_LOCATE_DEVICE_PATH            LocateDevicePath;
+  EFI_INSTALL_CONFIGURATION_TABLE   InstallConfigurationTable;
+
+  //
+  // Image Services
+  //
+  EFI_IMAGE_LOAD                    LoadImage;
+  EFI_IMAGE_START                   StartImage;
+  EFI_EXIT                          Exit;
+  EFI_IMAGE_UNLOAD                  UnloadImage;
+  EFI_EXIT_BOOT_SERVICES            ExitBootServices;
+
+  //
+  // Miscellaneous Services
+  //
+  EFI_GET_NEXT_MONOTONIC_COUNT      GetNextMonotonicCount;
+  EFI_STALL                         Stall;
+  EFI_SET_WATCHDOG_TIMER            SetWatchdogTimer;
+
+  //
+  // DriverSupport Services
+  //
+  EFI_CONNECT_CONTROLLER            ConnectController;
+  EFI_DISCONNECT_CONTROLLER         DisconnectController;
+
+  //
+  // Open and Close Protocol Services
+  //
+  EFI_OPEN_PROTOCOL                 OpenProtocol;
+  EFI_CLOSE_PROTOCOL                CloseProtocol;
+  EFI_OPEN_PROTOCOL_INFORMATION     OpenProtocolInformation;
+
+  //
+  // Library Services
+  //
+  EFI_PROTOCOLS_PER_HANDLE          ProtocolsPerHandle;
+  EFI_LOCATE_HANDLE_BUFFER          LocateHandleBuffer;
+  EFI_LOCATE_PROTOCOL               LocateProtocol;
+  EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES    InstallMultipleProtocolInterfaces;
+  EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES  UninstallMultipleProtocolInterfaces;
+
+  //
+  // 32-bit CRC Services
+  //
+  EFI_CALCULATE_CRC32               CalculateCrc32;
+
+  //
+  // Miscellaneous Services
+  //
+  EFI_COPY_MEM                      CopyMem;
+  EFI_SET_MEM                       SetMem;
+  EFI_CREATE_EVENT_EX               CreateEventEx;
+} EFI_BOOT_SERVICES;
+
+///
+/// Contains a set of GUID/pointer pairs comprised of the ConfigurationTable field in the
+/// EFI System Table.
+///
+typedef struct {
+  ///
+  /// The 128-bit GUID value that uniquely identifies the system configuration table.
+  ///
+  EFI_GUID                          VendorGuid;
+  ///
+  /// A pointer to the table associated with VendorGuid.
+  ///
+  VOID                              *VendorTable;
+} EFI_CONFIGURATION_TABLE;
+
+///
+/// EFI System Table
+///
+typedef struct {
+  ///
+  /// The table header for the EFI System Table.
+  ///
+  EFI_TABLE_HEADER                  Hdr;
+  ///
+  /// A pointer to a null terminated string that identifies the vendor
+  /// that produces the system firmware for the platform.
+  ///
+  CHAR16                            *FirmwareVendor;
+  ///
+  /// A firmware vendor specific value that identifies the revision
+  /// of the system firmware for the platform.
+  ///
+  UINT32                            FirmwareRevision;
+  ///
+  /// The handle for the active console input device. This handle must support
+  /// EFI_SIMPLE_TEXT_INPUT_PROTOCOL and EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL.
+  ///
+  EFI_HANDLE                        ConsoleInHandle;
+  ///
+  /// A pointer to the EFI_SIMPLE_TEXT_INPUT_PROTOCOL interface that is
+  /// associated with ConsoleInHandle.
+  ///
+  EFI_SIMPLE_TEXT_INPUT_PROTOCOL    *ConIn;
+  ///
+  /// The handle for the active console output device.
+  ///
+  EFI_HANDLE                        ConsoleOutHandle;
+  ///
+  /// A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
+  /// that is associated with ConsoleOutHandle.
+  ///
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   *ConOut;
+  ///
+  /// The handle for the active standard error console device.
+  /// This handle must support the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.
+  ///
+  EFI_HANDLE                        StandardErrorHandle;
+  ///
+  /// A pointer to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL interface
+  /// that is associated with StandardErrorHandle.
+  ///
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL   *StdErr;
+  ///
+  /// A pointer to the EFI Runtime Services Table.
+  ///
+  EFI_RUNTIME_SERVICES              *RuntimeServices;
+  ///
+  /// A pointer to the EFI Boot Services Table.
+  ///
+  EFI_BOOT_SERVICES                 *BootServices;
+  ///
+  /// The number of system configuration tables in the buffer ConfigurationTable.
+  ///
+  UINTN                             NumberOfTableEntries;
+  ///
+  /// A pointer to the system configuration tables.
+  /// The number of entries in the table is NumberOfTableEntries.
+  ///
+  EFI_CONFIGURATION_TABLE           *ConfigurationTable;
+} EFI_SYSTEM_TABLE;
+
+/**
+  This is the declaration of an EFI image entry point. This entry point is
+  the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
+  both device drivers and bus drivers.
+
+  @param[in]  ImageHandle       The firmware allocated handle for the UEFI image.
+  @param[in]  SystemTable       A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval Others                An unexpected error occurred.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_ENTRY_POINT)(
+  IN  EFI_HANDLE                   ImageHandle,
+  IN  EFI_SYSTEM_TABLE             *SystemTable
+  );
+
+//
+// EFI Load Option. This data structure describes format of UEFI boot option variables.
+//
+// NOTE: EFI Load Option is a byte packed buffer of variable length fields.
+// The first two fields have fixed length. They are declared as members of the
+// EFI_LOAD_OPTION structure. All the other fields are variable length fields.
+// They are listed in the comment block below for reference purposes.
+//
+#pragma pack(1)
+typedef struct _EFI_LOAD_OPTION {
+  ///
+  /// The attributes for this load option entry. All unused bits must be zero
+  /// and are reserved by the UEFI specification for future growth.
+  ///
+  UINT32                           Attributes;
+  ///
+  /// Length in bytes of the FilePathList. OptionalData starts at offset
+  /// sizeof(UINT32) + sizeof(UINT16) + StrSize(Description) + FilePathListLength
+  /// of the EFI_LOAD_OPTION descriptor.
+  ///
+  UINT16                           FilePathListLength;
+  ///
+  /// The user readable description for the load option.
+  /// This field ends with a Null character.
+  ///
+  // CHAR16                        Description[];
+  ///
+  /// A packed array of UEFI device paths. The first element of the array is a
+  /// device path that describes the device and location of the Image for this
+  /// load option. The FilePathList[0] is specific to the device type. Other
+  /// device paths may optionally exist in the FilePathList, but their usage is
+  /// OSV specific. Each element in the array is variable length, and ends at
+  /// the device path end structure. Because the size of Description is
+  /// arbitrary, this data structure is not guaranteed to be aligned on a
+  /// natural boundary. This data structure may have to be copied to an aligned
+  /// natural boundary before it is used.
+  ///
+  // EFI_DEVICE_PATH_PROTOCOL      FilePathList[];
+  ///
+  /// The remaining bytes in the load option descriptor are a binary data buffer
+  /// that is passed to the loaded image. If the field is zero bytes long, a
+  /// NULL pointer is passed to the loaded image. The number of bytes in
+  /// OptionalData can be computed by subtracting the starting offset of
+  /// OptionalData from total size in bytes of the EFI_LOAD_OPTION.
+  ///
+  // UINT8                         OptionalData[];
+} EFI_LOAD_OPTION;
+#pragma pack()
+
+//
+// EFI Load Options Attributes
+//
+#define LOAD_OPTION_ACTIVE              0x00000001
+#define LOAD_OPTION_FORCE_RECONNECT     0x00000002
+#define LOAD_OPTION_HIDDEN              0x00000008
+#define LOAD_OPTION_CATEGORY            0x00001F00
+
+#define LOAD_OPTION_CATEGORY_BOOT       0x00000000
+#define LOAD_OPTION_CATEGORY_APP        0x00000100
+
+#define EFI_BOOT_OPTION_SUPPORT_KEY     0x00000001
+#define EFI_BOOT_OPTION_SUPPORT_APP     0x00000002
+#define EFI_BOOT_OPTION_SUPPORT_SYSPREP 0x00000010
+#define EFI_BOOT_OPTION_SUPPORT_COUNT   0x00000300
+
+///
+/// EFI Boot Key Data
+///
+typedef union {
+  struct {
+    ///
+    /// Indicates the revision of the EFI_KEY_OPTION structure. This revision level should be 0.
+    ///
+    UINT32  Revision        : 8;
+    ///
+    /// Either the left or right Shift keys must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  ShiftPressed    : 1;
+    ///
+    /// Either the left or right Control keys must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  ControlPressed  : 1;
+    ///
+    /// Either the left or right Alt keys must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  AltPressed      : 1;
+    ///
+    /// Either the left or right Logo keys must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  LogoPressed     : 1;
+    ///
+    /// The Menu key must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  MenuPressed     : 1;
+    ///
+    /// The SysReq key must be pressed (1) or must not be pressed (0).
+    ///
+    UINT32  SysReqPressed    : 1;
+    UINT32  Reserved        : 16;
+    ///
+    /// Specifies the actual number of entries in EFI_KEY_OPTION.Keys, from 0-3. If
+    /// zero, then only the shift state is considered. If more than one, then the boot option will
+    /// only be launched if all of the specified keys are pressed with the same shift state.
+    ///
+    UINT32  InputKeyCount   : 2;
+  } Options;
+  UINT32  PackedValue;
+} EFI_BOOT_KEY_DATA;
+
+///
+/// EFI Key Option.
+///
+#pragma pack(1)
+typedef struct {
+  ///
+  /// Specifies options about how the key will be processed.
+  ///
+  EFI_BOOT_KEY_DATA  KeyData;
+  ///
+  /// The CRC-32 which should match the CRC-32 of the entire EFI_LOAD_OPTION to
+  /// which BootOption refers. If the CRC-32s do not match this value, then this key
+  /// option is ignored.
+  ///
+  UINT32             BootOptionCrc;
+  ///
+  /// The Boot#### option which will be invoked if this key is pressed and the boot option
+  /// is active (LOAD_OPTION_ACTIVE is set).
+  ///
+  UINT16             BootOption;
+  ///
+  /// The key codes to compare against those returned by the
+  /// EFI_SIMPLE_TEXT_INPUT and EFI_SIMPLE_TEXT_INPUT_EX protocols.
+  /// The number of key codes (0-3) is specified by the EFI_KEY_CODE_COUNT field in KeyOptions.
+  ///
+  //EFI_INPUT_KEY      Keys[];
+} EFI_KEY_OPTION;
+#pragma pack()
+
+//
+// EFI File location to boot from on removable media devices
+//
+#define EFI_REMOVABLE_MEDIA_FILE_NAME_IA32    L"\\EFI\\BOOT\\BOOTIA32.EFI"
+#define EFI_REMOVABLE_MEDIA_FILE_NAME_IA64    L"\\EFI\\BOOT\\BOOTIA64.EFI"
+#define EFI_REMOVABLE_MEDIA_FILE_NAME_X64     L"\\EFI\\BOOT\\BOOTX64.EFI"
+#define EFI_REMOVABLE_MEDIA_FILE_NAME_ARM     L"\\EFI\\BOOT\\BOOTARM.EFI"
+#define EFI_REMOVABLE_MEDIA_FILE_NAME_AARCH64 L"\\EFI\\BOOT\\BOOTAA64.EFI"
+
+#if   defined (MDE_CPU_IA32)
+  #define EFI_REMOVABLE_MEDIA_FILE_NAME   EFI_REMOVABLE_MEDIA_FILE_NAME_IA32
+#elif defined (MDE_CPU_IPF)
+  #define EFI_REMOVABLE_MEDIA_FILE_NAME   EFI_REMOVABLE_MEDIA_FILE_NAME_IA64
+#elif defined (MDE_CPU_X64)
+  #define EFI_REMOVABLE_MEDIA_FILE_NAME   EFI_REMOVABLE_MEDIA_FILE_NAME_X64
+#elif defined (MDE_CPU_EBC)
+#elif defined (MDE_CPU_ARM)
+  #define EFI_REMOVABLE_MEDIA_FILE_NAME   EFI_REMOVABLE_MEDIA_FILE_NAME_ARM
+#elif defined (MDE_CPU_AARCH64)
+  #define EFI_REMOVABLE_MEDIA_FILE_NAME   EFI_REMOVABLE_MEDIA_FILE_NAME_AARCH64
+#else
+  #error Unknown Processor Type
+#endif
+
+#include <Uefi/UefiPxe.h>
+#include <Uefi/UefiGpt.h>
+#include <Uefi/UefiInternalFormRepresentation.h>
+
+#endif
diff --git a/MdePkg/Include/X64/ProcessorBind.h b/MdePkg/Include/X64/ProcessorBind.h
new file mode 100644
index 000000000000..f32842468e38
--- /dev/null
+++ b/MdePkg/Include/X64/ProcessorBind.h
@@ -0,0 +1,337 @@
+/** @file
+  Processor or Compiler specific defines and types x64 (Intel 64, AMD64).
+
+  Copyright (c) 2006 - 2015, 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 __PROCESSOR_BIND_H__
+#define __PROCESSOR_BIND_H__
+
+///
+/// Define the processor type so other code can make processor based choices
+///
+#define MDE_CPU_X64
+
+//
+// Make sure we are using the correct packing rules per EFI specification
+//
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#if defined(__GNUC__) && defined(__pic__) && !defined(USING_LTO)
+//
+// Mark all symbol declarations and references as hidden, meaning they will
+// not be subject to symbol preemption. This allows the compiler to refer to
+// symbols directly using relative references rather than via the GOT, which
+// contains absolute symbol addresses that are subject to runtime relocation.
+//
+// The LTO linker will not emit GOT based relocations when all symbol
+// references can be resolved locally, and so there is no need to set the
+// pragma in that case (and doing so will cause other issues).
+//
+#pragma GCC visibility push (hidden)
+#endif
+
+#if defined(__INTEL_COMPILER)
+//
+// Disable ICC's remark #869: "Parameter" was never referenced warning.
+// This is legal ANSI C code so we disable the remark that is turned on with -Wall
+//
+#pragma warning ( disable : 869 )
+
+//
+// Disable ICC's remark #1418: external function definition with no prior declaration.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1418 )
+
+//
+// Disable ICC's remark #1419: external declaration in primary source file
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 1419 )
+
+//
+// Disable ICC's remark #593: "Variable" was set but never used.
+// This is legal ANSI C code so we disable the remark that is turned on with /W4
+//
+#pragma warning ( disable : 593 )
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+
+//
+// Disable warning that make it impossible to compile at /W4
+// This only works for Microsoft* tools
+//
+
+//
+// Disabling bitfield type checking warnings.
+//
+#pragma warning ( disable : 4214 )
+
+//
+// Disabling the unreferenced formal parameter warnings.
+//
+#pragma warning ( disable : 4100 )
+
+//
+// Disable slightly different base types warning as CHAR8 * can not be set
+// to a constant string.
+//
+#pragma warning ( disable : 4057 )
+
+//
+// ASSERT(FALSE) or while (TRUE) are legal constructs so suppress this warning
+//
+#pragma warning ( disable : 4127 )
+
+//
+// This warning is caused by functions defined but not used. For precompiled header only.
+//
+#pragma warning ( disable : 4505 )
+
+//
+// This warning is caused by empty (after preprocessing) source file. For precompiled header only.
+//
+#pragma warning ( disable : 4206 )
+
+#if _MSC_VER == 1800 || _MSC_VER == 1900
+
+//
+// Disable these warnings for VS2013.
+//
+
+//
+// This warning is for potentially uninitialized local variable, and it may cause false 
+// positive issues in VS2013 and VS2015 build
+//
+#pragma warning ( disable : 4701 )
+  
+//
+// This warning is for potentially uninitialized local pointer variable, and it may cause 
+// false positive issues in VS2013 and VS2015 build
+//
+#pragma warning ( disable : 4703 )
+  
+#endif
+
+#endif
+
+
+#if defined(_MSC_EXTENSIONS)
+  //
+  // use Microsoft C compiler dependent integer width types
+  //
+
+  ///
+  /// 8-byte unsigned value
+  ///
+  typedef unsigned __int64    UINT64;
+  ///
+  /// 8-byte signed value
+  ///
+  typedef __int64             INT64;
+  ///
+  /// 4-byte unsigned value
+  ///
+  typedef unsigned __int32    UINT32;
+  ///
+  /// 4-byte signed value
+  ///
+  typedef __int32             INT32;
+  ///
+  /// 2-byte unsigned value
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#else
+  ///
+  /// 8-byte unsigned value
+  ///
+  typedef unsigned long long  UINT64;
+  ///
+  /// 8-byte signed value
+  ///
+  typedef long long           INT64;
+  ///
+  /// 4-byte unsigned value
+  ///
+  typedef unsigned int        UINT32;
+  ///
+  /// 4-byte signed value
+  ///
+  typedef int                 INT32;
+  ///
+  /// 2-byte unsigned value
+  ///
+  typedef unsigned short      UINT16;
+  ///
+  /// 2-byte Character.  Unless otherwise specified all strings are stored in the
+  /// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+  ///
+  typedef unsigned short      CHAR16;
+  ///
+  /// 2-byte signed value
+  ///
+  typedef short               INT16;
+  ///
+  /// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+  /// values are undefined.
+  ///
+  typedef unsigned char       BOOLEAN;
+  ///
+  /// 1-byte unsigned value
+  ///
+  typedef unsigned char       UINT8;
+  ///
+  /// 1-byte Character
+  ///
+  typedef char                CHAR8;
+  ///
+  /// 1-byte signed value
+  ///
+  typedef signed char         INT8;
+#endif
+
+///
+/// Unsigned value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef UINT64  UINTN;
+///
+/// Signed value of native width.  (4 bytes on supported 32-bit processor instructions,
+/// 8 bytes on supported 64-bit processor instructions)
+///
+typedef INT64   INTN;
+
+
+//
+// Processor specific defines
+//
+
+///
+/// A value of native width with the highest bit set.
+///
+#define MAX_BIT     0x8000000000000000ULL
+///
+/// A value of native width with the two highest bits set.
+///
+#define MAX_2_BITS  0xC000000000000000ULL
+
+///
+/// Maximum legal x64 address
+///
+#define MAX_ADDRESS   0xFFFFFFFFFFFFFFFFULL
+
+///
+/// Maximum legal x64 INTN and UINTN values.
+///
+#define MAX_INTN   ((INTN)0x7FFFFFFFFFFFFFFFULL)
+#define MAX_UINTN  ((UINTN)0xFFFFFFFFFFFFFFFFULL)
+
+///
+/// The stack alignment required for x64
+///
+#define CPU_STACK_ALIGNMENT   16
+
+///
+/// Page allocation granularity for x64
+///
+#define DEFAULT_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+#define RUNTIME_PAGE_ALLOCATION_GRANULARITY   (0x1000)
+
+//
+// Modifier to ensure that all protocol member functions and EFI intrinsics
+// use the correct C calling convention. All protocol member functions and
+// EFI intrinsics are required to modify their member functions with EFIAPI.
+//
+#ifdef EFIAPI
+  ///
+  /// If EFIAPI is already defined, then we use that definition.
+  ///
+#elif defined(_MSC_EXTENSIONS)
+  ///
+  /// Microsoft* compiler specific method for EFIAPI calling convention.
+  /// 
+  #define EFIAPI __cdecl  
+#elif defined(__GNUC__)
+  ///
+  /// Define the standard calling convention regardless of optimization level.
+  /// The GCC support assumes a GCC compiler that supports the EFI ABI. The EFI
+  /// ABI is much closer to the x64 Microsoft* ABI than standard x64 (x86-64) 
+  /// GCC ABI. Thus a standard x64 (x86-64) GCC compiler can not be used for 
+  /// x64. Warning the assembly code in the MDE x64 does not follow the correct 
+  /// ABI for the standard x64 (x86-64) GCC.
+  ///
+  #define EFIAPI 
+#else
+  ///
+  /// The default for a non Microsoft* or GCC compiler is to assume the EFI ABI
+  /// is the standard. 
+  ///
+  #define EFIAPI       
+#endif
+
+#if defined(__GNUC__)
+  ///
+  /// For GNU assembly code, .global or .globl can declare global symbols.
+  /// Define this macro to unify the usage.
+  ///
+  #define ASM_GLOBAL .globl
+#endif
+
+/**
+  Return the pointer to the first instruction of a function given a function pointer.
+  On x64 CPU architectures, these two pointer values are the same, 
+  so the implementation of this macro is very simple.
+  
+  @param  FunctionPointer   A pointer to a function.
+
+  @return The pointer to the first instruction of a function given a function pointer.
+  
+**/
+#define FUNCTION_ENTRY_POINT(FunctionPointer) (VOID *)(UINTN)(FunctionPointer)
+
+#ifndef __USER_LABEL_PREFIX__
+#define __USER_LABEL_PREFIX__
+#endif
+
+#endif
+
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/ArmCache.c b/MdePkg/Library/BaseCacheMaintenanceLib/ArmCache.c
new file mode 100644
index 000000000000..67a412e91fd3
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/ArmCache.c
@@ -0,0 +1,247 @@
+/** @file
+  Cache Maintenance Functions. These functions vary by ARM architecture so the MdePkg 
+  versions are null functions used to make sure things will compile. 
+
+  Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 common header file for this module.
+//
+#include <Base.h>
+#include <Library/DebugLib.h>
+
+/**
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+**/
+VOID
+EFIAPI
+InvalidateInstructionCache (
+  VOID
+  )
+{
+  ASSERT(FALSE);
+}
+
+/**
+  Invalidates a range of instruction cache lines in the cache coherency domain
+  of the calling CPU.
+
+  Invalidates the instruction cache lines specified by Address and Length. If
+  Address is not aligned on a cache line boundary, then entire instruction
+  cache line containing Address is invalidated. If Address + Length is not
+  aligned on a cache line boundary, then the entire instruction cache line
+  containing Address + Length -1 is invalidated. This function may choose to
+  invalidate the entire instruction cache if that is more efficient than
+  invalidating the specified range. If Length is 0, then no instruction cache
+  lines are invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address
+
+**/
+VOID *
+EFIAPI
+InvalidateInstructionCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  ASSERT(FALSE);
+  return Address;
+}
+
+/**
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU.
+
+  Writes Back and Invalidates the entire data cache in cache coherency domain
+  of the calling CPU. This function guarantees that all dirty cache lines are
+  written back to system memory, and also invalidates all the data cache lines
+  in the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackInvalidateDataCache (
+  VOID
+  )
+{
+  ASSERT(FALSE);
+}
+
+/**
+  Writes back and invalidates a range of data cache lines in the cache
+  coherency domain of the calling CPU.
+
+  Writes back and invalidates the data cache lines specified by Address and
+  Length. If Address is not aligned on a cache line boundary, then entire data
+  cache line containing Address is written back and invalidated. If Address +
+  Length is not aligned on a cache line boundary, then the entire data cache
+  line containing Address + Length -1 is written back and invalidated. This
+  function may choose to write back and invalidate the entire data cache if
+  that is more efficient than writing back and invalidating the specified
+  range. If Length is 0, then no data cache lines are written back and
+  invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back and
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back and invalidate from the
+                  data cache.
+
+  @return Address
+
+**/
+VOID *
+EFIAPI
+WriteBackInvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  ASSERT(FALSE);
+  return Address;
+}
+
+/**
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU. This function guarantees that all dirty cache lines are written back to
+  system memory. This function may also invalidate all the data cache lines in
+  the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackDataCache (
+  VOID
+  )
+{
+  ASSERT(FALSE);
+}
+
+/**
+  Writes back a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Writes back the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is written back. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is written back. This function may choose to write back the entire
+  data cache if that is more efficient than writing back the specified range.
+  If Length is 0, then no data cache lines are written back. This function may
+  also invalidate all the data cache lines in the specified range of the cache
+  coherency domain of the calling CPU. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing
+                  mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back from the data cache.
+
+  @return Address
+
+**/
+VOID *
+EFIAPI
+WriteBackDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  ASSERT(FALSE);
+  return Address;
+}
+
+/**
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU. This function must be used with care because dirty cache lines are not
+  written back to system memory. It is typically used for cache diagnostics. If
+  the CPU does not support invalidation of the entire data cache, then a write
+  back and invalidate operation should be performed on the entire data cache.
+
+**/
+VOID
+EFIAPI
+InvalidateDataCache (
+  VOID
+  )
+{
+  ASSERT(FALSE);
+}
+
+/**
+  Invalidates a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Invalidates the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is invalidated. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is invalidated. This function must never invalidate any cache lines
+  outside the specified range. If Length is 0, then no data cache lines are
+  invalidated. Address is returned. This function must be used with care
+  because dirty cache lines are not written back to system memory. It is
+  typically used for cache diagnostics. If the CPU does not support
+  invalidation of a data cache range, then a write back and invalidate
+  operation should be performed on the data cache range.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+  @param  Length  The number of bytes to invalidate from the data cache.
+
+  @return Address
+
+**/
+VOID *
+EFIAPI
+InvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  ASSERT(FALSE);
+  return Address;
+}
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf b/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
new file mode 100644
index 000000000000..69418110f945
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
@@ -0,0 +1,61 @@
+## @file
+#  Instance of Cache Maintenance Library using Base Library services.
+#
+#  Cache Maintenance Library that uses Base Library services to maintain caches.
+#  This library assumes there are no chipset dependencies required to maintain caches.
+#
+#  Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseCacheMaintenanceLib
+  MODULE_UNI_FILE                = BaseCacheMaintenanceLib.uni
+  FILE_GUID                      = 123dd843-57c9-4158-8418-ce68b3944ce7
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.1
+  LIBRARY_CLASS                  = CacheMaintenanceLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources.IA32]
+  X86Cache.c
+
+[Sources.X64]
+  X86Cache.c
+
+[Sources.IPF]
+  IpfCache.c
+
+[Sources.EBC]
+  EbcCache.c
+
+[Sources.ARM]
+  ArmCache.c
+
+[Sources.AARCH64]
+  ArmCache.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+
+[LibraryClasses.Ipf]
+  PalLib
+
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.uni b/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.uni
new file mode 100644
index 000000000000..9df91beec3fe
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of Cache Maintenance Library using Base Library services.
+//
+// Cache Maintenance Library that uses Base Library services to maintain caches.
+// This library assumes there are no chipset dependencies required to maintain caches.
+//
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Cache Maintenance Library using Base Library services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The Cache Maintenance Library that uses Base Library services to maintain caches. This library assumes there are no chipset dependencies required to maintain caches."
+
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/EbcCache.c b/MdePkg/Library/BaseCacheMaintenanceLib/EbcCache.c
new file mode 100644
index 000000000000..efbb03aa5cc6
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/EbcCache.c
@@ -0,0 +1,231 @@
+/** @file
+  Cache Maintenance Functions.
+
+  Copyright (c) 2006 - 2008, 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 <Base.h>
+#include <Library/DebugLib.h>
+
+/**
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+**/
+VOID
+EFIAPI
+InvalidateInstructionCache (
+  VOID
+  )
+{
+}
+
+/**
+  Invalidates a range of instruction cache lines in the cache coherency domain
+  of the calling CPU.
+
+  Invalidates the instruction cache lines specified by Address and Length. If
+  Address is not aligned on a cache line boundary, then entire instruction
+  cache line containing Address is invalidated. If Address + Length is not
+  aligned on a cache line boundary, then the entire instruction cache line
+  containing Address + Length -1 is invalidated. This function may choose to
+  invalidate the entire instruction cache if that is more efficient than
+  invalidating the specified range. If Length is 0, then no instruction cache
+  lines are invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateInstructionCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  return Address;
+}
+
+/**
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU.
+
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU. This function guarantees that all dirty cache lines are
+  written back to system memory, and also invalidates all the data cache lines
+  in the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackInvalidateDataCache (
+  VOID
+  )
+{
+}
+
+/**
+  Writes back and invalidates a range of data cache lines in the cache
+  coherency domain of the calling CPU.
+
+  Writes Back and Invalidate the data cache lines specified by Address and
+  Length. If Address is not aligned on a cache line boundary, then entire data
+  cache line containing Address is written back and invalidated. If Address +
+  Length is not aligned on a cache line boundary, then the entire data cache
+  line containing Address + Length -1 is written back and invalidated. This
+  function may choose to write back and invalidate the entire data cache if
+  that is more efficient than writing back and invalidating the specified
+  range. If Length is 0, then no data cache lines are written back and
+  invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back and
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back and invalidate from the
+                  data cache.
+
+  @return Address of cache invalidation.
+
+**/
+VOID *
+EFIAPI
+WriteBackInvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  return Address;
+}
+
+/**
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU. This function guarantees that all dirty cache lines are written back to
+  system memory. This function may also invalidate all the data cache lines in
+  the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackDataCache (
+  VOID
+  )
+{
+}
+
+/**
+  Writes back a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Writes back the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is written back. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is written back. This function may choose to write back the entire
+  data cache if that is more efficient than writing back the specified range.
+  If Length is 0, then no data cache lines are written back. This function may
+  also invalidate all the data cache lines in the specified range of the cache
+  coherency domain of the calling CPU. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing
+                  mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back from the data cache.
+
+  @return Address of cache written in main memory.
+
+**/
+VOID *
+EFIAPI
+WriteBackDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  return Address;
+}
+
+/**
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU. This function must be used with care because dirty cache lines are not
+  written back to system memory. It is typically used for cache diagnostics. If
+  the CPU does not support invalidation of the entire data cache, then a write
+  back and invalidate operation should be performed on the entire data cache.
+
+**/
+VOID
+EFIAPI
+InvalidateDataCache (
+  VOID
+  )
+{
+}
+
+/**
+  Invalidates a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Invalidates the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is invalidated. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is invalidated. This function must never invalidate any cache lines
+  outside the specified range. If Length is 0, then no data cache lines are
+  invalidated. Address is returned. This function must be used with care
+  because dirty cache lines are not written back to system memory. It is
+  typically used for cache diagnostics. If the CPU does not support
+  invalidation of a data cache range, then a write back and invalidate
+  operation should be performed on the data cache range.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+  @param  Length  The number of bytes to invalidate from the data cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  return Address;
+}
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/IpfCache.c b/MdePkg/Library/BaseCacheMaintenanceLib/IpfCache.c
new file mode 100644
index 000000000000..47153ac9a65f
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/IpfCache.c
@@ -0,0 +1,242 @@
+/** @file
+  Cache Maintenance Functions.
+
+  Copyright (c) 2006 - 2009, 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 <Base.h>
+#include <Library/CacheMaintenanceLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PalLib.h>
+
+/**
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+**/
+VOID
+EFIAPI
+InvalidateInstructionCache (
+  VOID
+  )
+{
+  PalCall (PAL_CACHE_FLUSH, PAL_CACHE_FLUSH_INSTRUCTION_ALL, PAL_CACHE_FLUSH_INVALIDATE_LINES | PAL_CACHE_FLUSH_NO_INTERRUPT, 0);
+}
+
+/**
+  Invalidates a range of instruction cache lines in the cache coherency domain
+  of the calling CPU.
+
+  Invalidates the instruction cache lines specified by Address and Length. If
+  Address is not aligned on a cache line boundary, then entire instruction
+  cache line containing Address is invalidated. If Address + Length is not
+  aligned on a cache line boundary, then the entire instruction cache line
+  containing Address + Length -1 is invalidated. This function may choose to
+  invalidate the entire instruction cache if that is more efficient than
+  invalidating the specified range. If Length is 0, then no instruction cache
+  lines are invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateInstructionCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  return AsmFlushCacheRange (Address, Length);
+}
+
+/**
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU.
+
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU. This function guarantees that all dirty cache lines are
+  written back to system memory, and also invalidates all the data cache lines
+  in the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackInvalidateDataCache (
+  VOID
+  )
+{
+  PalCall (PAL_CACHE_FLUSH, PAL_CACHE_FLUSH_DATA_ALL, PAL_CACHE_FLUSH_INVALIDATE_LINES | PAL_CACHE_FLUSH_NO_INTERRUPT, 0);
+}
+
+/**
+  Writes back and invalidates a range of data cache lines in the cache
+  coherency domain of the calling CPU.
+
+  Writes back and invalidates the data cache lines specified by Address and
+  Length. If Address is not aligned on a cache line boundary, then entire data
+  cache line containing Address is written back and invalidated. If Address +
+  Length is not aligned on a cache line boundary, then the entire data cache
+  line containing Address + Length -1 is written back and invalidated. This
+  function may choose to write back and invalidate the entire data cache if
+  that is more efficient than writing back and invalidating the specified
+  range. If Length is 0, then no data cache lines are written back and
+  invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back and
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back and invalidate from the
+                  data cache.
+
+  @return Address of cache invalidation.
+
+**/
+VOID *
+EFIAPI
+WriteBackInvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  return AsmFlushCacheRange (Address, Length);
+}
+
+/**
+  Writes Back the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Writes Back the entire data cache in cache coherency domain of the calling
+  CPU. This function guarantees that all dirty cache lines are written back to
+  system memory. This function may also invalidate all the data cache lines in
+  the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackDataCache (
+  VOID
+  )
+{
+  PalCall (PAL_CACHE_FLUSH, PAL_CACHE_FLUSH_DATA_ALL, PAL_CACHE_FLUSH_NO_INVALIDATE_LINES | PAL_CACHE_FLUSH_NO_INTERRUPT, 0);
+}
+
+/**
+  Writes Back a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Writes Back the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is written back. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is written back. This function may choose to write back the entire
+  data cache if that is more efficient than writing back the specified range.
+  If Length is 0, then no data cache lines are written back. This function may
+  also invalidate all the data cache lines in the specified range of the cache
+  coherency domain of the calling CPU. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing
+                  mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back from the data cache.
+
+  @return Address of cache written in main memory.
+
+**/
+VOID *
+EFIAPI
+WriteBackDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  return AsmFlushCacheRange (Address, Length);
+}
+
+/**
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU. This function must be used with care because dirty cache lines are not
+  written back to system memory. It is typically used for cache diagnostics. If
+  the CPU does not support invalidation of the entire data cache, then a write
+  back and invalidate operation should be performed on the entire data cache.
+
+**/
+VOID
+EFIAPI
+InvalidateDataCache (
+  VOID
+  )
+{
+  //
+  // Invalidation of the entire data cache without writing back is not supported 
+  // on IPF architecture, so a write back and invalidate operation is performed.
+  //
+  WriteBackInvalidateDataCache ();
+}
+
+/**
+  Invalidates a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Invalidates the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is invalidated. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is invalidated. This function must never invalidate any cache lines
+  outside the specified range. If Length is 0, then no data cache lines are
+  invalidated. Address is returned. This function must be used with care
+  because dirty cache lines are not written back to system memory. It is
+  typically used for cache diagnostics. If the CPU does not support
+  invalidation of a data cache range, then a write back and invalidate
+  operation should be performed on the data cache range.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+  @param  Length  The number of bytes to invalidate from the data cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  //
+  // Invalidation of a data cache range without writing back is not supported on
+  // IPF architecture, so write back and invalidate operation is performed.
+  //
+  return AsmFlushCacheRange (Address, Length);
+}
diff --git a/MdePkg/Library/BaseCacheMaintenanceLib/X86Cache.c b/MdePkg/Library/BaseCacheMaintenanceLib/X86Cache.c
new file mode 100644
index 000000000000..66b839e72489
--- /dev/null
+++ b/MdePkg/Library/BaseCacheMaintenanceLib/X86Cache.c
@@ -0,0 +1,278 @@
+/** @file
+  Cache Maintenance Functions.
+
+  Copyright (c) 2006 - 2015, 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 <Base.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Invalidates the entire instruction cache in cache coherency domain of the
+  calling CPU.
+
+**/
+VOID
+EFIAPI
+InvalidateInstructionCache (
+  VOID
+  )
+{
+}
+
+/**
+  Invalidates a range of instruction cache lines in the cache coherency domain
+  of the calling CPU.
+
+  Invalidates the instruction cache lines specified by Address and Length. If
+  Address is not aligned on a cache line boundary, then entire instruction
+  cache line containing Address is invalidated. If Address + Length is not
+  aligned on a cache line boundary, then the entire instruction cache line
+  containing Address + Length -1 is invalidated. This function may choose to
+  invalidate the entire instruction cache if that is more efficient than
+  invalidating the specified range. If Length is 0, then no instruction cache
+  lines are invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateInstructionCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  if (Length == 0) {
+    return Address;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Address));
+  return Address;
+}
+
+/**
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU.
+
+  Writes back and invalidates the entire data cache in cache coherency domain
+  of the calling CPU. This function guarantees that all dirty cache lines are
+  written back to system memory, and also invalidates all the data cache lines
+  in the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackInvalidateDataCache (
+  VOID
+  )
+{
+  AsmWbinvd ();
+}
+
+/**
+  Writes back and invalidates a range of data cache lines in the cache
+  coherency domain of the calling CPU.
+
+  Writes back and invalidates the data cache lines specified by Address and
+  Length. If Address is not aligned on a cache line boundary, then entire data
+  cache line containing Address is written back and invalidated. If Address +
+  Length is not aligned on a cache line boundary, then the entire data cache
+  line containing Address + Length -1 is written back and invalidated. This
+  function may choose to write back and invalidate the entire data cache if
+  that is more efficient than writing back and invalidating the specified
+  range. If Length is 0, then no data cache lines are written back and
+  invalidated. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back and
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back and invalidate from the
+                  data cache.
+
+  @return Address of cache invalidation.
+
+**/
+VOID *
+EFIAPI
+WriteBackInvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  UINT32                            RegEbx;
+  UINT32                            RegEdx;
+  UINTN                             CacheLineSize;
+  UINTN                             Start;
+  UINTN                             End;
+
+  if (Length == 0) {
+    return Address;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Address));
+
+  //
+  // If the CPU does not support CLFLUSH instruction, 
+  // then promote flush range to flush entire cache.
+  //
+  AsmCpuid (0x01, NULL, &RegEbx, NULL, &RegEdx);
+  if ((RegEdx & BIT19) == 0) {
+    AsmWbinvd ();
+    return Address;
+  }
+
+  //
+  // Cache line size is 8 * Bits 15-08 of EBX returned from CPUID 01H
+  //
+  CacheLineSize = (RegEbx & 0xff00) >> 5;
+
+  Start = (UINTN)Address;
+  //
+  // Calculate the cache line alignment
+  //
+  End = (Start + Length + (CacheLineSize - 1)) & ~(CacheLineSize - 1);
+  Start &= ~((UINTN)CacheLineSize - 1);
+
+  do {
+    Start = (UINTN)AsmFlushCacheLine ((VOID*)Start) + CacheLineSize;
+  } while (Start != End);
+  return Address;
+}
+
+/**
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Writes back the entire data cache in cache coherency domain of the calling
+  CPU. This function guarantees that all dirty cache lines are written back to
+  system memory. This function may also invalidate all the data cache lines in
+  the cache coherency domain of the calling CPU.
+
+**/
+VOID
+EFIAPI
+WriteBackDataCache (
+  VOID
+  )
+{
+  WriteBackInvalidateDataCache ();
+}
+
+/**
+  Writes back a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Writes back the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is written back. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is written back. This function may choose to write back the entire
+  data cache if that is more efficient than writing back the specified range.
+  If Length is 0, then no data cache lines are written back. This function may
+  also invalidate all the data cache lines in the specified range of the cache
+  coherency domain of the calling CPU. Address is returned.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to write back. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing
+                  mode, then Address is a virtual address.
+  @param  Length  The number of bytes to write back from the data cache.
+
+  @return Address of cache written in main memory.
+
+**/
+VOID *
+EFIAPI
+WriteBackDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  return WriteBackInvalidateDataCacheRange (Address, Length);
+}
+
+/**
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU.
+
+  Invalidates the entire data cache in cache coherency domain of the calling
+  CPU. This function must be used with care because dirty cache lines are not
+  written back to system memory. It is typically used for cache diagnostics. If
+  the CPU does not support invalidation of the entire data cache, then a write
+  back and invalidate operation should be performed on the entire data cache.
+
+**/
+VOID
+EFIAPI
+InvalidateDataCache (
+  VOID
+  )
+{
+  AsmInvd ();
+}
+
+/**
+  Invalidates a range of data cache lines in the cache coherency domain of the
+  calling CPU.
+
+  Invalidates the data cache lines specified by Address and Length. If Address
+  is not aligned on a cache line boundary, then entire data cache line
+  containing Address is invalidated. If Address + Length is not aligned on a
+  cache line boundary, then the entire data cache line containing Address +
+  Length -1 is invalidated. This function must never invalidate any cache lines
+  outside the specified range. If Length is 0, then no data cache lines are
+  invalidated. Address is returned. This function must be used with care
+  because dirty cache lines are not written back to system memory. It is
+  typically used for cache diagnostics. If the CPU does not support
+  invalidation of a data cache range, then a write back and invalidate
+  operation should be performed on the data cache range.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the data cache lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+  @param  Length  The number of bytes to invalidate from the data cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+InvalidateDataCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  //
+  // Invalidation of a data cache range without writing back is not supported on
+  // x86 architecture, so write back and invalidate operation is performed.
+  //
+  return WriteBackInvalidateDataCacheRange (Address, Length);
+}
diff --git a/MdePkg/Library/BaseCpuLib/AArch64/CpuFlushTlb.S b/MdePkg/Library/BaseCpuLib/AArch64/CpuFlushTlb.S
new file mode 100644
index 000000000000..4b9a326f608f
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/AArch64/CpuFlushTlb.S
@@ -0,0 +1,38 @@
+#------------------------------------------------------------------------------
+#
+# CpuFlushTlb() for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(CpuFlushTlb)
+
+#/**
+#  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+#
+#  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuFlushTlb (
+#  VOID
+#  )#
+#
+ASM_PFX(CpuFlushTlb):
+  tlbi  vmalle1                 // Invalidate Inst TLB and Data TLB
+  dsb   sy
+  isb
+  ret
diff --git a/MdePkg/Library/BaseCpuLib/AArch64/CpuSleep.S b/MdePkg/Library/BaseCpuLib/AArch64/CpuSleep.S
new file mode 100644
index 000000000000..b08bdfb8f39d
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/AArch64/CpuSleep.S
@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------
+#
+# CpuSleep() for AArch64
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM LTD. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.align 3
+GCC_ASM_EXPORT(CpuSleep)
+
+#/**
+#  Places the CPU in a sleep state until an interrupt is received.
+#
+#  Places the CPU in a sleep state until an interrupt is received. If interrupts
+#  are disabled prior to calling this function, then the CPU will be placed in a
+#  sleep state indefinitely.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuSleep (
+#  VOID
+#  );
+#
+
+ASM_PFX(CpuSleep):
+    wfi
+    ret
diff --git a/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.S b/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.S
new file mode 100644
index 000000000000..738f73356a3f
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------ 
+#
+# CpuFlushTlb() for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(CpuFlushTlb)
+
+#/**
+#  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+#
+#  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuFlushTlb (
+#  VOID
+#  )#
+#
+ASM_PFX(CpuFlushTlb):
+    mov r0,#0
+    mcr p15,0,r0,c8,c5,0        // Invalidate all the unlocked entried in TLB
+    bx  LR
diff --git a/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.asm b/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.asm
new file mode 100644
index 000000000000..037d221a794d
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Arm/CpuFlushTlb.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ 
+;
+; CpuFlushTlb() for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+  EXPORT CpuFlushTlb
+  AREA cpu_flush_tlb, CODE, READONLY
+
+;/**
+;  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+;
+;  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+;
+;**/
+;VOID
+;EFIAPI
+;CpuFlushTlb (
+;  VOID
+;  );
+;
+CpuFlushTlb 
+    MOV r0,#0
+    MCR p15,0,r0,c8,c5,0        ;Invalidate all the unlocked entried in TLB
+    BX LR
+
+  END
diff --git a/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.S b/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.S
new file mode 100644
index 000000000000..b84c80862350
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------ 
+#
+# CpuSleep() for ARMv7
+#
+# ARMv6 versions was:
+#    MOV r0,#0
+#    MCR p15,0,r0,c7,c0,4   ;Wait for Interrupt instruction
+#
+# But this is a no-op on ARMv7
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(CpuSleep)
+
+#/**
+#  Places the CPU in a sleep state until an interrupt is received.
+#
+#  Places the CPU in a sleep state until an interrupt is received. If interrupts
+#  are disabled prior to calling this function, then the CPU will be placed in a
+#  sleep state indefinitely.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuSleep (
+#  VOID
+#  );
+#
+ASM_PFX(CpuSleep):
+    wfi
+    bx  lr
diff --git a/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.asm b/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.asm
new file mode 100644
index 000000000000..399b80f720fb
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Arm/CpuSleep.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------ 
+;
+; CpuSleep() for ARMv7
+;
+; ARMv6 versions was:
+;    MOV r0,#0
+;    MCR p15,0,r0,c7,c0,4   ;Wait for Interrupt instruction
+;
+; But this is a no-op on ARMv7
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2011, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+  EXPORT CpuSleep
+  AREA cpu_sleep, CODE, READONLY
+
+;/**
+;  Places the CPU in a sleep state until an interrupt is received.
+;
+;  Places the CPU in a sleep state until an interrupt is received. If interrupts
+;  are disabled prior to calling this function, then the CPU will be placed in a
+;  sleep state indefinitely.
+;
+;**/
+;VOID
+;EFIAPI
+;CpuSleep (
+;  VOID
+;  );
+;
+CpuSleep
+    WFI
+    BX LR
+
+  END
diff --git a/MdePkg/Library/BaseCpuLib/BaseCpuLib.inf b/MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
new file mode 100644
index 000000000000..7237b8ff118e
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
@@ -0,0 +1,82 @@
+## @file
+#  Instance of CPU Library for various architecture.
+#
+#  CPU Library implemented using ASM functions for IA-32 and X64,
+#  PAL CALLs for IPF, and empty functions for EBC.
+#
+#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+#  Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseCpuLib
+  MODULE_UNI_FILE                = BaseCpuLib.uni
+  FILE_GUID                      = 4FBD2538-249C-4b50-8F4A-A9E66609CBF6
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = CpuLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources.IA32]
+  Ia32/CpuSleep.c | MSFT 
+  Ia32/CpuFlushTlb.c | MSFT 
+
+  Ia32/CpuSleep.nasm| INTEL
+  Ia32/CpuSleep.asm | INTEL 
+  Ia32/CpuFlushTlb.nasm| INTEL
+  Ia32/CpuFlushTlb.asm | INTEL 
+
+  Ia32/CpuSleepGcc.c | GCC 
+  Ia32/CpuFlushTlbGcc.c | GCC 
+
+[Sources.X64]
+  X64/CpuFlushTlb.nasm
+  X64/CpuFlushTlb.asm 
+  X64/CpuSleep.nasm
+  X64/CpuSleep.asm
+
+  X64/CpuSleep.nasm| GCC
+  X64/CpuSleep.S | GCC 
+  X64/CpuFlushTlb.nasm| GCC
+  X64/CpuFlushTlb.S | GCC 
+
+[Sources.IPF]
+  Ipf/CpuFlushTlb.s
+  Ipf/CpuSleep.c
+
+[Sources.EBC]
+  Ebc/CpuSleepFlushTlb.c
+
+[Sources.ARM]
+  Arm/CpuFlushTlb.asm | RVCT
+  Arm/CpuSleep.asm    | RVCT  
+  Arm/CpuFlushTlb.S   | GCC
+  Arm/CpuSleep.S      | GCC  
+
+[Sources.AARCH64]
+  AArch64/CpuFlushTlb.S | GCC
+  AArch64/CpuSleep.S    | GCC
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses.IPF]
+  PalLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseCpuLib/BaseCpuLib.uni b/MdePkg/Library/BaseCpuLib/BaseCpuLib.uni
new file mode 100644
index 000000000000..19510f427583
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/BaseCpuLib.uni
@@ -0,0 +1,24 @@
+// /** @file
+// Instance of CPU Library for various architecture.
+//
+// CPU Library implemented using ASM functions for IA-32 and X64,
+// PAL CALLs for IPF, and empty functions for EBC.
+//
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+// Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of CPU Library for various architectures"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "CPU Library implemented using ASM functions for IA-32 and X64, PAL CALLs for IPF, and empty functions for EBC."
+
diff --git a/MdePkg/Library/BaseCpuLib/Ebc/CpuSleepFlushTlb.c b/MdePkg/Library/BaseCpuLib/Ebc/CpuSleepFlushTlb.c
new file mode 100644
index 000000000000..81ae029c59e4
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ebc/CpuSleepFlushTlb.c
@@ -0,0 +1,46 @@
+/** @file
+  Base Library CPU Functions for EBC
+
+  Copyright (c) 2006 - 2008, 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 <Base.h>
+#include <Library/DebugLib.h>
+
+/**
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+**/
+VOID
+EFIAPI
+CpuFlushTlb (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Places the CPU in a sleep state until an interrupt is received.
+
+  Places the CPU in a sleep state until an interrupt is received. If interrupts
+  are disabled prior to calling this function, then the CPU will be placed in a
+  sleep state indefinitely.
+
+**/
+VOID
+EFIAPI
+CpuSleep (
+  VOID
+  )
+{
+}
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.asm b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.asm
new file mode 100644
index 000000000000..2b54d35a6ffc
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuFlushTlb.Asm
+;
+; Abstract:
+;
+;   CpuFlushTlb function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuFlushTlb (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuFlushTlb PROC
+    mov     eax, cr3
+    mov     cr3, eax                    ; moving to CR3 flushes TLB
+    ret
+CpuFlushTlb ENDP
+
+    END
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.c
new file mode 100644
index 000000000000..25b16c52f632
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.c
@@ -0,0 +1,34 @@
+/** @file
+  CpuFlushTlb function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+/**
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+**/
+VOID
+EFIAPI
+CpuFlushTlb (
+  VOID
+  )
+{
+  _asm {
+    mov     eax, cr3
+    mov     cr3, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.nasm b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.nasm
new file mode 100644
index 000000000000..aa343459f3f2
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuFlushTlb.Asm
+;
+; Abstract:
+;
+;   CpuFlushTlb function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuFlushTlb (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuFlushTlb)
+ASM_PFX(CpuFlushTlb):
+    mov     eax, cr3
+    mov     cr3, eax                    ; moving to CR3 flushes TLB
+    ret
+
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlbGcc.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlbGcc.c
new file mode 100644
index 000000000000..4cff85122f9c
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlbGcc.c
@@ -0,0 +1,32 @@
+/** @file
+  CpuFlushTlb function for Ia32/X64 GCC.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 <Library/BaseLib.h>
+
+/**
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+  Flushes all the Translation Lookaside Buffers(TLB) entries in a CPU.
+
+**/
+VOID
+EFIAPI
+CpuFlushTlb (
+  VOID
+  )
+{
+  AsmWriteCr3 (AsmReadCr3 ());
+}
+
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.asm b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.asm
new file mode 100644
index 000000000000..592d36d377e4
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuSleep.Asm
+;
+; Abstract:
+;
+;   CpuSleep function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuSleep (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuSleep    PROC
+    hlt
+    ret
+CpuSleep    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.c
new file mode 100644
index 000000000000..40b0453967d6
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.c
@@ -0,0 +1,34 @@
+/** @file
+  CpuSleep function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+/**
+  Places the CPU in a sleep state until an interrupt is received.
+
+  Places the CPU in a sleep state until an interrupt is received. If interrupts
+  are disabled prior to calling this function, then the CPU will be placed in a
+  sleep state indefinitely.
+
+**/
+VOID
+EFIAPI
+CpuSleep (
+  VOID
+  )
+{
+  _asm {
+    hlt
+  }
+}
+
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.nasm b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.nasm
new file mode 100644
index 000000000000..c808f9630170
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.nasm
@@ -0,0 +1,36 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuSleep.Asm
+;
+; Abstract:
+;
+;   CpuSleep function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuSleep (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuSleep)
+ASM_PFX(CpuSleep):
+    hlt
+    ret
+
diff --git a/MdePkg/Library/BaseCpuLib/Ia32/CpuSleepGcc.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleepGcc.c
new file mode 100644
index 000000000000..b61a61fcc9ae
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleepGcc.c
@@ -0,0 +1,33 @@
+/** @file
+  CpuSleep function for Ia32/X64 GCC.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+
+**/
+
+
+/**
+  Places the CPU in a sleep state until an interrupt is received.
+
+  Places the CPU in a sleep state until an interrupt is received. If interrupts
+  are disabled prior to calling this function, then the CPU will be placed in a
+  sleep state indefinitely.
+
+**/
+VOID
+EFIAPI
+CpuSleep (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("hlt"::: "memory");
+}
+
diff --git a/MdePkg/Library/BaseCpuLib/Ipf/CpuFlushTlb.s b/MdePkg/Library/BaseCpuLib/Ipf/CpuFlushTlb.s
new file mode 100644
index 000000000000..e0d40163181e
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ipf/CpuFlushTlb.s
@@ -0,0 +1,58 @@
+/// @file
+///   CpuFlushTlb() function for Itanium-based architecture.
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name:  CpuFlushTlb.s
+///
+///
+
+.auto
+.text
+
+ASM_GLOBAL PalCall
+.type   PalCall, @function
+
+.proc   CpuFlushTlb
+.type   CpuFlushTlb, @function
+CpuFlushTlb::
+        alloc               loc0 = ar.pfs, 0, 3, 5, 0
+        mov                 out0 = 0
+        mov                 out1 = 6
+        mov                 out2 = 0
+        mov                 out3 = 0
+        mov                 loc1 = b0
+        mov                 out4 = 0
+        brl.call.sptk       b0  = PalCall
+        mov                 loc2 = psr              // save PSR
+        mov                 ar.pfs = loc0
+        extr.u              r14 = r10, 32, 32       // r14 <- count1
+        rsm                 1 << 14                 // Disable interrupts
+        extr.u              r15 = r11, 32, 32       // r15 <- stride1
+        extr.u              r10 = r10, 0, 32        // r10 <- count2
+        add                 r10 = -1, r10
+        extr.u              r11 = r11, 0, 32        // r11 <- stride2
+        br.cond.sptk        LoopPredicate
+LoopOuter:
+        mov                 ar.lc = r10             // LC <- count2
+        mov                 ar.ec = r0              // EC <- 0
+Loop:
+        ptc.e               r9
+        add                 r9 = r11, r9            // r9 += stride2
+        br.ctop.sptk        Loop
+        add                 r9 = r15, r9            // r9 += stride1
+LoopPredicate:
+        cmp.ne              p6 = r0, r14            // count1 == 0?
+        add                 r14 = -1, r14
+(p6)    br.cond.sptk        LoopOuter
+        mov                 psr.l = loc2
+        mov                 b0  = loc1
+        br.ret.sptk.many    b0
+.endp
diff --git a/MdePkg/Library/BaseCpuLib/Ipf/CpuSleep.c b/MdePkg/Library/BaseCpuLib/Ipf/CpuSleep.c
new file mode 100644
index 000000000000..86d2c184772b
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/Ipf/CpuSleep.c
@@ -0,0 +1,66 @@
+/** @file
+  Base Library CPU functions for Itanium
+
+  Copyright (c) 2006 - 2009, 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 <Library/PalLib.h>
+#include <Library/BaseLib.h>
+
+/**
+  Places the CPU in a sleep state until an interrupt is received.
+
+  Places the CPU in a sleep state until an interrupt is received. If interrupts
+  are disabled prior to calling this function, then the CPU will be placed in a
+  sleep state indefinitely.
+
+**/
+VOID
+EFIAPI
+CpuSleep (
+  VOID
+  )
+{
+  UINT64  Tpr;
+
+  //
+  // It is the TPR register that controls if external interrupt would bring processor in LIGHT HALT low-power state
+  // back to normal state. PAL_HALT_LIGHT does not depend on PSR setting.
+  // So here if interrupts are disabled (via PSR.i), TRP.mmi needs to be set to prevent processor being interrupted by external interrupts.
+  // If interrupts are enabled, then just use current TRP setting.
+  //
+  if (GetInterruptState ()) {
+    //
+    // If interrupts are enabled, then call PAL_HALT_LIGHT with the current TPR setting.
+    //
+    PalCall (PAL_HALT_LIGHT, 0, 0, 0);
+  } else {
+    //
+    // If interrupts are disabled on entry, then mask all interrupts in TPR before calling PAL_HALT_LIGHT.
+    //
+
+    //
+    // Save TPR
+    //
+    Tpr = AsmReadTpr();
+    //
+    // Set TPR.mmi to mask all external interrupts
+    //
+    AsmWriteTpr (BIT16 | Tpr);
+
+    PalCall (PAL_HALT_LIGHT, 0, 0, 0);
+
+    //
+    // Restore TPR
+    //
+    AsmWriteTpr (Tpr);
+  }
+}
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.S b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.S
new file mode 100644
index 000000000000..7820f5a0e334
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.S
@@ -0,0 +1,35 @@
+#------------------------------------------------------------------------------ 
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuFlushTlb.Asm
+#
+# Abstract:
+#
+#   CpuFlushTlb function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(CpuFlushTlb)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# CpuFlushTlb (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(CpuFlushTlb):
+    mov     %cr3, %rax
+    mov     %rax, %cr3
+    ret
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.asm b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.asm
new file mode 100644
index 000000000000..9df888210381
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuFlushTlb.Asm
+;
+; Abstract:
+;
+;   CpuFlushTlb function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuFlushTlb (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuFlushTlb PROC
+    mov     rax, cr3
+    mov     cr3, rax
+    ret
+CpuFlushTlb ENDP
+
+    END
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.nasm b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.nasm
new file mode 100644
index 000000000000..cdcbbca4ddb1
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuFlushTlb.Asm
+;
+; Abstract:
+;
+;   CpuFlushTlb function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuFlushTlb (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuFlushTlb)
+ASM_PFX(CpuFlushTlb):
+    mov     rax, cr3
+    mov     cr3, rax
+    ret
+
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuSleep.S b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.S
new file mode 100644
index 000000000000..44d58e912cc5
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.S
@@ -0,0 +1,34 @@
+#------------------------------------------------------------------------------ ;
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuSleep.S
+#
+# Abstract:
+#
+#   CpuSleep function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# CpuSleep (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(CpuSleep)
+ASM_PFX(CpuSleep):
+    hlt
+    ret
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuSleep.asm b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.asm
new file mode 100644
index 000000000000..a0448b776641
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuSleep.Asm
+;
+; Abstract:
+;
+;   CpuSleep function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuSleep (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuSleep    PROC
+    hlt
+    ret
+CpuSleep    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseCpuLib/X64/CpuSleep.nasm b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.nasm
new file mode 100644
index 000000000000..0deed7f224e1
--- /dev/null
+++ b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuSleep.Asm
+;
+; Abstract:
+;
+;   CpuSleep function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuSleep (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuSleep)
+ASM_PFX(CpuSleep):
+    hlt
+    ret
+
diff --git a/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf b/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
new file mode 100644
index 000000000000..5bb0a7808652
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
@@ -0,0 +1,36 @@
+## @file
+#  Debug Library with empty functions.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseDebugLibNull
+  MODULE_UNI_FILE                = BaseDebugLibNull.uni
+  FILE_GUID                      = 9ba1d976-0624-41a3-8650-28165e8d9ae8
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DebugLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.uni b/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.uni
new file mode 100644
index 000000000000..3cf6a75b3161
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Debug Library with empty functions.
+//
+// Debug Library with empty functions.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Debug Library with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Debug Library with empty functions."
+
diff --git a/MdePkg/Library/BaseDebugLibNull/DebugLib.c b/MdePkg/Library/BaseDebugLibNull/DebugLib.c
new file mode 100644
index 000000000000..f3fa4aa84fc4
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibNull/DebugLib.c
@@ -0,0 +1,198 @@
+/** @file
+  Null Base Debug Library instance with empty functions.
+
+  Copyright (c) 2006 - 2015, 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 <Base.h>
+#include <Library/DebugLib.h>
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      Format string for the debug message to print.
+  @param  ...         Variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  )
+{
+}
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated the assert condition.
+  @param  LineNumber   The line number in the source file that generated the assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  )
+{
+}
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  return Buffer;
+}
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return FALSE;
+}
+
diff --git a/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf b/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf
new file mode 100644
index 000000000000..7d588a0da870
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf
@@ -0,0 +1,49 @@
+## @file
+#  Instance of Debug Library based on Serial Port Library.
+#  It uses Print Library to produce formatted output strings to seiral port device.
+#
+#  Copyright (c) 2006 - 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseDebugLibSerialPort
+  MODULE_UNI_FILE                = BaseDebugLibSerialPort.uni
+  FILE_GUID                      = BB83F95F-EDBC-4884-A520-CD42AF388FAE
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugLib 
+  CONSTRUCTOR                    = BaseDebugLibSerialPortConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DebugLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  SerialPortLib
+  BaseMemoryLib
+  PcdLib
+  PrintLib
+  BaseLib
+  DebugPrintErrorLevelLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue  ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask      ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel ## CONSUMES
+
diff --git a/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.uni b/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.uni
new file mode 100644
index 000000000000..4b902078ca2f
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Debug Library based on Serial Port Library.
+//
+// It uses Print Library to produce formatted output strings to seiral port device.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Debug Library based on Serial Port Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "It uses Print Library to produce formatted output strings to a serial port device."
+
diff --git a/MdePkg/Library/BaseDebugLibSerialPort/DebugLib.c b/MdePkg/Library/BaseDebugLibSerialPort/DebugLib.c
new file mode 100644
index 000000000000..1bef983c908d
--- /dev/null
+++ b/MdePkg/Library/BaseDebugLibSerialPort/DebugLib.c
@@ -0,0 +1,284 @@
+/** @file
+  Base Debug library instance base on Serial Port library.
+  It uses PrintLib to send debug messages to serial port device.
+  
+  NOTE: If the Serial Port library enables hardware flow control, then a call 
+  to DebugPrint() or DebugAssert() may hang if writes to the serial port are 
+  being blocked.  This may occur if a key(s) are pressed in a terminal emulator
+  used to monitor the DEBUG() and ASSERT() messages. 
+
+  Copyright (c) 2006 - 2011, 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 <Base.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PrintLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/SerialPortLib.h>
+#include <Library/DebugPrintErrorLevelLib.h>
+
+//
+// Define the maximum debug and assert message length that this library supports 
+//
+#define MAX_DEBUG_MESSAGE_LENGTH  0x100
+
+/**
+  The constructor function initialize the Serial Port Library
+
+  @retval EFI_SUCCESS   The constructor always returns RETURN_SUCCESS.
+
+**/
+RETURN_STATUS
+EFIAPI
+BaseDebugLibSerialPortConstructor (
+  VOID
+  )
+{
+  return SerialPortInitialize ();
+}
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      Format string for the debug message to print.
+  @param  ...         Variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  )
+{
+  CHAR8    Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+  VA_LIST  Marker;
+
+  //
+  // If Format is NULL, then ASSERT().
+  //
+  ASSERT (Format != NULL);
+
+  //
+  // Check driver debug mask value and global mask
+  //
+  if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
+    return;
+  }
+
+  //
+  // Convert the DEBUG() message to an ASCII String
+  //
+  VA_START (Marker, Format);
+  AsciiVSPrint (Buffer, sizeof (Buffer), Format, Marker);
+  VA_END (Marker);
+
+  //
+  // Send the print string to a Serial Port 
+  //
+  SerialPortWrite ((UINT8 *)Buffer, AsciiStrLen (Buffer));
+}
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated the assert condition.
+  @param  LineNumber   The line number in the source file that generated the assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  )
+{
+  CHAR8  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+
+  //
+  // Generate the ASSERT() message in Ascii format
+  //
+  AsciiSPrint (Buffer, sizeof (Buffer), "ASSERT [%a] %a(%d): %a\n", gEfiCallerBaseName, FileName, LineNumber, Description);
+
+  //
+  // Send the print string to the Console Output device
+  //
+  SerialPortWrite ((UINT8 *)Buffer, AsciiStrLen (Buffer));
+
+  //
+  // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
+  //
+  if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
+    CpuBreakpoint ();
+  } else if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
+    CpuDeadLoop ();
+  }
+}
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  //
+  // If Buffer is NULL, then ASSERT().
+  //
+  ASSERT (Buffer != NULL);
+
+  //
+  // SetMem() checks for the the ASSERT() condition on Length and returns Buffer
+  //
+  return SetMem (Buffer, Length, PcdGet8(PcdDebugClearMemoryValue));
+}
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
+}
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
+}
+
diff --git a/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.c b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.c
new file mode 100644
index 000000000000..3e159e5caf4f
--- /dev/null
+++ b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.c
@@ -0,0 +1,59 @@
+/** @file
+  Debug Print Error Level library instance that retrieves the current error 
+  level from PcdDebugPrintErrorLevel.  This generic library instance does not 
+  support the setting of the global debug print error level mask for the platform.
+
+  Copyright (c) 2011, 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 <Base.h>
+#include <Library/DebugPrintErrorLevelLib.h>
+#include <Library/PcdLib.h>
+
+/**
+  Returns the debug print error level mask for the current module.
+
+  @return  Debug print error level mask for the current module.
+
+**/
+UINT32
+EFIAPI
+GetDebugPrintErrorLevel (
+  VOID
+  )
+{
+  //
+  // Retrieve the current debug print error level mask from PcdDebugPrintErrorLevel.
+  //
+  return PcdGet32 (PcdDebugPrintErrorLevel);
+}
+
+/**
+  Sets the global debug print error level mask fpr the entire platform.
+  
+  @param   ErrorLevel     Global debug print error level.
+  
+  @retval  TRUE           The debug print error level mask was sucessfully set.
+  @retval  FALSE          The debug print error level mask could not be set.
+
+**/
+BOOLEAN
+EFIAPI
+SetDebugPrintErrorLevel (
+  UINT32  ErrorLevel
+  )
+{
+  //
+  // This library uinstance does not support setting the global debug print error
+  // level mask.
+  //
+  return FALSE;
+}
diff --git a/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
new file mode 100644
index 000000000000..f92edc20ee8a
--- /dev/null
+++ b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
@@ -0,0 +1,40 @@
+## @file
+#  Debug Print Error Level library instance based on PcdDebugPrintErrorLevel.
+#  It retrieves the current error level from PcdDebugPrintErrorLevel.  
+#
+#  Copyright (c) 2011 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseDebugPrintErrorLevelLib
+  MODULE_UNI_FILE                = BaseDebugPrintErrorLevelLib.uni
+  FILE_GUID                      = A2C09E18-E4D2-407e-AFCC-628B79113F72
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugPrintErrorLevelLib
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseDebugPrintErrorLevelLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PcdLib
+  
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel  ## CONSUMES
+
diff --git a/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.uni b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.uni
new file mode 100644
index 000000000000..2b306d377f47
--- /dev/null
+++ b/MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Debug Print Error Level library instance based on PcdDebugPrintErrorLevel.
+//
+// It retrieves the current error level from PcdDebugPrintErrorLevel.
+//
+// Copyright (c) 2011 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Debug Print Error Level library instance based on PcdDebugPrintErrorLevel"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "It retrieves the current error level from PcdDebugPrintErrorLevel."
+
diff --git a/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.c b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.c
new file mode 100644
index 000000000000..ddd464532046
--- /dev/null
+++ b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.c
@@ -0,0 +1,484 @@
+/** @file
+  Provide generic extract guided section functions.
+
+  Copyright (c) 2007 - 2011, 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 <PiPei.h>
+
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/ExtractGuidedSectionLib.h>
+
+#define EXTRACT_HANDLER_INFO_SIGNATURE SIGNATURE_32 ('E', 'G', 'S', 'I')
+
+typedef struct {
+  UINT32                                  Signature;
+  UINT32                                  NumberOfExtractHandler;
+  GUID                                    *ExtractHandlerGuidTable;
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER   *ExtractDecodeHandlerTable;
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *ExtractGetInfoHandlerTable;
+} EXTRACT_GUIDED_SECTION_HANDLER_INFO;
+
+/**
+  HandlerInfo table address is set by PcdGuidedExtractHandlerTableAddress, which is used to store 
+  the registered guid and Handler list. When it is initialized, it will be directly returned. 
+  Or, HandlerInfo table will be initialized in this function.
+
+  @param[in, out]  InfoPointer   The pointer to the handler information structure.
+
+  @retval  RETURN_SUCCESS            HandlerInfo table can be used to store guid and function tables.
+  @retval  RETURN_OUT_OF_RESOURCES   HandlerInfo table address is not writable.
+**/
+RETURN_STATUS
+GetExtractGuidedSectionHandlerInfo (
+  IN OUT EXTRACT_GUIDED_SECTION_HANDLER_INFO **InfoPointer
+  )
+{
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  
+  //
+  // Set the available memory address to handler info.
+  //
+  HandlerInfo = (EXTRACT_GUIDED_SECTION_HANDLER_INFO*)(VOID*)(UINTN) PcdGet64 (PcdGuidedExtractHandlerTableAddress);
+  if (HandlerInfo == NULL) {
+    *InfoPointer = NULL;
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // First check whether the handler information structure is initialized.
+  //
+  if (HandlerInfo->Signature == EXTRACT_HANDLER_INFO_SIGNATURE) {
+    //
+    // The handler information has been initialized and is returned.
+    //
+    *InfoPointer = HandlerInfo;
+    return RETURN_SUCCESS;
+  }
+
+  //
+  // Try to initialize the handler information structure
+  //
+  HandlerInfo->Signature = EXTRACT_HANDLER_INFO_SIGNATURE;
+  if (HandlerInfo->Signature != EXTRACT_HANDLER_INFO_SIGNATURE) {
+    //
+    // The handler information structure was not writeable because the memory is not ready.
+    //
+    *InfoPointer = NULL;
+    return RETURN_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Init HandlerInfo structure
+  //
+  HandlerInfo->NumberOfExtractHandler     = 0;
+  HandlerInfo->ExtractHandlerGuidTable    = (GUID *) (HandlerInfo + 1);
+  HandlerInfo->ExtractDecodeHandlerTable  = (EXTRACT_GUIDED_SECTION_DECODE_HANDLER *) (
+                                              (UINT8 *)HandlerInfo->ExtractHandlerGuidTable + 
+                                              PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (GUID)
+                                             );
+  HandlerInfo->ExtractGetInfoHandlerTable = (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *) (
+                                              (UINT8 *)HandlerInfo->ExtractDecodeHandlerTable + 
+                                              PcdGet32 (PcdMaximumGuidedExtractHandler) * 
+                                              sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER)
+                                             );
+  *InfoPointer = HandlerInfo;
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieve the list GUIDs that have been registered through ExtractGuidedSectionRegisterHandlers().
+
+  Sets ExtractHandlerGuidTable so it points at a callee allocated array of registered GUIDs.
+  The total number of GUIDs in the array are returned. Since the array of GUIDs is callee allocated
+  and caller must treat this array of GUIDs as read-only data. 
+  If ExtractHandlerGuidTable is NULL, then ASSERT().
+
+  @param[out]  ExtractHandlerGuidTable  A pointer to the array of GUIDs that have been registered through
+                                        ExtractGuidedSectionRegisterHandlers().
+
+  @return The number of the supported extract guided Handler.
+
+**/
+UINTN
+EFIAPI
+ExtractGuidedSectionGetGuidList (
+  OUT  GUID  **ExtractHandlerGuidTable
+  )
+{
+  RETURN_STATUS                       Status;
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+
+  ASSERT (ExtractHandlerGuidTable != NULL);
+
+  //
+  // Get all registered handler information
+  //
+  Status = GetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (RETURN_ERROR (Status)) {
+    *ExtractHandlerGuidTable = NULL;
+    return 0;
+  }
+
+  //
+  // Get GuidTable and Table Number
+  //
+  ASSERT (HandlerInfo != NULL);
+  *ExtractHandlerGuidTable = HandlerInfo->ExtractHandlerGuidTable;
+  return HandlerInfo->NumberOfExtractHandler;
+}
+
+/**
+  Registers handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and EXTRACT_GUIDED_SECTION_DECODE_HANDLER
+  for a specific GUID section type.
+
+  Registers the handlers specified by GetInfoHandler and DecodeHandler with the GUID specified by SectionGuid.
+  If the GUID value specified by SectionGuid has already been registered, then return RETURN_ALREADY_STARTED.
+  If there are not enough resources available to register the handlers  then RETURN_OUT_OF_RESOURCES is returned.
+  
+  If SectionGuid is NULL, then ASSERT().
+  If GetInfoHandler is NULL, then ASSERT().
+  If DecodeHandler is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the the handlers
+                             of the GUIDed section type being registered.
+  @param[in]  GetInfoHandler The pointer to a function that examines a GUIDed section and returns the
+                             size of the decoded buffer and the size of an optional scratch buffer
+                             required to actually decode the data in a GUIDed section.
+  @param[in]  DecodeHandler  The pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. 
+
+  @retval  RETURN_SUCCESS           The handlers were registered.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to register the handlers.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionRegisterHandlers (
+  IN CONST  GUID                                     *SectionGuid,
+  IN        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  GetInfoHandler,
+  IN        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    DecodeHandler
+  )
+{
+  UINT32                              Index;
+  RETURN_STATUS                       Status;
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+
+  //
+  // Check input parameter
+  //
+  ASSERT (SectionGuid != NULL);
+  ASSERT (GetInfoHandler != NULL);
+  ASSERT (DecodeHandler != NULL);
+
+  //
+  // Get the registered handler information
+  //
+  Status = GetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionGuid)) {
+      //
+      // If the guided handler has been registered before, only update its handler.
+      //
+      HandlerInfo->ExtractDecodeHandlerTable [Index] = DecodeHandler;
+      HandlerInfo->ExtractGetInfoHandlerTable [Index] = GetInfoHandler;
+      return RETURN_SUCCESS;
+    }
+  }
+
+  //
+  // Check the global table is enough to contain new Handler.
+  //
+  if (HandlerInfo->NumberOfExtractHandler >= PcdGet32 (PcdMaximumGuidedExtractHandler)) {
+    return RETURN_OUT_OF_RESOURCES;
+  }
+  
+  //
+  // Register new Handler and guid value.
+  //
+  CopyGuid (HandlerInfo->ExtractHandlerGuidTable + HandlerInfo->NumberOfExtractHandler, SectionGuid);
+  HandlerInfo->ExtractDecodeHandlerTable [HandlerInfo->NumberOfExtractHandler] = DecodeHandler;
+  HandlerInfo->ExtractGetInfoHandlerTable [HandlerInfo->NumberOfExtractHandler++] = GetInfoHandler;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieves a GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to retrieve and return the size of the decoded buffer and the size of an
+  optional scratch buffer required to actually decode the data in a GUIDed section.
+
+  Examines a GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler 
+  of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to retrieve the OututBufferSize, ScratchSize, and Attributes values. The return status from the handler of
+  type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER is returned.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBufferSize is NULL, then ASSERT().
+  If ScratchBufferSize is NULL, then ASSERT().
+  If SectionAttribute is NULL, then ASSERT().
+
+  @param[in]  InputSection       A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBufferSize   A pointer to the size, in bytes, of an output buffer required if the buffer
+                                 specified by InputSection were decoded.
+  @param[out] ScratchBufferSize  A pointer to the size, in bytes, required as scratch space if the buffer specified by
+                                 InputSection were decoded.
+  @param[out] SectionAttribute   A pointer to the attributes of the GUIDed section.  See the Attributes field of
+                                 EFI_GUID_DEFINED_SECTION in the PI Specification.
+
+  @retval  RETURN_SUCCESS      Successfully retrieved the required information.
+  @retval  RETURN_UNSUPPORTED  The GUID from the section specified by InputSection does not match any of
+                               the GUIDs registered with ExtractGuidedSectionRegisterHandlers().
+  @retval  Others              The return status from the handler associated with the GUID retrieved from
+                               the section specified by InputSection.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetInfo (
+  IN  CONST VOID    *InputSection,
+  OUT       UINT32  *OutputBufferSize,
+  OUT       UINT32  *ScratchBufferSize,
+  OUT       UINT16  *SectionAttribute   
+  )
+{
+  UINT32                              Index;
+  RETURN_STATUS                       Status;
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  EFI_GUID                            *SectionDefinitionGuid;
+  
+  //
+  // Check input parameter
+  //
+  ASSERT (InputSection != NULL);
+  ASSERT (OutputBufferSize != NULL);
+  ASSERT (ScratchBufferSize != NULL);
+  ASSERT (SectionAttribute != NULL);
+
+  //
+  // Get all registered handler information.
+  //
+  Status = GetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionDefinitionGuid)) {
+      //
+      // Call the match handler to get information for the input section data.
+      //
+      return HandlerInfo->ExtractGetInfoHandlerTable [Index] (
+                InputSection,
+                OutputBufferSize,
+                ScratchBufferSize,
+                SectionAttribute
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves the GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to decode the data in a GUIDed section and return the result in a caller
+  allocated output buffer.
+
+  Decodes the GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler
+  of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to decode InputSection into the buffer specified by OutputBuffer and the authentication status of this
+  decode operation is returned in AuthenticationStatus.  If the decoded buffer is identical to the data in InputSection,
+  then OutputBuffer is set to point at the data in InputSection.  Otherwise, the decoded data will be placed in a caller
+  allocated buffer specified by OutputBuffer.    This function is responsible for computing the  EFI_AUTH_STATUS_PLATFORM_OVERRIDE
+  bit of in AuthenticationStatus.  The return status from the handler of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER is returned. 
+   
+  If InputSection is NULL, then ASSERT().
+  If OutputBuffer is NULL, then ASSERT().
+  If ScratchBuffer is NULL and this decode operation requires a scratch buffer, then ASSERT().
+  If AuthenticationStatus is NULL, then ASSERT().  
+
+  @param[in]  InputSection   A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBuffer   A pointer to a buffer that contains the result of a decode operation. 
+  @param[in]  ScratchBuffer  A caller allocated buffer that may be required by this function as a scratch buffer to perform the decode operation. 
+  @param[out] AuthenticationStatus 
+                             A pointer to the authentication status of the decoded output buffer. See the definition
+                             of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI section of the PI
+                             Specification.
+
+  @retval  RETURN_SUCCESS           The buffer specified by InputSection was decoded.
+  @retval  RETURN_UNSUPPORTED       The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER The section specified by InputSection can not be decoded.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionDecode (
+  IN  CONST VOID    *InputSection,
+  OUT       VOID    **OutputBuffer,
+  IN        VOID    *ScratchBuffer,        OPTIONAL
+  OUT       UINT32  *AuthenticationStatus  
+  )
+{
+  UINT32                              Index;
+  RETURN_STATUS                       Status;
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  EFI_GUID                            *SectionDefinitionGuid;
+  
+  //
+  // Check input parameter
+  //
+  ASSERT (InputSection != NULL);
+  ASSERT (OutputBuffer != NULL);
+  ASSERT (AuthenticationStatus != NULL);
+
+  //
+  // Get all registered handler information.
+  //  
+  Status = GetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+
+  //
+  // Search the match registered Extract handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionDefinitionGuid)) {
+      //
+      // Call the match handler to extract raw data for the input guided section.
+      //
+      return HandlerInfo->ExtractDecodeHandlerTable [Index] (
+                InputSection,
+                OutputBuffer,
+                ScratchBuffer,
+                AuthenticationStatus
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and 
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER for a specific GUID section type.
+  
+  Retrieves the handlers associated with SectionGuid and returns them in 
+  GetInfoHandler and DecodeHandler.
+
+  If the GUID value specified by SectionGuid has not been registered, then 
+  return RETURN_NOT_FOUND.
+  
+  If SectionGuid is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the handlersof the GUIDed 
+                             section type being retrieved.
+  @param[out] GetInfoHandler Pointer to a function that examines a GUIDed section and returns 
+                             the size of the decoded buffer and the size of an optional scratch 
+                             buffer required to actually decode the data in a GUIDed section.  
+                             This is an optional parameter that may be NULL. If it is NULL, then 
+                             the previously registered handler is not returned.
+  @param[out] DecodeHandler  Pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. This is an optional parameter that may be NULL.
+                             If it is NULL, then the previously registered handler is not returned.
+
+  @retval  RETURN_SUCCESS     The handlers were retrieved.
+  @retval  RETURN_NOT_FOUND   No handlers have been registered with the specified GUID.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetHandlers (
+  IN CONST   GUID                                     *SectionGuid,
+  OUT        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  *GetInfoHandler,  OPTIONAL
+  OUT        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    *DecodeHandler    OPTIONAL
+  )
+{
+  UINT32                              Index;
+  RETURN_STATUS                       Status;
+  EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+
+  //
+  // Check input parameter
+  //
+  ASSERT (SectionGuid != NULL);
+
+  //
+  // Get the registered handler information
+  //
+  Status = GetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionGuid)) {
+
+      //
+      // If the guided handler has been registered before, then return the registered handlers.
+      //
+      if (GetInfoHandler != NULL) {
+        *GetInfoHandler = HandlerInfo->ExtractGetInfoHandlerTable[Index];
+      }
+      if (DecodeHandler != NULL) {
+        *DecodeHandler = HandlerInfo->ExtractDecodeHandlerTable[Index];
+      }
+      return RETURN_SUCCESS;
+    }
+  }
+  return RETURN_NOT_FOUND;
+}
diff --git a/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.inf b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.inf
new file mode 100644
index 000000000000..e82d7f085cfb
--- /dev/null
+++ b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.inf
@@ -0,0 +1,54 @@
+## @file
+#  Base ExtractGuidedSection Library.
+#  This instance can also be used in SEC phase only when the memory is ready in SEC phase.
+#  PCD PcdGuidedExtractHandlerTableAddress points to the available pysical memory space
+#  that is used to store Guided Extract Handlers.
+#  Note: A driver of type DXE_RUNTIME_DRIVER can use this ExtractGuidedSectionLib
+#  in their initialization without any issues. They only have to be careful in
+#  the implementation of runtime services, because this BASE library instance doesn't
+#  convert the address pointed by PcdGuidedExtractHandlerTableAddress to the virtual address.
+#  And a driver should use this ExtractGuidedSectionLib to do implementation internally, also
+#  this ExtractGuidedSectionLib couldn't be used for guided section extraction that is required
+#  by PEI and DXE core for recovery or capsule image processing, etc.
+#
+#  Copyright (c) 2007 - 2015, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseExtractGuidedSectionLib
+  MODULE_UNI_FILE                = BaseExtractGuidedSectionLib.uni
+  FILE_GUID                      = 4e3236e9-d1c8-4c04-a89f-26f1c44b2592
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ExtractGuidedSectionLib
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  BaseExtractGuidedSectionLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseMemoryLib
+  DebugLib
+  PcdLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumGuidedExtractHandler         ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdGuidedExtractHandlerTableAddress    ## CONSUMES
+
diff --git a/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.uni b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.uni
new file mode 100644
index 000000000000..fcb7d658a711
--- /dev/null
+++ b/MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.uni
@@ -0,0 +1,27 @@
+// /** @file
+// Base ExtractGuidedSection Library.
+//
+// This instance can also be used in SEC phase only when the memory is ready in SEC phase.
+// PCD PcdGuidedExtractHandlerTableAddress points to the available pysical memory space
+// that is used to store Guided Extract Handlers.
+// Note: A driver of type DXE_RUNTIME_DRIVER can use this ExtractGuidedSectionLib
+// in their initialization without any issues. They only have to be careful in
+// the implementation of runtime services, because this BASE library instance doesn't
+// convert the address pointed by PcdGuidedExtractHandlerTableAddress to the virtual address.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Base ExtractGuidedSection Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This instance can also be used in the SEC phase only when the memory is ready in the SEC phase. PCD PcdGuidedExtractHandlerTableAddress points to the available physical memory space that is used to store Guided Extract Handlers. Note: A driver of type DXE_RUNTIME_DRIVER can use this ExtractGuidedSectionLib in its initialization without any issues. Be careful in the implementation of runtime services, because this BASE library instance doesn't convert the address pointed by PcdGuidedExtractHandlerTableAddress to the virtual address."
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
new file mode 100644
index 000000000000..f41c4a4c715f
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
@@ -0,0 +1,82 @@
+## @file
+#  Instance of I/O Library using compiler intrinsics.
+#
+#  I/O Library that uses compiler intrinsics to perform IN and OUT instructions
+#  for IA-32 and x64.  On IPF, I/O port requests are translated into MMIO requests.
+#  MMIO requests are forwarded directly to memory.  For EBC, I/O port requests
+#  ASSERT().
+#
+#  Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+#  Copyright (c) 2017, AMD Incorporated. 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseIoLibIntrinsic
+  MODULE_UNI_FILE                = BaseIoLibIntrinsic.uni
+  FILE_GUID                      = 926c9cd0-4bb8-479b-9ac4-8a2a23f85307
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = IoLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 EBC IPF ARM AARCH64
+#
+
+[Sources]
+  IoLibMmioBuffer.c
+  BaseIoLibIntrinsicInternal.h
+  IoHighLevel.c
+
+[Sources.IA32]
+  IoLibGcc.c    | GCC
+  IoLibMsc.c    | MSFT
+  IoLibIcc.c    | INTEL
+  IoLib.c
+  Ia32/IoFifo.nasm
+  Ia32/IoFifo.asm
+
+[Sources.X64]
+  IoLibGcc.c    | GCC
+  IoLibMsc.c    | MSFT
+  IoLibIcc.c    | INTEL
+  IoLib.c
+  X64/IoFifo.nasm
+  X64/IoFifo.asm
+
+[Sources.EBC]
+  IoLibEbc.c
+  IoLib.c
+
+[Sources.IPF]
+  IoLibIpf.c
+
+[Sources.ARM]
+  IoLibArm.c
+
+[Sources.AARCH64]
+  IoLibArm.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
+[LibraryClasses.IPF]
+  PcdLib
+
+[Pcd.IPF]
+  gEfiMdePkgTokenSpaceGuid.PcdIoBlockBaseAddressForIpf  ## SOMETIMES_CONSUMES
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.uni b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.uni
new file mode 100644
index 000000000000..3696eda9b6af
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.uni
@@ -0,0 +1,24 @@
+// /** @file
+// Instance of I/O Library using compiler intrinsics.
+//
+// I/O Library that uses compiler intrinsics to perform IN and OUT instructions
+// for IA-32 and x64.  On IPF, I/O port requests are translated into MMIO requests.
+// MMIO requests are forwarded directly to memory.
+//
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of I/O Library using compiler intrinsics"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "I/O Library that uses compiler intrinsics to perform IN and OUT instructions for IA-32 and x64.  On IPF, I/O port requests are translated into MMIO requests. MMIO requests are forwarded directly to memory."
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicInternal.h b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicInternal.h
new file mode 100644
index 000000000000..9b20df0b6926
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsicInternal.h
@@ -0,0 +1,26 @@
+/** @file
+  Common header file shared by all source files.
+
+  This file includes package header files, dependent library classes.
+
+  Copyright (c) 2007 - 2008, 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 __BASEIOLIB_INTRINSIC_INTERNAL_H_
+#define __BASEIOLIB_INTRINSIC_INTERNAL_H_
+
+
+
+#include <Base.h>
+
+#include <Library/IoLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+#endif
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.asm b/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.asm
new file mode 100644
index 000000000000..729880d62914
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.asm
@@ -0,0 +1,141 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2017, AMD Incorporated. 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.
+;
+;------------------------------------------------------------------------------
+
+    .586P
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo8 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo8 PROC
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insb
+    pop     edi
+    ret
+IoReadFifo8 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo16 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo16 PROC
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insw
+    pop     edi
+    ret
+IoReadFifo16 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo32 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo32 PROC
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insd
+    pop     edi
+    ret
+IoReadFifo32 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo8 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo8 PROC
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsb
+    pop     esi
+    ret
+IoWriteFifo8 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo16 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo16 PROC
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsw
+    pop     esi
+    ret
+IoWriteFifo16 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo32 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo32 PROC
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsd
+    pop     esi
+    ret
+IoWriteFifo32 ENDP
+
+    END
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.nasm b/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.nasm
new file mode 100644
index 000000000000..102bbb865448
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/Ia32/IoFifo.nasm
@@ -0,0 +1,137 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2017, AMD Incorporated. 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.
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo8 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo8)
+ASM_PFX(IoReadFifo8):
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insb
+    pop     edi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo16 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo16)
+ASM_PFX(IoReadFifo16):
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insw
+    pop     edi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo32 (
+;    IN  UINTN                 Port,
+;    IN  UINTN                 Size,
+;    OUT VOID                  *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo32)
+ASM_PFX(IoReadFifo32):
+    push    edi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 16]
+rep insd
+    pop     edi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo8 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo8)
+ASM_PFX(IoWriteFifo8):
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsb
+    pop     esi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo16 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo16)
+ASM_PFX(IoWriteFifo16):
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsw
+    pop     esi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo32 (
+;    IN UINTN                  Port,
+;    IN UINTN                  Size,
+;    IN VOID                   *Buffer
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo32)
+ASM_PFX(IoWriteFifo32):
+    push    esi
+    cld
+    mov     dx, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     esi, [esp + 16]
+rep outsd
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoHighLevel.c b/MdePkg/Library/BaseIoLibIntrinsic/IoHighLevel.c
new file mode 100644
index 000000000000..8a03e33934fe
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoHighLevel.c
@@ -0,0 +1,2356 @@
+/** @file
+  High-level Io/Mmio functions.
+
+  All assertions for bit field operations are handled bit field functions in the
+  Base Library.
+
+  Copyright (c) 2006 - 2012, 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.
+
+  The following IoLib instances contain the same copy of this file:
+
+    BaseIoLibIntrinsic
+    DxeIoLibCpuIo
+    PeiIoLibCpuIo
+
+**/
+
+#include "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) | OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) & AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) ((IoRead8 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. 
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra bits left in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra bits left in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra bits left in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) | OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) & AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) ((IoRead16 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  bits left in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra bits left in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra bits left in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra bits left in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) | OrData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) & AndData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  bits left in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra bits left in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra bits left in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra bits left in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) | OrData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) & AndData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  bits left in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra bits left in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra bits left in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra bits left in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) | OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) & AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) ((MmioRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra bits left in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra bits left in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra bits left in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) | OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) & AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) ((MmioRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra bits left in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra bits left in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra bits left in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) | OrData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) & AndData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra bits left in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra bits left in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra bits left in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) | OrData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) & AndData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra bits left in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra bits left in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra bits left in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLib.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLib.c
new file mode 100644
index 000000000000..407c66a03ae5
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLib.c
@@ -0,0 +1,317 @@
+/** @file
+  Common I/O Library routines.
+
+  Copyright (c) 2006 - 2008, 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 "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  UINT8                             Value;
+
+  MemoryFence ();
+  Value = *(volatile UINT8*)Address;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  MemoryFence ();
+  *(volatile UINT8*)Address = Value;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  UINT16                            Value;
+
+  ASSERT ((Address & 1) == 0);
+
+  MemoryFence ();
+  Value = *(volatile UINT16*)Address;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT ((Address & 1) == 0);
+
+  MemoryFence ();
+  *(volatile UINT16*)Address = Value;
+  MemoryFence ();
+  
+  return Value;
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  UINT32                            Value;
+
+  ASSERT ((Address & 3) == 0);
+  
+  MemoryFence ();
+  Value = *(volatile UINT32*)Address;
+  MemoryFence ();
+  
+  return Value;
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT ((Address & 3) == 0);
+  
+  MemoryFence ();
+  *(volatile UINT32*)Address = Value;
+  MemoryFence ();
+  
+  return Value;
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  UINT64                            Value;
+
+  ASSERT ((Address & 7) == 0);
+  
+  MemoryFence ();
+  Value = *(volatile UINT64*)Address;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT ((Address & 7) == 0);
+  
+  MemoryFence ();
+  *(volatile UINT64*)Address = Value;
+  MemoryFence ();
+  
+  return Value;
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibArm.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibArm.c
new file mode 100644
index 000000000000..3192c172a2ab
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibArm.c
@@ -0,0 +1,599 @@
+/** @file
+  I/O Library for ARM. 
+
+  Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 common header file for this module.
+//
+#include "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT (FALSE);
+  return Value;
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT (FALSE);
+  return Value;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT (FALSE);
+  return Value;
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  UINT8                             Value;
+
+  Value = *(volatile UINT8*)Address;
+  return Value;
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  *(volatile UINT8*)Address = Value;
+  return Value;
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  UINT16                            Value;
+
+  ASSERT ((Address & 1) == 0);
+  Value = *(volatile UINT16*)Address;
+  return Value;
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT ((Address & 1) == 0);
+  *(volatile UINT16*)Address = Value;
+  return Value;
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  UINT32                            Value;
+
+  ASSERT ((Address & 3) == 0);
+  Value = *(volatile UINT32*)Address;
+  return Value;
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT ((Address & 3) == 0);
+  *(volatile UINT32*)Address = Value;
+  return Value;
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  UINT64                            Value;
+
+  ASSERT ((Address & 7) == 0);
+  Value = *(volatile UINT64*)Address;
+  return Value;
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT ((Address & 7) == 0);
+  *(volatile UINT64*)Address = Value;
+  return Value;
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibEbc.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibEbc.c
new file mode 100644
index 000000000000..d000675767c2
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibEbc.c
@@ -0,0 +1,342 @@
+/** @file
+  I/O Library for EBC.
+
+  EBC does not support port I/O.  All APIs in this file ASSERT().
+
+  Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  ASSERT (FALSE);
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibGcc.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibGcc.c
new file mode 100644
index 000000000000..c57da737ec9d
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibGcc.c
@@ -0,0 +1,196 @@
+/** @file
+  I/O Library. This file has compiler specifics for GCC as there is no
+  ANSI C standard for doing IO.
+
+  GCC - uses EFIAPI assembler. __asm__ calls GAS. __volatile__ makes sure the
+  compiler puts the assembler in this exact location. The complex GNUC
+  operations are not optimzed. It would be possible to also write these
+  with EFIAPI assembler.
+
+  We don't advocate putting compiler specifics in libraries or drivers but there
+  is no other way to make this work.
+
+  Copyright (c) 2006 - 2010, 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 "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+__inline__
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  UINT8   Data;
+
+  __asm__ __volatile__ ("inb %w1,%b0" : "=a" (Data) : "d" ((UINT16)Port));
+  return Data;
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+__inline__
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  __asm__ __volatile__ ("outb %b0,%w1" : : "a" (Value), "d" ((UINT16)Port));
+  return Value;;
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+__inline__
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  UINT16   Data;
+
+  ASSERT ((Port & 1) == 0);
+  __asm__ __volatile__ ("inw %w1,%w0" : "=a" (Data) : "d" ((UINT16)Port));
+  return Data;
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+__inline__
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT ((Port & 1) == 0);
+  __asm__ __volatile__ ("outw %w0,%w1" : : "a" (Value), "d" ((UINT16)Port));
+  return Value;;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+__inline__
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  UINT32   Data;
+
+  ASSERT ((Port & 3) == 0);
+  __asm__ __volatile__ ("inl %w1,%0" : "=a" (Data) : "d" ((UINT16)Port));
+  return Data;
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+__inline__
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT ((Port & 3) == 0);
+  __asm__ __volatile__ ("outl %0,%w1" : : "a" (Value), "d" ((UINT16)Port));
+  return Value;
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibIcc.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibIcc.c
new file mode 100644
index 000000000000..adb2eff9403c
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibIcc.c
@@ -0,0 +1,214 @@
+/** @file
+  I/O Library. This file has compiler specifics for ICC as there
+  is no ANSI C standard for doing IO.
+
+  Copyright (c) 2006 - 2008, 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 "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  UINT8   Data;
+
+  __asm {
+    mov dx, word ptr [Port]
+    in  al, dx
+
+    mov Data, al
+  }
+  return Data;
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  __asm {
+    mov al, byte ptr [Value]
+    mov dx, word ptr [Port]
+    out dx, al
+  }
+  return Value; 
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  UINT16  Data;
+
+  ASSERT ((Port & 1) == 0);
+
+  __asm {
+    mov dx, word ptr [Port]
+    in  ax, dx
+    mov word ptr [Data], ax
+  }
+
+  return Data;
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT ((Port & 1) == 0);
+
+  __asm {
+    mov ax, word ptr [Value]
+    mov dx, word ptr [Port]
+    out dx, ax
+  }
+
+  return Value;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  UINT32 Data;
+
+  ASSERT ((Port & 3) == 0);
+
+  __asm {
+    mov dx, word ptr [Port]
+    in  eax, dx
+    mov dword ptr [Data], eax
+  }
+  
+  return Data;
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT ((Port & 3) == 0);
+  
+  __asm {
+    mov eax, dword ptr [Value]
+    mov dx, word ptr [Port]
+    out dx, eax
+  }
+
+  return Value;
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibIpf.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibIpf.c
new file mode 100644
index 000000000000..e5fccb76ff7e
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibIpf.c
@@ -0,0 +1,736 @@
+/** @file
+  Common I/O Library routines.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 "BaseIoLibIntrinsicInternal.h"
+#include <Library/PcdLib.h>
+
+#define MAP_PORT_BASE_TO_MEM(_Port) \
+    ((((_Port) & 0xfffc) << 10) | ((_Port) & 0x0fff))
+
+/**
+  Translates I/O port address to memory address.
+
+  This function translates I/O port address to memory address by adding the 64MB
+  aligned I/O Port space to the I/O address.
+  If I/O Port space base is not 64MB aligned, then ASSERT ().  
+
+  @param  Port  The I/O port to read.
+
+  @return The memory address.
+
+**/
+UINTN
+InternalGetMemoryMapAddress (
+  IN UINTN                  Port
+  )
+{
+  UINTN                     Address;
+  UINTN                     IoBlockBaseAddress;
+
+  Address            = MAP_PORT_BASE_TO_MEM (Port);
+  IoBlockBaseAddress = PcdGet64(PcdIoBlockBaseAddressForIpf);
+
+  //
+  // Make sure that the I/O Port space base is 64MB aligned.
+  // 
+  ASSERT ((IoBlockBaseAddress & 0x3ffffff) == 0);
+  Address += IoBlockBaseAddress;
+
+  return Address;
+}
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  return MmioRead8 (InternalGetMemoryMapAddress (Port));
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  return MmioRead16 (InternalGetMemoryMapAddress (Port));
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  return MmioRead32 (InternalGetMemoryMapAddress (Port));
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (InternalGetMemoryMapAddress (Port), Value);
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (InternalGetMemoryMapAddress (Port), Value);
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (InternalGetMemoryMapAddress (Port), Value);
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT8 *Buffer8;
+
+  Buffer8 = (UINT8 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer8++ = IoRead8 (Port);
+  }
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT16 *Buffer16;
+
+  Buffer16 = (UINT16 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer16++ = IoRead16 (Port);
+  }
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT32 *Buffer32;
+
+  Buffer32 = (UINT32 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer32++ = IoRead32 (Port);
+  }
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT8 *Buffer8;
+
+  Buffer8 = (UINT8 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite8 (Port, *Buffer8++);
+  }
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT16 *Buffer16;
+
+  Buffer16 = (UINT16 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite16 (Port, *Buffer16++);
+  }
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT32 *Buffer32;
+
+  Buffer32 = (UINT32 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite32 (Port, *Buffer32++);
+  }
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  UINT8            Data;
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  Data = *((volatile UINT8 *) Address);
+  MemoryFence ();
+
+  return Data;
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  UINT16           Data;
+
+  //
+  // Make sure that Address is 16-bit aligned.
+  // 
+  ASSERT ((Address & 1) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  Data = *((volatile UINT16 *) Address);
+  MemoryFence ();
+
+  return Data;
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  UINT32           Data;
+
+  //
+  // Make sure that Address is 32-bit aligned.
+  // 
+  ASSERT ((Address & 3) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  Data = *((volatile UINT32 *) Address);
+  MemoryFence ();
+
+  return Data;
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  UINT64           Data;
+
+  //
+  // Make sure that Address is 64-bit aligned.
+  // 
+  ASSERT ((Address & 7) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  Data = *((volatile UINT64 *) Address);
+  MemoryFence ();
+
+  return Data;
+
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  Address |= BIT63;
+
+  MemoryFence ();
+  *((volatile UINT8 *) Address) = Value;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure that Address is 16-bit aligned.
+  // 
+  ASSERT ((Address & 1) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  *((volatile UINT16 *) Address) = Value;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure that Address is 32-bit aligned.
+  // 
+  ASSERT ((Address & 3) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  *((volatile UINT32 *) Address) = Value;
+  MemoryFence ();
+
+  return Value;
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure that Address is 64-bit aligned.
+  // 
+  ASSERT ((Address & 7) == 0);
+
+  Address |= BIT63;
+
+  MemoryFence ();
+  *((volatile UINT64 *) Address) = Value;
+  MemoryFence ();
+
+  return Value;
+}
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibMmioBuffer.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibMmioBuffer.c
new file mode 100644
index 000000000000..8163f8d7ac6e
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibMmioBuffer.c
@@ -0,0 +1,411 @@
+/** @file
+  I/O Library MMIO Buffer Functions.
+
+  Copyright (c) 2007 - 2010, 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 "BaseIoLibIntrinsicInternal.h"
+
+/**
+  Copy data from the MMIO region to system memory by using 8-bit access.
+
+  Copy data from the MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8   *ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length-- != 0) {
+    *(Buffer++) = MmioRead8 (StartAddress++);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from the MMIO region to system memory by using 16-bit access.
+
+  Copy data from the MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from the MMIO region to system memory by using 32-bit access.
+
+  Copy data from the MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from the MMIO region to system memory by using 64-bit access.
+
+  Copy data from the MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead64 (StartAddress);
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to the MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to the MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  VOID* ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = (UINT8 *) Buffer;
+  
+  while (Length-- != 0) {
+     MmioWrite8 (StartAddress++, *(Buffer++));
+  }
+
+  return ReturnBuffer;
+ 
+}
+
+/**
+  Copy data from system memory to the MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to the MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = (UINT16 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite16 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to the MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to the MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = (UINT32 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite32 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to the MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to the MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = (UINT64 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite64 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/IoLibMsc.c b/MdePkg/Library/BaseIoLibIntrinsic/IoLibMsc.c
new file mode 100644
index 000000000000..3a7608752090
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/IoLibMsc.c
@@ -0,0 +1,228 @@
+/** @file
+  I/O Library. This file has compiler specifics for Microsft C as there is no
+  ANSI C standard for doing IO.
+
+  MSC - uses intrinsic functions and the optimize will remove the function call
+  overhead.
+
+  We don't advocate putting compiler specifics in libraries or drivers but there
+  is no other way to make this work.
+
+  Copyright (c) 2006 - 2010, 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 "BaseIoLibIntrinsicInternal.h"
+
+//
+// Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+//
+
+int            _inp (unsigned short port);
+unsigned short _inpw (unsigned short port);
+unsigned long  _inpd (unsigned short port);
+int            _outp (unsigned short port, int databyte );
+unsigned short _outpw (unsigned short port, unsigned short dataword );
+unsigned long  _outpd (unsigned short port, unsigned long dataword );
+void          _ReadWriteBarrier (void);
+
+#pragma intrinsic(_inp)
+#pragma intrinsic(_inpw)
+#pragma intrinsic(_inpd)
+#pragma intrinsic(_outp)
+#pragma intrinsic(_outpw)
+#pragma intrinsic(_outpd)
+#pragma intrinsic(_ReadWriteBarrier)
+
+//
+// _ReadWriteBarrier() forces memory reads and writes to complete at the point
+// in the call. This is only a hint to the compiler and does emit code.
+// In past versions of the compiler, _ReadWriteBarrier was enforced only
+// locally and did not affect functions up the call tree. In Visual C++
+// 2005, _ReadWriteBarrier is enforced all the way up the call tree.
+//
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  UINT8                             Value;
+
+  _ReadWriteBarrier ();
+  Value = (UINT8)_inp ((UINT16)Port);
+  _ReadWriteBarrier ();
+  return Value;
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  _ReadWriteBarrier ();
+  (UINT8)_outp ((UINT16)Port, Value);
+  _ReadWriteBarrier ();
+  return Value;
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  UINT16                            Value;
+
+  ASSERT ((Port & 1) == 0);
+  _ReadWriteBarrier ();
+  Value = _inpw ((UINT16)Port);
+  _ReadWriteBarrier ();
+  return Value;
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT ((Port & 1) == 0);
+  _ReadWriteBarrier ();
+  _outpw ((UINT16)Port, Value);
+  _ReadWriteBarrier ();
+  return Value;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  UINT32                            Value;
+
+  ASSERT ((Port & 3) == 0);
+  _ReadWriteBarrier ();
+  Value = _inpd ((UINT16)Port);
+  _ReadWriteBarrier ();
+  return Value;
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT ((Port & 3) == 0);
+  _ReadWriteBarrier ();
+  _outpd ((UINT16)Port, Value);
+  _ReadWriteBarrier ();
+  return Value;
+}
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.asm b/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.asm
new file mode 100644
index 000000000000..7e294a620201
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.asm
@@ -0,0 +1,127 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2017, AMD Incorporated. 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.
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo8 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo8 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insb
+    mov     rdi, r8             ; restore rdi
+    ret
+IoReadFifo8 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo16 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo16 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insw
+    mov     rdi, r8             ; restore rdi
+    ret
+IoReadFifo16 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo32 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoReadFifo32 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insd
+    mov     rdi, r8             ; restore rdi
+    ret
+IoReadFifo32 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo8 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo8 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsb
+    mov     rsi, r8             ; restore rsi
+    ret
+IoWriteFifo8 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo16 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo16 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsw
+    mov     rsi, r8             ; restore rsi
+    ret
+IoWriteFifo16 ENDP
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo32 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+IoWriteFifo32 PROC
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsd
+    mov     rsi, r8             ; restore rsi
+    ret
+IoWriteFifo32 ENDP
+
+    END
+
diff --git a/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.nasm b/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.nasm
new file mode 100644
index 000000000000..27c97d23c741
--- /dev/null
+++ b/MdePkg/Library/BaseIoLibIntrinsic/X64/IoFifo.nasm
@@ -0,0 +1,126 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2017, AMD Incorporated. 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.
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo8 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo8)
+ASM_PFX(IoReadFifo8):
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insb
+    mov     rdi, r8             ; restore rdi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo16 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo16)
+ASM_PFX(IoReadFifo16):
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insw
+    mov     rdi, r8             ; restore rdi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoReadFifo32 (
+;    IN  UINTN                 Port,              // rcx
+;    IN  UINTN                 Size,              // rdx
+;    OUT VOID                  *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoReadFifo32)
+ASM_PFX(IoReadFifo32):
+    cld
+    xchg    rcx, rdx
+    xchg    rdi, r8             ; rdi: buffer address; r8: save rdi
+rep insd
+    mov     rdi, r8             ; restore rdi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo8 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo8)
+ASM_PFX(IoWriteFifo8):
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsb
+    mov     rsi, r8             ; restore rsi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo16 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo16)
+ASM_PFX(IoWriteFifo16):
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsw
+    mov     rsi, r8             ; restore rsi
+    ret
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  IoWriteFifo32 (
+;    IN UINTN                  Port,              // rcx
+;    IN UINTN                  Size,              // rdx
+;    IN VOID                   *Buffer            // r8
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(IoWriteFifo32)
+ASM_PFX(IoWriteFifo32):
+    cld
+    xchg    rcx, rdx
+    xchg    rsi, r8             ; rsi: buffer address; r8: save rsi
+rep outsd
+    mov     rsi, r8             ; restore rsi
+    ret
+
diff --git a/MdePkg/Library/BaseLib/AArch64/CpuBreakpoint.S b/MdePkg/Library/BaseLib/AArch64/CpuBreakpoint.S
new file mode 100644
index 000000000000..68bc05549d69
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/CpuBreakpoint.S
@@ -0,0 +1,37 @@
+#------------------------------------------------------------------------------
+#
+# CpuBreakpoint() for AArch64
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(CpuBreakpoint)
+
+#/**
+#  Generates a breakpoint on the CPU.
+#
+#  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+#  that code can resume normal execution after the breakpoint.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuBreakpoint (
+#  VOID
+#  );
+#
+ASM_PFX(CpuBreakpoint):
+    svc   0xdbdb    // Superviser exception. Takes 16bit arg -> Armv7 had 'swi' here.
+    ret
diff --git a/MdePkg/Library/BaseLib/AArch64/DisableInterrupts.S b/MdePkg/Library/BaseLib/AArch64/DisableInterrupts.S
new file mode 100644
index 000000000000..9d67d07a86b5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/DisableInterrupts.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------
+#
+# DisableInterrupts() for AArch64
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(DisableInterrupts)
+
+.set DAIF_WR_IRQ_BIT,   (1 << 1)
+
+#/**
+#  Disables CPU interrupts.
+#
+#**/
+#VOID
+#EFIAPI
+#DisableInterrupts (
+#  VOID
+#  );
+#
+ASM_PFX(DisableInterrupts):
+   msr  daifset, #DAIF_WR_IRQ_BIT
+   ret
diff --git a/MdePkg/Library/BaseLib/AArch64/EnableInterrupts.S b/MdePkg/Library/BaseLib/AArch64/EnableInterrupts.S
new file mode 100644
index 000000000000..14915ed24b29
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/EnableInterrupts.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------
+#
+# EnableInterrupts() for AArch64
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(EnableInterrupts)
+
+.set DAIF_WR_IRQ_BIT,   (1 << 1)
+
+#/**
+#  Enables CPU interrupts.
+#
+#**/
+#VOID
+#EFIAPI
+#EnableInterrupts (
+#  VOID
+#  );
+#
+ASM_PFX(EnableInterrupts):
+    msr  daifclr, #DAIF_WR_IRQ_BIT
+    ret
diff --git a/MdePkg/Library/BaseLib/AArch64/GetInterruptsState.S b/MdePkg/Library/BaseLib/AArch64/GetInterruptsState.S
new file mode 100644
index 000000000000..1818c62560fe
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/GetInterruptsState.S
@@ -0,0 +1,45 @@
+#------------------------------------------------------------------------------
+#
+# GetInterruptState() function for AArch64
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(GetInterruptState)
+
+.set DAIF_RD_IRQ_BIT,   (1 << 7)
+
+#/**
+#  Retrieves the current CPU interrupt state.
+#
+#  Returns TRUE is interrupts are currently enabled. Otherwise
+#  returns FALSE.
+#
+#  @retval TRUE  CPU interrupts are enabled.
+#  @retval FALSE CPU interrupts are disabled.
+#
+#**/
+#
+#BOOLEAN
+#EFIAPI
+#GetInterruptState (
+#  VOID
+# );
+#
+ASM_PFX(GetInterruptState):
+    mrs    x0, daif
+    tst    x0, #DAIF_RD_IRQ_BIT   // Check IRQ mask; set Z=1 if clear/unmasked
+    cset   w0, eq                 // if Z=1 (eq) return 1, else 0
+    ret
diff --git a/MdePkg/Library/BaseLib/AArch64/MemoryFence.S b/MdePkg/Library/BaseLib/AArch64/MemoryFence.S
new file mode 100644
index 000000000000..8dbd54aa08cf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/MemoryFence.S
@@ -0,0 +1,39 @@
+##------------------------------------------------------------------------------
+#
+# MemoryFence() for AArch64
+#
+# Copyright (c) 2013, ARM Ltd. All rights reserved.
+#
+# 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.
+#
+##------------------------------------------------------------------------------
+
+.text
+.p2align 2
+
+GCC_ASM_EXPORT(MemoryFence)
+
+
+#/**
+#  Used to serialize load and store operations.
+#
+#  All loads and stores that proceed calls to this function are guaranteed to be
+#  globally visible when this function returns.
+#
+#**/
+#VOID
+#EFIAPI
+#MemoryFence (
+#  VOID
+#  );
+#
+ASM_PFX(MemoryFence):
+    // System wide Data Memory Barrier.
+    dmb sy
+    ret
diff --git a/MdePkg/Library/BaseLib/AArch64/SetJumpLongJump.S b/MdePkg/Library/BaseLib/AArch64/SetJumpLongJump.S
new file mode 100644
index 000000000000..9fa096e33b4c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/SetJumpLongJump.S
@@ -0,0 +1,97 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2009-2013, ARM Ltd.  All rights reserved.
+# 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.
+#
+#------------------------------------------------------------------------------
+.text
+.p2align 3
+
+GCC_ASM_EXPORT(SetJump)
+GCC_ASM_EXPORT(InternalLongJump)
+
+#define GPR_LAYOUT                         \
+        REG_PAIR (x19, x20,  0);           \
+        REG_PAIR (x21, x22, 16);           \
+        REG_PAIR (x23, x24, 32);           \
+        REG_PAIR (x25, x26, 48);           \
+        REG_PAIR (x27, x28, 64);           \
+        REG_PAIR (x29, x30, 80);/*FP, LR*/ \
+        REG_ONE  (x16,      96) /*IP0*/
+
+#define FPR_LAYOUT                      \
+        REG_PAIR ( d8,  d9, 112);       \
+        REG_PAIR (d10, d11, 128);       \
+        REG_PAIR (d12, d13, 144);       \
+        REG_PAIR (d14, d15, 160);
+
+#/**
+#  Saves the current CPU context that can be restored with a call to LongJump() and returns 0.#
+#
+#  Saves the current CPU context in the buffer specified by JumpBuffer and returns 0.  The initial
+#  call to SetJump() must always return 0.  Subsequent calls to LongJump() cause a non-zero
+#  value to be returned by SetJump().
+#
+#  If JumpBuffer is NULL, then ASSERT().
+#  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+#
+#  @param  JumpBuffer    A pointer to CPU context buffer.
+#
+#**/
+#
+#UINTN
+#EFIAPI
+#SetJump (
+#  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer  // X0
+#  );
+#
+ASM_PFX(SetJump):
+        mov     x16, sp // use IP0 so save SP
+#define REG_PAIR(REG1, REG2, OFFS)      stp REG1, REG2, [x0, OFFS]
+#define REG_ONE(REG1, OFFS)             str REG1, [x0, OFFS]
+        GPR_LAYOUT
+        FPR_LAYOUT
+#undef REG_PAIR
+#undef REG_ONE
+        mov     w0, #0
+        ret
+
+#/**
+#  Restores the CPU context that was saved with SetJump().#
+#
+#  Restores the CPU context from the buffer specified by JumpBuffer.
+#  This function never returns to the caller.
+#  Instead is resumes execution based on the state of JumpBuffer.
+#
+#  @param  JumpBuffer    A pointer to CPU context buffer.
+#  @param  Value         The value to return when the SetJump() context is restored.
+#
+#**/
+#VOID
+#EFIAPI
+#InternalLongJump (
+#  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,  // X0
+#  IN      UINTN                     Value         // X1
+#  );
+#
+ASM_PFX(InternalLongJump):
+#define REG_PAIR(REG1, REG2, OFFS)      ldp REG1, REG2, [x0, OFFS]
+#define REG_ONE(REG1, OFFS)             ldr REG1, [x0, OFFS]
+        GPR_LAYOUT
+        FPR_LAYOUT
+#undef REG_PAIR
+#undef REG_ONE
+        mov     sp, x16
+        cmp     w1, #0
+        mov     w0, #1
+        csel    w0, w1, w0, ne
+        // use br not ret, as ret is guaranteed to mispredict
+        br      x30
+
+ASM_FUNCTION_REMOVE_IF_UNREFERENCED
diff --git a/MdePkg/Library/BaseLib/AArch64/SwitchStack.S b/MdePkg/Library/BaseLib/AArch64/SwitchStack.S
new file mode 100644
index 000000000000..1bc6320061b0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/AArch64/SwitchStack.S
@@ -0,0 +1,69 @@
+//------------------------------------------------------------------------------
+//
+// Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+// Portions copyright (c) 2011 - 2013, ARM Limited. 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.
+//
+//------------------------------------------------------------------------------
+
+.text
+.align 5
+
+GCC_ASM_EXPORT(InternalSwitchStackAsm)
+GCC_ASM_EXPORT(CpuPause)
+
+/**
+//
+//  This allows the caller to switch the stack and goes to the new entry point
+//
+// @param      EntryPoint   The pointer to the location to enter
+// @param      Context      Parameter to pass in
+// @param      Context2     Parameter2 to pass in
+// @param      NewStack     New Location of the stack
+//
+// @return     Nothing. Goes to the Entry Point passing in the new parameters
+//
+VOID
+EFIAPI
+InternalSwitchStackAsm (
+  SWITCH_STACK_ENTRY_POINT EntryPoint,
+  VOID  *Context,
+  VOID  *Context2,
+  VOID  *NewStack
+  );
+**/
+ASM_PFX(InternalSwitchStackAsm):
+    mov   x29, #0
+    mov   x30, x0
+    mov   sp, x3
+    mov   x0, x1
+    mov   x1, x2
+    ret
+
+/**
+//
+//  Requests CPU to pause for a short period of time.
+//
+//  Requests CPU to pause for a short period of time. Typically used in MP
+//  systems to prevent memory starvation while waiting for a spin lock.
+//
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+**/
+ASM_PFX(CpuPause):
+    nop
+    nop
+    nop
+    nop
+    nop
+    ret
diff --git a/MdePkg/Library/BaseLib/ARShiftU64.c b/MdePkg/Library/BaseLib/ARShiftU64.c
new file mode 100644
index 000000000000..be33df38ca88
--- /dev/null
+++ b/MdePkg/Library/BaseLib/ARShiftU64.c
@@ -0,0 +1,41 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits are filled
+  with the original integer's bit 63. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to bit 63 of Operand.  The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+ARShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 64);
+  return InternalMathARShiftU64 (Operand, Count);
+}
diff --git a/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.S b/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.S
new file mode 100644
index 000000000000..d418c69d67cc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------ 
+#
+# CpuBreakpoint() for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(CpuBreakpoint)
+
+#/**
+#  Generates a breakpoint on the CPU.
+#
+#  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+#  that code can resume normal execution after the breakpoint.
+#
+#**/
+#VOID
+#EFIAPI
+#CpuBreakpoint (
+#  VOID
+#  );
+#
+ASM_PFX(CpuBreakpoint):
+    swi  0xdbdbdb  
+    bx   lr
diff --git a/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.asm b/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.asm
new file mode 100644
index 000000000000..6b4a865ef285
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/CpuBreakpoint.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------ 
+;
+; CpuBreakpoint() for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT CpuBreakpoint
+
+  AREA Cpu_Breakpoint, CODE, READONLY
+
+;/**
+;  Generates a breakpoint on the CPU.
+;
+;  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+;  that code can resume normal execution after the breakpoint.
+;
+;**/
+;VOID
+;EFIAPI
+;CpuBreakpoint (
+;  VOID
+;  );
+;
+CpuBreakpoint
+    swi   0xdbdbdb
+    bx    lr
+    
+  END
diff --git a/MdePkg/Library/BaseLib/Arm/CpuPause.asm b/MdePkg/Library/BaseLib/Arm/CpuPause.asm
new file mode 100644
index 000000000000..22f3e0646c20
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/CpuPause.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------ 
+;
+; CpuPause() for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+  EXPORT CpuPause
+  AREA cpu_pause, CODE, READONLY
+
+;/**
+;  Requests CPU to pause for a short period of time.
+;
+;  Requests CPU to pause for a short period of time. Typically used in MP
+;  systems to prevent memory starvation while waiting for a spin lock.
+;
+;**/
+;VOID
+;EFIAPI
+;CpuPause (
+;  VOID
+;  );
+;
+CpuPause
+    NOP
+    NOP
+    NOP
+    NOP
+    NOP
+    BX LR
+
+  END
diff --git a/MdePkg/Library/BaseLib/Arm/DisableInterrupts.S b/MdePkg/Library/BaseLib/Arm/DisableInterrupts.S
new file mode 100644
index 000000000000..d1278be87510
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/DisableInterrupts.S
@@ -0,0 +1,35 @@
+#------------------------------------------------------------------------------ 
+#
+# DisableInterrupts() for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(DisableInterrupts)
+
+#/**
+#  Disables CPU interrupts.
+#
+#**/
+#VOID
+#EFIAPI
+#DisableInterrupts (
+#  VOID
+#  );
+#
+ASM_PFX(DisableInterrupts):
+    mrs  R0,CPSR
+    orr  R0,R0,#0x80    @Disable IRQ interrupts
+    msr  CPSR_c,R0
+    bx   LR
diff --git a/MdePkg/Library/BaseLib/Arm/DisableInterrupts.asm b/MdePkg/Library/BaseLib/Arm/DisableInterrupts.asm
new file mode 100644
index 000000000000..0d87abeac7f0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/DisableInterrupts.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ 
+;
+; DisableInterrupts() for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT DisableInterrupts
+
+    AREA Interrupt_disable, CODE, READONLY
+
+;/**
+;  Disables CPU interrupts.
+;
+;**/
+;VOID
+;EFIAPI
+;DisableInterrupts (
+;  VOID
+;  );
+;
+DisableInterrupts
+    MRS     R0,CPSR
+    ORR     R0,R0,#0x80             ;Disable IRQ interrupts
+    MSR     CPSR_c,R0
+    BX      LR
+    
+    END
diff --git a/MdePkg/Library/BaseLib/Arm/EnableInterrupts.S b/MdePkg/Library/BaseLib/Arm/EnableInterrupts.S
new file mode 100644
index 000000000000..0f22ee3940ba
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/EnableInterrupts.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------ 
+#
+# EnableInterrupts() for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT(EnableInterrupts)
+
+
+#/**
+#  Enables CPU interrupts.
+#
+#**/
+#VOID
+#EFIAPI
+#EnableInterrupts (
+#  VOID
+#  );
+#
+ASM_PFX(EnableInterrupts):
+    mrs  R0,CPSR
+    bic  R0,R0,#0x80    @Enable IRQ interrupts
+    msr  CPSR_c,R0
+    bx   LR
diff --git a/MdePkg/Library/BaseLib/Arm/EnableInterrupts.asm b/MdePkg/Library/BaseLib/Arm/EnableInterrupts.asm
new file mode 100644
index 000000000000..fceb8c795af9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/EnableInterrupts.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ 
+;
+; EnableInterrupts() for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT EnableInterrupts
+
+    AREA Interrupt_enable, CODE, READONLY
+
+;/**
+;  Enables CPU interrupts.
+;
+;**/
+;VOID
+;EFIAPI
+;EnableInterrupts (
+;  VOID
+;  );
+;
+EnableInterrupts
+    MRS     R0,CPSR
+    BIC     R0,R0,#0x80             ;Enable IRQ interrupts
+    MSR     CPSR_c,R0
+    BX      LR
+    
+    END
diff --git a/MdePkg/Library/BaseLib/Arm/GetInterruptsState.S b/MdePkg/Library/BaseLib/Arm/GetInterruptsState.S
new file mode 100644
index 000000000000..2567b1ddd97a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/GetInterruptsState.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------ 
+#
+# GetInterruptState() function for ARM
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+.text
+.p2align 2
+GCC_ASM_EXPORT (GetInterruptState)
+
+#/**
+#  Retrieves the current CPU interrupt state.
+#
+#  Returns TRUE is interrupts are currently enabled. Otherwise
+#  returns FALSE.
+#
+#  @retval TRUE  CPU interrupts are enabled.
+#  @retval FALSE CPU interrupts are disabled.
+#
+#**/
+#
+#BOOLEAN
+#EFIAPI
+#GetInterruptState (
+#  VOID
+# );
+#
+ASM_PFX(GetInterruptState):
+    mrs    R0, CPSR
+    tst    R0, #0x80  @Check if IRQ is enabled.
+    moveq  R0, #1
+    movne  R0, #0
+    bx     LR
diff --git a/MdePkg/Library/BaseLib/Arm/GetInterruptsState.asm b/MdePkg/Library/BaseLib/Arm/GetInterruptsState.asm
new file mode 100644
index 000000000000..af39ed4cb46f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/GetInterruptsState.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------ 
+;
+; GetInterruptState() function for ARM
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT GetInterruptState
+
+    AREA Interrupt_enable, CODE, READONLY
+
+;/**
+;  Retrieves the current CPU interrupt state.
+;
+;  Returns TRUE is interrupts are currently enabled. Otherwise
+;  returns FALSE.
+;
+;  @retval TRUE  CPU interrupts are enabled.
+;  @retval FALSE CPU interrupts are disabled.
+;
+;**/
+;
+;BOOLEAN
+;EFIAPI
+;GetInterruptState (
+;  VOID
+; );
+;
+GetInterruptState
+    MRS     R0, CPSR
+    TST     R0, #0x80                ;Check if IRQ is enabled.
+    MOVEQ   R0, #1
+    MOVNE   R0, #0
+    BX      LR
+    
+    END
diff --git a/MdePkg/Library/BaseLib/Arm/InternalSwitchStack.c b/MdePkg/Library/BaseLib/Arm/InternalSwitchStack.c
new file mode 100644
index 000000000000..914e0e656bc0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/InternalSwitchStack.c
@@ -0,0 +1,79 @@
+/** @file
+  SwitchStack() function for ARM.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BaseLibInternals.h"
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  This internal worker function transfers control to the function
+  specified by EntryPoint using the new stack specified by NewStack,
+  and passes in the parameters specified by Context1 and Context2.
+  Context1 and Context2 are optional and may be NULL.
+  The function EntryPoint must never return.
+
+  @param EntryPoint   The pointer to the function to enter.
+  @param Context1     The first parameter to pass in.
+  @param Context2     The second Parameter to pass in
+  @param NewStack     The new Location of the stack
+
+**/
+VOID
+EFIAPI
+InternalSwitchStackAsm (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+  
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack, and passes in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.
+  Marker will be ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  Marker      A VA_LIST marker for the variable argument list.
+
+**/
+VOID
+EFIAPI
+InternalSwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VA_LIST                   Marker
+  )
+
+{
+  InternalSwitchStackAsm (EntryPoint, Context1, Context2, NewStack);
+}
diff --git a/MdePkg/Library/BaseLib/Arm/Math64.S b/MdePkg/Library/BaseLib/Arm/Math64.S
new file mode 100755
index 000000000000..aec60b2017df
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/Math64.S
@@ -0,0 +1,269 @@
+#------------------------------------------------------------------------------ 
+#
+# Replacement for Math64.c that is coded to use older GCC intrinsics. 
+# Doing this reduces the number of intrinsics that are required when
+# you port to a new version of gcc. 
+#
+# Need to split this into multple files to size optimize the image.
+#
+# Copyright (c) 2009 - 2010, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+	.text
+	.align 2
+	GCC_ASM_EXPORT(InternalMathLShiftU64)
+
+ASM_PFX(InternalMathLShiftU64):
+	stmfd	sp!, {r4, r5, r6}
+	mov	r6, r1
+	rsb	ip, r2, #32
+	mov	r4, r6, asl r2
+	subs	r1, r2, #32
+	orr	r4, r4, r0, lsr ip
+	mov	r3, r0, asl r2
+	movpl	r4, r0, asl r1
+	mov	r5, r0
+	mov	r0, r3
+	mov	r1, r4
+	ldmfd	sp!, {r4, r5, r6}
+	bx	lr
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathRShiftU64)
+
+ASM_PFX(InternalMathRShiftU64):
+	stmfd	sp!, {r4, r5, r6}
+	mov	r5, r0
+	rsb	ip, r2, #32
+	mov	r3, r5, lsr r2
+	subs	r0, r2, #32
+	orr	r3, r3, r1, asl ip
+	mov	r4, r1, lsr r2
+	movpl	r3, r1, lsr r0
+	mov	r6, r1
+	mov	r0, r3
+	mov	r1, r4
+	ldmfd	sp!, {r4, r5, r6}
+	bx	lr
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathARShiftU64)
+
+ASM_PFX(InternalMathARShiftU64):
+	stmfd	sp!, {r4, r5, r6}
+	mov	r5, r0
+	rsb	ip, r2, #32
+	mov	r3, r5, lsr r2
+	subs	r0, r2, #32
+	orr	r3, r3, r1, asl ip
+	mov	r4, r1, asr r2
+	movpl	r3, r1, asr r0
+	mov	r6, r1
+	mov	r0, r3
+	mov	r1, r4
+	ldmfd	sp!, {r4, r5, r6}
+	bx	lr
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathLRotU64)
+
+ASM_PFX(InternalMathLRotU64):
+	stmfd	sp!, {r4, r5, r6, r7, lr}
+	add	r7, sp, #12
+	mov	r6, r1
+	rsb	ip, r2, #32
+	mov	r4, r6, asl r2
+	rsb	lr, r2, #64
+	subs	r1, r2, #32
+	orr	r4, r4, r0, lsr ip
+	mov	r3, r0, asl r2
+	movpl	r4, r0, asl r1
+	sub	ip, r2, #32
+	mov	r5, r0
+	mov	r0, r0, lsr lr
+	rsbs	r2, r2, #32
+	orr	r0, r0, r6, asl ip
+	mov	r1, r6, lsr lr
+	movpl	r0, r6, lsr r2
+	orr	r1, r1, r4
+	orr	r0, r0, r3
+	ldmfd	sp!, {r4, r5, r6, r7, pc}
+
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathRRotU64)
+
+ASM_PFX(InternalMathRRotU64):
+	stmfd	sp!, {r4, r5, r6, r7, lr}
+	add	r7, sp, #12
+	mov	r5, r0
+	rsb	ip, r2, #32
+	mov	r3, r5, lsr r2
+	rsb	lr, r2, #64
+	subs	r0, r2, #32
+	orr	r3, r3, r1, asl ip
+	mov	r4, r1, lsr r2
+	movpl	r3, r1, lsr r0
+	sub	ip, r2, #32
+	mov	r6, r1
+	mov	r1, r1, asl lr
+	rsbs	r2, r2, #32
+	orr	r1, r1, r5, lsr ip
+	mov	r0, r5, asl lr
+	movpl	r1, r5, asl r2
+	orr	r0, r0, r3
+	orr	r1, r1, r4
+	ldmfd	sp!, {r4, r5, r6, r7, pc}
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathMultU64x32)
+
+ASM_PFX(InternalMathMultU64x32):
+	stmfd	sp!, {r7, lr}
+	add	r7, sp, #0
+	mov	r3, #0
+	mov	ip, r0
+	mov	lr, r1
+	umull	r0, r1, ip, r2
+	mla	r1, lr, r2, r1
+	mla	r1, ip, r3, r1
+	ldmfd	sp!, {r7, pc}
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathMultU64x64)
+
+ASM_PFX(InternalMathMultU64x64):
+	stmfd	sp!, {r7, lr}
+	add	r7, sp, #0
+	mov	ip, r0
+	mov	lr, r1
+	umull	r0, r1, ip, r2
+	mla	r1, lr, r2, r1
+	mla	r1, ip, r3, r1
+	ldmfd	sp!, {r7, pc}
+
+	.align 2
+	GCC_ASM_EXPORT(InternalMathDivU64x32)
+
+ASM_PFX(InternalMathDivU64x32):
+	stmfd	sp!, {r7, lr}
+	add	r7, sp, #0
+	mov	r3, #0
+	bl 	ASM_PFX(__udivdi3)
+	ldmfd	sp!, {r7, pc}
+	
+	
+	.align 2
+	GCC_ASM_EXPORT(InternalMathModU64x32)
+
+ASM_PFX(InternalMathModU64x32):
+	stmfd	sp!, {r7, lr}
+	add	r7, sp, #0
+	mov	r3, #0
+	bl 	ASM_PFX(__umoddi3)
+	ldmfd	sp!, {r7, pc}
+	
+	
+	.align 2
+	GCC_ASM_EXPORT(InternalMathDivRemU64x32)
+
+ASM_PFX(InternalMathDivRemU64x32):
+	stmfd	sp!, {r4, r5, r6, r7, lr}
+	add	r7, sp, #12
+	stmfd	sp!, {r10, r11}
+	subs	r6, r3, #0
+	mov	r10, r0
+	mov	r11, r1
+	moveq	r4, r2
+	moveq	r5, #0
+	beq	L22
+	mov	r4, r2
+	mov	r5, #0
+	mov	r3, #0
+	bl 	ASM_PFX(__umoddi3)
+	str	r0, [r6, #0]
+L22:
+	mov	r0, r10
+	mov	r1, r11
+	mov	r2, r4
+	mov	r3, r5
+	bl 	ASM_PFX(__udivdi3)
+	ldmfd	sp!, {r10, r11}
+	ldmfd	sp!, {r4, r5, r6, r7, pc}
+	
+	
+	.align 2
+	GCC_ASM_EXPORT(InternalMathDivRemU64x64)
+
+ASM_PFX(InternalMathDivRemU64x64):
+	stmfd	sp!, {r4, r5, r6, r7, lr}
+	add	r7, sp, #12
+	stmfd	sp!, {r10, r11}
+	ldr	r6, [sp, #28]
+	mov	r4, r0
+	cmp	r6, #0
+	mov	r5, r1
+	mov	r10, r2
+	mov	r11, r3
+	beq	L26
+	bl 	ASM_PFX(__umoddi3)
+	stmia	r6, {r0-r1}
+L26:
+	mov	r0, r4
+	mov	r1, r5
+	mov	r2, r10
+	mov	r3, r11
+	bl 	ASM_PFX(__udivdi3)
+	ldmfd	sp!, {r10, r11}
+	ldmfd	sp!, {r4, r5, r6, r7, pc}
+	
+	
+	.align 2
+	GCC_ASM_EXPORT(InternalMathDivRemS64x64)
+
+ASM_PFX(InternalMathDivRemS64x64):
+	stmfd	sp!, {r4, r5, r6, r7, lr}
+	add	r7, sp, #12
+	stmfd	sp!, {r10, r11}
+	ldr	r6, [sp, #28]
+	mov	r4, r0
+	cmp	r6, #0
+	mov	r5, r1
+	mov	r10, r2
+	mov	r11, r3
+	beq	L30
+	bl 	ASM_PFX(__moddi3)
+	stmia	r6, {r0-r1}
+L30:
+	mov	r0, r4
+	mov	r1, r5
+	mov	r2, r10
+	mov	r3, r11
+	bl 	ASM_PFX(__divdi3)
+	ldmfd	sp!, {r10, r11}
+	ldmfd	sp!, {r4, r5, r6, r7, pc}
+	
+	
+	.align 2
+	GCC_ASM_EXPORT(InternalMathSwapBytes64)
+
+ASM_PFX(InternalMathSwapBytes64):
+	stmfd	sp!, {r4, r5, r7, lr}
+	mov	r5, r1
+	bl	ASM_PFX(SwapBytes32)
+	mov	r4, r0
+	mov	r0, r5
+	bl	ASM_PFX(SwapBytes32)
+	mov	r1, r4
+	ldmfd	sp!, {r4, r5, r7, pc}
+
+
+ASM_FUNCTION_REMOVE_IF_UNREFERENCED
\ No newline at end of file
diff --git a/MdePkg/Library/BaseLib/Arm/MemoryFence.S b/MdePkg/Library/BaseLib/Arm/MemoryFence.S
new file mode 100644
index 000000000000..2208dd35442a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/MemoryFence.S
@@ -0,0 +1,39 @@
+##------------------------------------------------------------------------------
+#
+# MemoryFence() for AArch64
+#
+# Copyright (c) 2013, ARM Ltd. All rights reserved.
+#
+# 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.
+#
+##------------------------------------------------------------------------------
+
+.text
+.p2align 2
+
+GCC_ASM_EXPORT(MemoryFence)
+
+
+#/**
+#  Used to serialize load and store operations.
+#
+#  All loads and stores that proceed calls to this function are guaranteed to be
+#  globally visible when this function returns.
+#
+#**/
+#VOID
+#EFIAPI
+#MemoryFence (
+#  VOID
+#  );
+#
+ASM_PFX(MemoryFence):
+    // System wide Data Memory Barrier.
+    dmb
+    bx   lr
diff --git a/MdePkg/Library/BaseLib/Arm/MemoryFence.asm b/MdePkg/Library/BaseLib/Arm/MemoryFence.asm
new file mode 100644
index 000000000000..f1bc4eb10633
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/MemoryFence.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; MemoryFence() for AArch64
+;
+; Copyright (c) 2013, ARM Ltd. All rights reserved.
+;
+; 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT MemoryFence
+
+    AREA MemoryBarriers, CODE, READONLY
+
+;/**
+;  Used to serialize load and store operations.
+;
+;  All loads and stores that proceed calls to this function are guaranteed to be
+;  globally visible when this function returns.
+;
+;**/
+;VOID
+;EFIAPI
+;MemoryFence (
+;  VOID
+;  );
+;
+MemoryFence FUNCTION
+    dmb
+    bx      lr
+    ENDFUNC
+
+    END
diff --git a/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.S b/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.S
new file mode 100644
index 000000000000..75c092535dbf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.S
@@ -0,0 +1,70 @@
+#------------------------------------------------------------------------------ 
+#
+# Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+.text
+.p2align 2
+
+GCC_ASM_EXPORT(SetJump)
+GCC_ASM_EXPORT(InternalLongJump)
+
+#/**
+#  Saves the current CPU context that can be restored with a call to LongJump() and returns 0.#
+#
+#  Saves the current CPU context in the buffer specified by JumpBuffer and returns 0.  The initial
+#  call to SetJump() must always return 0.  Subsequent calls to LongJump() cause a non-zero
+#  value to be returned by SetJump().
+#
+#  If JumpBuffer is NULL, then ASSERT().
+#  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+#
+#  @param  JumpBuffer    A pointer to CPU context buffer.
+#
+#**/
+#
+#UINTN
+#EFIAPI
+#SetJump (
+#  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer  // R0
+#  );
+#
+ASM_PFX(SetJump):
+  mov   r3, r13
+  stmia r0, {r3-r12,r14}
+  eor   r0, r0, r0
+  bx    lr
+
+#/**
+#  Restores the CPU context that was saved with SetJump().#
+#
+#  Restores the CPU context from the buffer specified by JumpBuffer.
+#  This function never returns to the caller.
+#  Instead is resumes execution based on the state of JumpBuffer.
+#
+#  @param  JumpBuffer    A pointer to CPU context buffer.
+#  @param  Value         The value to return when the SetJump() context is restored.
+#
+#**/
+#VOID
+#EFIAPI
+#InternalLongJump (
+#  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,  // R0
+#  IN      UINTN                     Value         // R1
+#  );
+#
+ASM_PFX(InternalLongJump):
+  ldmia  r0, {r3-r12,r14}
+  mov    r13, r3
+  mov    r0, r1
+  bx     lr
+
+ASM_FUNCTION_REMOVE_IF_UNREFERENCED
diff --git a/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.asm b/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.asm
new file mode 100644
index 000000000000..4f95a7533e7f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/SetJumpLongJump.asm
@@ -0,0 +1,70 @@
+;------------------------------------------------------------------------------ 
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+
+  EXPORT  SetJump
+  EXPORT  InternalLongJump
+
+  AREA  BaseLib, CODE, READONLY
+
+;/**
+;  Saves the current CPU context that can be restored with a call to LongJump() and returns 0.;
+;
+;  Saves the current CPU context in the buffer specified by JumpBuffer and returns 0.  The initial
+;  call to SetJump() must always return 0.  Subsequent calls to LongJump() cause a non-zero
+;  value to be returned by SetJump().
+;
+;  If JumpBuffer is NULL, then ASSERT().
+;  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+;
+;  @param  JumpBuffer    A pointer to CPU context buffer.
+;
+;**/
+;
+;UINTN
+;EFIAPI
+;SetJump (
+;  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer  // R0
+;  )
+;
+SetJump
+  MOV  R3, R13
+  STM  R0, {R3-R12,R14}
+  EOR  R0, R0
+  BX   LR
+
+;/**
+;  Restores the CPU context that was saved with SetJump().;
+;
+;  Restores the CPU context from the buffer specified by JumpBuffer.
+;  This function never returns to the caller.
+;  Instead is resumes execution based on the state of JumpBuffer.
+;
+;  @param  JumpBuffer    A pointer to CPU context buffer.
+;  @param  Value         The value to return when the SetJump() context is restored.
+;
+;**/
+;VOID
+;EFIAPI
+;InternalLongJump (
+;  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,  // R0
+;  IN      UINTN                     Value         // R1
+;  );
+;
+InternalLongJump
+  LDM   R0, {R3-R12,R14}
+  MOV   R13, R3
+  MOV   R0, R1
+  BX    LR
+
+  END
diff --git a/MdePkg/Library/BaseLib/Arm/SwitchStack.S b/MdePkg/Library/BaseLib/Arm/SwitchStack.S
new file mode 100644
index 000000000000..e7433d43ea62
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/SwitchStack.S
@@ -0,0 +1,68 @@
+//------------------------------------------------------------------------------ 
+//
+// Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+// Portions copyright (c) 2011, ARM Limited. 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.
+//
+//------------------------------------------------------------------------------
+  
+.text
+.align 5
+
+GCC_ASM_EXPORT(InternalSwitchStackAsm)
+GCC_ASM_EXPORT(CpuPause)            
+  
+/**
+//
+//  This allows the caller to switch the stack and goes to the new entry point
+//
+// @param      EntryPoint   The pointer to the location to enter
+// @param      Context      Parameter to pass in
+// @param      Context2     Parameter2 to pass in
+// @param      NewStack     New Location of the stack
+//
+// @return     Nothing. Goes to the Entry Point passing in the new parameters
+//
+VOID
+EFIAPI
+InternalSwitchStackAsm (
+  SWITCH_STACK_ENTRY_POINT EntryPoint,
+  VOID  *Context,
+  VOID  *Context2,
+  VOID  *NewStack
+  );
+**/
+ASM_PFX(InternalSwitchStackAsm):
+    MOV   LR, R0
+    MOV   SP, R3
+    MOV   R0, R1
+    MOV   R1, R2
+    BX    LR
+
+/**
+//
+//  Requests CPU to pause for a short period of time.
+//
+//  Requests CPU to pause for a short period of time. Typically used in MP
+//  systems to prevent memory starvation while waiting for a spin lock.
+//
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+**/
+ASM_PFX(CpuPause):
+    nop
+    nop
+    nop
+    nop
+    nop
+    BX    LR
diff --git a/MdePkg/Library/BaseLib/Arm/SwitchStack.asm b/MdePkg/Library/BaseLib/Arm/SwitchStack.asm
new file mode 100644
index 000000000000..12ba53c34cbf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/SwitchStack.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------ 
+;
+; Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+;
+;------------------------------------------------------------------------------
+  
+    EXPORT InternalSwitchStackAsm
+            
+    AREA   Switch_Stack, CODE, READONLY
+  
+;/**
+;  This allows the caller to switch the stack and goes to the new entry point
+;
+; @param      EntryPoint   The pointer to the location to enter
+; @param      Context      Parameter to pass in
+; @param      Context2     Parameter2 to pass in
+; @param      NewStack     New Location of the stack
+;
+; @return     Nothing. Goes to the Entry Point passing in the new parameters
+;
+;**/
+;VOID
+;EFIAPI
+;InternalSwitchStackAsm (
+;  SWITCH_STACK_ENTRY_POINT EntryPoint,
+;  VOID  *Context,
+;  VOID  *Context2,
+;  VOID  *NewStack
+;  );
+;
+InternalSwitchStackAsm
+    MOV   LR, R0
+    MOV   SP, R3
+    MOV   R0, R1
+    MOV   R1, R2
+    BX    LR
+    END
diff --git a/MdePkg/Library/BaseLib/Arm/Unaligned.c b/MdePkg/Library/BaseLib/Arm/Unaligned.c
new file mode 100644
index 000000000000..72eeceba38bc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Arm/Unaligned.c
@@ -0,0 +1,252 @@
+/** @file
+  Unaligned access functions of BaseLib for ARM.
+  
+  volatile was added to work around optimization issues.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BaseLibInternals.h"
+
+/**
+  Reads a 16-bit value from memory that may be unaligned.
+
+  This function returns the 16-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+
+  @return The 16-bit value read from Buffer.
+
+**/
+UINT16
+EFIAPI
+ReadUnaligned16 (
+  IN CONST UINT16              *Buffer
+  )
+{
+  volatile UINT8 LowerByte;
+  volatile UINT8 HigherByte;
+
+  ASSERT (Buffer != NULL);
+
+  LowerByte = ((UINT8*)Buffer)[0];
+  HigherByte = ((UINT8*)Buffer)[1];
+
+  return (UINT16)(LowerByte | (HigherByte << 8));
+}
+
+/**
+  Writes a 16-bit value to memory that may be unaligned.
+
+  This function writes the 16-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+  @param  Value   16-bit value to write to Buffer.
+
+  @return The 16-bit value to write to Buffer.
+
+**/
+UINT16
+EFIAPI
+WriteUnaligned16 (
+  OUT UINT16                    *Buffer,
+  IN  UINT16                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  ((volatile UINT8*)Buffer)[0] = (UINT8)Value;
+  ((volatile UINT8*)Buffer)[1] = (UINT8)(Value >> 8);
+
+  return Value;
+}
+
+/**
+  Reads a 24-bit value from memory that may be unaligned.
+
+  This function returns the 24-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+
+  @return The 24-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned24 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return (UINT32)(
+            ReadUnaligned16 ((UINT16*)Buffer) |
+            (((UINT8*)Buffer)[2] << 16)
+            );
+}
+
+/**
+  Writes a 24-bit value to memory that may be unaligned.
+
+  This function writes the 24-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+  @param  Value   24-bit value to write to Buffer.
+
+  @return The 24-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned24 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned16 ((UINT16*)Buffer, (UINT16)Value);
+  *(UINT8*)((UINT16*)Buffer + 1) = (UINT8)(Value >> 16);
+  return Value;
+}
+
+/**
+  Reads a 32-bit value from memory that may be unaligned.
+
+  This function returns the 32-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+
+  @return The 32-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned32 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  UINT16  LowerBytes;
+  UINT16  HigherBytes;
+
+  ASSERT (Buffer != NULL);
+
+  LowerBytes  = ReadUnaligned16 ((UINT16*) Buffer);
+  HigherBytes = ReadUnaligned16 ((UINT16*) Buffer + 1);
+
+  return (UINT32) (LowerBytes | (HigherBytes << 16));
+}
+
+/**
+  Writes a 32-bit value to memory that may be unaligned.
+
+  This function writes the 32-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+  @param  Value   32-bit value to write to Buffer.
+
+  @return The 32-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned32 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned16 ((UINT16*)Buffer, (UINT16)Value);
+  WriteUnaligned16 ((UINT16*)Buffer + 1, (UINT16)(Value >> 16));
+  return Value;
+}
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  IN CONST UINT64              *Buffer
+  )
+{
+  UINT32  LowerBytes;
+  UINT32  HigherBytes;
+
+  ASSERT (Buffer != NULL);
+
+  LowerBytes  = ReadUnaligned32 ((UINT32*) Buffer);
+  HigherBytes = ReadUnaligned32 ((UINT32*) Buffer + 1);
+
+  return (UINT64) (LowerBytes | LShiftU64 (HigherBytes, 32));
+}
+
+/**
+  Writes a 64-bit value to memory that may be unaligned.
+
+  This function writes the 64-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+  @param  Value   64-bit value to write to Buffer.
+
+  @return The 64-bit value to write to Buffer.
+
+**/
+UINT64
+EFIAPI
+WriteUnaligned64 (
+  OUT UINT64                    *Buffer,
+  IN  UINT64                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned32 ((UINT32*)Buffer, (UINT32)Value);
+  WriteUnaligned32 ((UINT32*)Buffer + 1, (UINT32)RShiftU64 (Value, 32));
+  return Value;
+}
diff --git a/MdePkg/Library/BaseLib/BaseLib.inf b/MdePkg/Library/BaseLib/BaseLib.inf
new file mode 100644
index 000000000000..b6e122a4e1da
--- /dev/null
+++ b/MdePkg/Library/BaseLib/BaseLib.inf
@@ -0,0 +1,872 @@
+## @file
+#  Base Library implementation.
+#
+#  Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+#  Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseLib
+  MODULE_UNI_FILE                = BaseLib.uni
+  FILE_GUID                      = 27d67720-ea68-48ae-93da-a3a074c90e30
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.1
+  LIBRARY_CLASS                  = BaseLib 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources]
+  CheckSum.c
+  SwitchStack.c
+  SwapBytes64.c
+  SwapBytes32.c
+  SwapBytes16.c
+  LongJump.c
+  SetJump.c
+  RShiftU64.c
+  RRotU64.c
+  RRotU32.c
+  MultU64x64.c
+  MultU64x32.c
+  MultS64x64.c
+  ModU64x32.c
+  LShiftU64.c
+  LRotU64.c
+  LRotU32.c
+  LowBitSet64.c
+  LowBitSet32.c
+  HighBitSet64.c
+  HighBitSet32.c
+  GetPowerOfTwo64.c
+  GetPowerOfTwo32.c
+  DivU64x64Remainder.c
+  DivU64x32Remainder.c
+  DivU64x32.c
+  DivS64x64Remainder.c
+  ARShiftU64.c
+  BitField.c
+  CpuDeadLoop.c
+  Cpu.c
+  LinkedList.c
+  SafeString.c
+  String.c
+  FilePaths.c
+  BaseLibInternals.h
+
+[Sources.Ia32]
+  Ia32/Wbinvd.c | MSFT 
+  Ia32/WriteMm7.c | MSFT 
+  Ia32/WriteMm6.c | MSFT 
+  Ia32/WriteMm5.c | MSFT 
+  Ia32/WriteMm4.c | MSFT 
+  Ia32/WriteMm3.c | MSFT 
+  Ia32/WriteMm2.c | MSFT 
+  Ia32/WriteMm1.c | MSFT 
+  Ia32/WriteMm0.c | MSFT 
+  Ia32/WriteLdtr.c | MSFT 
+  Ia32/WriteIdtr.c | MSFT 
+  Ia32/WriteGdtr.c | MSFT 
+  Ia32/WriteDr7.c | MSFT 
+  Ia32/WriteDr6.c | MSFT 
+  Ia32/WriteDr5.c | MSFT 
+  Ia32/WriteDr4.c | MSFT 
+  Ia32/WriteDr3.c | MSFT 
+  Ia32/WriteDr2.c | MSFT 
+  Ia32/WriteDr1.c | MSFT 
+  Ia32/WriteDr0.c | MSFT 
+  Ia32/WriteCr4.c | MSFT 
+  Ia32/WriteCr3.c | MSFT 
+  Ia32/WriteCr2.c | MSFT 
+  Ia32/WriteCr0.c | MSFT 
+  Ia32/WriteMsr64.c | MSFT 
+  Ia32/SwapBytes64.c | MSFT 
+  Ia32/SetJump.c | MSFT 
+  Ia32/RRotU64.c | MSFT 
+  Ia32/RShiftU64.c | MSFT 
+  Ia32/ReadPmc.c | MSFT 
+  Ia32/ReadTsc.c | MSFT 
+  Ia32/ReadLdtr.c | MSFT 
+  Ia32/ReadIdtr.c | MSFT 
+  Ia32/ReadGdtr.c | MSFT 
+  Ia32/ReadTr.c | MSFT 
+  Ia32/ReadSs.c | MSFT 
+  Ia32/ReadGs.c | MSFT 
+  Ia32/ReadFs.c | MSFT 
+  Ia32/ReadEs.c | MSFT 
+  Ia32/ReadDs.c | MSFT 
+  Ia32/ReadCs.c | MSFT 
+  Ia32/ReadMsr64.c | MSFT 
+  Ia32/ReadMm7.c | MSFT 
+  Ia32/ReadMm6.c | MSFT 
+  Ia32/ReadMm5.c | MSFT 
+  Ia32/ReadMm4.c | MSFT 
+  Ia32/ReadMm3.c | MSFT 
+  Ia32/ReadMm2.c | MSFT 
+  Ia32/ReadMm1.c | MSFT 
+  Ia32/ReadMm0.c | MSFT 
+  Ia32/ReadEflags.c | MSFT 
+  Ia32/ReadDr7.c | MSFT 
+  Ia32/ReadDr6.c | MSFT 
+  Ia32/ReadDr5.c | MSFT 
+  Ia32/ReadDr4.c | MSFT 
+  Ia32/ReadDr3.c | MSFT 
+  Ia32/ReadDr2.c | MSFT 
+  Ia32/ReadDr1.c | MSFT 
+  Ia32/ReadDr0.c | MSFT 
+  Ia32/ReadCr4.c | MSFT 
+  Ia32/ReadCr3.c | MSFT 
+  Ia32/ReadCr2.c | MSFT 
+  Ia32/ReadCr0.c | MSFT 
+  Ia32/Mwait.c | MSFT 
+  Ia32/Monitor.c | MSFT 
+  Ia32/ModU64x32.c | MSFT 
+  Ia32/MultU64x64.c | MSFT 
+  Ia32/MultU64x32.c | MSFT 
+  Ia32/LShiftU64.c | MSFT 
+  Ia32/LRotU64.c | MSFT 
+  Ia32/LongJump.c | MSFT 
+  Ia32/Invd.c | MSFT 
+  Ia32/FxRestore.c | MSFT 
+  Ia32/FxSave.c | MSFT 
+  Ia32/FlushCacheLine.c | MSFT 
+  Ia32/EnablePaging32.c | MSFT 
+  Ia32/EnableInterrupts.c | MSFT 
+  Ia32/EnableDisableInterrupts.c | MSFT 
+  Ia32/DivU64x64Remainder.nasm| MSFT
+  Ia32/DivU64x64Remainder.asm | MSFT 
+  Ia32/DivU64x32Remainder.c | MSFT 
+  Ia32/DivU64x32.c | MSFT 
+  Ia32/DisablePaging32.c | MSFT 
+  Ia32/DisableInterrupts.c | MSFT 
+  Ia32/CpuPause.c | MSFT 
+  Ia32/CpuIdEx.c | MSFT 
+  Ia32/CpuId.c | MSFT 
+  Ia32/CpuBreakpoint.c | MSFT 
+  Ia32/ARShiftU64.c | MSFT 
+  Ia32/Thunk16.nasm | MSFT
+  Ia32/Thunk16.asm | MSFT
+  Ia32/EnablePaging64.nasm| MSFT
+  Ia32/EnablePaging64.asm | MSFT
+  Ia32/EnableCache.c | MSFT
+  Ia32/DisableCache.c | MSFT
+  Ia32/RdRand.nasm| MSFT
+  Ia32/RdRand.asm | MSFT
+
+  Ia32/Wbinvd.nasm| INTEL
+  Ia32/Wbinvd.asm | INTEL 
+  Ia32/WriteMm7.nasm| INTEL
+  Ia32/WriteMm7.asm | INTEL 
+  Ia32/WriteMm6.nasm| INTEL
+  Ia32/WriteMm6.asm | INTEL 
+  Ia32/WriteMm5.nasm| INTEL
+  Ia32/WriteMm5.asm | INTEL 
+  Ia32/WriteMm4.nasm| INTEL
+  Ia32/WriteMm4.asm | INTEL 
+  Ia32/WriteMm3.nasm| INTEL
+  Ia32/WriteMm3.asm | INTEL 
+  Ia32/WriteMm2.nasm| INTEL
+  Ia32/WriteMm2.asm | INTEL 
+  Ia32/WriteMm1.nasm| INTEL
+  Ia32/WriteMm1.asm | INTEL 
+  Ia32/WriteMm0.nasm| INTEL
+  Ia32/WriteMm0.asm | INTEL 
+  Ia32/WriteLdtr.nasm| INTEL
+  Ia32/WriteLdtr.asm | INTEL 
+  Ia32/WriteIdtr.nasm| INTEL
+  Ia32/WriteIdtr.asm | INTEL 
+  Ia32/WriteGdtr.nasm| INTEL
+  Ia32/WriteGdtr.asm | INTEL 
+  Ia32/WriteDr7.nasm| INTEL
+  Ia32/WriteDr7.asm | INTEL 
+  Ia32/WriteDr6.nasm| INTEL
+  Ia32/WriteDr6.asm | INTEL 
+  Ia32/WriteDr5.nasm| INTEL
+  Ia32/WriteDr5.asm | INTEL 
+  Ia32/WriteDr4.nasm| INTEL
+  Ia32/WriteDr4.asm | INTEL 
+  Ia32/WriteDr3.nasm| INTEL
+  Ia32/WriteDr3.asm | INTEL 
+  Ia32/WriteDr2.nasm| INTEL
+  Ia32/WriteDr2.asm | INTEL 
+  Ia32/WriteDr1.nasm| INTEL
+  Ia32/WriteDr1.asm | INTEL 
+  Ia32/WriteDr0.nasm| INTEL
+  Ia32/WriteDr0.asm | INTEL 
+  Ia32/WriteCr4.nasm| INTEL
+  Ia32/WriteCr4.asm | INTEL 
+  Ia32/WriteCr3.nasm| INTEL
+  Ia32/WriteCr3.asm | INTEL 
+  Ia32/WriteCr2.nasm| INTEL
+  Ia32/WriteCr2.asm | INTEL 
+  Ia32/WriteCr0.nasm| INTEL
+  Ia32/WriteCr0.asm | INTEL 
+  Ia32/WriteMsr64.nasm| INTEL
+  Ia32/WriteMsr64.asm | INTEL 
+  Ia32/SwapBytes64.nasm| INTEL
+  Ia32/SwapBytes64.asm | INTEL 
+  Ia32/SetJump.nasm| INTEL
+  Ia32/SetJump.asm | INTEL 
+  Ia32/RRotU64.nasm| INTEL
+  Ia32/RRotU64.asm | INTEL 
+  Ia32/RShiftU64.nasm| INTEL
+  Ia32/RShiftU64.asm | INTEL 
+  Ia32/ReadPmc.nasm| INTEL
+  Ia32/ReadPmc.asm | INTEL 
+  Ia32/ReadTsc.nasm| INTEL
+  Ia32/ReadTsc.asm | INTEL 
+  Ia32/ReadLdtr.nasm| INTEL
+  Ia32/ReadLdtr.asm | INTEL 
+  Ia32/ReadIdtr.nasm| INTEL
+  Ia32/ReadIdtr.asm | INTEL 
+  Ia32/ReadGdtr.nasm| INTEL
+  Ia32/ReadGdtr.asm | INTEL 
+  Ia32/ReadTr.nasm| INTEL
+  Ia32/ReadTr.asm | INTEL 
+  Ia32/ReadSs.nasm| INTEL
+  Ia32/ReadSs.asm | INTEL 
+  Ia32/ReadGs.nasm| INTEL
+  Ia32/ReadGs.asm | INTEL 
+  Ia32/ReadFs.nasm| INTEL
+  Ia32/ReadFs.asm | INTEL 
+  Ia32/ReadEs.nasm| INTEL
+  Ia32/ReadEs.asm | INTEL 
+  Ia32/ReadDs.nasm| INTEL
+  Ia32/ReadDs.asm | INTEL 
+  Ia32/ReadCs.nasm| INTEL
+  Ia32/ReadCs.asm | INTEL 
+  Ia32/ReadMsr64.nasm| INTEL
+  Ia32/ReadMsr64.asm | INTEL 
+  Ia32/ReadMm7.nasm| INTEL
+  Ia32/ReadMm7.asm | INTEL 
+  Ia32/ReadMm6.nasm| INTEL
+  Ia32/ReadMm6.asm | INTEL 
+  Ia32/ReadMm5.nasm| INTEL
+  Ia32/ReadMm5.asm | INTEL 
+  Ia32/ReadMm4.nasm| INTEL
+  Ia32/ReadMm4.asm | INTEL 
+  Ia32/ReadMm3.nasm| INTEL
+  Ia32/ReadMm3.asm | INTEL 
+  Ia32/ReadMm2.nasm| INTEL
+  Ia32/ReadMm2.asm | INTEL 
+  Ia32/ReadMm1.nasm| INTEL
+  Ia32/ReadMm1.asm | INTEL 
+  Ia32/ReadMm0.nasm| INTEL
+  Ia32/ReadMm0.asm | INTEL 
+  Ia32/ReadEflags.nasm| INTEL
+  Ia32/ReadEflags.asm | INTEL 
+  Ia32/ReadDr7.nasm| INTEL
+  Ia32/ReadDr7.asm | INTEL 
+  Ia32/ReadDr6.nasm| INTEL
+  Ia32/ReadDr6.asm | INTEL 
+  Ia32/ReadDr5.nasm| INTEL
+  Ia32/ReadDr5.asm | INTEL 
+  Ia32/ReadDr4.nasm| INTEL
+  Ia32/ReadDr4.asm | INTEL 
+  Ia32/ReadDr3.nasm| INTEL
+  Ia32/ReadDr3.asm | INTEL 
+  Ia32/ReadDr2.nasm| INTEL
+  Ia32/ReadDr2.asm | INTEL 
+  Ia32/ReadDr1.nasm| INTEL
+  Ia32/ReadDr1.asm | INTEL 
+  Ia32/ReadDr0.nasm| INTEL
+  Ia32/ReadDr0.asm | INTEL 
+  Ia32/ReadCr4.nasm| INTEL
+  Ia32/ReadCr4.asm | INTEL 
+  Ia32/ReadCr3.nasm| INTEL
+  Ia32/ReadCr3.asm | INTEL 
+  Ia32/ReadCr2.nasm| INTEL
+  Ia32/ReadCr2.asm | INTEL 
+  Ia32/ReadCr0.nasm| INTEL
+  Ia32/ReadCr0.asm | INTEL 
+  Ia32/Mwait.nasm| INTEL
+  Ia32/Mwait.asm | INTEL 
+  Ia32/Monitor.nasm| INTEL
+  Ia32/Monitor.asm | INTEL 
+  Ia32/ModU64x32.nasm| INTEL
+  Ia32/ModU64x32.asm | INTEL 
+  Ia32/MultU64x64.nasm| INTEL
+  Ia32/MultU64x64.asm | INTEL 
+  Ia32/MultU64x32.nasm| INTEL
+  Ia32/MultU64x32.asm | INTEL 
+  Ia32/LShiftU64.nasm| INTEL
+  Ia32/LShiftU64.asm | INTEL 
+  Ia32/LRotU64.nasm| INTEL
+  Ia32/LRotU64.asm | INTEL 
+  Ia32/LongJump.nasm| INTEL
+  Ia32/LongJump.asm | INTEL 
+  Ia32/Invd.nasm| INTEL
+  Ia32/Invd.asm | INTEL 
+  Ia32/FxRestore.nasm| INTEL
+  Ia32/FxRestore.asm | INTEL 
+  Ia32/FxSave.nasm| INTEL
+  Ia32/FxSave.asm | INTEL 
+  Ia32/FlushCacheLine.nasm| INTEL
+  Ia32/FlushCacheLine.asm | INTEL 
+  Ia32/EnablePaging32.nasm| INTEL
+  Ia32/EnablePaging32.asm | INTEL 
+  Ia32/EnableInterrupts.nasm| INTEL
+  Ia32/EnableInterrupts.asm | INTEL 
+  Ia32/EnableDisableInterrupts.nasm| INTEL
+  Ia32/EnableDisableInterrupts.asm | INTEL 
+  Ia32/DivU64x64Remainder.nasm| INTEL
+  Ia32/DivU64x64Remainder.asm | INTEL 
+  Ia32/DivU64x32Remainder.nasm| INTEL
+  Ia32/DivU64x32Remainder.asm | INTEL 
+  Ia32/DivU64x32.nasm| INTEL
+  Ia32/DivU64x32.asm | INTEL 
+  Ia32/DisablePaging32.nasm| INTEL
+  Ia32/DisablePaging32.asm | INTEL
+  Ia32/DisableInterrupts.nasm| INTEL
+  Ia32/DisableInterrupts.asm | INTEL 
+  Ia32/CpuPause.nasm| INTEL
+  Ia32/CpuPause.asm | INTEL 
+  Ia32/CpuIdEx.nasm| INTEL
+  Ia32/CpuIdEx.asm | INTEL 
+  Ia32/CpuId.nasm| INTEL
+  Ia32/CpuId.asm | INTEL 
+  Ia32/CpuBreakpoint.nasm| INTEL
+  Ia32/CpuBreakpoint.asm | INTEL 
+  Ia32/ARShiftU64.nasm| INTEL
+  Ia32/ARShiftU64.asm | INTEL 
+  Ia32/Thunk16.nasm | INTEL
+  Ia32/Thunk16.asm | INTEL
+  Ia32/EnablePaging64.nasm| INTEL
+  Ia32/EnablePaging64.asm | INTEL
+  Ia32/EnableCache.nasm| INTEL
+  Ia32/EnableCache.asm | INTEL
+  Ia32/DisableCache.nasm| INTEL
+  Ia32/DisableCache.asm | INTEL
+  Ia32/RdRand.nasm| INTEL
+  Ia32/RdRand.asm | INTEL
+
+  Ia32/GccInline.c | GCC
+  Ia32/Thunk16.nasm | GCC 
+  Ia32/Thunk16.S | XCODE 
+  Ia32/EnableDisableInterrupts.nasm| GCC
+  Ia32/EnableDisableInterrupts.S | GCC 
+  Ia32/EnablePaging64.nasm| GCC
+  Ia32/EnablePaging64.S | GCC 
+  Ia32/DisablePaging32.nasm| GCC
+  Ia32/DisablePaging32.S | GCC 
+  Ia32/EnablePaging32.nasm| GCC
+  Ia32/EnablePaging32.S | GCC 
+  Ia32/Mwait.nasm| GCC
+  Ia32/Mwait.S | GCC 
+  Ia32/Monitor.nasm| GCC
+  Ia32/Monitor.S | GCC 
+  Ia32/CpuIdEx.nasm| GCC
+  Ia32/CpuIdEx.S | GCC 
+  Ia32/CpuId.nasm| GCC
+  Ia32/CpuId.S | GCC 
+  Ia32/LongJump.nasm| GCC
+  Ia32/LongJump.S | GCC 
+  Ia32/SetJump.nasm| GCC
+  Ia32/SetJump.S | GCC 
+  Ia32/SwapBytes64.nasm| GCC
+  Ia32/SwapBytes64.S | GCC 
+  Ia32/DivU64x64Remainder.nasm| GCC
+  Ia32/DivU64x64Remainder.S | GCC 
+  Ia32/DivU64x32Remainder.nasm| GCC
+  Ia32/DivU64x32Remainder.S | GCC 
+  Ia32/ModU64x32.nasm| GCC
+  Ia32/ModU64x32.S | GCC 
+  Ia32/DivU64x32.nasm| GCC
+  Ia32/DivU64x32.S | GCC 
+  Ia32/MultU64x64.nasm| GCC
+  Ia32/MultU64x64.S | GCC 
+  Ia32/MultU64x32.nasm| GCC
+  Ia32/MultU64x32.S | GCC 
+  Ia32/RRotU64.nasm| GCC
+  Ia32/RRotU64.S | GCC 
+  Ia32/LRotU64.nasm| GCC
+  Ia32/LRotU64.S | GCC 
+  Ia32/ARShiftU64.nasm| GCC
+  Ia32/ARShiftU64.S | GCC 
+  Ia32/RShiftU64.nasm| GCC
+  Ia32/RShiftU64.S | GCC 
+  Ia32/LShiftU64.nasm| GCC
+  Ia32/LShiftU64.S | GCC 
+  Ia32/EnableCache.nasm| GCC
+  Ia32/EnableCache.S | GCC
+  Ia32/DisableCache.nasm| GCC
+  Ia32/DisableCache.S | GCC
+  Ia32/RdRand.nasm| GCC
+  Ia32/RdRand.S | GCC
+
+  Ia32/DivS64x64Remainder.c
+  Ia32/InternalSwitchStack.c | MSFT
+  Ia32/InternalSwitchStack.c | INTEL
+  Ia32/InternalSwitchStack.S | GCC
+  Ia32/InternalSwitchStack.nasm | GCC
+  Ia32/Non-existing.c
+  Unaligned.c
+  X86WriteIdtr.c
+  X86WriteGdtr.c
+  X86Thunk.c
+  X86ReadIdtr.c
+  X86ReadGdtr.c
+  X86Msr.c
+  X86MemoryFence.c | MSFT
+  X86MemoryFence.c | INTEL
+  X86GetInterruptState.c
+  X86FxSave.c
+  X86FxRestore.c
+  X86EnablePaging64.c
+  X86EnablePaging32.c
+  X86DisablePaging64.c
+  X86DisablePaging32.c
+  X86RdRand.c
+
+[Sources.X64]
+  X64/Thunk16.nasm
+  X64/Thunk16.asm
+  X64/CpuIdEx.nasm
+  X64/CpuIdEx.asm
+  X64/CpuId.nasm
+  X64/CpuId.asm
+  X64/LongJump.nasm
+  X64/LongJump.asm
+  X64/SetJump.nasm
+  X64/SetJump.asm
+  X64/SwitchStack.nasm
+  X64/SwitchStack.asm
+  X64/EnableCache.nasm
+  X64/EnableCache.asm
+  X64/DisableCache.nasm
+  X64/DisableCache.asm
+
+  X64/CpuBreakpoint.c | MSFT 
+  X64/WriteMsr64.c | MSFT 
+  X64/ReadMsr64.c | MSFT 
+  X64/RdRand.nasm| MSFT
+  X64/RdRand.asm | MSFT
+  X64/CpuPause.nasm| MSFT
+  X64/CpuPause.asm | MSFT
+  X64/EnableDisableInterrupts.nasm| MSFT
+  X64/EnableDisableInterrupts.asm | MSFT
+  X64/DisableInterrupts.nasm| MSFT
+  X64/DisableInterrupts.asm | MSFT
+  X64/EnableInterrupts.nasm| MSFT
+  X64/EnableInterrupts.asm | MSFT
+  X64/FlushCacheLine.nasm| MSFT
+  X64/FlushCacheLine.asm | MSFT
+  X64/Invd.nasm| MSFT
+  X64/Invd.asm | MSFT
+  X64/Wbinvd.nasm| MSFT
+  X64/Wbinvd.asm | MSFT
+  X64/DisablePaging64.nasm| MSFT
+  X64/DisablePaging64.asm | MSFT
+  X64/Mwait.nasm| MSFT
+  X64/Mwait.asm | MSFT
+  X64/Monitor.nasm| MSFT
+  X64/Monitor.asm | MSFT
+  X64/ReadPmc.nasm| MSFT
+  X64/ReadPmc.asm | MSFT
+  X64/ReadTsc.nasm| MSFT
+  X64/ReadTsc.asm | MSFT
+  X64/WriteMm7.nasm| MSFT
+  X64/WriteMm7.asm | MSFT
+  X64/WriteMm6.nasm| MSFT
+  X64/WriteMm6.asm | MSFT
+  X64/WriteMm5.nasm| MSFT
+  X64/WriteMm5.asm | MSFT
+  X64/WriteMm4.nasm| MSFT
+  X64/WriteMm4.asm | MSFT
+  X64/WriteMm3.nasm| MSFT
+  X64/WriteMm3.asm | MSFT
+  X64/WriteMm2.nasm| MSFT
+  X64/WriteMm2.asm | MSFT
+  X64/WriteMm1.nasm| MSFT
+  X64/WriteMm1.asm | MSFT
+  X64/WriteMm0.nasm| MSFT
+  X64/WriteMm0.asm | MSFT
+  X64/ReadMm7.nasm| MSFT
+  X64/ReadMm7.asm | MSFT
+  X64/ReadMm6.nasm| MSFT
+  X64/ReadMm6.asm | MSFT
+  X64/ReadMm5.nasm| MSFT
+  X64/ReadMm5.asm | MSFT
+  X64/ReadMm4.nasm| MSFT
+  X64/ReadMm4.asm | MSFT
+  X64/ReadMm3.nasm| MSFT
+  X64/ReadMm3.asm | MSFT
+  X64/ReadMm2.nasm| MSFT
+  X64/ReadMm2.asm | MSFT
+  X64/ReadMm1.nasm| MSFT
+  X64/ReadMm1.asm | MSFT
+  X64/ReadMm0.nasm| MSFT
+  X64/ReadMm0.asm | MSFT
+  X64/FxRestore.nasm| MSFT
+  X64/FxRestore.asm | MSFT
+  X64/FxSave.nasm| MSFT
+  X64/FxSave.asm | MSFT
+  X64/WriteLdtr.nasm| MSFT
+  X64/WriteLdtr.asm | MSFT
+  X64/ReadLdtr.nasm| MSFT
+  X64/ReadLdtr.asm | MSFT
+  X64/WriteIdtr.nasm| MSFT
+  X64/WriteIdtr.asm | MSFT
+  X64/ReadIdtr.nasm| MSFT
+  X64/ReadIdtr.asm | MSFT
+  X64/WriteGdtr.nasm| MSFT
+  X64/WriteGdtr.asm | MSFT
+  X64/ReadGdtr.nasm| MSFT
+  X64/ReadGdtr.asm | MSFT
+  X64/ReadTr.nasm| MSFT
+  X64/ReadTr.asm | MSFT
+  X64/ReadSs.nasm| MSFT
+  X64/ReadSs.asm | MSFT
+  X64/ReadGs.nasm| MSFT
+  X64/ReadGs.asm | MSFT
+  X64/ReadFs.nasm| MSFT
+  X64/ReadFs.asm | MSFT
+  X64/ReadEs.nasm| MSFT
+  X64/ReadEs.asm | MSFT
+  X64/ReadDs.nasm| MSFT
+  X64/ReadDs.asm | MSFT
+  X64/ReadCs.nasm| MSFT
+  X64/ReadCs.asm | MSFT
+  X64/WriteDr7.nasm| MSFT
+  X64/WriteDr7.asm | MSFT
+  X64/WriteDr6.nasm| MSFT
+  X64/WriteDr6.asm | MSFT
+  X64/WriteDr5.nasm| MSFT
+  X64/WriteDr5.asm | MSFT
+  X64/WriteDr4.nasm| MSFT
+  X64/WriteDr4.asm | MSFT
+  X64/WriteDr3.nasm| MSFT
+  X64/WriteDr3.asm | MSFT
+  X64/WriteDr2.nasm| MSFT
+  X64/WriteDr2.asm | MSFT
+  X64/WriteDr1.nasm| MSFT
+  X64/WriteDr1.asm | MSFT
+  X64/WriteDr0.nasm| MSFT
+  X64/WriteDr0.asm | MSFT
+  X64/ReadDr7.nasm| MSFT
+  X64/ReadDr7.asm | MSFT
+  X64/ReadDr6.nasm| MSFT
+  X64/ReadDr6.asm | MSFT
+  X64/ReadDr5.nasm| MSFT
+  X64/ReadDr5.asm | MSFT
+  X64/ReadDr4.nasm| MSFT
+  X64/ReadDr4.asm | MSFT
+  X64/ReadDr3.nasm| MSFT
+  X64/ReadDr3.asm | MSFT
+  X64/ReadDr2.nasm| MSFT
+  X64/ReadDr2.asm | MSFT
+  X64/ReadDr1.nasm| MSFT
+  X64/ReadDr1.asm | MSFT
+  X64/ReadDr0.nasm| MSFT
+  X64/ReadDr0.asm | MSFT
+  X64/WriteCr4.nasm| MSFT
+  X64/WriteCr4.asm | MSFT
+  X64/WriteCr3.nasm| MSFT
+  X64/WriteCr3.asm | MSFT
+  X64/WriteCr2.nasm| MSFT
+  X64/WriteCr2.asm | MSFT
+  X64/WriteCr0.nasm| MSFT
+  X64/WriteCr0.asm | MSFT
+  X64/ReadCr4.nasm| MSFT
+  X64/ReadCr4.asm | MSFT
+  X64/ReadCr3.nasm| MSFT
+  X64/ReadCr3.asm | MSFT
+  X64/ReadCr2.nasm| MSFT
+  X64/ReadCr2.asm | MSFT
+  X64/ReadCr0.nasm| MSFT
+  X64/ReadCr0.asm | MSFT
+  X64/ReadEflags.nasm| MSFT
+  X64/ReadEflags.asm | MSFT
+
+  X64/CpuBreakpoint.nasm| INTEL
+  X64/CpuBreakpoint.asm | INTEL 
+  X64/WriteMsr64.nasm| INTEL
+  X64/WriteMsr64.asm | INTEL 
+  X64/ReadMsr64.nasm| INTEL
+  X64/ReadMsr64.asm | INTEL 
+  X64/RdRand.nasm| INTEL
+  X64/RdRand.asm | INTEL
+  X64/CpuPause.nasm| INTEL
+  X64/CpuPause.asm | INTEL
+  X64/EnableDisableInterrupts.nasm| INTEL
+  X64/EnableDisableInterrupts.asm | INTEL
+  X64/DisableInterrupts.nasm| INTEL
+  X64/DisableInterrupts.asm | INTEL
+  X64/EnableInterrupts.nasm| INTEL
+  X64/EnableInterrupts.asm | INTEL
+  X64/FlushCacheLine.nasm| INTEL
+  X64/FlushCacheLine.asm | INTEL
+  X64/Invd.nasm| INTEL
+  X64/Invd.asm | INTEL
+  X64/Wbinvd.nasm| INTEL
+  X64/Wbinvd.asm | INTEL
+  X64/DisablePaging64.nasm| INTEL
+  X64/DisablePaging64.asm | INTEL
+  X64/Mwait.nasm| INTEL
+  X64/Mwait.asm | INTEL
+  X64/Monitor.nasm| INTEL
+  X64/Monitor.asm | INTEL
+  X64/ReadPmc.nasm| INTEL
+  X64/ReadPmc.asm | INTEL
+  X64/ReadTsc.nasm| INTEL
+  X64/ReadTsc.asm | INTEL
+  X64/WriteMm7.nasm| INTEL
+  X64/WriteMm7.asm | INTEL
+  X64/WriteMm6.nasm| INTEL
+  X64/WriteMm6.asm | INTEL
+  X64/WriteMm5.nasm| INTEL
+  X64/WriteMm5.asm | INTEL
+  X64/WriteMm4.nasm| INTEL
+  X64/WriteMm4.asm | INTEL
+  X64/WriteMm3.nasm| INTEL
+  X64/WriteMm3.asm | INTEL
+  X64/WriteMm2.nasm| INTEL
+  X64/WriteMm2.asm | INTEL
+  X64/WriteMm1.nasm| INTEL
+  X64/WriteMm1.asm | INTEL
+  X64/WriteMm0.nasm| INTEL
+  X64/WriteMm0.asm | INTEL
+  X64/ReadMm7.nasm| INTEL
+  X64/ReadMm7.asm | INTEL
+  X64/ReadMm6.nasm| INTEL
+  X64/ReadMm6.asm | INTEL
+  X64/ReadMm5.nasm| INTEL
+  X64/ReadMm5.asm | INTEL
+  X64/ReadMm4.nasm| INTEL
+  X64/ReadMm4.asm | INTEL
+  X64/ReadMm3.nasm| INTEL
+  X64/ReadMm3.asm | INTEL
+  X64/ReadMm2.nasm| INTEL
+  X64/ReadMm2.asm | INTEL
+  X64/ReadMm1.nasm| INTEL
+  X64/ReadMm1.asm | INTEL
+  X64/ReadMm0.nasm| INTEL
+  X64/ReadMm0.asm | INTEL
+  X64/FxRestore.nasm| INTEL
+  X64/FxRestore.asm | INTEL
+  X64/FxSave.nasm| INTEL
+  X64/FxSave.asm | INTEL
+  X64/WriteLdtr.nasm| INTEL
+  X64/WriteLdtr.asm | INTEL
+  X64/ReadLdtr.nasm| INTEL
+  X64/ReadLdtr.asm | INTEL
+  X64/WriteIdtr.nasm| INTEL
+  X64/WriteIdtr.asm | INTEL
+  X64/ReadIdtr.nasm| INTEL
+  X64/ReadIdtr.asm | INTEL
+  X64/WriteGdtr.nasm| INTEL
+  X64/WriteGdtr.asm | INTEL
+  X64/ReadGdtr.nasm| INTEL
+  X64/ReadGdtr.asm | INTEL
+  X64/ReadTr.nasm| INTEL
+  X64/ReadTr.asm | INTEL
+  X64/ReadSs.nasm| INTEL
+  X64/ReadSs.asm | INTEL
+  X64/ReadGs.nasm| INTEL
+  X64/ReadGs.asm | INTEL
+  X64/ReadFs.nasm| INTEL
+  X64/ReadFs.asm | INTEL
+  X64/ReadEs.nasm| INTEL
+  X64/ReadEs.asm | INTEL
+  X64/ReadDs.nasm| INTEL
+  X64/ReadDs.asm | INTEL
+  X64/ReadCs.nasm| INTEL
+  X64/ReadCs.asm | INTEL
+  X64/WriteDr7.nasm| INTEL
+  X64/WriteDr7.asm | INTEL
+  X64/WriteDr6.nasm| INTEL
+  X64/WriteDr6.asm | INTEL
+  X64/WriteDr5.nasm| INTEL
+  X64/WriteDr5.asm | INTEL
+  X64/WriteDr4.nasm| INTEL
+  X64/WriteDr4.asm | INTEL
+  X64/WriteDr3.nasm| INTEL
+  X64/WriteDr3.asm | INTEL
+  X64/WriteDr2.nasm| INTEL
+  X64/WriteDr2.asm | INTEL
+  X64/WriteDr1.nasm| INTEL
+  X64/WriteDr1.asm | INTEL
+  X64/WriteDr0.nasm| INTEL
+  X64/WriteDr0.asm | INTEL
+  X64/ReadDr7.nasm| INTEL
+  X64/ReadDr7.asm | INTEL
+  X64/ReadDr6.nasm| INTEL
+  X64/ReadDr6.asm | INTEL
+  X64/ReadDr5.nasm| INTEL
+  X64/ReadDr5.asm | INTEL
+  X64/ReadDr4.nasm| INTEL
+  X64/ReadDr4.asm | INTEL
+  X64/ReadDr3.nasm| INTEL
+  X64/ReadDr3.asm | INTEL
+  X64/ReadDr2.nasm| INTEL
+  X64/ReadDr2.asm | INTEL
+  X64/ReadDr1.nasm| INTEL
+  X64/ReadDr1.asm | INTEL
+  X64/ReadDr0.nasm| INTEL
+  X64/ReadDr0.asm | INTEL
+  X64/WriteCr4.nasm| INTEL
+  X64/WriteCr4.asm | INTEL
+  X64/WriteCr3.nasm| INTEL
+  X64/WriteCr3.asm | INTEL
+  X64/WriteCr2.nasm| INTEL
+  X64/WriteCr2.asm | INTEL
+  X64/WriteCr0.nasm| INTEL
+  X64/WriteCr0.asm | INTEL
+  X64/ReadCr4.nasm| INTEL
+  X64/ReadCr4.asm | INTEL
+  X64/ReadCr3.nasm| INTEL
+  X64/ReadCr3.asm | INTEL
+  X64/ReadCr2.nasm| INTEL
+  X64/ReadCr2.asm | INTEL
+  X64/ReadCr0.nasm| INTEL
+  X64/ReadCr0.asm | INTEL
+  X64/ReadEflags.nasm| INTEL
+  X64/ReadEflags.asm | INTEL
+
+  X64/Non-existing.c
+  Math64.c
+  Unaligned.c
+  X86WriteIdtr.c
+  X86WriteGdtr.c
+  X86Thunk.c
+  X86ReadIdtr.c
+  X86ReadGdtr.c
+  X86Msr.c
+  X86MemoryFence.c | MSFT
+  X86MemoryFence.c | INTEL
+  X86GetInterruptState.c
+  X86FxSave.c
+  X86FxRestore.c
+  X86EnablePaging64.c
+  X86EnablePaging32.c
+  X86DisablePaging64.c
+  X86DisablePaging32.c
+  X86RdRand.c
+  X64/GccInline.c | GCC
+  X64/Thunk16.S | XCODE 
+  X64/SwitchStack.nasm| GCC
+  X64/SwitchStack.S | GCC 
+  X64/SetJump.nasm| GCC
+  X64/SetJump.S | GCC 
+  X64/LongJump.nasm| GCC
+  X64/LongJump.S | GCC 
+  X64/EnableDisableInterrupts.nasm| GCC
+  X64/EnableDisableInterrupts.S | GCC 
+  X64/DisablePaging64.nasm| GCC
+  X64/DisablePaging64.S | GCC 
+  X64/CpuId.nasm| GCC
+  X64/CpuId.S | GCC 
+  X64/CpuIdEx.nasm| GCC
+  X64/CpuIdEx.S | GCC 
+  X64/EnableCache.nasm| GCC
+  X64/EnableCache.S | GCC
+  X64/DisableCache.nasm| GCC
+  X64/DisableCache.S | GCC
+  X64/RdRand.nasm| GCC
+  X64/RdRand.S | GCC
+  ChkStkGcc.c  | GCC 
+
+[Sources.IPF]
+  Ipf/AccessGp.s
+  Ipf/ReadCpuid.s
+  Ipf/ExecFc.s
+  Ipf/AsmPalCall.s
+  Ipf/AccessPsr.s
+  Ipf/AccessPmr.s
+  Ipf/AccessKr.s
+  Ipf/AccessKr7.s
+  Ipf/AccessGcr.s
+  Ipf/AccessEicr.s
+  Ipf/AccessDbr.s
+  Ipf/AccessMsr.s        | INTEL
+  Ipf/AccessMsr.s        | GCC
+  Ipf/AccessMsrDb.s      | MSFT
+  Ipf/InternalFlushCacheRange.s
+  Ipf/FlushCacheRange.c
+  Ipf/InternalSwitchStack.c
+  Ipf/GetInterruptState.s
+  Ipf/CpuPause.s
+  Ipf/CpuBreakpoint.c    | INTEL
+  Ipf/CpuBreakpointMsc.c | MSFT
+  Ipf/AsmCpuMisc.s       | GCC
+  Ipf/Unaligned.c
+  Ipf/SwitchStack.s
+  Ipf/LongJmp.s
+  Ipf/SetJmp.s
+  Ipf/ReadCr.s
+  Ipf/ReadAr.s
+  Ipf/Ia64gen.h
+  Ipf/Asm.h
+  Math64.c
+
+[Sources.EBC]
+  Ebc/CpuBreakpoint.c
+  Ebc/SetJumpLongJump.c
+  Ebc/SwitchStack.c
+  Unaligned.c
+  Math64.c
+
+[Sources.ARM]
+  Arm/InternalSwitchStack.c
+  Arm/Unaligned.c
+  Math64.c                   | RVCT 
+    
+  Arm/SwitchStack.asm        | RVCT
+  Arm/SetJumpLongJump.asm    | RVCT
+  Arm/DisableInterrupts.asm  | RVCT
+  Arm/EnableInterrupts.asm   | RVCT
+  Arm/GetInterruptsState.asm | RVCT
+  Arm/CpuPause.asm           | RVCT
+  Arm/CpuBreakpoint.asm      | RVCT
+  Arm/MemoryFence.asm        | RVCT
+ 
+  Arm/Math64.S                  | GCC
+  Arm/SwitchStack.S             | GCC
+  Arm/EnableInterrupts.S        | GCC
+  Arm/DisableInterrupts.S       | GCC
+  Arm/GetInterruptsState.S      | GCC
+  Arm/SetJumpLongJump.S         | GCC
+  Arm/CpuBreakpoint.S           | GCC
+  Arm/MemoryFence.S             | GCC
+
+[Sources.AARCH64]
+  Arm/InternalSwitchStack.c
+  Arm/Unaligned.c
+  Math64.c
+
+  AArch64/MemoryFence.S             | GCC
+  AArch64/SwitchStack.S             | GCC
+  AArch64/EnableInterrupts.S        | GCC
+  AArch64/DisableInterrupts.S       | GCC
+  AArch64/GetInterruptsState.S      | GCC
+  AArch64/SetJumpLongJump.S         | GCC
+  AArch64/CpuBreakpoint.S           | GCC
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PcdLib
+  DebugLib
+  BaseMemoryLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength      ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength     ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength   ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask            ## SOMETIMES_CONSUMES
+
+[FeaturePcd]
+  gEfiMdePkgTokenSpaceGuid.PcdVerifyNodeInList  ## CONSUMES
diff --git a/MdePkg/Library/BaseLib/BaseLib.uni b/MdePkg/Library/BaseLib/BaseLib.uni
new file mode 100644
index 000000000000..6e4c32eb0324
--- /dev/null
+++ b/MdePkg/Library/BaseLib/BaseLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Base Library implementation.
+//
+// Base Library implementation.
+//
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+// Portions copyright (c) 2011 - 2013, ARM Ltd. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Base Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Library implementation."
+
diff --git a/MdePkg/Library/BaseLib/BaseLibInternals.h b/MdePkg/Library/BaseLib/BaseLibInternals.h
new file mode 100644
index 000000000000..ad0d823f2f44
--- /dev/null
+++ b/MdePkg/Library/BaseLib/BaseLibInternals.h
@@ -0,0 +1,1865 @@
+/** @file
+  Declaration of internal functions in BaseLib.
+
+  Copyright (c) 2006 - 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 __BASE_LIB_INTERNALS__
+#define __BASE_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+//
+// Math functions
+//
+
+/**
+  Shifts a 64-bit integer left between 0 and 63 bits. The low bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the left by Count bits. The
+  low Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift left.
+  @param  Count   The number of bits to shift left.
+
+  @return Operand << Count
+
+**/
+UINT64
+EFIAPI
+InternalMathLShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+InternalMathRShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits
+  are filled with original integer's bit 63. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to bit 63 of Operand.  The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand arithmetically shifted right by Count
+
+**/
+UINT64
+EFIAPI
+InternalMathARShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+/**
+  Rotates a 64-bit integer left between 0 and 63 bits, filling
+  the low bits with the high bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the left by Count bits. The
+  low Count bits are filled with the high Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand <<< Count
+
+**/
+UINT64
+EFIAPI
+InternalMathLRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+/**
+  Rotates a 64-bit integer right between 0 and 63 bits, filling
+  the high bits with the high low bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the right by Count bits.
+  The high Count bits are filled with the low Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >>> Count
+
+**/
+UINT64
+EFIAPI
+InternalMathRRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  );
+
+/**
+  Switches the endianess of a 64-bit integer.
+
+  This function swaps the bytes in a 64-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Operand A 64-bit unsigned value.
+
+  @return The byte swapped Operand.
+
+**/
+UINT64
+EFIAPI
+InternalMathSwapBytes64 (
+  IN      UINT64                    Operand
+  );
+
+/**
+  Multiplies a 64-bit unsigned integer by a 32-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 32-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 32-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x32 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT32                    Multiplier
+  );
+
+/**
+  Multiplies a 64-bit unsigned integer by a 64-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiples the 64-bit unsigned value Multiplicand by the 64-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 64-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x64 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT64                    Multiplier
+  );
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. This
+  function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  );
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 32-bit remainder. This function
+  returns the 32-bit unsigned remainder.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend % Divisor
+
+**/
+UINT32
+EFIAPI
+InternalMathModU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  );
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result and an optional 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivRemU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor,
+  OUT     UINT32                    *Remainder OPTIONAL
+  );
+
+/**
+  Divides a 64-bit unsigned integer by a 64-bit unsigned integer and
+  generates a 64-bit unsigned result and an optional 64-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 64-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 64-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 64-bit unsigned value.
+  @param  Remainder A pointer to a 64-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivRemU64x64 (
+  IN      UINT64                    Dividend,
+  IN      UINT64                    Divisor,
+  OUT     UINT64                    *Remainder OPTIONAL
+  );
+
+/**
+  Divides a 64-bit signed integer by a 64-bit signed integer and
+  generates a 64-bit signed result and an optional 64-bit signed remainder.
+
+  This function divides the 64-bit signed value Dividend by the 64-bit
+  signed value Divisor and generates a 64-bit signed quotient. If Remainder
+  is not NULL, then the 64-bit signed remainder is returned in Remainder.
+  This function returns the 64-bit signed quotient.
+
+  @param  Dividend  A 64-bit signed value.
+  @param  Divisor   A 64-bit signed value.
+  @param  Remainder A pointer to a 64-bit signed value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+INT64
+EFIAPI
+InternalMathDivRemS64x64 (
+  IN      INT64                     Dividend,
+  IN      INT64                     Divisor,
+  OUT     INT64                     *Remainder  OPTIONAL
+  );
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.
+  Marker will be ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  Marker      VA_LIST marker for the variable argument list.
+
+**/
+VOID
+EFIAPI
+InternalSwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VA_LIST                   Marker
+  );
+
+
+/**
+  Worker function that locates the Node in the List.
+
+  By searching the List, finds the location of the Node in List. At the same time,
+  verifies the validity of this list.
+
+  If List is NULL, then ASSERT().
+  If List->ForwardLink is NULL, then ASSERT().
+  If List->backLink is NULL, then ASSERT().
+  If Node is NULL, then ASSERT();
+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number
+  of nodes in ListHead, including the ListHead node, is greater than or
+  equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  List  A pointer to a node in a linked list.
+  @param  Node  A pointer to one nod.
+
+  @retval TRUE   Node is in List.
+  @retval FALSE  Node isn't in List, or List is invalid.
+
+**/
+BOOLEAN
+EFIAPI
+IsNodeInList (
+  IN      CONST LIST_ENTRY      *List,
+  IN      CONST LIST_ENTRY      *Node
+  );
+
+/**
+  Worker function that returns a bit field from Operand.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+
+  @return The bit field read.
+
+**/
+UINTN
+EFIAPI
+BitFieldReadUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  );
+
+
+/**
+  Worker function that reads a bit field from Operand, performs a bitwise OR,
+  and returns the result.
+
+  Performs a bitwise OR between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new value is returned.
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+  @param  OrData    The value to OR with the read value from the value
+
+  @return The new value.
+
+**/
+UINTN
+EFIAPI
+BitFieldOrUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINTN                     OrData
+  );
+
+
+/**
+  Worker function that reads a bit field from Operand, performs a bitwise AND,
+  and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new value is returned.
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+  @param  AndData    The value to And with the read value from the value
+
+  @return The new value.
+
+**/
+UINTN
+EFIAPI
+BitFieldAndUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINTN                     AndData
+  );
+
+
+/**
+  Worker function that checks ASSERT condition for JumpBuffer
+
+  Checks ASSERT condition for JumpBuffer.
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+
+**/
+VOID
+EFIAPI
+InternalAssertJumpBuffer (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  );
+
+
+/**
+  Restores the CPU context that was saved with SetJump().
+
+  Restores the CPU context from the buffer specified by JumpBuffer.
+  This function never returns to the caller.
+  Instead is resumes execution based on the state of JumpBuffer.
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+  @param  Value         The value to return when the SetJump() context is restored.
+
+**/
+VOID
+EFIAPI
+InternalLongJump (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+  IN      UINTN                     Value
+  );
+
+
+/**
+  Check if a Unicode character is a decimal character.
+
+  This internal function checks if a Unicode character is a
+  decimal character. The valid decimal character is from
+  L'0' to L'9'.
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a decmial character.
+  @retval FALSE If the Char is not a decmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalIsDecimalDigitCharacter (
+  IN      CHAR16                    Char
+  );
+
+
+/**
+  Convert a Unicode character to upper case only if
+  it maps to a valid small-case ASCII character.
+
+  This internal function only deal with Unicode character
+  which maps to a valid small-case ASCII character, i.e.
+  L'a' to L'z'. For other Unicode character, the input character
+  is returned directly.
+
+  @param  Char  The character to convert.
+
+  @retval LowerCharacter   If the Char is with range L'a' to L'z'.
+  @retval Unchanged        Otherwise.
+
+**/
+CHAR16
+EFIAPI
+InternalCharToUpper (
+  IN      CHAR16                    Char
+  );
+
+
+/**
+  Convert a Unicode character to numerical value.
+
+  This internal function only deal with Unicode character
+  which maps to a valid hexadecimal ASII character, i.e.
+  L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
+  Unicode character, the value returned does not make sense.
+
+  @param  Char  The character to convert.
+
+  @return The numerical value converted.
+
+**/
+UINTN
+EFIAPI
+InternalHexCharToUintn (
+  IN      CHAR16                    Char
+  );
+
+
+/**
+  Check if a Unicode character is a hexadecimal character.
+
+  This internal function checks if a Unicode character is a
+  decimal character.  The valid hexadecimal character is
+  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
+
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a hexadecmial character.
+  @retval FALSE If the Char is not a hexadecmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalIsHexaDecimalDigitCharacter (
+  IN      CHAR16                    Char
+  );
+
+
+/**
+  Check if a ASCII character is a decimal character.
+
+  This internal function checks if a Unicode character is a
+  decimal character. The valid decimal character is from
+  '0' to '9'.
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a decmial character.
+  @retval FALSE If the Char is not a decmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalAsciiIsDecimalDigitCharacter (
+  IN      CHAR8                     Char
+  );
+
+
+/**
+  Converts a lowercase Ascii character to upper one.
+
+  If Chr is lowercase Ascii character, then converts it to upper one.
+
+  If Value >= 0xA0, then ASSERT().
+  If (Value & 0x0F) >= 0x0A, then ASSERT().
+
+  @param  Chr   one Ascii character
+
+  @return The uppercase value of Ascii character
+
+**/
+CHAR8
+EFIAPI
+InternalBaseLibAsciiToUpper (
+  IN      CHAR8                     Chr
+  );
+
+
+/**
+  Check if a ASCII character is a hexadecimal character.
+
+  This internal function checks if a ASCII character is a
+  decimal character.  The valid hexadecimal character is
+  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
+
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a hexadecmial character.
+  @retval FALSE If the Char is not a hexadecmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalAsciiIsHexaDecimalDigitCharacter (
+  IN      CHAR8                    Char
+  );
+
+
+/**
+  Convert a ASCII character to numerical value.
+
+  This internal function only deal with Unicode character
+  which maps to a valid hexadecimal ASII character, i.e.
+  '0' to '9', 'a' to 'f' or 'A' to 'F'. For other
+  ASCII character, the value returned does not make sense.
+
+  @param  Char  The character to convert.
+
+  @return The numerical value converted.
+
+**/
+UINTN
+EFIAPI
+InternalAsciiHexCharToUintn (
+  IN      CHAR8                    Char
+  );
+
+
+//
+// Ia32 and x64 specific functions
+//
+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and x64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadGdtr (
+  OUT     IA32_DESCRIPTOR           *Gdtr
+  );
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  );
+
+/**
+  Reads the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and x64.
+
+  @param  Idtr  The pointer to an IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  );
+
+/**
+  Writes the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Idtr  The pointer to an IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  );
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and x64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxSave (
+  OUT     IA32_FX_BUFFER            *Buffer
+  );
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and x64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxRestore (
+  IN      CONST IA32_FX_BUFFER      *Buffer
+  );
+
+/**
+  Enables the 32-bit paging mode on the CPU.
+
+  Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode. This function is
+  only available on IA-32. After the 32-bit paging mode is enabled, control is
+  transferred to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit protected mode with flat descriptors. This
+      means all descriptors must have a base of 0 and a limit of 4GB.
+  3)  CR0 and CR4 must be compatible with 32-bit protected mode with flat
+      descriptors.
+  4)  CR3 must point to valid page tables that will be used once the transition
+      is complete, and those page tables must guarantee that the pages for this
+      function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is enabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is enabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is enabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+InternalX86EnablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+/**
+  Disables the 32-bit paging mode on the CPU.
+
+  Disables the 32-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 32-paged protected
+  mode. This function is only available on IA-32. After the 32-bit paging mode
+  is disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be NULL. The function EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit paged mode.
+  3)  CR0, CR3, and CR4 must be compatible with 32-bit paged mode.
+  4)  CR3 must point to valid page tables that guarantee that the pages for
+      this function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is disabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is disabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is
+                      disabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+InternalX86DisablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+/**
+  Enables the 64-bit paging mode on the CPU.
+
+  Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode with flat
+  descriptors. This function is only available on IA-32. After the 64-bit
+  paging mode is enabled, control is transferred to the function specified by
+  EntryPoint using the new stack specified by NewStack and passing in the
+  parameters specified by Context1 and Context2. Context1 and Context2 are
+  optional and may be 0. The function EntryPoint must never return.
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for long mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is enabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is enabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is enabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+InternalX86EnablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT64                    EntryPoint,
+  IN      UINT64                    Context1,  OPTIONAL
+  IN      UINT64                    Context2,  OPTIONAL
+  IN      UINT64                    NewStack
+  );
+
+/**
+  Disables the 64-bit paging mode on the CPU.
+
+  Disables the 64-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 64-paging mode.
+  This function is only available on x64. After the 64-bit paging mode is
+  disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be 0. The function EntryPoint must never return.
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for 32-bit protected mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is disabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is disabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is disabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+InternalX86DisablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT32                    EntryPoint,
+  IN      UINT32                    Context1,  OPTIONAL
+  IN      UINT32                    Context2,  OPTIONAL
+  IN      UINT32                    NewStack
+  );
+
+/**
+  Generates a 16-bit random number through RDRAND instruction.
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+ **/
+BOOLEAN
+EFIAPI
+InternalX86RdRand16 (
+  OUT     UINT16                    *Rand
+  );
+
+/**
+  Generates a 32-bit random number through RDRAND instruction.
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+InternalX86RdRand32 (
+  OUT     UINT32                    *Rand
+  );
+
+/**
+  Generates a 64-bit random number through RDRAND instruction.
+
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+InternalX86RdRand64  (
+  OUT     UINT64                    *Rand
+  );
+
+
+#elif defined (MDE_CPU_IPF)
+//
+//
+// IPF specific functions
+//
+
+/**
+  Reads control register DCR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_DCR.
+
+  @return The 64-bit control register DCR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterDcr (
+  VOID
+  );
+
+
+/**
+  Reads control register ITM.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_ITM.
+
+  @return The 64-bit control register ITM.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterItm (
+  VOID
+  );
+
+
+/**
+  Reads control register IVA.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IVA.
+
+  @return The 64-bit control register IVA.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIva (
+  VOID
+  );
+
+
+/**
+  Reads control register PTA.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_PTA.
+
+  @return The 64-bit control register PTA.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterPta (
+  VOID
+  );
+
+
+/**
+  Reads control register IPSR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IPSR.
+
+  @return The 64-bit control register IPSR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIpsr (
+  VOID
+  );
+
+
+/**
+  Reads control register ISR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_ISR.
+
+  @return The 64-bit control register ISR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIsr (
+  VOID
+  );
+
+
+/**
+  Reads control register IIP.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IIP.
+
+  @return The 64-bit control register IIP.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIip (
+  VOID
+  );
+
+
+/**
+  Reads control register IFA.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IFA.
+
+  @return The 64-bit control register IFA.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIfa (
+  VOID
+  );
+
+
+/**
+  Reads control register ITIR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_ITIR.
+
+  @return The 64-bit control register ITIR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterItir (
+  VOID
+  );
+
+
+/**
+  Reads control register IIPA.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IIPA.
+
+  @return The 64-bit control register IIPA.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIipa (
+  VOID
+  );
+
+
+/**
+  Reads control register IFS.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IFS.
+
+  @return The 64-bit control register IFS.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIfs (
+  VOID
+  );
+
+
+/**
+  Reads control register IIM.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IIM.
+
+  @return The 64-bit control register IIM.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIim (
+  VOID
+  );
+
+
+/**
+  Reads control register IHA.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IHA.
+
+  @return The 64-bit control register IHA.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIha (
+  VOID
+  );
+
+
+/**
+  Reads control register LID.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_LID.
+
+  @return The 64-bit control register LID.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterLid (
+  VOID
+  );
+
+
+/**
+  Reads control register IVR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IVR.
+
+  @return The 64-bit control register IVR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIvr (
+  VOID
+  );
+
+
+/**
+  Reads control register TPR.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_TPR.
+
+  @return The 64-bit control register TPR.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterTpr (
+  VOID
+  );
+
+
+/**
+  Reads control register EOI.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_EOI.
+
+  @return The 64-bit control register EOI.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterEoi (
+  VOID
+  );
+
+
+/**
+  Reads control register IRR0.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IRR0.
+
+  @return The 64-bit control register IRR0.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIrr0 (
+  VOID
+  );
+
+
+/**
+  Reads control register IRR1.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IRR1.
+
+  @return The 64-bit control register IRR1.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIrr1 (
+  VOID
+  );
+
+
+/**
+  Reads control register IRR2.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IRR2.
+
+  @return The 64-bit control register IRR2.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIrr2 (
+  VOID
+  );
+
+
+/**
+  Reads control register IRR3.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_IRR3.
+
+  @return The 64-bit control register IRR3.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterIrr3 (
+  VOID
+  );
+
+
+/**
+  Reads control register ITV.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_ITV.
+
+  @return The 64-bit control register ITV.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterItv (
+  VOID
+  );
+
+
+/**
+  Reads control register PMV.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_PMV.
+
+  @return The 64-bit control register PMV.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterPmv (
+  VOID
+  );
+
+
+/**
+  Reads control register CMCV.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_CMCV.
+
+  @return The 64-bit control register CMCV.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterCmcv (
+  VOID
+  );
+
+
+/**
+  Reads control register LRR0.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_LRR0.
+
+  @return The 64-bit control register LRR0.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterLrr0 (
+  VOID
+  );
+
+
+/**
+  Reads control register LRR1.
+
+  This is a worker function for AsmReadControlRegister()
+  when its parameter Index is IPF_CONTROL_REGISTER_LRR1.
+
+  @return The 64-bit control register LRR1.
+
+**/
+UINT64
+EFIAPI
+AsmReadControlRegisterLrr1 (
+  VOID
+  );
+
+
+/**
+  Reads application register K0.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K0.
+
+  @return The 64-bit application register K0.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK0 (
+  VOID
+  );
+
+
+
+/**
+  Reads application register K1.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K1.
+
+  @return The 64-bit application register K1.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK1 (
+  VOID
+  );
+
+
+/**
+  Reads application register K2.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K2.
+
+  @return The 64-bit application register K2.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK2 (
+  VOID
+  );
+
+
+/**
+  Reads application register K3.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K3.
+
+  @return The 64-bit application register K3.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK3 (
+  VOID
+  );
+
+
+/**
+  Reads application register K4.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K4.
+
+  @return The 64-bit application register K4.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK4 (
+  VOID
+  );
+
+
+/**
+  Reads application register K5.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K5.
+
+  @return The 64-bit application register K5.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK5 (
+  VOID
+  );
+
+
+/**
+  Reads application register K6.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K6.
+
+  @return The 64-bit application register K6.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK6 (
+  VOID
+  );
+
+
+/**
+  Reads application register K7.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_K7.
+
+  @return The 64-bit application register K7.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterK7 (
+  VOID
+  );
+
+
+/**
+  Reads application register RSC.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_RSC.
+
+  @return The 64-bit application register RSC.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterRsc (
+  VOID
+  );
+
+
+/**
+  Reads application register BSP.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_BSP.
+
+  @return The 64-bit application register BSP.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterBsp (
+  VOID
+  );
+
+
+/**
+  Reads application register BSPSTORE.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_BSPSTORE.
+
+  @return The 64-bit application register BSPSTORE.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterBspstore (
+  VOID
+  );
+
+
+/**
+  Reads application register RNAT.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_RNAT.
+
+  @return The 64-bit application register RNAT.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterRnat (
+  VOID
+  );
+
+
+/**
+  Reads application register FCR.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_FCR.
+
+  @return The 64-bit application register FCR.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterFcr (
+  VOID
+  );
+
+
+/**
+  Reads application register EFLAG.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_EFLAG.
+
+  @return The 64-bit application register EFLAG.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterEflag (
+  VOID
+  );
+
+
+/**
+  Reads application register CSD.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_CSD.
+
+  @return The 64-bit application register CSD.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterCsd (
+  VOID
+  );
+
+
+/**
+  Reads application register SSD.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_SSD.
+
+  @return The 64-bit application register SSD.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterSsd (
+  VOID
+  );
+
+
+/**
+  Reads application register CFLG.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_CFLG.
+
+  @return The 64-bit application register CFLG.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterCflg (
+  VOID
+  );
+
+
+/**
+  Reads application register FSR.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_FSR.
+
+  @return The 64-bit application register FSR.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterFsr (
+  VOID
+  );
+
+
+/**
+  Reads application register FIR.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_FIR.
+
+  @return The 64-bit application register FIR.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterFir (
+  VOID
+  );
+
+
+/**
+  Reads application register FDR.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_FDR.
+
+  @return The 64-bit application register FDR.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterFdr (
+  VOID
+  );
+
+
+/**
+  Reads application register CCV.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_CCV.
+
+  @return The 64-bit application register CCV.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterCcv (
+  VOID
+  );
+
+
+/**
+  Reads application register UNAT.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_UNAT.
+
+  @return The 64-bit application register UNAT.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterUnat (
+  VOID
+  );
+
+
+/**
+  Reads application register FPSR.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_FPSR.
+
+  @return The 64-bit application register FPSR.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterFpsr (
+  VOID
+  );
+
+
+/**
+  Reads application register ITC.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_ITC.
+
+  @return The 64-bit application register ITC.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterItc (
+  VOID
+  );
+
+
+/**
+  Reads application register PFS.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_PFS.
+
+  @return The 64-bit application register PFS.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterPfs (
+  VOID
+  );
+
+
+/**
+  Reads application register LC.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_LC.
+
+  @return The 64-bit application register LC.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterLc (
+  VOID
+  );
+
+
+/**
+  Reads application register EC.
+
+  This is a worker function for AsmReadApplicationRegister()
+  when its parameter Index is IPF_APPLICATION_REGISTER_EC.
+
+  @return The 64-bit application register EC.
+
+**/
+UINT64
+EFIAPI
+AsmReadApplicationRegisterEc (
+  VOID
+  );
+
+
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  NewBsp      A pointer to the new memory location for RSE backing
+                      store.
+
+**/
+VOID
+EFIAPI
+AsmSwitchStackAndBackingStore (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VOID                      *NewBsp
+  );
+
+/**
+  Internal worker function to invalidate a range of instruction cache lines
+  in the cache coherency domain of the calling CPU.
+
+  Internal worker function to invalidate the instruction cache lines specified
+  by Address and Length. If Address is not aligned on a cache line boundary,
+  then entire instruction cache line containing Address is invalidated. If
+  Address + Length is not aligned on a cache line boundary, then the entire
+  instruction cache line containing Address + Length -1 is invalidated. This
+  function may choose to invalidate the entire instruction cache if that is more
+  efficient than invalidating the specified range. If Length is 0, the no instruction
+  cache lines are invalidated. Address is returned.
+  This function is only available on IPF.
+
+  @param  Address The base address of the instruction cache lines to
+                  invalidate. If the CPU is in a physical addressing mode, then
+                  Address is a physical address. If the CPU is in a virtual
+                  addressing mode, then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address
+
+**/
+VOID *
+EFIAPI
+InternalFlushCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  );
+
+#else
+
+#endif
+
+#endif
diff --git a/MdePkg/Library/BaseLib/BitField.c b/MdePkg/Library/BaseLib/BitField.c
new file mode 100644
index 000000000000..5a8ccff4e89d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/BitField.c
@@ -0,0 +1,922 @@
+/** @file
+  Bit field functions of BaseLib.
+
+  Copyright (c) 2006 - 2013, 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 "BaseLibInternals.h"
+
+/**
+  Worker function that returns a bit field from Operand.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+
+  @return The bit field read.
+
+**/
+UINTN
+EFIAPI
+InternalBaseLibBitFieldReadUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  //
+  // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
+  // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
+  //
+  return (Operand & ~((UINTN)-2 << EndBit)) >> StartBit;
+}
+
+/**
+  Worker function that reads a bit field from Operand, performs a bitwise OR,
+  and returns the result.
+
+  Performs a bitwise OR between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new value is returned.
+
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+  @param  OrData    The value to OR with the read value from the value.
+
+  @return The new value.
+
+**/
+UINTN
+EFIAPI
+InternalBaseLibBitFieldOrUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINTN                     OrData
+  )
+{
+  //
+  // Higher bits in OrData those are not used must be zero. 
+  //
+  // EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
+  // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
+  //
+  ASSERT ((OrData >> (EndBit - StartBit)) == ((OrData >> (EndBit - StartBit)) & 1));
+  
+  //
+  // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
+  // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
+  //
+  return Operand | ((OrData << StartBit) & ~((UINTN) -2 << EndBit));
+}
+
+/**
+  Worker function that reads a bit field from Operand, performs a bitwise AND,
+  and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new value is returned.
+
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+  @param  AndData    The value to And with the read value from the value.
+
+  @return The new value.
+
+**/
+UINTN
+EFIAPI
+InternalBaseLibBitFieldAndUint (
+  IN      UINTN                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINTN                     AndData
+  )
+{
+  //
+  // Higher bits in AndData those are not used must be zero. 
+  //
+  // EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
+  // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
+  //
+  ASSERT ((AndData >> (EndBit - StartBit)) == ((AndData >> (EndBit - StartBit)) & 1));
+
+  //
+  // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
+  // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
+  //
+  return Operand & ~((~AndData << StartBit) & ~((UINTN)-2 << EndBit));
+}
+
+/**
+  Returns a bit field from an 8-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The bit field read.
+
+**/
+UINT8
+EFIAPI
+BitFieldRead8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT (EndBit < 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT8)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an 8-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 8-bit value is
+  returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldWrite8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT (EndBit < 8);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldAndThenOr8 (Operand, StartBit, EndBit, 0, Value);
+}
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the value.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldOr8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT (EndBit < 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT8)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the value.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldAnd8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  ASSERT (EndBit < 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT8)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field from an 8-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 8-bit value is returned.
+
+  If 8-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 8-bit value.
+
+**/
+UINT8
+EFIAPI
+BitFieldAndThenOr8 (
+  IN      UINT8                     Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT (EndBit < 8);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldOr8 (
+           BitFieldAnd8 (Operand, StartBit, EndBit, AndData),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Returns a bit field from a 16-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The bit field read.
+
+**/
+UINT16
+EFIAPI
+BitFieldRead16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT (EndBit < 16);
+  ASSERT (StartBit <= EndBit);
+  return (UINT16)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a 16-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 16-bit value is
+  returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldWrite16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT (EndBit < 16);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldAndThenOr16 (Operand, StartBit, EndBit, 0, Value);
+}
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the value.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldOr16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT (EndBit < 16);
+  ASSERT (StartBit <= EndBit);
+  return (UINT16)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the value.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldAnd16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  ASSERT (EndBit < 16);
+  ASSERT (StartBit <= EndBit);
+  return (UINT16)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field from a 16-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 16-bit value is returned.
+
+  If 16-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 16-bit value.
+
+**/
+UINT16
+EFIAPI
+BitFieldAndThenOr16 (
+  IN      UINT16                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT (EndBit < 16);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldOr16 (
+           BitFieldAnd16 (Operand, StartBit, EndBit, AndData),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Returns a bit field from a 32-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The bit field read.
+
+**/
+UINT32
+EFIAPI
+BitFieldRead32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT (EndBit < 32);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a 32-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 32-bit value is
+  returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldWrite32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT (EndBit < 32);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldAndThenOr32 (Operand, StartBit, EndBit, 0, Value);
+}
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the value.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldOr32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT (EndBit < 32);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the value.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldAnd32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  ASSERT (EndBit < 32);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field from a 32-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 32-bit value is returned.
+
+  If 32-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 32-bit value.
+
+**/
+UINT32
+EFIAPI
+BitFieldAndThenOr32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT (EndBit < 32);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldOr32 (
+           BitFieldAnd32 (Operand, StartBit, EndBit, AndData),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Returns a bit field from a 64-bit value.
+
+  Returns the bitfield specified by the StartBit and the EndBit from Operand.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The bit field read.
+
+**/
+UINT64
+EFIAPI
+BitFieldRead64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT (EndBit < 64);
+  ASSERT (StartBit <= EndBit);
+  return RShiftU64 (Operand & ~LShiftU64 ((UINT64)-2, EndBit), StartBit);
+}
+
+/**
+  Writes a bit field to a 64-bit value, and returns the result.
+
+  Writes Value to the bit field specified by the StartBit and the EndBit in
+  Operand. All other bits in Operand are preserved. The new 64-bit value is
+  returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldWrite64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  ASSERT (EndBit < 64);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldAndThenOr64 (Operand, StartBit, EndBit, 0, Value);
+}
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise OR, and returns the
+  result.
+
+  Performs a bitwise OR between the bit field specified by StartBit
+  and EndBit in Operand and the value specified by OrData. All other bits in
+  Operand are preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the value
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldOr64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  UINT64  Value1;
+  UINT64  Value2;
+
+  ASSERT (EndBit < 64);
+  ASSERT (StartBit <= EndBit);
+  //
+  // Higher bits in OrData those are not used must be zero. 
+  //
+  // EndBit - StartBit + 1 might be 64 while the result right shifting 64 on RShiftU64() API is invalid,
+  // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
+  //
+  ASSERT (RShiftU64 (OrData, EndBit - StartBit) == (RShiftU64 (OrData, EndBit - StartBit) & 1));
+
+  Value1 = LShiftU64 (OrData, StartBit);
+  Value2 = LShiftU64 ((UINT64) - 2, EndBit);
+
+  return Operand | (Value1 & ~Value2);
+}
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise AND, and returns
+  the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData. All other bits in Operand are
+  preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the value.
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldAnd64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  UINT64  Value1;
+  UINT64  Value2;
+  
+  ASSERT (EndBit < 64);
+  ASSERT (StartBit <= EndBit);
+  //
+  // Higher bits in AndData those are not used must be zero. 
+  //
+  // EndBit - StartBit + 1 might be 64 while the right shifting 64 on RShiftU64() API is invalid,
+  // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
+  //
+  ASSERT (RShiftU64 (AndData, EndBit - StartBit) == (RShiftU64 (AndData, EndBit - StartBit) & 1));
+
+  Value1 = LShiftU64 (~AndData, StartBit);
+  Value2 = LShiftU64 ((UINT64)-2, EndBit);
+
+  return Operand & ~(Value1 & ~Value2);
+}
+
+/**
+  Reads a bit field from a 64-bit value, performs a bitwise AND followed by a
+  bitwise OR, and returns the result.
+
+  Performs a bitwise AND between the bit field specified by StartBit and EndBit
+  in Operand and the value specified by AndData, followed by a bitwise 
+  OR with value specified by OrData. All other bits in Operand are
+  preserved. The new 64-bit value is returned.
+
+  If 64-bit operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Operand   Operand on which to perform the bitfield operation.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the value.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The new 64-bit value.
+
+**/
+UINT64
+EFIAPI
+BitFieldAndThenOr64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  ASSERT (EndBit < 64);
+  ASSERT (StartBit <= EndBit);
+  return BitFieldOr64 (
+           BitFieldAnd64 (Operand, StartBit, EndBit, AndData),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
diff --git a/MdePkg/Library/BaseLib/CheckSum.c b/MdePkg/Library/BaseLib/CheckSum.c
new file mode 100644
index 000000000000..7b31d9a0729f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/CheckSum.c
@@ -0,0 +1,337 @@
+/** @file
+  Utility functions to generate checksum based on 2's complement
+  algorithm.
+
+  Copyright (c) 2007 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Returns the sum of all elements in a buffer in unit of UINT8.
+  During calculation, the carry bits are dropped.
+
+  This function calculates the sum of all elements in a buffer
+  in unit of UINT8. The carry bits in result of addition are dropped.
+  The result is returned as UINT8. If Length is Zero, then Zero is
+  returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT8
+EFIAPI
+CalculateSum8 (
+  IN      CONST UINT8              *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT8     Sum;
+  UINTN     Count;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
+
+  for (Sum = 0, Count = 0; Count < Length; Count++) {
+    Sum = (UINT8) (Sum + *(Buffer + Count));
+  }
+  
+  return Sum;
+}
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer
+  of 8-bit values.
+
+  This function first calculates the sum of the 8-bit values in the
+  buffer specified by Buffer and Length.  The carry bits in the result
+  of addition are dropped. Then, the two's complement of the sum is
+  returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The 2's complement checksum of Buffer.
+
+**/
+UINT8
+EFIAPI
+CalculateCheckSum8 (
+  IN      CONST UINT8              *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT8     CheckSum;
+
+  CheckSum = CalculateSum8 (Buffer, Length);
+
+  //
+  // Return the checksum based on 2's complement.
+  //
+  return (UINT8) (0x100 - CheckSum);
+}
+
+/**
+  Returns the sum of all elements in a buffer of 16-bit values.  During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 16-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 16-bit result is returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT16
+EFIAPI
+CalculateSum16 (
+  IN      CONST UINT16             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT16    Sum;
+  UINTN     Count;
+  UINTN     Total;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN) Buffer & 0x1) == 0);
+  ASSERT ((Length & 0x1) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
+
+  Total = Length / sizeof (*Buffer);
+  for (Sum = 0, Count = 0; Count < Total; Count++) {
+    Sum = (UINT16) (Sum + *(Buffer + Count));
+  }
+  
+  return Sum;
+}
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  16-bit values.
+
+  This function first calculates the sum of the 16-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The 2's complement checksum of Buffer.
+
+**/
+UINT16
+EFIAPI
+CalculateCheckSum16 (
+  IN      CONST UINT16             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT16     CheckSum;
+
+  CheckSum = CalculateSum16 (Buffer, Length);
+
+  //
+  // Return the checksum based on 2's complement.
+  //
+  return (UINT16) (0x10000 - CheckSum);
+}
+
+
+/**
+  Returns the sum of all elements in a buffer of 32-bit values. During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 32-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 32-bit result is returned. If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT32
+EFIAPI
+CalculateSum32 (
+  IN      CONST UINT32             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT32    Sum;
+  UINTN     Count;
+  UINTN     Total;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN) Buffer & 0x3) == 0);
+  ASSERT ((Length & 0x3) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
+
+  Total = Length / sizeof (*Buffer);
+  for (Sum = 0, Count = 0; Count < Total; Count++) {
+    Sum = Sum + *(Buffer + Count);
+  }
+  
+  return Sum;
+}
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  32-bit values.
+
+  This function first calculates the sum of the 32-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The 2's complement checksum of Buffer.
+
+**/
+UINT32
+EFIAPI
+CalculateCheckSum32 (
+  IN      CONST UINT32             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT32     CheckSum;
+
+  CheckSum = CalculateSum32 (Buffer, Length);
+
+  //
+  // Return the checksum based on 2's complement.
+  //
+  return (UINT32) ((UINT32)(-1) - CheckSum + 1);
+}
+
+
+/**
+  Returns the sum of all elements in a buffer of 64-bit values.  During
+  calculation, the carry bits are dropped.
+
+  This function calculates the sum of the 64-bit values in the buffer
+  specified by Buffer and Length. The carry bits in result of addition are dropped.
+  The 64-bit result is returned.  If Length is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the sum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Sum         The sum of Buffer with carry bits dropped during additions.
+
+**/
+UINT64
+EFIAPI
+CalculateSum64 (
+  IN      CONST UINT64             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT64    Sum;
+  UINTN     Count;
+  UINTN     Total;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN) Buffer & 0x7) == 0);
+  ASSERT ((Length & 0x7) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
+
+  Total = Length / sizeof (*Buffer);
+  for (Sum = 0, Count = 0; Count < Total; Count++) {
+    Sum = Sum + *(Buffer + Count);
+  }
+  
+  return Sum;
+}
+
+
+/**
+  Returns the two's complement checksum of all elements in a buffer of
+  64-bit values.
+
+  This function first calculates the sum of the 64-bit values in the buffer
+  specified by Buffer and Length.  The carry bits in the result of addition
+  are dropped. Then, the two's complement of the sum is returned.  If Length
+  is 0, then 0 is returned.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to carry out the checksum operation.
+  @param  Length      The size, in bytes, of Buffer.
+
+  @return Checksum    The 2's complement checksum of Buffer.
+
+**/
+UINT64
+EFIAPI
+CalculateCheckSum64 (
+  IN      CONST UINT64             *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  UINT64     CheckSum;
+
+  CheckSum = CalculateSum64 (Buffer, Length);
+
+  //
+  // Return the checksum based on 2's complement.
+  //
+  return (UINT64) ((UINT64)(-1) - CheckSum + 1);
+}
+
+
diff --git a/MdePkg/Library/BaseLib/ChkStkGcc.c b/MdePkg/Library/BaseLib/ChkStkGcc.c
new file mode 100644
index 000000000000..2f4e576fdd35
--- /dev/null
+++ b/MdePkg/Library/BaseLib/ChkStkGcc.c
@@ -0,0 +1,24 @@
+/** @file
+  Provides hack function for passng GCC build.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Hack function for passing GCC build.
+**/
+VOID 
+__chkstk() 
+{
+}
+
diff --git a/MdePkg/Library/BaseLib/Cpu.c b/MdePkg/Library/BaseLib/Cpu.c
new file mode 100644
index 000000000000..38bab1e2a5ba
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Cpu.c
@@ -0,0 +1,65 @@
+/** @file
+  Base Library CPU Functions for all architectures.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+
+/**
+  Disables CPU interrupts and returns the interrupt state prior to the disable
+  operation.
+
+  @retval TRUE  CPU interrupts were enabled on entry to this call.
+  @retval FALSE CPU interrupts were disabled on entry to this call.
+
+**/
+BOOLEAN
+EFIAPI
+SaveAndDisableInterrupts (
+  VOID
+  )
+{
+  BOOLEAN                           InterruptState;
+
+  InterruptState = GetInterruptState ();
+  DisableInterrupts ();
+  return InterruptState;
+}
+
+/**
+  Set the current CPU interrupt state.
+
+  Sets the current CPU interrupt state to the state specified by
+  InterruptState. If InterruptState is TRUE, then interrupts are enabled. If
+  InterruptState is FALSE, then interrupts are disabled. InterruptState is
+  returned.
+
+  @param  InterruptState  TRUE if interrupts should be enabled. FALSE if
+                          interrupts should be disabled.
+
+  @return InterruptState
+
+**/
+BOOLEAN
+EFIAPI
+SetInterruptState (
+  IN      BOOLEAN                   InterruptState
+  )
+{
+  if (InterruptState) {
+    EnableInterrupts ();
+  } else {
+    DisableInterrupts ();
+  }
+  return InterruptState;
+}
diff --git a/MdePkg/Library/BaseLib/CpuDeadLoop.c b/MdePkg/Library/BaseLib/CpuDeadLoop.c
new file mode 100644
index 000000000000..21c6f39e7cba
--- /dev/null
+++ b/MdePkg/Library/BaseLib/CpuDeadLoop.c
@@ -0,0 +1,38 @@
+/** @file
+  Base Library CPU Functions for all architectures.
+
+  Copyright (c) 2006 - 2008, 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 <Base.h>
+#include <Library/BaseLib.h>
+
+/**
+  Executes an infinite loop.
+
+  Forces the CPU to execute an infinite loop. A debugger may be used to skip
+  past the loop and the code that follows the loop must execute properly. This
+  implies that the infinite loop must not cause the code that follow it to be
+  optimized away.
+
+**/
+VOID
+EFIAPI
+CpuDeadLoop (
+  VOID
+  )
+{
+  volatile UINTN  Index;
+
+  for (Index = 0; Index == 0;);
+}
diff --git a/MdePkg/Library/BaseLib/DivS64x64Remainder.c b/MdePkg/Library/BaseLib/DivS64x64Remainder.c
new file mode 100644
index 000000000000..a93d73476452
--- /dev/null
+++ b/MdePkg/Library/BaseLib/DivS64x64Remainder.c
@@ -0,0 +1,53 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Divides a 64-bit signed integer by a 64-bit signed integer and generates a
+  64-bit signed result and a optional 64-bit signed remainder.
+
+  This function divides the 64-bit signed value Dividend by the 64-bit signed
+  value Divisor and generates a 64-bit signed quotient. If Remainder is not
+  NULL, then the 64-bit signed remainder is returned in Remainder. This
+  function returns the 64-bit signed quotient.
+
+  It is the caller's responsibility to not call this function with a Divisor of 0.
+  If Divisor is 0, then the quotient and remainder should be assumed to be 
+  the largest negative integer.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit signed value.
+  @param  Divisor   A 64-bit signed value.
+  @param  Remainder A pointer to a 64-bit signed value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+INT64
+EFIAPI
+DivS64x64Remainder (
+  IN      INT64                     Dividend,
+  IN      INT64                     Divisor,
+  OUT     INT64                     *Remainder  OPTIONAL
+  )
+{
+  ASSERT (Divisor != 0);
+  return InternalMathDivRemS64x64 (Dividend, Divisor, Remainder);
+}
diff --git a/MdePkg/Library/BaseLib/DivU64x32.c b/MdePkg/Library/BaseLib/DivU64x32.c
new file mode 100644
index 000000000000..501addabb856
--- /dev/null
+++ b/MdePkg/Library/BaseLib/DivU64x32.c
@@ -0,0 +1,45 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 64-bit unsigned result.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. This
+  function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+DivU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  ASSERT (Divisor != 0);
+  return InternalMathDivU64x32 (Dividend, Divisor);
+}
diff --git a/MdePkg/Library/BaseLib/DivU64x32Remainder.c b/MdePkg/Library/BaseLib/DivU64x32Remainder.c
new file mode 100644
index 000000000000..e18a0a2fdf1c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/DivU64x32Remainder.c
@@ -0,0 +1,49 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 64-bit unsigned result and an optional 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+DivU64x32Remainder (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor,
+  OUT     UINT32                    *Remainder  OPTIONAL
+  )
+{
+  ASSERT (Divisor != 0);
+  return InternalMathDivRemU64x32 (Dividend, Divisor, Remainder);
+}
diff --git a/MdePkg/Library/BaseLib/DivU64x64Remainder.c b/MdePkg/Library/BaseLib/DivU64x64Remainder.c
new file mode 100644
index 000000000000..13509b832905
--- /dev/null
+++ b/MdePkg/Library/BaseLib/DivU64x64Remainder.c
@@ -0,0 +1,49 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Divides a 64-bit unsigned integer by a 64-bit unsigned integer and generates
+  a 64-bit unsigned result and an optional 64-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 64-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 64-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 64-bit unsigned value.
+  @param  Remainder A pointer to a 64-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+DivU64x64Remainder (
+  IN      UINT64                    Dividend,
+  IN      UINT64                    Divisor,
+  OUT     UINT64                    *Remainder  OPTIONAL
+  )
+{
+  ASSERT (Divisor != 0);
+  return InternalMathDivRemU64x64 (Dividend, Divisor, Remainder);
+}
diff --git a/MdePkg/Library/BaseLib/Ebc/CpuBreakpoint.c b/MdePkg/Library/BaseLib/Ebc/CpuBreakpoint.c
new file mode 100644
index 000000000000..4f33bd856d52
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ebc/CpuBreakpoint.c
@@ -0,0 +1,129 @@
+/** @file
+  Base Library CPU Functions for EBC
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+extern
+UINT64
+_break (
+  CHAR8 BreakCode
+  );
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  _break (3);
+}
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+}
+
+/**
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Retrieves the current CPU interrupt state.
+
+  Returns TRUE means interrupts are currently enabled. Otherwise,
+  returns FALSE.
+
+  @retval TRUE  CPU interrupts are enabled.
+  @retval FALSE CPU interrupts are disabled.
+
+**/
+BOOLEAN
+EFIAPI
+GetInterruptState (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+  return FALSE;
+}
+
+/**
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+**/
+VOID
+EFIAPI
+EnableDisableInterrupts (
+  VOID
+  )
+{
+  EnableInterrupts ();
+  DisableInterrupts ();
+}
+
+/**
+  Requests CPU to pause for a short period of time.
+
+  Requests CPU to pause for a short period of time. Typically used in MP
+  systems to prevent memory starvation while waiting for a spin lock.
+
+**/
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+{
+}
+
diff --git a/MdePkg/Library/BaseLib/Ebc/SetJumpLongJump.c b/MdePkg/Library/BaseLib/Ebc/SetJumpLongJump.c
new file mode 100644
index 000000000000..0d6583d95690
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ebc/SetJumpLongJump.c
@@ -0,0 +1,67 @@
+/** @file
+  Implementation of SetJump() and LongJump() on EBC.
+
+  SetJump() and LongJump() are not currently supported for the EBC processor type.
+  Implementation for EBC just returns 0 for SetJump(), and ASSERT() for LongJump().
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Saves the current CPU context that can be restored with a call to LongJump() and returns 0.
+
+  Saves the current CPU context in the buffer specified by JumpBuffer and returns 0.  The initial
+  call to SetJump() must always return 0.  Subsequent calls to LongJump() cause a non-zero
+  value to be returned by SetJump().
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+
+  @retval 0 Indicates a return from SetJump().
+
+**/
+UINTN
+EFIAPI
+SetJump (
+  OUT      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  )
+{
+  InternalAssertJumpBuffer (JumpBuffer);
+  return 0;
+}
+
+/**
+  Restores the CPU context that was saved with SetJump().
+
+  Restores the CPU context from the buffer specified by JumpBuffer.
+  This function never returns to the caller.
+  Instead it resumes execution based on the state of JumpBuffer.
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+  @param  Value         The value to return when the SetJump() context is restored.
+
+**/
+VOID
+EFIAPI
+InternalLongJump (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+  IN      UINTN                     Value
+  )
+{
+  //
+  // This function cannot work on EBC
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/BaseLib/Ebc/SwitchStack.c b/MdePkg/Library/BaseLib/Ebc/SwitchStack.c
new file mode 100644
index 000000000000..c90b07a285dc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ebc/SwitchStack.c
@@ -0,0 +1,58 @@
+/** @file
+  Switch Stack functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.
+  Marker will be ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  Marker      A VA_LIST marker for the variable argument list.
+
+**/
+VOID
+EFIAPI
+InternalSwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VA_LIST                   Marker
+  )
+
+{
+  //
+  // This version of this function does not actually change the stack pointer
+  // This is to support compilation of CPU types that do not support assemblers
+  // such as EBC
+  //
+  EntryPoint (Context1, Context2);
+}
diff --git a/MdePkg/Library/BaseLib/FilePaths.c b/MdePkg/Library/BaseLib/FilePaths.c
new file mode 100644
index 000000000000..53e986021255
--- /dev/null
+++ b/MdePkg/Library/BaseLib/FilePaths.c
@@ -0,0 +1,118 @@
+/** @file
+  Defines file-path manipulation functions.
+
+  Copyright (c) 2011 - 2016, 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  <Library/BaseMemoryLib.h>
+#include  <Library/BaseLib.h>
+
+/**
+  Removes the last directory or file entry in a path. For a path which is
+  like L"fs0:startup.nsh", it's converted to L"fs0:".
+
+  @param[in,out] Path     A pointer to the path to modify.
+
+  @retval FALSE     Nothing was found to remove.
+  @retval TRUE      A directory or file was removed.
+**/
+BOOLEAN
+EFIAPI
+PathRemoveLastItem(
+  IN OUT CHAR16 *Path
+  )
+{
+  CHAR16        *Walker;
+  CHAR16        *LastSlash;
+  //
+  // get directory name from path... ('chop' off extra)
+  //
+  for ( Walker = Path, LastSlash = NULL
+      ; Walker != NULL && *Walker != CHAR_NULL
+      ; Walker++
+     ){
+    if (*Walker == L'\\' && *(Walker + 1) != CHAR_NULL) {
+      LastSlash = Walker+1;
+    } else if (*Walker == L':' && *(Walker + 1) != L'\\' && *(Walker + 1) != CHAR_NULL) {
+      LastSlash = Walker+1;
+    }
+  }
+  if (LastSlash != NULL) {
+    *LastSlash = CHAR_NULL;
+    return (TRUE);
+  }
+  return (FALSE);
+}
+
+/**
+  Function to clean up paths.
+
+  - Single periods in the path are removed.
+  - Double periods in the path are removed along with a single parent directory.
+  - Forward slashes L'/' are converted to backward slashes L'\'.
+
+  This will be done inline and the existing buffer may be larger than required
+  upon completion.
+
+  @param[in] Path       The pointer to the string containing the path.
+
+  @return       Returns Path, otherwise returns NULL to indicate that an error has occured.
+**/
+CHAR16*
+EFIAPI
+PathCleanUpDirectories(
+  IN CHAR16 *Path
+)
+{
+  CHAR16  *TempString;
+
+  if (Path == NULL) {
+    return NULL;
+  }
+
+  //
+  // Replace the '/' with '\'
+  //
+  for (TempString = Path; *TempString != CHAR_NULL; TempString++) {
+    if (*TempString == L'/') {
+      *TempString = L'\\';
+    }
+  }
+
+  //
+  // Remove all the "\.". E.g.: fs0:\abc\.\def\.
+  //
+  while ((TempString = StrStr (Path, L"\\.\\")) != NULL) {
+    CopyMem (TempString, TempString + 2, StrSize (TempString + 2));
+  }
+  if (StrCmp (Path + StrLen (Path) - 2, L"\\.") == 0) {
+    Path[StrLen (Path) - 1] = CHAR_NULL;
+  }
+
+  //
+  // Remove all the "\..". E.g.: fs0:\abc\..\def\..
+  //
+  while (((TempString = StrStr(Path, L"\\..")) != NULL) &&
+         ((*(TempString + 3) == L'\\') || (*(TempString + 3) == CHAR_NULL))
+        ) {
+    *(TempString + 1) = CHAR_NULL;
+    PathRemoveLastItem(Path);
+    CopyMem (Path + StrLen (Path), TempString + 3, StrSize (TempString + 3));
+  }
+
+  //
+  // Replace the "\\" with "\"
+  //
+  while ((TempString = StrStr (Path, L"\\\\")) != NULL) {
+    CopyMem (TempString, TempString + 1, StrSize (TempString + 1));
+  }
+
+  return Path;
+}
+
diff --git a/MdePkg/Library/BaseLib/GetPowerOfTwo32.c b/MdePkg/Library/BaseLib/GetPowerOfTwo32.c
new file mode 100644
index 000000000000..67b64d696c28
--- /dev/null
+++ b/MdePkg/Library/BaseLib/GetPowerOfTwo32.c
@@ -0,0 +1,44 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Returns the value of the highest bit set in a 32-bit value. Equivalent to
+  1 << log2(x).
+
+  This function computes the value of the highest bit set in the 32-bit value
+  specified by Operand. If Operand is zero, then zero is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @return 1 << HighBitSet32(Operand)
+  @retval 0 Operand is zero.
+
+**/
+UINT32
+EFIAPI
+GetPowerOfTwo32 (
+  IN      UINT32                    Operand
+  )
+{
+  if (0 == Operand) {
+    return 0;
+  }
+
+  return 1ul << HighBitSet32 (Operand);
+}
diff --git a/MdePkg/Library/BaseLib/GetPowerOfTwo64.c b/MdePkg/Library/BaseLib/GetPowerOfTwo64.c
new file mode 100644
index 000000000000..021b30e764b9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/GetPowerOfTwo64.c
@@ -0,0 +1,44 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Returns the value of the highest bit set in a 64-bit value. Equivalent to
+  1 << log2(x).
+
+  This function computes the value of the highest bit set in the 64-bit value
+  specified by Operand. If Operand is zero, then zero is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @return 1 << HighBitSet64(Operand)
+  @retval 0 Operand is zero.
+
+**/
+UINT64
+EFIAPI
+GetPowerOfTwo64 (
+  IN      UINT64                    Operand
+  )
+{
+  if (Operand == 0) {
+    return 0;
+  }
+
+  return LShiftU64 (1, (UINTN) HighBitSet64 (Operand));
+}
diff --git a/MdePkg/Library/BaseLib/HighBitSet32.c b/MdePkg/Library/BaseLib/HighBitSet32.c
new file mode 100644
index 000000000000..7d7339808b18
--- /dev/null
+++ b/MdePkg/Library/BaseLib/HighBitSet32.c
@@ -0,0 +1,47 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Returns the bit position of the highest bit set in a 32-bit value. Equivalent
+  to log2(x).
+
+  This function computes the bit position of the highest bit set in the 32-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 31 is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @retval 0..31  Position of the highest bit set in Operand if found.
+  @retval -1     Operand is zero.
+
+**/
+INTN
+EFIAPI
+HighBitSet32 (
+  IN      UINT32                    Operand
+  )
+{
+  INTN                              BitIndex;
+
+  if (Operand == 0) {
+    return - 1;
+  }
+  for (BitIndex = 31; (INT32)Operand > 0; BitIndex--, Operand <<= 1);
+  return BitIndex;
+}
diff --git a/MdePkg/Library/BaseLib/HighBitSet64.c b/MdePkg/Library/BaseLib/HighBitSet64.c
new file mode 100644
index 000000000000..4fc96fd0e89d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/HighBitSet64.c
@@ -0,0 +1,55 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Returns the bit position of the highest bit set in a 64-bit value. Equivalent
+  to log2(x).
+
+  This function computes the bit position of the highest bit set in the 64-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 63 is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @retval 0..63   Position of the highest bit set in Operand if found.
+  @retval -1      Operand is zero.
+
+**/
+INTN
+EFIAPI
+HighBitSet64 (
+  IN      UINT64                    Operand
+  )
+{
+  if (Operand == (UINT32)Operand) {
+    //
+    // Operand is just a 32-bit integer
+    //
+    return HighBitSet32 ((UINT32)Operand);
+  }
+
+  //
+  // Operand is really a 64-bit integer
+  //
+  if (sizeof (UINTN) == sizeof (UINT32)) {
+    return HighBitSet32 (((UINT32*)&Operand)[1]) + 32;
+  } else {
+    return HighBitSet32 ((UINT32)RShiftU64 (Operand, 32)) + 32;
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/ARShiftU64.S b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.S
new file mode 100644
index 000000000000..32f84199c967
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   ARShiftU64.S
+#
+# Abstract:
+#
+#   64-bit arithmetic right shift function for IA-32
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathARShiftU64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathARShiftU64 (
+#   IN      UINT64                    Operand,
+#   IN      UINTN                     Count
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathARShiftU64):
+    movb    12(%esp), %cl
+    movl    8(%esp), %eax
+    cltd
+    testb   $32, %cl
+    jnz     L0
+    movl    %eax, %edx
+    movl    4(%esp), %eax
+L0:    
+    shrdl   %cl, %edx, %eax
+    sar     %cl, %edx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/ARShiftU64.asm b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.asm
new file mode 100644
index 000000000000..478c184a6ef9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ARShiftU64.asm
+;
+; Abstract:
+;
+;   64-bit arithmetic right shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathARShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+InternalMathARShiftU64  PROC
+    mov     cl, [esp + 12]
+    mov     eax, [esp + 8]
+    cdq
+    test    cl, 32
+    jnz     @F
+    mov     edx, eax
+    mov     eax, [esp + 4]
+@@:    
+    shrd    eax, edx, cl
+    sar     edx, cl
+    ret
+InternalMathARShiftU64  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ARShiftU64.c b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.c
new file mode 100644
index 000000000000..c2ebaeb33b4b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.c
@@ -0,0 +1,51 @@
+/** @file
+  64-bit arithmetic right shift function for IA-32.
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits
+  are filled with original integer's bit 63. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to bit 63 of Operand.  The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand arithmetically shifted right by Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathARShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  _asm {
+    mov     cl, byte ptr [Count]
+    mov     eax, dword ptr [Operand + 4]
+    cdq
+    test    cl, 32
+    jnz     L0
+    mov     edx, eax
+    mov     eax, dword ptr [Operand + 0]
+L0:
+    shrd    eax, edx, cl
+    sar     edx, cl
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ARShiftU64.nasm b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.nasm
new file mode 100644
index 000000000000..448e3ab8d230
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ARShiftU64.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ARShiftU64.nasm
+;
+; Abstract:
+;
+;   64-bit arithmetic right shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathARShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathARShiftU64)
+ASM_PFX(InternalMathARShiftU64):
+    mov     cl, [esp + 12]
+    mov     eax, [esp + 8]
+    cdq
+    test    cl, 32
+    jnz     .0
+    mov     edx, eax
+    mov     eax, [esp + 4]
+.0:
+    shrd    eax, edx, cl
+    sar     edx, cl
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.asm b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.asm
new file mode 100644
index 000000000000..f4ce3f90b106
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   CpuBreakpoint.Asm
+;
+; Abstract:
+;
+;   CpuBreakpoint function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuBreakpoint (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuBreakpoint   PROC
+    int  3
+    ret
+CpuBreakpoint   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.c b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.c
new file mode 100644
index 000000000000..23a773a04384
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.c
@@ -0,0 +1,41 @@
+/** @file
+  CpuBreakpoint function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+void __debugbreak ();
+
+#pragma intrinsic(__debugbreak)
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __debugbreak ();
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.nasm b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.nasm
new file mode 100644
index 000000000000..4f91895e7b05
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuBreakpoint.nasm
@@ -0,0 +1,36 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   CpuBreakpoint.Asm
+;
+; Abstract:
+;
+;   CpuBreakpoint function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuBreakpoint (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuBreakpoint)
+ASM_PFX(CpuBreakpoint):
+    int  3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuId.S b/MdePkg/Library/BaseLib/Ia32/CpuId.S
new file mode 100644
index 000000000000..6f9e10c8f3ca
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuId.S
@@ -0,0 +1,63 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuId.S
+#
+# Abstract:
+#
+#   AsmCpuid function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL  ASM_PFX(AsmCpuid)
+
+#------------------------------------------------------------------------------
+#  VOID
+#  EFIAPI
+#  AsmCpuid (
+#    IN   UINT32  RegisterInEax,
+#    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(AsmCpuid):
+    push    %ebx
+    push    %ebp
+    movl    %esp, %ebp
+    movl    12(%ebp), %eax
+    cpuid
+    push    %ecx
+    movl    16(%ebp), %ecx
+    jecxz   L1
+    movl    %eax, (%ecx)
+L1:
+    movl    20(%ebp), %ecx
+    jecxz   L2
+    movl    %ebx, (%ecx)
+L2:
+    movl    24(%ebp), %ecx
+    jecxz   L3
+    popl    (%ecx)
+L3:
+    movl    28(%ebp), %ecx
+    jecxz   L4
+    movl    %edx, (%ecx)
+L4:
+    movl    12(%ebp), %eax
+    leave
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuId.asm b/MdePkg/Library/BaseLib/Ia32/CpuId.asm
new file mode 100644
index 000000000000..e2f9d0b1466f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuId.asm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586P
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  AsmCpuid (
+;    IN   UINT32  RegisterInEax,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    );
+;------------------------------------------------------------------------------
+AsmCpuid    PROC    USES    ebx
+    push    ebp
+    mov     ebp, esp
+    mov     eax, [ebp + 12]
+    cpuid
+    push    ecx
+    mov     ecx, [ebp + 16]
+    jecxz   @F
+    mov     [ecx], eax
+@@:
+    mov     ecx, [ebp + 20]
+    jecxz   @F
+    mov     [ecx], ebx
+@@:
+    mov     ecx, [ebp + 24]
+    jecxz   @F
+    pop     DWORD [ecx]
+@@:
+    mov     ecx, [ebp + 28]
+    jecxz   @F
+    mov     [ecx], edx
+@@:
+    mov     eax, [ebp + 12]
+    leave
+    ret
+AsmCpuid    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuId.c b/MdePkg/Library/BaseLib/Ia32/CpuId.c
new file mode 100644
index 000000000000..d9c72662e62c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuId.c
@@ -0,0 +1,74 @@
+/** @file
+  AsmCpuid function.
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+/**
+  Retrieves CPUID information.
+
+  Executes the CPUID instruction with EAX set to the value specified by Index.
+  This function always returns Index.
+  If Eax is not NULL, then the value of EAX after CPUID is returned in Eax.
+  If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx.
+  If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx.
+  If Edx is not NULL, then the value of EDX after CPUID is returned in Edx.
+  This function is only available on IA-32 and x64.
+
+  @param  Index         The 32-bit value to load into EAX prior to invoking the CPUID
+                        instruction.
+  @param  RegisterEax   A pointer to the 32-bit EAX value returned by the CPUID
+                        instruction. This is an optional parameter that may be NULL.
+  @param  RegisterEbx   A pointer to the 32-bit EBX value returned by the CPUID
+                        instruction. This is an optional parameter that may be NULL.
+  @param  RegisterEcx   A pointer to the 32-bit ECX value returned by the CPUID
+                        instruction. This is an optional parameter that may be NULL.
+  @param  RegisterEdx   A pointer to the 32-bit EDX value returned by the CPUID
+                        instruction. This is an optional parameter that may be NULL.
+
+  @return Index.
+
+**/
+UINT32
+EFIAPI
+AsmCpuid (
+  IN      UINT32                    Index,
+  OUT     UINT32                    *RegisterEax,  OPTIONAL
+  OUT     UINT32                    *RegisterEbx,  OPTIONAL
+  OUT     UINT32                    *RegisterEcx,  OPTIONAL
+  OUT     UINT32                    *RegisterEdx   OPTIONAL
+  )
+{
+  _asm {
+    mov     eax, Index
+    cpuid
+    push    ecx
+    mov     ecx, RegisterEax
+    jecxz   SkipEax
+    mov     [ecx], eax
+SkipEax:
+    mov     ecx, RegisterEbx
+    jecxz   SkipEbx
+    mov     [ecx], ebx
+SkipEbx:
+    pop     eax
+    mov     ecx, RegisterEcx
+    jecxz   SkipEcx
+    mov     [ecx], eax
+SkipEcx:
+    mov     ecx, RegisterEdx
+    jecxz   SkipEdx
+    mov     [ecx], edx
+SkipEdx:
+    mov     eax, Index
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuId.nasm b/MdePkg/Library/BaseLib/Ia32/CpuId.nasm
new file mode 100644
index 000000000000..5996b9263289
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuId.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  AsmCpuid (
+;    IN   UINT32  RegisterInEax,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmCpuid)
+ASM_PFX(AsmCpuid):
+    push    ebx
+    push    ebp
+    mov     ebp, esp
+    mov     eax, [ebp + 12]
+    cpuid
+    push    ecx
+    mov     ecx, [ebp + 16]
+    jecxz   .0
+    mov     [ecx], eax
+.0:
+    mov     ecx, [ebp + 20]
+    jecxz   .1
+    mov     [ecx], ebx
+.1:
+    mov     ecx, [ebp + 24]
+    jecxz   .2
+    pop     DWORD [ecx]
+.2:
+    mov     ecx, [ebp + 28]
+    jecxz   .3
+    mov     [ecx], edx
+.3:
+    mov     eax, [ebp + 12]
+    leave
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.S b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.S
new file mode 100644
index 000000000000..edcaa89b5141
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.S
@@ -0,0 +1,67 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2012, 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.
+#
+# Module Name:
+#
+#   CpuIdEx.S
+#
+# Abstract:
+#
+#   AsmCpuidEx function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+    .code:
+
+#------------------------------------------------------------------------------
+#  UINT32
+#  EFIAPI
+#  AsmCpuidEx (
+#    IN   UINT32  RegisterInEax,
+#    IN   UINT32  RegisterInEcx,
+#    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmCpuidEx)
+ASM_PFX(AsmCpuidEx):
+    push    %ebx
+    push    %ebp
+    movl    %esp, %ebp
+    movl    12(%ebp), %eax
+    movl    16(%ebp), %ecx
+    cpuid
+    push    %ecx
+    movl    20(%ebp), %ecx
+    jecxz   L1
+    movl    %eax, (%ecx)
+L1:
+    movl    24(%ebp), %ecx
+    jecxz   L2
+    movl    %ebx, (%ecx)
+L2:
+    movl    32(%ebp), %ecx
+    jecxz   L3
+    movl    %edx, (%ecx)
+L3:
+    movl    28(%ebp), %ecx
+    jecxz   L4
+    popl    (%ecx)
+L4:
+    movl    12(%ebp), %eax
+    leave
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm
new file mode 100644
index 000000000000..1b2ccb58b047
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm
@@ -0,0 +1,68 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   CpuIdEx.Asm
+;
+; Abstract:
+;
+;   AsmCpuidEx function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  UINT32
+;  EFIAPI
+;  AsmCpuidEx (
+;    IN   UINT32  RegisterInEax,
+;    IN   UINT32  RegisterInEcx,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+AsmCpuidEx  PROC    USES    ebx
+    push    ebp
+    mov     ebp, esp
+    mov     eax, [ebp + 12]
+    mov     ecx, [ebp + 16]
+    cpuid
+    push    ecx
+    mov     ecx, [ebp + 20]
+    jecxz   @F
+    mov     [ecx], eax
+@@:
+    mov     ecx, [ebp + 24]
+    jecxz   @F
+    mov     [ecx], ebx
+@@:
+    mov     ecx, [ebp + 32]
+    jecxz   @F
+    mov     [ecx], edx
+@@:
+    mov     ecx, [ebp + 28]
+    jecxz   @F
+    pop     DWORD [ecx]
+@@:
+    mov     eax, [ebp + 12]
+    leave
+    ret
+AsmCpuidEx  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.c b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.c
new file mode 100644
index 000000000000..1b3d91dcaa4f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.c
@@ -0,0 +1,82 @@
+/** @file
+  AsmCpuidEx function.
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+/**
+  Retrieves CPUID information using an extended leaf identifier.
+
+  Executes the CPUID instruction with EAX set to the value specified by Index
+  and ECX set to the value specified by SubIndex. This function always returns
+  Index. This function is only available on IA-32 and x64.
+
+  If Eax is not NULL, then the value of EAX after CPUID is returned in Eax.
+  If Ebx is not NULL, then the value of EBX after CPUID is returned in Ebx.
+  If Ecx is not NULL, then the value of ECX after CPUID is returned in Ecx.
+  If Edx is not NULL, then the value of EDX after CPUID is returned in Edx.
+
+  @param  Index         The 32-bit value to load into EAX prior to invoking the
+                        CPUID instruction.
+  @param  SubIndex      The 32-bit value to load into ECX prior to invoking the
+                        CPUID instruction.
+  @param  RegisterEax   A pointer to the 32-bit EAX value returned by the CPUID
+                        instruction. This is an optional parameter that may be
+                        NULL.
+  @param  RegisterEbx   A pointer to the 32-bit EBX value returned by the CPUID
+                        instruction. This is an optional parameter that may be
+                        NULL.
+  @param  RegisterEcx   A pointer to the 32-bit ECX value returned by the CPUID
+                        instruction. This is an optional parameter that may be
+                        NULL.
+  @param  RegisterEdx   A pointer to the 32-bit EDX value returned by the CPUID
+                        instruction. This is an optional parameter that may be
+                        NULL.
+
+  @return Index.
+
+**/
+UINT32
+EFIAPI
+AsmCpuidEx (
+  IN      UINT32                    Index,
+  IN      UINT32                    SubIndex,
+  OUT     UINT32                    *RegisterEax,  OPTIONAL
+  OUT     UINT32                    *RegisterEbx,  OPTIONAL
+  OUT     UINT32                    *RegisterEcx,  OPTIONAL
+  OUT     UINT32                    *RegisterEdx   OPTIONAL
+  )
+{
+  _asm {
+    mov     eax, Index
+    mov     ecx, SubIndex
+    cpuid
+    push    ecx
+    mov     ecx, RegisterEax
+    jecxz   SkipEax
+    mov     [ecx], eax
+SkipEax:
+    mov     ecx, RegisterEbx
+    jecxz   SkipEbx
+    mov     [ecx], ebx
+SkipEbx:
+    pop     eax
+    mov     ecx, RegisterEcx
+    jecxz   SkipEcx
+    mov     [ecx], eax
+SkipEcx:
+    mov     ecx, RegisterEdx
+    jecxz   SkipEdx
+    mov     [ecx], edx
+SkipEdx:
+    mov     eax, Index
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.nasm b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.nasm
new file mode 100644
index 000000000000..e3d16ec109f2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.nasm
@@ -0,0 +1,67 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   CpuIdEx.Asm
+;
+; Abstract:
+;
+;   AsmCpuidEx function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  UINT32
+;  EFIAPI
+;  AsmCpuidEx (
+;    IN   UINT32  RegisterInEax,
+;    IN   UINT32  RegisterInEcx,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmCpuidEx)
+ASM_PFX(AsmCpuidEx):
+    push    ebx
+    push    ebp
+    mov     ebp, esp
+    mov     eax, [ebp + 12]
+    mov     ecx, [ebp + 16]
+    cpuid
+    push    ecx
+    mov     ecx, [ebp + 20]
+    jecxz   .0
+    mov     [ecx], eax
+.0:
+    mov     ecx, [ebp + 24]
+    jecxz   .1
+    mov     [ecx], ebx
+.1:
+    mov     ecx, [ebp + 32]
+    jecxz   .2
+    mov     [ecx], edx
+.2:
+    mov     ecx, [ebp + 28]
+    jecxz   .3
+    pop     DWORD [ecx]
+.3:
+    mov     eax, [ebp + 12]
+    leave
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuPause.asm b/MdePkg/Library/BaseLib/Ia32/CpuPause.asm
new file mode 100644
index 000000000000..14ff32286b2a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuPause.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuPause.Asm
+;
+; Abstract:
+;
+;   CpuPause function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuPause (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuPause    PROC
+    pause
+    ret
+CpuPause    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuPause.c b/MdePkg/Library/BaseLib/Ia32/CpuPause.c
new file mode 100644
index 000000000000..e3094e228d88
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuPause.c
@@ -0,0 +1,35 @@
+/** @file
+  CpuPause function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Requests CPU to pause for a short period of time.
+
+  Requests CPU to pause for a short period of time. Typically used in MP
+  systems to prevent memory starvation while waiting for a spin lock.
+
+**/
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+{
+  _asm {
+    pause
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/CpuPause.nasm b/MdePkg/Library/BaseLib/Ia32/CpuPause.nasm
new file mode 100644
index 000000000000..fb92687669fa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/CpuPause.nasm
@@ -0,0 +1,36 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuPause.Asm
+;
+; Abstract:
+;
+;   CpuPause function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuPause (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuPause)
+ASM_PFX(CpuPause):
+    pause
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableCache.S b/MdePkg/Library/BaseLib/Ia32/DisableCache.S
new file mode 100644
index 000000000000..cadfa7a496c3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableCache.S
@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DisableCache.S
+#
+# Abstract:
+#
+#   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+#   WBINVD instruction.
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# AsmDisableCache (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmDisableCache)
+ASM_PFX(AsmDisableCache):
+    movl    %cr0, %eax
+    btsl    $30, %eax
+    btrl    $29, %eax
+    movl    %eax, %cr0
+    wbinvd
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableCache.asm b/MdePkg/Library/BaseLib/Ia32/DisableCache.asm
new file mode 100644
index 000000000000..35ed81c8617d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableCache.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisableCache.Asm
+;
+; Abstract:
+;
+;   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+;   WBINVD instruction.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmDisableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmDisableCache PROC
+    mov     eax, cr0
+    bts     eax, 30
+    btr     eax, 29
+    mov     cr0, eax
+    wbinvd
+    ret
+AsmDisableCache ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableCache.c b/MdePkg/Library/BaseLib/Ia32/DisableCache.c
new file mode 100644
index 000000000000..598063949804
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableCache.c
@@ -0,0 +1,36 @@
+/** @file
+  AsmDisableCache function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Set CD bit and clear NW bit of CR0 followed by a WBINVD.
+
+  Disables the caches by setting the CD bit of CR0 to 1, clearing the NW bit of CR0 to 0,
+  and executing a WBINVD instruction.  This function is only available on IA-32 and x64.
+
+**/
+VOID
+EFIAPI
+AsmDisableCache (
+  VOID
+  )
+{
+  _asm {
+    mov     eax, cr0
+    bts     eax, 30
+    btr     eax, 29
+    mov     cr0, eax
+    wbinvd
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableCache.nasm b/MdePkg/Library/BaseLib/Ia32/DisableCache.nasm
new file mode 100644
index 000000000000..c956b7230b66
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableCache.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisableCache.Asm
+;
+; Abstract:
+;
+;   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+;   WBINVD instruction.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmDisableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmDisableCache)
+ASM_PFX(AsmDisableCache):
+    mov     eax, cr0
+    bts     eax, 30
+    btr     eax, 29
+    mov     cr0, eax
+    wbinvd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.asm b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.asm
new file mode 100644
index 000000000000..f6e47b5531bf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisableInterrupts.Asm
+;
+; Abstract:
+;
+;   DisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; DisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+DisableInterrupts   PROC
+    cli
+    ret
+DisableInterrupts   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.c b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.c
new file mode 100644
index 000000000000..a20b3d3064d1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.c
@@ -0,0 +1,32 @@
+/** @file
+  DisableInterrupts function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{
+  _asm {
+    cli
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.nasm b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.nasm
new file mode 100644
index 000000000000..ccf69b08a798
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisableInterrupts.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisableInterrupts.Asm
+;
+; Abstract:
+;
+;   DisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; DisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(DisableInterrupts)
+ASM_PFX(DisableInterrupts):
+    cli
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DisablePaging32.S b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.S
new file mode 100644
index 000000000000..08b3cc6b6859
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DisablePaging32.S
+#
+# Abstract:
+#
+#   InternalX86DisablePaging32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalX86DisablePaging32)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalX86DisablePaging32 (
+#   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+#   IN      VOID                      *Context1,    OPTIONAL
+#   IN      VOID                      *Context2,    OPTIONAL
+#   IN      VOID                      *NewStack
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalX86DisablePaging32):
+    movl    4(%esp), %ebx
+    movl    8(%esp), %ecx
+    movl    12(%esp), %edx
+    pushfl
+    pop     %edi                        # save EFLAGS to edi
+    cli
+    movl    %cr0, %eax
+    btrl    $31, %eax
+    movl    16(%esp), %esp
+    movl    %eax, %cr0
+    push    %edi
+    popfl                               # restore EFLAGS from edi
+    push    %edx
+    push    %ecx
+    call    *%ebx
+    jmp     .                           # EntryPoint() should not return
diff --git a/MdePkg/Library/BaseLib/Ia32/DisablePaging32.asm b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.asm
new file mode 100644
index 000000000000..ce6f23f97b92
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisablePaging32.Asm
+;
+; Abstract:
+;
+;   AsmDisablePaging32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86DisablePaging32 (
+;   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+;   IN      VOID                      *Context1,    OPTIONAL
+;   IN      VOID                      *Context2,    OPTIONAL
+;   IN      VOID                      *NewStack
+;   );
+;------------------------------------------------------------------------------
+InternalX86DisablePaging32    PROC
+    mov     ebx, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    pushfd
+    pop     edi                         ; save EFLAGS to edi
+    cli
+    mov     eax, cr0
+    btr     eax, 31
+    mov     esp, [esp + 16]
+    mov     cr0, eax
+    push    edi
+    popfd                               ; restore EFLAGS from edi
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $                           ; EntryPoint() should not return
+InternalX86DisablePaging32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DisablePaging32.c b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.c
new file mode 100644
index 000000000000..eb7556652d45
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.c
@@ -0,0 +1,77 @@
+/** @file
+  AsmDisablePaging32 function.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Disables the 32-bit paging mode on the CPU.
+
+  Disables the 32-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 32-paged protected
+  mode. This function is only available on IA-32. After the 32-bit paging mode
+  is disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be NULL. The function EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit paged mode.
+  3)  CR0, CR3, and CR4 must be compatible with 32-bit paged mode.
+  4)  CR3 must point to valid page tables that guarantee that the pages for
+      this function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is disabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is disabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is
+                      disabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is disabled.
+
+**/
+__declspec (naked)
+VOID
+EFIAPI
+InternalX86DisablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,    OPTIONAL
+  IN      VOID                      *Context2,    OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  _asm {
+    push    ebp
+    mov     ebp, esp
+    mov     ebx, EntryPoint
+    mov     ecx, Context1
+    mov     edx, Context2
+    pushfd
+    pop     edi                         // save EFLAGS to edi
+    cli
+    mov     eax, cr0
+    btr     eax, 31
+    mov     esp, NewStack
+    mov     cr0, eax
+    push    edi
+    popfd                               // restore EFLAGS from edi
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $                           // EntryPoint() should not return
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/DisablePaging32.nasm b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.nasm
new file mode 100644
index 000000000000..62813c968c00
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DisablePaging32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisablePaging32.Asm
+;
+; Abstract:
+;
+;   AsmDisablePaging32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86DisablePaging32 (
+;   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+;   IN      VOID                      *Context1,    OPTIONAL
+;   IN      VOID                      *Context2,    OPTIONAL
+;   IN      VOID                      *NewStack
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86DisablePaging32)
+ASM_PFX(InternalX86DisablePaging32):
+    mov     ebx, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    pushfd
+    pop     edi                         ; save EFLAGS to edi
+    cli
+    mov     eax, cr0
+    btr     eax, 31
+    mov     esp, [esp + 16]
+    mov     cr0, eax
+    push    edi
+    popfd                               ; restore EFLAGS from edi
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $                           ; EntryPoint() should not return
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DivS64x64Remainder.c b/MdePkg/Library/BaseLib/Ia32/DivS64x64Remainder.c
new file mode 100644
index 000000000000..90c1042a05eb
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivS64x64Remainder.c
@@ -0,0 +1,53 @@
+/** @file
+  Integer division worker functions for Ia32.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Worker function that Divides a 64-bit signed integer by a 64-bit signed integer and
+  generates a  64-bit signed result and a optional 64-bit signed remainder.
+
+  This function divides the 64-bit signed value Dividend by the 64-bit
+  signed value Divisor and generates a 64-bit signed quotient. If Remainder
+  is not NULL, then the 64-bit signed remainder is returned in Remainder.
+  This function returns the 64-bit signed quotient.
+
+  @param  Dividend  A 64-bit signed value.
+  @param  Divisor   A 64-bit signed value.
+  @param  Remainder A pointer to a 64-bit signed value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+INT64
+EFIAPI
+InternalMathDivRemS64x64 (
+  IN      INT64                     Dividend,
+  IN      INT64                     Divisor,
+  OUT     INT64                     *Remainder  OPTIONAL
+  )
+{
+  INT64                             Quot;
+
+  Quot = InternalMathDivRemU64x64 (
+           (UINT64) (Dividend >= 0 ? Dividend : -Dividend),
+           (UINT64) (Divisor >= 0 ? Divisor : -Divisor),
+           (UINT64 *) Remainder
+           );
+  if (Remainder != NULL && Dividend < 0) {
+    *Remainder = -*Remainder;
+  }
+  return (Dividend ^ Divisor) >= 0 ? Quot : -Quot;
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32.S b/MdePkg/Library/BaseLib/Ia32/DivU64x32.S
new file mode 100644
index 000000000000..55a6854860c9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32.S
@@ -0,0 +1,41 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DivU64x32.S
+#
+# Abstract:
+#
+#   Calculate the quotient of a 64-bit integer by a 32-bit integer
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathDivU64x32)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathDivU64x32 (
+#   IN      UINT64                    Dividend,
+#   IN      UINT32                    Divisor
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathDivU64x32):
+    movl    8(%esp), %eax
+    movl    12(%esp), %ecx
+    xorl    %edx, %edx
+    divl    %ecx
+    push    %eax                    # save quotient on stack
+    movl    8(%esp), %eax
+    divl    %ecx
+    pop     %edx                    # restore high-order dword of the quotient
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32.asm b/MdePkg/Library/BaseLib/Ia32/DivU64x32.asm
new file mode 100644
index 000000000000..838241fe12ae
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32.asm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x32.asm
+;
+; Abstract:
+;
+;   Calculate the quotient of a 64-bit integer by a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor
+;   );
+;------------------------------------------------------------------------------
+InternalMathDivU64x32   PROC
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 12]
+    xor     edx, edx
+    div     ecx
+    push    eax                     ; save quotient on stack
+    mov     eax, [esp + 8]
+    div     ecx
+    pop     edx                     ; restore high-order dword of the quotient
+    ret
+InternalMathDivU64x32   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32.c b/MdePkg/Library/BaseLib/Ia32/DivU64x32.c
new file mode 100644
index 000000000000..e680bf2dd2c8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32.c
@@ -0,0 +1,50 @@
+/** @file
+  Calculate the quotient of a 64-bit integer by a 32-bit integer
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+
+
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. This
+  function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  _asm {
+    mov     eax, dword ptr [Dividend + 4]
+    mov     ecx, Divisor
+    xor     edx, edx
+    div     ecx
+    push    eax                     ; save quotient on stack
+    mov     eax, dword ptr [Dividend]
+    div     ecx
+    pop     edx                     ; restore high-order dword of the quotient
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32.nasm b/MdePkg/Library/BaseLib/Ia32/DivU64x32.nasm
new file mode 100644
index 000000000000..6b96f8299ea2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x32.nasm
+;
+; Abstract:
+;
+;   Calculate the quotient of a 64-bit integer by a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathDivU64x32)
+ASM_PFX(InternalMathDivU64x32):
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 12]
+    xor     edx, edx
+    div     ecx
+    push    eax                     ; save quotient on stack
+    mov     eax, [esp + 8]
+    div     ecx
+    pop     edx                     ; restore high-order dword of the quotient
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.S b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.S
new file mode 100644
index 000000000000..743abf272ba4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DivError.S
+#
+# Abstract:
+#
+#   Set error flag for all division functions
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathDivRemU64x32)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathDivRemU64x32 (
+#   IN      UINT64                    Dividend,
+#   IN      UINT32                    Divisor,
+#   OUT     UINT32                    *Remainder
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathDivRemU64x32):
+    movl    12(%esp), %ecx          # ecx <- divisor
+    movl    8(%esp), %eax           # eax <- dividend[32..63]
+    xorl    %edx, %edx
+    divl    %ecx                    # eax <- quotient[32..63], edx <- remainder
+    push    %eax
+    movl    8(%esp), %eax           # eax <- dividend[0..31]
+    divl    %ecx                    # eax <- quotient[0..31]
+    movl    20(%esp), %ecx          # ecx <- Remainder
+    jecxz   L1                      # abandon remainder if Remainder == NULL
+    movl    %edx, (%ecx)
+L1:
+    pop     %edx                    # edx <- quotient[32..63]
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.asm b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.asm
new file mode 100644
index 000000000000..f5e0c11c6c5f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.asm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivError.asm
+;
+; Abstract:
+;
+;   Set error flag for all division functions
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivRemU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor,
+;   OUT     UINT32                    *Remainder
+;   );
+;------------------------------------------------------------------------------
+InternalMathDivRemU64x32    PROC
+    mov     ecx, [esp + 12]         ; ecx <- divisor
+    mov     eax, [esp + 8]          ; eax <- dividend[32..63]
+    xor     edx, edx
+    div     ecx                     ; eax <- quotient[32..63], edx <- remainder
+    push    eax
+    mov     eax, [esp + 8]          ; eax <- dividend[0..31]
+    div     ecx                     ; eax <- quotient[0..31]
+    mov     ecx, [esp + 20]         ; ecx <- Remainder
+    jecxz   @F                      ; abandon remainder if Remainder == NULL
+    mov     [ecx], edx
+@@:
+    pop     edx                     ; edx <- quotient[32..63]
+    ret
+InternalMathDivRemU64x32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.c b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.c
new file mode 100644
index 000000000000..87f9352cf436
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.c
@@ -0,0 +1,55 @@
+/** @file
+  Set error flag for all division functions
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result and an optional 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivRemU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor,
+  OUT     UINT32                    *Remainder
+  )
+{
+  _asm {
+    mov     ecx, Divisor
+    mov     eax, dword ptr [Dividend + 4]
+    xor     edx, edx
+    div     ecx
+    push    eax
+    mov     eax, dword ptr [Dividend + 0]
+    div     ecx
+    mov     ecx, Remainder
+    jecxz   RemainderNull                      // abandon remainder if Remainder == NULL
+    mov     [ecx], edx
+RemainderNull:
+    pop     edx
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.nasm b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.nasm
new file mode 100644
index 000000000000..1ccc4de4aff2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x32Remainder.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivError.asm
+;
+; Abstract:
+;
+;   Set error flag for all division functions
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivRemU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor,
+;   OUT     UINT32                    *Remainder
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathDivRemU64x32)
+ASM_PFX(InternalMathDivRemU64x32):
+    mov     ecx, [esp + 12]         ; ecx <- divisor
+    mov     eax, [esp + 8]          ; eax <- dividend[32..63]
+    xor     edx, edx
+    div     ecx                     ; eax <- quotient[32..63], edx <- remainder
+    push    eax
+    mov     eax, [esp + 8]          ; eax <- dividend[0..31]
+    div     ecx                     ; eax <- quotient[0..31]
+    mov     ecx, [esp + 20]         ; ecx <- Remainder
+    jecxz   .0                      ; abandon remainder if Remainder == NULL
+    mov     [ecx], edx
+.0:
+    pop     edx                     ; edx <- quotient[32..63]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.S b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.S
new file mode 100644
index 000000000000..bd2aeba2e69b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.S
@@ -0,0 +1,89 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DivU64x64Remainder.S
+#
+# Abstract:
+#
+#   Calculate the quotient of a 64-bit integer by a 64-bit integer and returns
+#   both the quotient and the remainder
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathDivRemU64x32), ASM_PFX(InternalMathDivRemU64x64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathDivRemU64x64 (
+#   IN      UINT64                    Dividend,
+#   IN      UINT64                    Divisor,
+#   OUT     UINT64                    *Remainder    OPTIONAL
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathDivRemU64x64):
+    movl    16(%esp), %ecx              # ecx <- divisor[32..63]
+    testl   %ecx, %ecx
+    jnz     Hard                        # call _@DivRemU64x64 if Divisor > 2^32
+    movl    20(%esp), %ecx
+    jecxz   L1
+    andl     $0, 4(%ecx)                # zero high dword of remainder
+    movl    %ecx, 16(%esp)              # set up stack frame to match DivRemU64x32
+L1:
+    jmp     ASM_PFX(InternalMathDivRemU64x32)
+Hard:
+    push    %ebx
+    push    %esi
+    push    %edi
+    mov     20(%esp), %edx
+    mov     16(%esp), %eax              # edx:eax <- dividend
+    movl    %edx, %edi
+    movl    %eax, %esi                  # edi:esi <- dividend
+    mov     24(%esp), %ebx              # ecx:ebx <- divisor
+L2:
+    shrl    %edx
+    rcrl    $1, %eax
+    shrdl   $1, %ecx, %ebx
+    shrl    %ecx
+    jnz     L2
+    divl    %ebx
+    movl    %eax, %ebx                  # ebx <- quotient                     
+    movl    28(%esp), %ecx              # ecx <- high dword of divisor        
+    mull    24(%esp)                    # edx:eax <- quotient * divisor[0..31]
+    imull   %ebx, %ecx                  # ecx <- quotient * divisor[32..63]   
+    addl    %ecx, %edx                  # edx <- (quotient * divisor)[32..63] 
+    mov     32(%esp), %ecx              # ecx <- addr for Remainder           
+    jc      TooLarge                    # product > 2^64                      
+    cmpl    %edx, %edi                  # compare high 32 bits                
+    ja      Correct                                                           
+    jb      TooLarge                    # product > dividend                  
+    cmpl    %eax, %esi                                                        
+    jae     Correct                     # product <= dividend                 
+TooLarge:
+    decl    %ebx                        # adjust quotient by -1              
+    jecxz   Return                      # return if Remainder == NULL        
+    sub     24(%esp), %eax                                                   
+    sbb     28(%esp), %edx              # edx:eax <- (quotient - 1) * divisor
+Correct:
+    jecxz   Return
+    subl    %eax, %esi
+    sbbl    %edx, %edi                  # edi:esi <- remainder
+    movl    %esi, (%ecx)
+    movl    %edi, 4(%ecx)
+Return:
+    movl    %ebx, %eax                  # eax <- quotient         
+    xorl    %edx, %edx                  # quotient is 32 bits long
+    pop     %edi
+    pop     %esi
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.asm b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.asm
new file mode 100644
index 000000000000..ce352f13b429
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.asm
@@ -0,0 +1,92 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x64Remainder.asm
+;
+; Abstract:
+;
+;   Calculate the quotient of a 64-bit integer by a 64-bit integer and returns
+;   both the quotient and the remainder
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+EXTERN  InternalMathDivRemU64x32:PROC
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivRemU64x64 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT64                    Divisor,
+;   OUT     UINT64                    *Remainder    OPTIONAL
+;   );
+;------------------------------------------------------------------------------
+InternalMathDivRemU64x64    PROC
+    mov     ecx, [esp + 16]             ; ecx <- divisor[32..63]
+    test    ecx, ecx
+    jnz     _@DivRemU64x64              ; call _@DivRemU64x64 if Divisor > 2^32
+    mov     ecx, [esp + 20]
+    jecxz   @F
+    and     dword ptr [ecx + 4], 0      ; zero high dword of remainder
+    mov     [esp + 16], ecx             ; set up stack frame to match DivRemU64x32
+@@:
+    jmp     InternalMathDivRemU64x32
+InternalMathDivRemU64x64    ENDP
+
+_@DivRemU64x64  PROC PRIVATE    USES    ebx esi edi
+    mov     edx, dword ptr [esp + 20]
+    mov     eax, dword ptr [esp + 16]   ; edx:eax <- dividend
+    mov     edi, edx
+    mov     esi, eax                    ; edi:esi <- dividend
+    mov     ebx, dword ptr [esp + 24]   ; ecx:ebx <- divisor
+@@:
+    shr     edx, 1
+    rcr     eax, 1
+    shrd    ebx, ecx, 1
+    shr     ecx, 1
+    jnz     @B
+    div     ebx
+    mov     ebx, eax                    ; ebx <- quotient
+    mov     ecx, [esp + 28]             ; ecx <- high dword of divisor
+    mul     dword ptr [esp + 24]        ; edx:eax <- quotient * divisor[0..31]
+    imul    ecx, ebx                    ; ecx <- quotient * divisor[32..63]
+    add     edx, ecx                    ; edx <- (quotient * divisor)[32..63]
+    mov     ecx, dword ptr [esp + 32]   ; ecx <- addr for Remainder
+    jc      @TooLarge                   ; product > 2^64
+    cmp     edi, edx                    ; compare high 32 bits
+    ja      @Correct
+    jb      @TooLarge                   ; product > dividend
+    cmp     esi, eax
+    jae     @Correct                    ; product <= dividend
+@TooLarge:
+    dec     ebx                         ; adjust quotient by -1
+    jecxz   @Return                     ; return if Remainder == NULL
+    sub     eax, dword ptr [esp + 24]
+    sbb     edx, dword ptr [esp + 28]   ; edx:eax <- (quotient - 1) * divisor
+@Correct:
+    jecxz   @Return
+    sub     esi, eax
+    sbb     edi, edx                    ; edi:esi <- remainder
+    mov     [ecx], esi
+    mov     [ecx + 4], edi
+@Return:
+    mov     eax, ebx                    ; eax <- quotient
+    xor     edx, edx                    ; quotient is 32 bits long
+    ret
+_@DivRemU64x64  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.nasm b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.nasm
new file mode 100644
index 000000000000..c70e1291a9eb
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/DivU64x64Remainder.nasm
@@ -0,0 +1,94 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x64Remainder.nasm
+;
+; Abstract:
+;
+;   Calculate the quotient of a 64-bit integer by a 64-bit integer and returns
+;   both the quotient and the remainder
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+extern ASM_PFX(InternalMathDivRemU64x32)
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathDivRemU64x64 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT64                    Divisor,
+;   OUT     UINT64                    *Remainder    OPTIONAL
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathDivRemU64x64)
+ASM_PFX(InternalMathDivRemU64x64):
+    mov     ecx, [esp + 16]             ; ecx <- divisor[32..63]
+    test    ecx, ecx
+    jnz     _@DivRemU64x64              ; call _@DivRemU64x64 if Divisor > 2^32
+    mov     ecx, [esp + 20]
+    jecxz   .0
+    and     dword [ecx + 4], 0      ; zero high dword of remainder
+    mov     [esp + 16], ecx             ; set up stack frame to match DivRemU64x32
+.0:
+    jmp     ASM_PFX(InternalMathDivRemU64x32)
+
+_@DivRemU64x64:
+    push    ebx
+    push    esi
+    push    edi
+    mov     edx, dword [esp + 20]
+    mov     eax, dword [esp + 16]   ; edx:eax <- dividend
+    mov     edi, edx
+    mov     esi, eax                    ; edi:esi <- dividend
+    mov     ebx, dword [esp + 24]   ; ecx:ebx <- divisor
+.1:
+    shr     edx, 1
+    rcr     eax, 1
+    shrd    ebx, ecx, 1
+    shr     ecx, 1
+    jnz     .1
+    div     ebx
+    mov     ebx, eax                    ; ebx <- quotient
+    mov     ecx, [esp + 28]             ; ecx <- high dword of divisor
+    mul     dword [esp + 24]        ; edx:eax <- quotient * divisor[0..31]
+    imul    ecx, ebx                    ; ecx <- quotient * divisor[32..63]
+    add     edx, ecx                    ; edx <- (quotient * divisor)[32..63]
+    mov     ecx, dword [esp + 32]   ; ecx <- addr for Remainder
+    jc      @TooLarge                   ; product > 2^64
+    cmp     edi, edx                    ; compare high 32 bits
+    ja      @Correct
+    jb      @TooLarge                   ; product > dividend
+    cmp     esi, eax
+    jae     @Correct                    ; product <= dividend
+@TooLarge:
+    dec     ebx                         ; adjust quotient by -1
+    jecxz   @Return                     ; return if Remainder == NULL
+    sub     eax, dword [esp + 24]
+    sbb     edx, dword [esp + 28]   ; edx:eax <- (quotient - 1) * divisor
+@Correct:
+    jecxz   @Return
+    sub     esi, eax
+    sbb     edi, edx                    ; edi:esi <- remainder
+    mov     [ecx], esi
+    mov     [ecx + 4], edi
+@Return:
+    mov     eax, ebx                    ; eax <- quotient
+    xor     edx, edx                    ; quotient is 32 bits long
+    pop     edi
+    pop     esi
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableCache.S b/MdePkg/Library/BaseLib/Ia32/EnableCache.S
new file mode 100644
index 000000000000..fd7f7e0a6f7e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableCache.S
@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   EnableCache.S
+#
+# Abstract:
+#
+#   Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear 
+#   the NW bit of CR0 to 0
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# AsmEnableCache (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmEnableCache)
+ASM_PFX(AsmEnableCache):
+    wbinvd
+    movl    %cr0, %eax
+    btrl    $30, %eax
+    btrl    $29, %eax
+    movl    %eax, %cr0
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableCache.asm b/MdePkg/Library/BaseLib/Ia32/EnableCache.asm
new file mode 100644
index 000000000000..124e10960d26
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableCache.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   EnableCache.Asm
+;
+; Abstract:
+;
+;  Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear 
+;  the NW bit of CR0 to 0
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmEnableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmEnableCache PROC
+    wbinvd
+    mov     eax, cr0
+    btr     eax, 29
+    btr     eax, 30
+    mov     cr0, eax
+    ret
+AsmEnableCache ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableCache.c b/MdePkg/Library/BaseLib/Ia32/EnableCache.c
new file mode 100644
index 000000000000..912defb617ce
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableCache.c
@@ -0,0 +1,36 @@
+/** @file
+  AsmEnableCache function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Perform a WBINVD and clear both the CD and NW bits of CR0.
+
+  Enables the caches by executing a WBINVD instruction and then clear both the CD and NW
+  bits of CR0 to 0.  This function is only available on IA-32 and x64.
+
+**/
+VOID
+EFIAPI
+AsmEnableCache (
+  VOID
+  )
+{
+  _asm {
+    wbinvd
+    mov     eax, cr0
+    btr     eax, 30
+    btr     eax, 29
+    mov     cr0, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableCache.nasm b/MdePkg/Library/BaseLib/Ia32/EnableCache.nasm
new file mode 100644
index 000000000000..63c605df91b0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableCache.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   EnableCache.Asm
+;
+; Abstract:
+;
+;  Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear
+;  the NW bit of CR0 to 0
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmEnableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmEnableCache)
+ASM_PFX(AsmEnableCache):
+    wbinvd
+    mov     eax, cr0
+    btr     eax, 29
+    btr     eax, 30
+    mov     cr0, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.S b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.S
new file mode 100644
index 000000000000..446c36b57598
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   EnableDisableInterrupts.S
+#
+# Abstract:
+#
+#   EnableDisableInterrupts function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(EnableDisableInterrupts)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# EnableDisableInterrupts (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(EnableDisableInterrupts):
+    sti
+    cli
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.asm b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.asm
new file mode 100644
index 000000000000..8e707bfd0326
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   EnableDisableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableDisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableDisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+EnableDisableInterrupts    PROC
+    sti
+    cli
+    ret
+EnableDisableInterrupts    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.c b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.c
new file mode 100644
index 000000000000..d351afb932f2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.c
@@ -0,0 +1,36 @@
+/** @file
+  EnableDisableInterrupts function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+**/
+VOID
+EFIAPI
+EnableDisableInterrupts (
+  VOID
+  )
+{
+  _asm {
+    sti
+    nop
+    nop
+    cli
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.nasm b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.nasm
new file mode 100644
index 000000000000..d5cb3e6df3cf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableDisableInterrupts.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   EnableDisableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableDisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableDisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(EnableDisableInterrupts)
+ASM_PFX(EnableDisableInterrupts):
+    sti
+    cli
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.asm b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.asm
new file mode 100644
index 000000000000..891661992d9f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   EnableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+EnableInterrupts   PROC
+    sti
+    ret
+EnableInterrupts   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.c b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.c
new file mode 100644
index 000000000000..7fe14cb49fd8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.c
@@ -0,0 +1,32 @@
+/** @file
+  EnableInterrupts function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  _asm {
+    sti
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.nasm b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.nasm
new file mode 100644
index 000000000000..f4a41117c93b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnableInterrupts.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   EnableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(EnableInterrupts)
+ASM_PFX(EnableInterrupts):
+    sti
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging32.S b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.S
new file mode 100644
index 000000000000..2449556c45df
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   EnablePaging32.S
+#
+# Abstract:
+#
+#   InternalX86EnablePaging32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalX86EnablePaging32)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalX86EnablePaging32 (
+#   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+#   IN      VOID                      *Context1,    OPTIONAL
+#   IN      VOID                      *Context2,    OPTIONAL
+#   IN      VOID                      *NewStack
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalX86EnablePaging32):
+    movl    4(%esp), %ebx
+    movl    8(%esp), %ecx
+    movl    12(%esp), %edx
+    pushfl
+    pop     %edi                        # save flags in edi
+    cli
+    movl    %cr0, %eax
+    btsl    $31, %eax
+    movl    16(%esp), %esp
+    movl    %eax, %cr0
+    push    %edi
+    popfl                               # restore flags
+    push    %edx
+    push    %ecx
+    call    *%ebx
+    jmp     .
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging32.asm b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.asm
new file mode 100644
index 000000000000..88191330f09c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnablePaging32.Asm
+;
+; Abstract:
+;
+;   AsmEnablePaging32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86EnablePaging32 (
+;   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+;   IN      VOID                      *Context1,    OPTIONAL
+;   IN      VOID                      *Context2,    OPTIONAL
+;   IN      VOID                      *NewStack
+;   );
+;------------------------------------------------------------------------------
+InternalX86EnablePaging32 PROC
+    mov     ebx, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    pushfd
+    pop     edi                         ; save flags in edi
+    cli
+    mov     eax, cr0
+    bts     eax, 31
+    mov     esp, [esp + 16]
+    mov     cr0, eax
+    push    edi
+    popfd                               ; restore flags
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $
+InternalX86EnablePaging32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging32.c b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.c
new file mode 100644
index 000000000000..18e9d1129d59
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.c
@@ -0,0 +1,81 @@
+/** @file
+  AsmEnablePaging32 function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Enables the 32-bit paging mode on the CPU.
+
+  Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode. This function is
+  only available on IA-32. After the 32-bit paging mode is enabled, control is
+  transferred to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit protected mode with flat descriptors. This
+      means all descriptors must have a base of 0 and a limit of 4GB.
+  3)  CR0 and CR4 must be compatible with 32-bit protected mode with flat
+      descriptors.
+  4)  CR3 must point to valid page tables that will be used once the transition
+      is complete, and those page tables must guarantee that the pages for this
+      function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is enabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is enabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is enabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is enabled.
+
+**/
+__declspec (naked)
+VOID
+EFIAPI
+InternalX86EnablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,    OPTIONAL
+  IN      VOID                      *Context2,    OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  _asm {
+    push    ebp
+    mov     ebp, esp
+    mov     ebx, EntryPoint
+    mov     ecx, Context1
+    mov     edx, Context2
+    pushfd
+    pop     edi
+    cli
+    mov     eax, cr0
+    bts     eax, 31
+    mov     esp, NewStack
+    mov     cr0, eax
+    push    edi
+    popfd
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging32.nasm b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.nasm
new file mode 100644
index 000000000000..f0949be1679a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnablePaging32.Asm
+;
+; Abstract:
+;
+;   AsmEnablePaging32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86EnablePaging32 (
+;   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+;   IN      VOID                      *Context1,    OPTIONAL
+;   IN      VOID                      *Context2,    OPTIONAL
+;   IN      VOID                      *NewStack
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86EnablePaging32)
+ASM_PFX(InternalX86EnablePaging32):
+    mov     ebx, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    pushfd
+    pop     edi                         ; save flags in edi
+    cli
+    mov     eax, cr0
+    bts     eax, 31
+    mov     esp, [esp + 16]
+    mov     cr0, eax
+    push    edi
+    popfd                               ; restore flags
+    push    edx
+    push    ecx
+    call    ebx
+    jmp     $
+
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging64.S b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.S
new file mode 100644
index 000000000000..e1c7f6047492
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.S
@@ -0,0 +1,63 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   EnablePaging64.S
+#
+# Abstract:
+#
+#   InternalX86EnablePaging64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalX86EnablePaging64)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalX86EnablePaging64 (
+#   IN      UINT16                    CodeSelector,
+#   IN      UINT64                    EntryPoint,
+#   IN      UINT64                    Context1,    OPTIONAL
+#   IN      UINT64                    Context2,    OPTIONAL
+#   IN      UINT64                    NewStack
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalX86EnablePaging64):
+    cli
+    movl    $LongStart, (%esp)          # offset for far retf, seg is the 1st arg
+    movl    %cr4, %eax
+    orb     $0x20, %al
+    movl    %eax, %cr4                  # enable PAE
+    movl    $0xc0000080, %ecx
+    rdmsr
+    orb     $1, %ah                     # set LME
+    wrmsr
+    movl    %cr0, %eax
+    btsl    $31, %eax                   # set PG
+    movl    %eax, %cr0                  # enable paging
+    lret                                # topmost 2 dwords hold the address
+LongStart:                              # long mode starts here
+    .byte   0x67, 0x48                  # 32-bit address size, 64-bit operand size
+    movl    (%esp), %ebx                # mov rbx, [esp]
+    .byte   0x67, 0x48
+    movl    8(%esp), %ecx               # mov rcx, [esp + 8]
+    .byte   0x67, 0x48
+    movl    0x10(%esp), %edx            # mov rdx, [esp + 10h]
+    .byte   0x67, 0x48
+    movl    0x18(%esp), %esp            # mov rsp, [esp + 18h]
+    .byte   0x48
+    addl    $-0x20, %esp                # add rsp, -20h
+    call    *%ebx                       # call rbx
+    jmp     .                           # no one should get here
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging64.asm b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.asm
new file mode 100644
index 000000000000..128310d1d122
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.asm
@@ -0,0 +1,68 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnablePaging64.Asm
+;
+; Abstract:
+;
+;   AsmEnablePaging64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86EnablePaging64 (
+;   IN      UINT16                    Cs,
+;   IN      UINT64                    EntryPoint,
+;   IN      UINT64                    Context1,  OPTIONAL
+;   IN      UINT64                    Context2,  OPTIONAL
+;   IN      UINT64                    NewStack
+;   );
+;------------------------------------------------------------------------------
+InternalX86EnablePaging64 PROC
+    cli
+    mov     DWORD PTR [esp], @F         ; offset for far retf, seg is the 1st arg
+    mov     eax, cr4
+    or      al, (1 SHL 5)
+    mov     cr4, eax                    ; enable PAE
+    mov     ecx, 0c0000080h
+    rdmsr
+    or      ah, 1                       ; set LME
+    wrmsr
+    mov     eax, cr0
+    bts     eax, 31                     ; set PG
+    mov     cr0, eax                    ; enable paging
+    retf                                ; topmost 2 dwords hold the address
+@@:                                     ; long mode starts here
+    DB      67h, 48h                    ; 32-bit address size, 64-bit operand size
+    mov     ebx, [esp]                  ; mov rbx, [esp]
+    DB      67h, 48h
+    mov     ecx, [esp + 8]              ; mov rcx, [esp + 8]
+    DB      67h, 48h
+    mov     edx, [esp + 10h]            ; mov rdx, [esp + 10h]
+    DB      67h, 48h
+    mov     esp, [esp + 18h]            ; mov rsp, [esp + 18h]
+    DB      48h
+    add     esp, -20h                   ; add rsp, -20h
+    call    ebx                         ; call rbx
+    hlt                                 ; no one should get here
+InternalX86EnablePaging64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/EnablePaging64.nasm b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.nasm
new file mode 100644
index 000000000000..91c89ee4ae50
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/EnablePaging64.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnablePaging64.Asm
+;
+; Abstract:
+;
+;   AsmEnablePaging64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86EnablePaging64 (
+;   IN      UINT16                    Cs,
+;   IN      UINT64                    EntryPoint,
+;   IN      UINT64                    Context1,  OPTIONAL
+;   IN      UINT64                    Context2,  OPTIONAL
+;   IN      UINT64                    NewStack
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86EnablePaging64)
+ASM_PFX(InternalX86EnablePaging64):
+    cli
+    mov     DWORD [esp], .0         ; offset for far retf, seg is the 1st arg
+    mov     eax, cr4
+    or      al, (1 << 5)
+    mov     cr4, eax                    ; enable PAE
+    mov     ecx, 0xc0000080
+    rdmsr
+    or      ah, 1                       ; set LME
+    wrmsr
+    mov     eax, cr0
+    bts     eax, 31                     ; set PG
+    mov     cr0, eax                    ; enable paging
+    retf                                ; topmost 2 dwords hold the address
+.0:
+    DB      0x67, 0x48                    ; 32-bit address size, 64-bit operand size
+    mov     ebx, [esp]                  ; mov rbx, [esp]
+    DB      0x67, 0x48
+    mov     ecx, [esp + 8]              ; mov rcx, [esp + 8]
+    DB      0x67, 0x48
+    mov     edx, [esp + 0x10]            ; mov rdx, [esp + 10h]
+    DB      0x67, 0x48
+    mov     esp, [esp + 0x18]            ; mov rsp, [esp + 18h]
+    DB      0x48
+    add     esp, -0x20                   ; add rsp, -20h
+    call    ebx                         ; call rbx
+    hlt                                 ; no one should get here
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.asm b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.asm
new file mode 100644
index 000000000000..c6e704b38403
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   FlushCacheLine.Asm
+;
+; Abstract:
+;
+;   AsmFlushCacheLine function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586P
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; AsmFlushCacheLine (
+;   IN      VOID                      *LinearAddress
+;   );
+;------------------------------------------------------------------------------
+AsmFlushCacheLine   PROC
+    ;
+    ; If the CPU does not support CLFLUSH instruction, 
+    ; then promote flush range to flush entire cache.
+    ;
+    mov     eax, 1
+    push    ebx
+    cpuid
+    pop     ebx
+    mov     eax, [esp + 4]
+    test    edx, BIT19
+    jz      @F
+    clflush [eax]
+    ret
+@@:
+    wbinvd
+    ret
+AsmFlushCacheLine   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.c b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.c
new file mode 100644
index 000000000000..9a73ddfb4898
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.c
@@ -0,0 +1,58 @@
+/** @file
+  AsmFlushCacheLine function
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Flushes a cache line from all the instruction and data caches within the
+  coherency domain of the CPU.
+
+  Flushed the cache line specified by LinearAddress, and returns LinearAddress.
+  This function is only available on IA-32 and x64.
+
+  @param  LinearAddress The address of the cache line to flush. If the CPU is
+                        in a physical addressing mode, then LinearAddress is a
+                        physical address. If the CPU is in a virtual
+                        addressing mode, then LinearAddress is a virtual
+                        address.
+
+  @return LinearAddress
+**/
+VOID *
+EFIAPI
+AsmFlushCacheLine (
+  IN      VOID                      *LinearAddress
+  )
+{
+  //
+  // If the CPU does not support CLFLUSH instruction, 
+  // then promote flush range to flush entire cache.
+  //
+  _asm {
+    mov     eax, 1
+    cpuid
+    test    edx, BIT19
+    jz      NoClflush
+    mov     eax, dword ptr [LinearAddress]
+    clflush [eax]
+    jmp     Done
+NoClflush:
+    wbinvd
+Done:
+  }
+  
+  return LinearAddress;
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.nasm b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.nasm
new file mode 100644
index 000000000000..088b7aa80c7b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FlushCacheLine.nasm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   FlushCacheLine.Asm
+;
+; Abstract:
+;
+;   AsmFlushCacheLine function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; AsmFlushCacheLine (
+;   IN      VOID                      *LinearAddress
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmFlushCacheLine)
+ASM_PFX(AsmFlushCacheLine):
+    ;
+    ; If the CPU does not support CLFLUSH instruction,
+    ; then promote flush range to flush entire cache.
+    ;
+    mov     eax, 1
+    push    ebx
+    cpuid
+    pop     ebx
+    mov     eax, [esp + 4]
+    test    edx, BIT19
+    jz      .0
+    clflush [eax]
+    ret
+.0:
+    wbinvd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FxRestore.asm b/MdePkg/Library/BaseLib/Ia32/FxRestore.asm
new file mode 100644
index 000000000000..a637b31b689b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxRestore.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxRestore.Asm
+;
+; Abstract:
+;
+;   AsmFxRestore function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxRestore (
+;   IN CONST IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+InternalX86FxRestore  PROC
+    mov     eax, [esp + 4]              ; Buffer must be 16-byte aligned
+    fxrstor [eax]
+    ret
+InternalX86FxRestore  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/FxRestore.c b/MdePkg/Library/BaseLib/Ia32/FxRestore.c
new file mode 100644
index 000000000000..b64284aa8dc2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxRestore.c
@@ -0,0 +1,40 @@
+/** @file
+  AsmFxRestore function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and x64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxRestore (
+  IN CONST IA32_FX_BUFFER *Buffer
+  )
+{
+  _asm {
+    mov     eax, Buffer
+    fxrstor [eax]
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FxRestore.nasm b/MdePkg/Library/BaseLib/Ia32/FxRestore.nasm
new file mode 100644
index 000000000000..5c3374726597
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxRestore.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxRestore.Asm
+;
+; Abstract:
+;
+;   AsmFxRestore function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxRestore (
+;   IN CONST IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86FxRestore)
+ASM_PFX(InternalX86FxRestore):
+    mov     eax, [esp + 4]              ; Buffer must be 16-byte aligned
+    fxrstor [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FxSave.asm b/MdePkg/Library/BaseLib/Ia32/FxSave.asm
new file mode 100644
index 000000000000..20531de6b999
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxSave.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxSave.Asm
+;
+; Abstract:
+;
+;   AsmFxSave function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxSave (
+;   OUT IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+InternalX86FxSave PROC
+    mov     eax, [esp + 4]              ; Buffer must be 16-byte aligned
+    fxsave  [eax]
+    ret
+InternalX86FxSave ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/FxSave.c b/MdePkg/Library/BaseLib/Ia32/FxSave.c
new file mode 100644
index 000000000000..0de252f43d45
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxSave.c
@@ -0,0 +1,40 @@
+/** @file
+  AsmFxSave function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and x64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxSave (
+  OUT IA32_FX_BUFFER *Buffer
+  )
+{
+  _asm {
+    mov     eax, Buffer
+    fxsave  [eax]
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/FxSave.nasm b/MdePkg/Library/BaseLib/Ia32/FxSave.nasm
new file mode 100644
index 000000000000..f22e19e77bc3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/FxSave.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxSave.Asm
+;
+; Abstract:
+;
+;   AsmFxSave function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxSave (
+;   OUT IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86FxSave)
+ASM_PFX(InternalX86FxSave):
+    mov     eax, [esp + 4]              ; Buffer must be 16-byte aligned
+    fxsave  [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/GccInline.c b/MdePkg/Library/BaseLib/Ia32/GccInline.c
new file mode 100644
index 000000000000..68d56754d2b8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/GccInline.c
@@ -0,0 +1,1771 @@
+/** @file
+  GCC inline implementation of BaseLib processor specific functions.
+  
+  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BaseLibInternals.h"
+
+
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+  // This is a little bit of overkill and it is more about the compiler that it is
+  // actually processor synchronization. This is like the _ReadWriteBarrier 
+  // Microsoft specific intrinsic
+  __asm__ __volatile__ ("":::"memory");
+}
+
+
+/**
+  Enables CPU interrupts.
+
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("sti"::: "memory");
+}
+
+
+/**
+  Disables CPU interrupts.
+
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{  
+  __asm__ __volatile__ ("cli"::: "memory");
+}
+
+
+
+
+/**
+  Requests CPU to pause for a short period of time.
+
+  Requests CPU to pause for a short period of time. Typically used in MP
+  systems to prevent memory starvation while waiting for a spin lock.
+
+**/
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("pause");
+}
+
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("int $3");
+}
+
+
+
+/**
+  Returns a 64-bit Machine Specific Register(MSR).
+
+  Reads and returns the 64-bit MSR specified by Index. No parameter checking is
+  performed on Index, and some Index values may cause CPU exceptions. The
+  caller must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and X64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The value of the MSR identified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr64 (
+  IN      UINT32                    Index
+  )
+{
+  UINT64 Data;
+  
+  __asm__ __volatile__ (
+    "rdmsr"
+    : "=A" (Data)   // %0
+    : "c"  (Index)  // %1
+    );
+    
+  return Data;
+}
+
+/**
+  Writes a 64-bit value to a Machine Specific Register(MSR), and returns the
+  value.
+
+  Writes the 64-bit value specified by Value to the MSR specified by Index. The
+  64-bit value written to the MSR is returned. No parameter checking is
+  performed on Index or Value, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and Value are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and X64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 64-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "wrmsr"
+    :
+    : "c" (Index),
+      "A" (Value)
+    );
+    
+  return Value;
+}
+
+
+
+/**
+  Reads the current value of the EFLAGS register.
+
+  Reads and returns the current value of the EFLAGS register. This function is
+  only available on IA-32 and X64. This returns a 32-bit value on IA-32 and a
+  64-bit value on X64.
+
+  @return EFLAGS on IA-32 or RFLAGS on X64.
+
+**/
+UINTN
+EFIAPI
+AsmReadEflags (
+  VOID
+  )
+{
+  UINTN Eflags;
+  
+  __asm__ __volatile__ (
+    "pushfl     \n\t"
+    "popl %0        "
+    : "=r" (Eflags)
+    );
+    
+  return Eflags;
+}
+
+
+
+/**
+  Reads the current value of the Control Register 0 (CR0).
+
+  Reads and returns the current value of CR0. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 0 (CR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr0 (
+  VOID
+  )
+{
+  UINTN   Data;
+  
+  __asm__ __volatile__ (
+    "movl %%cr0,%0" 
+    : "=a" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of the Control Register 2 (CR2).
+
+  Reads and returns the current value of CR2. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 2 (CR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr2 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%cr2, %0" 
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+/**
+  Reads the current value of the Control Register 3 (CR3).
+
+  Reads and returns the current value of CR3. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 3 (CR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr3 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%cr3, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of the Control Register 4 (CR4).
+
+  Reads and returns the current value of CR4. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 4 (CR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr4 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%cr4, %0"
+    : "=a" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Writes a value to Control Register 0 (CR0).
+
+  Writes and returns a new value to CR0. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr0 The value to write to CR0.
+
+  @return The value written to CR0.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr0 (
+  UINTN  Cr0
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%cr0"
+    :
+    : "r" (Cr0)
+    );
+  return Cr0;
+}
+
+
+/**
+  Writes a value to Control Register 2 (CR2).
+
+  Writes and returns a new value to CR2. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr2 The value to write to CR2.
+
+  @return The value written to CR2.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr2 (
+  UINTN  Cr2
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%cr2"
+    :
+    : "r" (Cr2)
+    );
+  return Cr2;
+}
+
+
+/**
+  Writes a value to Control Register 3 (CR3).
+
+  Writes and returns a new value to CR3. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr3 The value to write to CR3.
+
+  @return The value written to CR3.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr3 (
+  UINTN  Cr3
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%cr3"
+    :
+    : "r" (Cr3)
+    );
+  return Cr3;
+}
+
+
+/**
+  Writes a value to Control Register 4 (CR4).
+
+  Writes and returns a new value to CR4. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr4 The value to write to CR4.
+
+  @return The value written to CR4.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr4 (
+  UINTN  Cr4
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%cr4"
+    :
+    : "r" (Cr4)
+    );
+  return Cr4;
+}
+
+
+/**
+  Reads the current value of Debug Register 0 (DR0).
+
+  Reads and returns the current value of DR0. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr0 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr0, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 1 (DR1).
+
+  Reads and returns the current value of DR1. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr1 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr1, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 2 (DR2).
+
+  Reads and returns the current value of DR2. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr2 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr2, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 3 (DR3).
+
+  Reads and returns the current value of DR3. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr3 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr3, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 4 (DR4).
+
+  Reads and returns the current value of DR4. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr4 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr4, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 5 (DR5).
+
+  Reads and returns the current value of DR5. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr5 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr5, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 6 (DR6).
+
+  Reads and returns the current value of DR6. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr6 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr6, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 7 (DR7).
+
+  Reads and returns the current value of DR7. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr7 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "movl %%dr7, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Writes a value to Debug Register 0 (DR0).
+
+  Writes and returns a new value to DR0. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr0 The value to write to Dr0.
+
+  @return The value written to Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr0 (
+  UINTN  Dr0
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr0"
+    :
+    : "r" (Dr0)
+    );
+  return Dr0;
+}
+
+
+/**
+  Writes a value to Debug Register 1 (DR1).
+
+  Writes and returns a new value to DR1. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr1 The value to write to Dr1.
+
+  @return The value written to Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr1 (
+  UINTN  Dr1
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr1"
+    :
+    : "r" (Dr1)
+    );
+  return Dr1;
+}
+
+
+/**
+  Writes a value to Debug Register 2 (DR2).
+
+  Writes and returns a new value to DR2. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr2 The value to write to Dr2.
+
+  @return The value written to Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr2 (
+  UINTN  Dr2
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr2"
+    :
+    : "r" (Dr2)
+    );
+  return Dr2;
+}
+
+
+/**
+  Writes a value to Debug Register 3 (DR3).
+
+  Writes and returns a new value to DR3. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr3 The value to write to Dr3.
+
+  @return The value written to Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr3 (
+  UINTN  Dr3
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr3"
+    :
+    : "r" (Dr3)
+    );
+  return Dr3;
+}
+
+
+/**
+  Writes a value to Debug Register 4 (DR4).
+
+  Writes and returns a new value to DR4. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr4 The value to write to Dr4.
+
+  @return The value written to Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr4 (
+  UINTN  Dr4
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr4"
+    :
+    : "r" (Dr4)
+    );
+  return Dr4;
+}
+
+
+/**
+  Writes a value to Debug Register 5 (DR5).
+
+  Writes and returns a new value to DR5. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr5 The value to write to Dr5.
+
+  @return The value written to Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr5 (
+  UINTN  Dr5
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr5"
+    :
+    : "r" (Dr5)
+    );
+  return Dr5;
+}
+
+
+/**
+  Writes a value to Debug Register 6 (DR6).
+
+  Writes and returns a new value to DR6. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr6 The value to write to Dr6.
+
+  @return The value written to Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr6 (
+  UINTN  Dr6
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr6"
+    :
+    : "r" (Dr6)
+    );
+  return Dr6;
+}
+
+
+/**
+  Writes a value to Debug Register 7 (DR7).
+
+  Writes and returns a new value to DR7. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr7 The value to write to Dr7.
+
+  @return The value written to Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr7 (
+  UINTN  Dr7
+  )
+{
+  __asm__ __volatile__ (
+    "movl %0, %%dr7"
+    :
+    : "r" (Dr7)
+    );
+  return Dr7;
+}
+
+
+/**
+  Reads the current value of Code Segment Register (CS).
+
+  Reads and returns the current value of CS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of CS.
+
+**/
+UINT16
+EFIAPI
+AsmReadCs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov   %%cs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Data Segment Register (DS).
+
+  Reads and returns the current value of DS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of DS.
+
+**/
+UINT16
+EFIAPI
+AsmReadDs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%ds, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Extra Segment Register (ES).
+
+  Reads and returns the current value of ES. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of ES.
+
+**/
+UINT16
+EFIAPI
+AsmReadEs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%es, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of FS Data Segment Register (FS).
+
+  Reads and returns the current value of FS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of FS.
+
+**/
+UINT16
+EFIAPI
+AsmReadFs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%fs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of GS Data Segment Register (GS).
+
+  Reads and returns the current value of GS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of GS.
+
+**/
+UINT16
+EFIAPI
+AsmReadGs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%gs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Stack Segment Register (SS).
+
+  Reads and returns the current value of SS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of SS.
+
+**/
+UINT16
+EFIAPI
+AsmReadSs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%ds, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Task Register (TR).
+
+  Reads and returns the current value of TR. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of TR.
+
+**/
+UINT16
+EFIAPI
+AsmReadTr (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "str  %0"
+    : "=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and X64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadGdtr (
+  OUT     IA32_DESCRIPTOR           *Gdtr
+  )
+{
+  __asm__ __volatile__ (
+    "sgdt %0"
+    : "=m" (*Gdtr)
+    );
+}
+
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  )
+{
+  __asm__ __volatile__ (
+    "lgdt %0"
+    :
+    : "m" (*Gdtr)
+    );
+    
+}
+
+
+/**
+  Reads the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and X64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  )
+{
+  __asm__ __volatile__ (
+    "sidt  %0"
+    : "=m" (*Idtr)
+    );
+}
+
+
+/**
+  Writes the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  )
+{
+  __asm__ __volatile__ (
+    "lidt %0"
+    :
+    : "m" (*Idtr)
+    );
+}
+
+
+/**
+  Reads the current Local Descriptor Table Register(LDTR) selector.
+
+  Reads and returns the current 16-bit LDTR descriptor value. This function is
+  only available on IA-32 and X64.
+
+  @return The current selector of LDT.
+
+**/
+UINT16
+EFIAPI
+AsmReadLdtr (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "sldt  %0"
+    : "=g" (Data)   // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Writes the current Local Descriptor Table Register (GDTR) selector.
+
+  Writes and the current LDTR descriptor specified by Ldtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Ldtr  16-bit LDTR selector value.
+
+**/
+VOID
+EFIAPI
+AsmWriteLdtr (
+  IN      UINT16                    Ldtr
+  )
+{
+  __asm__ __volatile__ (
+    "lldtw  %0"
+    :
+    : "g" (Ldtr)   // %0
+    );
+}
+
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and X64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxSave (
+  OUT     IA32_FX_BUFFER            *Buffer
+  )
+{
+  __asm__ __volatile__ (
+    "fxsave %0"
+    :
+    : "m" (*Buffer)  // %0
+    );    
+}
+
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and X64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxRestore (
+  IN      CONST IA32_FX_BUFFER      *Buffer
+  )
+{
+  __asm__ __volatile__ (
+    "fxrstor %0"
+    :
+    : "m" (*Buffer)  // %0
+    );
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #0 (MM0).
+
+  Reads and returns the current value of MM0. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM0.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm0 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm0,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #1 (MM1).
+
+  Reads and returns the current value of MM1. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM1.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm1 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm1,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #2 (MM2).
+
+  Reads and returns the current value of MM2. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM2.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm2 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm2,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #3 (MM3).
+
+  Reads and returns the current value of MM3. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM3.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm3 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm3,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #4 (MM4).
+
+  Reads and returns the current value of MM4. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM4.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm4 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm4,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #5 (MM5).
+
+  Reads and returns the current value of MM5. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM5.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm5 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm5,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #6 (MM6).
+
+  Reads and returns the current value of MM6. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM6.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm6 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm6,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #7 (MM7).
+
+  Reads and returns the current value of MM7. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM7.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm7 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "push %%eax          \n\t"
+    "push %%eax          \n\t"
+    "movq %%mm7,  (%%esp)\n\t"
+    "pop  %%eax          \n\t"
+    "pop  %%edx          \n\t"
+    : "=A"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #0 (MM0).
+
+  Writes the current value of MM0. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM0.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm0 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm0"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #1 (MM1).
+
+  Writes the current value of MM1. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM1.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm1 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm1"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #2 (MM2).
+
+  Writes the current value of MM2. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM2.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm2 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm2"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #3 (MM3).
+
+  Writes the current value of MM3. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM3.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm3 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm3"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #4 (MM4).
+
+  Writes the current value of MM4. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM4.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm4 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm4"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #5 (MM5).
+
+  Writes the current value of MM5. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM5.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm5 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm5"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #6 (MM6).
+
+  Writes the current value of MM6. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM6.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm6 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm6"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #7 (MM7).
+
+  Writes the current value of MM7. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM7.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm7 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movq %0, %%mm7"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Reads the current value of Time Stamp Counter (TSC).
+
+  Reads and returns the current value of TSC. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of TSC
+
+**/
+UINT64
+EFIAPI
+AsmReadTsc (
+  VOID
+  )
+{
+  UINT64  Data;
+  
+  __asm__ __volatile__ (
+    "rdtsc"
+    : "=A" (Data)
+    );
+  
+  return Data;  
+}
+
+
+/**
+  Reads the current value of a Performance Counter (PMC).
+
+  Reads and returns the current value of performance counter specified by
+  Index. This function is only available on IA-32 and X64.
+
+  @param  Index The 32-bit Performance Counter index to read.
+
+  @return The value of the PMC specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmc (
+  IN      UINT32                    Index
+  )
+{
+  UINT64  Data;
+  
+  __asm__ __volatile__ (
+    "rdpmc"
+    : "=A" (Data)
+    : "c"  (Index)
+    );
+  
+  return Data;  
+}
+
+
+
+
+/**
+  Executes a WBINVD instruction.
+
+  Executes a WBINVD instruction. This function is only available on IA-32 and
+  X64.
+
+**/
+VOID
+EFIAPI
+AsmWbinvd (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("wbinvd":::"memory");
+}
+
+
+/**
+  Executes a INVD instruction.
+
+  Executes a INVD instruction. This function is only available on IA-32 and
+  X64.
+
+**/
+VOID
+EFIAPI
+AsmInvd (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("invd":::"memory");
+    
+}
+
+
+/**
+  Flushes a cache line from all the instruction and data caches within the
+  coherency domain of the CPU.
+
+  Flushed the cache line specified by LinearAddress, and returns LinearAddress.
+  This function is only available on IA-32 and X64.
+
+  @param  LinearAddress The address of the cache line to flush. If the CPU is
+                        in a physical addressing mode, then LinearAddress is a
+                        physical address. If the CPU is in a virtual
+                        addressing mode, then LinearAddress is a virtual
+                        address.
+
+  @return LinearAddress
+**/
+VOID *
+EFIAPI
+AsmFlushCacheLine (
+  IN      VOID                      *LinearAddress
+  )
+{
+  UINT32  RegEdx;
+
+  //
+  // If the CPU does not support CLFLUSH instruction, 
+  // then promote flush range to flush entire cache.
+  //
+  AsmCpuid (0x01, NULL, NULL, NULL, &RegEdx);
+  if ((RegEdx & BIT19) == 0) {
+    __asm__ __volatile__ ("wbinvd":::"memory");
+    return LinearAddress;
+  }
+
+
+  __asm__ __volatile__ (
+    "clflush (%0)"
+    : "+a" (LinearAddress) 
+    : 
+    : "memory"
+    );
+    
+  return LinearAddress;
+}
+
+
diff --git a/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.S b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.S
new file mode 100644
index 000000000000..97e3ff3e7d7a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.S
@@ -0,0 +1,48 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2011, Apple Inc. 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.
+#
+# Module Name:
+#
+#   InternalSwitchStack.S
+#
+# Abstract:
+#
+#   Implementation of a stack switch on IA-32.
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalSwitchStack)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalSwitchStack (
+#   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+#   IN      VOID                      *Context1,   OPTIONAL
+#   IN      VOID                      *Context2,   OPTIONAL
+#   IN      VOID                      *NewStack
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalSwitchStack):
+  pushl %ebp
+	movl	%esp, %ebp
+
+	movl	20(%ebp), %esp      # switch stack
+	subl	$8, %esp
+
+	movl	16(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, (%esp)
+	pushl $0                  # keeps gdb from unwinding stack
+	jmp   *8(%ebp)            # call and never return 
+
diff --git a/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.c b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.c
new file mode 100644
index 000000000000..182b0b046e7a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.c
@@ -0,0 +1,60 @@
+/** @file
+  SwitchStack() function for IA-32.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.
+  Marker will be ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  Marker      VA_LIST marker for the variable argument list.
+
+**/
+VOID
+EFIAPI
+InternalSwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VA_LIST                   Marker
+  )
+{
+  BASE_LIBRARY_JUMP_BUFFER  JumpBuffer;
+
+  JumpBuffer.Eip = (UINTN)EntryPoint;
+  JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*);
+  JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2);
+  ((VOID**)JumpBuffer.Esp)[1] = Context1;
+  ((VOID**)JumpBuffer.Esp)[2] = Context2;
+
+  LongJump (&JumpBuffer, (UINTN)-1);
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.nasm b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.nasm
new file mode 100644
index 000000000000..b3c4f7bf7816
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/InternalSwitchStack.nasm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
+; Portions copyright (c) 2011, Apple Inc. 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.
+;
+; Module Name:
+;
+;   InternalSwitchStack.nasm
+;
+; Abstract:
+;
+;   Implementation of a stack switch on IA-32.
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalSwitchStack (
+;   IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+;   IN      VOID                      *Context1,   OPTIONAL
+;   IN      VOID                      *Context2,   OPTIONAL
+;   IN      VOID                      *NewStack
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSwitchStack)
+ASM_PFX(InternalSwitchStack):
+  push  ebp
+  mov   ebp, esp
+
+  mov   esp, [ebp + 20]    ; switch stack
+  sub   esp, 8
+  mov   eax, [ebp + 16]
+  mov   [esp + 4], eax
+  mov   eax, [ebp + 12]
+  mov   [esp], eax
+  push  0                  ; keeps gdb from unwinding stack
+  jmp   dword [ebp + 8]    ; call and never return
diff --git a/MdePkg/Library/BaseLib/Ia32/Invd.asm b/MdePkg/Library/BaseLib/Ia32/Invd.asm
new file mode 100644
index 000000000000..4cffebf06f33
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Invd.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   Invd.Asm
+;
+; Abstract:
+;
+;   AsmInvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486p
+    .model  flat
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmInvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmInvd    PROC
+    invd
+    ret
+AsmInvd    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/Invd.c b/MdePkg/Library/BaseLib/Ia32/Invd.c
new file mode 100644
index 000000000000..e5c29b6f5131
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Invd.c
@@ -0,0 +1,35 @@
+/** @file
+  AsmInvd function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Executes a INVD instruction.
+
+  Executes a INVD instruction. This function is only available on IA-32 and
+  x64.
+
+**/
+VOID
+EFIAPI
+AsmInvd (
+  VOID
+  )
+{
+  _asm {
+    invd
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Invd.nasm b/MdePkg/Library/BaseLib/Ia32/Invd.nasm
new file mode 100644
index 000000000000..13b8795e00c6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Invd.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   Invd.Asm
+;
+; Abstract:
+;
+;   AsmInvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmInvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmInvd)
+ASM_PFX(AsmInvd):
+    invd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LRotU64.S b/MdePkg/Library/BaseLib/Ia32/LRotU64.S
new file mode 100644
index 000000000000..87a6b5b9a20d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LRotU64.S
@@ -0,0 +1,48 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   LRotU64.S
+#
+# Abstract:
+#
+#   64-bit left rotation for Ia32
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathLRotU64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathLRotU64 (
+#   IN      UINT64                    Operand,
+#   IN      UINTN                     Count
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathLRotU64):
+    push    %ebx
+    movb    16(%esp), %cl
+    movl    12(%esp), %edx
+    movl    8(%esp), %eax
+    shldl   %cl, %edx, %ebx
+    shldl   %cl, %eax, %edx
+    rorl    %cl, %ebx
+    shldl   %cl, %ebx, %eax
+    testb   $32, %cl                    # Count >= 32?
+    jz      L0
+    movl    %eax, %ecx
+    movl    %edx, %eax
+    movl    %ecx, %edx
+L0:    
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/LRotU64.asm b/MdePkg/Library/BaseLib/Ia32/LRotU64.asm
new file mode 100644
index 000000000000..c8c1eabab000
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LRotU64.asm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   LRotU64.asm
+;
+; Abstract:
+;
+;   64-bit left rotation for Ia32
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathLRotU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+InternalMathLRotU64 PROC    USES    ebx
+    mov     cl, [esp + 16]
+    mov     edx, [esp + 12]
+    mov     eax, [esp + 8]
+    shld    ebx, edx, cl
+    shld    edx, eax, cl
+    ror     ebx, cl
+    shld    eax, ebx, cl
+    test    cl, 32                      ; Count >= 32?
+    jz      @F
+    mov     ecx, eax
+    mov     eax, edx
+    mov     edx, ecx
+@@:    
+    ret
+InternalMathLRotU64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/LRotU64.c b/MdePkg/Library/BaseLib/Ia32/LRotU64.c
new file mode 100644
index 000000000000..1dfef3b6e0f3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LRotU64.c
@@ -0,0 +1,55 @@
+/** @file
+  64-bit left rotation for Ia32
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Rotates a 64-bit integer left between 0 and 63 bits, filling
+  the low bits with the high bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand <<< Count
+
+**/
+UINT64
+EFIAPI
+InternalMathLRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  _asm {
+    mov     cl, byte ptr [Count]
+    mov     edx, dword ptr [Operand + 4]
+    mov     eax, dword ptr [Operand + 0]
+    shld    ebx, edx, cl
+    shld    edx, eax, cl
+    ror     ebx, cl
+    shld    eax, ebx, cl
+    test    cl, 32                      ; Count >= 32?
+    jz      L0
+    mov     ecx, eax
+    mov     eax, edx
+    mov     edx, ecx
+L0:
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LRotU64.nasm b/MdePkg/Library/BaseLib/Ia32/LRotU64.nasm
new file mode 100644
index 000000000000..e3dc015225fc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LRotU64.nasm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   LRotU64.nasm
+;
+; Abstract:
+;
+;   64-bit left rotation for Ia32
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathLRotU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathLRotU64)
+ASM_PFX(InternalMathLRotU64):
+    push    ebx
+    mov     cl, [esp + 16]
+    mov     edx, [esp + 12]
+    mov     eax, [esp + 8]
+    shld    ebx, edx, cl
+    shld    edx, eax, cl
+    ror     ebx, cl
+    shld    eax, ebx, cl
+    test    cl, 32                      ; Count >= 32?
+    jz      .0
+    mov     ecx, eax
+    mov     eax, edx
+    mov     edx, ecx
+.0:
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LShiftU64.S b/MdePkg/Library/BaseLib/Ia32/LShiftU64.S
new file mode 100644
index 000000000000..574583a0308e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LShiftU64.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   LShiftU64.S
+#
+# Abstract:
+#
+#   64-bit left shift function for IA-32
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathLShiftU64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathLShiftU64 (
+#   IN      UINT64                    Operand,
+#   IN      UINTN                     Count
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathLShiftU64):
+    movb    12(%esp), %cl
+    xorl    %eax, %eax
+    movl    4(%esp), %edx
+    testb   $32, %cl                    # Count >= 32?
+    jnz     L0
+    movl    %edx, %eax
+    movl    0x8(%esp), %edx
+L0:    
+    shld    %cl, %eax, %edx
+    shl     %cl, %eax
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/LShiftU64.asm b/MdePkg/Library/BaseLib/Ia32/LShiftU64.asm
new file mode 100644
index 000000000000..59cba4a81c00
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LShiftU64.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   LShiftU64.asm
+;
+; Abstract:
+;
+;   64-bit left shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathLShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+InternalMathLShiftU64   PROC
+    mov     cl, [esp + 12]
+    xor     eax, eax
+    mov     edx, [esp + 4]
+    test    cl, 32                      ; Count >= 32?
+    jnz     @F
+    mov     eax, edx
+    mov     edx, [esp + 8]
+@@:    
+    shld    edx, eax, cl
+    shl     eax, cl
+    ret
+InternalMathLShiftU64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/LShiftU64.c b/MdePkg/Library/BaseLib/Ia32/LShiftU64.c
new file mode 100644
index 000000000000..08266f786f63
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LShiftU64.c
@@ -0,0 +1,51 @@
+/** @file
+  64-bit left shift function for IA-32.
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Shifts a 64-bit integer left between 0 and 63 bits. The low bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the left by Count bits. The
+  low Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift left.
+  @param  Count   The number of bits to shift left.
+
+  @return Operand << Count
+
+**/
+UINT64
+EFIAPI
+InternalMathLShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  _asm {
+    mov     cl, byte ptr [Count]
+    xor     eax, eax
+    mov     edx, dword ptr [Operand + 0]
+    test    cl, 32                      // Count >= 32?
+    jnz     L0
+    mov     eax, edx
+    mov     edx, dword ptr [Operand + 4]
+L0:
+    shld    edx, eax, cl
+    shl     eax, cl
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LShiftU64.nasm b/MdePkg/Library/BaseLib/Ia32/LShiftU64.nasm
new file mode 100644
index 000000000000..93de11dfef5e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LShiftU64.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   LShiftU64.nasm
+;
+; Abstract:
+;
+;   64-bit left shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathLShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathLShiftU64)
+ASM_PFX(InternalMathLShiftU64):
+    mov     cl, [esp + 12]
+    xor     eax, eax
+    mov     edx, [esp + 4]
+    test    cl, 32                      ; Count >= 32?
+    jnz     .0
+    mov     eax, edx
+    mov     edx, [esp + 8]
+.0:
+    shld    edx, eax, cl
+    shl     eax, cl
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LongJump.S b/MdePkg/Library/BaseLib/Ia32/LongJump.S
new file mode 100644
index 000000000000..dfd52f23e9f0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LongJump.S
@@ -0,0 +1,41 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   LongJump.S
+#
+# Abstract:
+#
+#   Implementation of _LongJump() on IA-32.
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalLongJump)
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalLongJump (
+#   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+#   IN      UINTN                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalLongJump):
+    pop     %eax                        # skip return address
+    pop     %edx                        # edx <- JumpBuffer
+    pop     %eax                        # eax <- Value
+    movl    (%edx), %ebx
+    movl    4(%edx), %esi
+    movl    8(%edx), %edi
+    movl    12(%edx), %ebp
+    movl    16(%edx), %esp
+    jmp     *20(%edx)                   # restore "eip"
diff --git a/MdePkg/Library/BaseLib/Ia32/LongJump.asm b/MdePkg/Library/BaseLib/Ia32/LongJump.asm
new file mode 100644
index 000000000000..17d1006fe672
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LongJump.asm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   LongJump.Asm
+;
+; Abstract:
+;
+;   Implementation of _LongJump() on IA-32.
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalLongJump (
+;   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+;   IN      UINTN                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalLongJump    PROC
+    pop     eax                         ; skip return address
+    pop     edx                         ; edx <- JumpBuffer
+    pop     eax                         ; eax <- Value
+    mov     ebx, [edx]
+    mov     esi, [edx + 4]
+    mov     edi, [edx + 8]
+    mov     ebp, [edx + 12]
+    mov     esp, [edx + 16]
+    jmp     dword ptr [edx + 20]        ; restore "eip"
+InternalLongJump    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/LongJump.c b/MdePkg/Library/BaseLib/Ia32/LongJump.c
new file mode 100644
index 000000000000..8eb013f97334
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LongJump.c
@@ -0,0 +1,50 @@
+/** @file
+  Implementation of _LongJump() on IA-32.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Restores the CPU context that was saved with SetJump().
+
+  Restores the CPU context from the buffer specified by JumpBuffer.
+  This function never returns to the caller.
+  Instead is resumes execution based on the state of JumpBuffer.
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+  @param  Value         The value to return when the SetJump() context is restored.
+
+**/
+__declspec (naked)
+VOID
+EFIAPI
+InternalLongJump (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+  IN      UINTN                     Value
+  )
+{
+  _asm {
+    pop     eax                         ; skip return address
+    pop     edx                         ; edx <- JumpBuffer
+    pop     eax                         ; eax <- Value
+    mov     ebx, [edx]
+    mov     esi, [edx + 4]
+    mov     edi, [edx + 8]
+    mov     ebp, [edx + 12]
+    mov     esp, [edx + 16]
+    jmp     dword ptr [edx + 20]
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/LongJump.nasm b/MdePkg/Library/BaseLib/Ia32/LongJump.nasm
new file mode 100644
index 000000000000..5e643c0dcf99
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/LongJump.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   LongJump.Asm
+;
+; Abstract:
+;
+;   Implementation of _LongJump() on IA-32.
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalLongJump (
+;   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+;   IN      UINTN                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalLongJump)
+ASM_PFX(InternalLongJump):
+    pop     eax                         ; skip return address
+    pop     edx                         ; edx <- JumpBuffer
+    pop     eax                         ; eax <- Value
+    mov     ebx, [edx]
+    mov     esi, [edx + 4]
+    mov     edi, [edx + 8]
+    mov     ebp, [edx + 12]
+    mov     esp, [edx + 16]
+    jmp     dword [edx + 20]        ; restore "eip"
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ModU64x32.S b/MdePkg/Library/BaseLib/Ia32/ModU64x32.S
new file mode 100644
index 000000000000..91ea4630a00e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ModU64x32.S
@@ -0,0 +1,40 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   DivU64x32.S
+#
+# Abstract:
+#
+#   Calculate the remainder of a 64-bit integer by a 32-bit integer
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathModU64x32)
+
+#------------------------------------------------------------------------------
+# UINT32
+# EFIAPI
+# InternalMathModU64x32 (
+#   IN      UINT64                    Dividend,
+#   IN      UINT32                    Divisor
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathModU64x32):
+    movl    8(%esp), %eax
+    movl    12(%esp), %ecx
+    xorl    %edx, %edx
+    divl    %ecx
+    movl    4(%esp), %eax
+    divl    %ecx
+    movl    %edx, %eax
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/ModU64x32.asm b/MdePkg/Library/BaseLib/Ia32/ModU64x32.asm
new file mode 100644
index 000000000000..babaa4fc4c67
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ModU64x32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x32.asm
+;
+; Abstract:
+;
+;   Calculate the remainder of a 64-bit integer by a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalMathModU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor
+;   );
+;------------------------------------------------------------------------------
+InternalMathModU64x32   PROC
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 12]
+    xor     edx, edx
+    div     ecx
+    mov     eax, [esp + 4]
+    div     ecx
+    mov     eax, edx
+    ret
+InternalMathModU64x32   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ModU64x32.c b/MdePkg/Library/BaseLib/Ia32/ModU64x32.c
new file mode 100644
index 000000000000..3186ccb2a265
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ModU64x32.c
@@ -0,0 +1,48 @@
+/** @file
+  Calculate the remainder of a 64-bit integer by a 32-bit integer
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 32-bit remainder. This function
+  returns the 32-bit unsigned remainder.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend % Divisor
+
+**/
+UINT32
+EFIAPI
+InternalMathModU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  _asm {
+    mov     eax, dword ptr [Dividend + 4]
+    mov     ecx, Divisor
+    xor     edx, edx
+    div     ecx
+    mov     eax, dword ptr [Dividend + 0]
+    div     ecx
+    mov     eax, edx
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/ModU64x32.nasm b/MdePkg/Library/BaseLib/Ia32/ModU64x32.nasm
new file mode 100644
index 000000000000..cb3681cd2334
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ModU64x32.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DivU64x32.asm
+;
+; Abstract:
+;
+;   Calculate the remainder of a 64-bit integer by a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalMathModU64x32 (
+;   IN      UINT64                    Dividend,
+;   IN      UINT32                    Divisor
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathModU64x32)
+ASM_PFX(InternalMathModU64x32):
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 12]
+    xor     edx, edx
+    div     ecx
+    mov     eax, [esp + 4]
+    div     ecx
+    mov     eax, edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Monitor.S b/MdePkg/Library/BaseLib/Ia32/Monitor.S
new file mode 100644
index 000000000000..b6bfbeedf1f4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Monitor.S
@@ -0,0 +1,40 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   Monitor.S
+#
+# Abstract:
+#
+#   AsmMonitor function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(AsmMonitor)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# AsmMonitor (
+#   IN      UINTN                     Eax,
+#   IN      UINTN                     Ecx,
+#   IN      UINTN                     Edx
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(AsmMonitor):
+    movl    4(%esp), %eax
+    movl    8(%esp), %ecx
+    movl    12(%esp), %edx
+    monitor %eax, %ecx, %edx            # monitor
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/Monitor.asm b/MdePkg/Library/BaseLib/Ia32/Monitor.asm
new file mode 100644
index 000000000000..cd298bd37c6b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Monitor.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Monitor.Asm
+;
+; Abstract:
+;
+;   AsmMonitor function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmMonitor (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx,
+;   IN      UINTN                     Edx
+;   );
+;------------------------------------------------------------------------------
+AsmMonitor  PROC
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    DB      0fh, 1, 0c8h                ; monitor
+    ret
+AsmMonitor  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/Monitor.c b/MdePkg/Library/BaseLib/Ia32/Monitor.c
new file mode 100644
index 000000000000..d9c93255c96b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Monitor.c
@@ -0,0 +1,48 @@
+/** @file
+  AsmMonitor function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Sets up a monitor buffer that is used by AsmMwait().
+
+  Executes a MONITOR instruction with the register state specified by Eax, Ecx
+  and Edx. Returns Eax. This function is only available on IA-32 and x64.
+
+  @param  RegisterEax The value to load into EAX or RAX before executing the MONITOR
+                      instruction.
+  @param  RegisterEcx The value to load into ECX or RCX before executing the MONITOR
+                      instruction.
+  @param  RegisterEdx The value to load into EDX or RDX before executing the MONITOR
+                      instruction.
+
+  @return RegisterEax
+
+**/
+UINTN
+EFIAPI
+AsmMonitor (
+  IN      UINTN                     RegisterEax,
+  IN      UINTN                     RegisterEcx,
+  IN      UINTN                     RegisterEdx
+  )
+{
+  _asm {
+    mov     eax, RegisterEax
+    mov     ecx, RegisterEcx
+    mov     edx, RegisterEdx
+    _emit   0x0f             // monitor
+    _emit   0x01
+    _emit   0xc8
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Monitor.nasm b/MdePkg/Library/BaseLib/Ia32/Monitor.nasm
new file mode 100644
index 000000000000..6cf8ffd4d38a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Monitor.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Monitor.Asm
+;
+; Abstract:
+;
+;   AsmMonitor function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmMonitor (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx,
+;   IN      UINTN                     Edx
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmMonitor)
+ASM_PFX(AsmMonitor):
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    mov     edx, [esp + 12]
+    DB      0xf, 1, 0xc8                ; monitor
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x32.S b/MdePkg/Library/BaseLib/Ia32/MultU64x32.S
new file mode 100644
index 000000000000..245687a24366
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x32.S
@@ -0,0 +1,41 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   MultU64x32.S
+#
+# Abstract:
+#
+#   Calculate the product of a 64-bit integer and a 32-bit integer
+#
+#------------------------------------------------------------------------------
+
+
+    .code:
+
+ASM_GLOBAL ASM_PFX(InternalMathMultU64x32)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathMultU64x32 (
+#   IN      UINT64                    Multiplicand,
+#   IN      UINT32                    Multiplier
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathMultU64x32):
+    movl    12(%esp), %ecx
+    movl    %ecx, %eax
+    imull   8(%esp), %ecx               # overflow not detectable
+    mull    0x4(%esp)
+    addl    %ecx, %edx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x32.asm b/MdePkg/Library/BaseLib/Ia32/MultU64x32.asm
new file mode 100644
index 000000000000..5ea1ce705f59
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x32.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   MultU64x32.asm
+;
+; Abstract:
+;
+;   Calculate the product of a 64-bit integer and a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathMultU64x32 (
+;   IN      UINT64                    Multiplicand,
+;   IN      UINT32                    Multiplier
+;   );
+;------------------------------------------------------------------------------
+InternalMathMultU64x32  PROC
+    mov     ecx, [esp + 12]
+    mov     eax, ecx
+    imul    ecx, [esp + 8]              ; overflow not detectable
+    mul     dword ptr [esp + 4]
+    add     edx, ecx
+    ret
+InternalMathMultU64x32  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x32.c b/MdePkg/Library/BaseLib/Ia32/MultU64x32.c
new file mode 100644
index 000000000000..8b534aab2bd2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x32.c
@@ -0,0 +1,47 @@
+/** @file
+  Calculate the product of a 64-bit integer and a 32-bit integer
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Multiples a 64-bit unsigned integer by a 32-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiples the 64-bit unsigned value Multiplicand by the 32-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 32-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x32 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT32                    Multiplier
+  )
+{
+  _asm {
+    mov     ecx, Multiplier
+    mov     eax, ecx
+    imul    ecx, dword ptr [Multiplicand + 4]  // overflow not detectable
+    mul     dword ptr [Multiplicand + 0]
+    add     edx, ecx
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x32.nasm b/MdePkg/Library/BaseLib/Ia32/MultU64x32.nasm
new file mode 100644
index 000000000000..d4c9e512e06b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x32.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   MultU64x32.nasm
+;
+; Abstract:
+;
+;   Calculate the product of a 64-bit integer and a 32-bit integer
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathMultU64x32 (
+;   IN      UINT64                    Multiplicand,
+;   IN      UINT32                    Multiplier
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathMultU64x32)
+ASM_PFX(InternalMathMultU64x32):
+    mov     ecx, [esp + 12]
+    mov     eax, ecx
+    imul    ecx, [esp + 8]              ; overflow not detectable
+    mul     dword [esp + 4]
+    add     edx, ecx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x64.S b/MdePkg/Library/BaseLib/Ia32/MultU64x64.S
new file mode 100644
index 000000000000..3aae054813c2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x64.S
@@ -0,0 +1,44 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   MultU64x64.S
+#
+# Abstract:
+#
+#   Calculate the product of a 64-bit integer and another 64-bit integer
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathMultU64x64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathMultU64x64 (
+#   IN      UINT64                    Multiplicand,
+#   IN      UINT64                    Multiplier
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathMultU64x64):
+    push    %ebx                                     
+    movl    8(%esp), %ebx             # ebx <- M1[0..31]                
+    movl    16(%esp), %edx            # edx <- M2[0..31]                                   
+    movl    %ebx, %ecx                                                  
+    movl    %edx, %eax                
+    imull   20(%esp), %ebx            # ebx <- M1[0..31] * M2[32..63]   
+    imull   12(%esp), %edx            # edx <- M1[32..63] * M2[0..31]   
+    addl    %edx, %ebx                # carries are abandoned           
+    mull    %ecx                      # edx:eax <- M1[0..31] * M2[0..31]
+    addl    %ebx, %edx                # carries are abandoned           
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x64.asm b/MdePkg/Library/BaseLib/Ia32/MultU64x64.asm
new file mode 100644
index 000000000000..8dfdf2a80fb8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x64.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   MultU64x64.asm
+;
+; Abstract:
+;
+;   Calculate the product of a 64-bit integer and another 64-bit integer
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathMultU64x64 (
+;   IN      UINT64                    Multiplicand,
+;   IN      UINT64                    Multiplier
+;   );
+;------------------------------------------------------------------------------
+InternalMathMultU64x64  PROC    USES    ebx
+    mov     ebx, [esp + 8]              ; ebx <- M1[0..31]
+    mov     edx, [esp + 16]             ; edx <- M2[0..31]
+    mov     ecx, ebx
+    mov     eax, edx
+    imul    ebx, [esp + 20]             ; ebx <- M1[0..31] * M2[32..63]
+    imul    edx, [esp + 12]             ; edx <- M1[32..63] * M2[0..31]
+    add     ebx, edx                    ; carries are abandoned
+    mul     ecx                         ; edx:eax <- M1[0..31] * M2[0..31]
+    add     edx, ebx                    ; carries are abandoned
+    ret
+InternalMathMultU64x64  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x64.c b/MdePkg/Library/BaseLib/Ia32/MultU64x64.c
new file mode 100644
index 000000000000..5f1048627565
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x64.c
@@ -0,0 +1,51 @@
+/** @file
+  Calculate the product of a 64-bit integer and another 64-bit integer
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+
+
+
+/**
+  Multiplies a 64-bit unsigned integer by a 64-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 64-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 64-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x64 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT64                    Multiplier
+  )
+{
+  _asm {
+    mov     ebx, dword ptr [Multiplicand + 0]
+    mov     edx, dword ptr [Multiplier + 0]
+    mov     ecx, ebx
+    mov     eax, edx
+    imul    ebx, dword ptr [Multiplier + 4]
+    imul    edx, dword ptr [Multiplicand + 4]
+    add     ebx, edx
+    mul     ecx
+    add     edx, ebx
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/MultU64x64.nasm b/MdePkg/Library/BaseLib/Ia32/MultU64x64.nasm
new file mode 100644
index 000000000000..4fdbf86be207
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/MultU64x64.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   MultU64x64.nasm
+;
+; Abstract:
+;
+;   Calculate the product of a 64-bit integer and another 64-bit integer
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathMultU64x64 (
+;   IN      UINT64                    Multiplicand,
+;   IN      UINT64                    Multiplier
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathMultU64x64)
+ASM_PFX(InternalMathMultU64x64):
+    push    ebx
+    mov     ebx, [esp + 8]              ; ebx <- M1[0..31]
+    mov     edx, [esp + 16]             ; edx <- M2[0..31]
+    mov     ecx, ebx
+    mov     eax, edx
+    imul    ebx, [esp + 20]             ; ebx <- M1[0..31] * M2[32..63]
+    imul    edx, [esp + 12]             ; edx <- M1[32..63] * M2[0..31]
+    add     ebx, edx                    ; carries are abandoned
+    mul     ecx                         ; edx:eax <- M1[0..31] * M2[0..31]
+    add     edx, ebx                    ; carries are abandoned
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Mwait.S b/MdePkg/Library/BaseLib/Ia32/Mwait.S
new file mode 100644
index 000000000000..1b8ef9bad5e4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Mwait.S
@@ -0,0 +1,38 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   Mwait.S
+#
+# Abstract:
+#
+#   AsmMwait function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(AsmMwait)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# AsmMwait (
+#   IN      UINTN                     Eax,
+#   IN      UINTN                     Ecx
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(AsmMwait):
+    movl    4(%esp), %eax
+    movl    8(%esp), %ecx
+    mwait
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/Mwait.asm b/MdePkg/Library/BaseLib/Ia32/Mwait.asm
new file mode 100644
index 000000000000..51af87705bb3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Mwait.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Mwait.Asm
+;
+; Abstract:
+;
+;   AsmMwait function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmMwait (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx
+;   );
+;------------------------------------------------------------------------------
+AsmMwait    PROC
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    DB      0fh, 1, 0c9h                ; mwait
+    ret
+AsmMwait    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/Mwait.c b/MdePkg/Library/BaseLib/Ia32/Mwait.c
new file mode 100644
index 000000000000..0cac0ac3169d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Mwait.c
@@ -0,0 +1,44 @@
+/** @file
+  AsmMwait function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Executes an MWAIT instruction.
+
+  Executes an MWAIT instruction with the register state specified by Eax and
+  Ecx. Returns Eax. This function is only available on IA-32 and x64.
+
+  @param  RegisterEax The value to load into EAX or RAX before executing the MONITOR
+                      instruction.
+  @param  RegisterEcx The value to load into ECX or RCX before executing the MONITOR
+                      instruction.
+
+  @return RegisterEax
+
+**/
+UINTN
+EFIAPI
+AsmMwait (
+  IN      UINTN                     RegisterEax,
+  IN      UINTN                     RegisterEcx
+  )
+{
+  _asm {
+    mov     eax, RegisterEax
+    mov     ecx, RegisterEcx
+    _emit   0x0f              // mwait
+    _emit   0x01
+    _emit   0xC9
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Mwait.nasm b/MdePkg/Library/BaseLib/Ia32/Mwait.nasm
new file mode 100644
index 000000000000..1a369d37b4ba
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Mwait.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Mwait.Asm
+;
+; Abstract:
+;
+;   AsmMwait function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmMwait (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmMwait)
+ASM_PFX(AsmMwait):
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    DB      0xf, 1, 0xc9                ; mwait
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Non-existing.c b/MdePkg/Library/BaseLib/Ia32/Non-existing.c
new file mode 100644
index 000000000000..20146c07e373
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Non-existing.c
@@ -0,0 +1,57 @@
+/** @file
+  Non-existing BaseLib functions on Ia32
+
+  Copyright (c) 2006 - 2008, 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 <Library/DebugLib.h>
+
+/**
+  Disables the 64-bit paging mode on the CPU.
+
+  Disables the 64-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 64-paging mode.
+  This function is only available on x64. After the 64-bit paging mode is
+  disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be 0. The function EntryPoint must never return.
+
+  @param  CodeSelector  The 16-bit selector to load in the CS before EntryPoint
+                        is called. The descriptor in the GDT that this selector
+                        references must be setup for 32-bit protected mode.
+  @param  EntryPoint    The 64-bit virtual address of the function to call with
+                        the new stack after paging is disabled.
+  @param  Context1      The 64-bit virtual address of the context to pass into
+                        the EntryPoint function as the first parameter after
+                        paging is disabled.
+  @param  Context2      The 64-bit virtual address of the context to pass into
+                        the EntryPoint function as the second parameter after
+                        paging is disabled.
+  @param  NewStack      The 64-bit virtual address of the new stack to use for
+                        the EntryPoint function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+InternalX86DisablePaging64 (
+  IN      UINT16                    CodeSelector,
+  IN      UINT32                    EntryPoint,
+  IN      UINT32                    Context1,  OPTIONAL
+  IN      UINT32                    Context2,  OPTIONAL
+  IN      UINT32                    NewStack
+  )
+{
+  //
+  // This function cannot work on IA32 platform
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/RRotU64.S b/MdePkg/Library/BaseLib/Ia32/RRotU64.S
new file mode 100644
index 000000000000..a504f820185c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RRotU64.S
@@ -0,0 +1,48 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   RRotU64.S
+#
+# Abstract:
+#
+#   64-bit right rotation for Ia32
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMathRRotU64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathRRotU64 (
+#   IN      UINT64                    Operand,
+#   IN      UINTN                     Count
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathRRotU64):
+    push    %ebx
+    movb    16(%esp), %cl
+    movl    8(%esp), %eax
+    movl    12(%esp), %edx
+    shrdl   %cl, %eax, %ebx
+    shrdl   %cl, %edx, %eax
+    roll    %cl, %ebx
+    shrdl   %cl, %ebx, %edx
+    testb   $32, %cl                    # Count >= 32?
+    jz      L0
+    movl    %eax, %ecx                  # switch eax & edx if Count >= 32
+    movl    %edx, %eax
+    movl    %ecx, %edx
+L0:    
+    pop     %ebx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/RRotU64.asm b/MdePkg/Library/BaseLib/Ia32/RRotU64.asm
new file mode 100644
index 000000000000..261db376015d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RRotU64.asm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   RRotU64.asm
+;
+; Abstract:
+;
+;   64-bit right rotation for Ia32
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathRRotU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+InternalMathRRotU64 PROC    USES    ebx
+    mov     cl, [esp + 16]
+    mov     eax, [esp + 8]
+    mov     edx, [esp + 12]
+    shrd    ebx, eax, cl
+    shrd    eax, edx, cl
+    rol     ebx, cl
+    shrd    edx, ebx, cl
+    test    cl, 32                      ; Count >= 32?
+    jz      @F
+    mov     ecx, eax                    ; switch eax & edx if Count >= 32
+    mov     eax, edx
+    mov     edx, ecx
+@@:    
+    ret
+InternalMathRRotU64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/RRotU64.c b/MdePkg/Library/BaseLib/Ia32/RRotU64.c
new file mode 100644
index 000000000000..bbf0146fc6eb
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RRotU64.c
@@ -0,0 +1,55 @@
+/** @file
+  64-bit right rotation for Ia32
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Rotates a 64-bit integer right between 0 and 63 bits, filling
+  the high bits with the high low bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >>> Count
+
+**/
+UINT64
+EFIAPI
+InternalMathRRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  _asm {
+    mov     cl, byte ptr [Count]
+    mov     eax, dword ptr [Operand + 0]
+    mov     edx, dword ptr [Operand + 4]
+    shrd    ebx, eax, cl
+    shrd    eax, edx, cl
+    rol     ebx, cl
+    shrd    edx, ebx, cl
+    test    cl, 32                      // Count >= 32?
+    jz      L0
+    mov     ecx, eax
+    mov     eax, edx
+    mov     edx, ecx
+L0:
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/RRotU64.nasm b/MdePkg/Library/BaseLib/Ia32/RRotU64.nasm
new file mode 100644
index 000000000000..5946b3dc2ca7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RRotU64.nasm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   RRotU64.nasm
+;
+; Abstract:
+;
+;   64-bit right rotation for Ia32
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathRRotU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathRRotU64)
+ASM_PFX(InternalMathRRotU64):
+    push    ebx
+    mov     cl, [esp + 16]
+    mov     eax, [esp + 8]
+    mov     edx, [esp + 12]
+    shrd    ebx, eax, cl
+    shrd    eax, edx, cl
+    rol     ebx, cl
+    shrd    edx, ebx, cl
+    test    cl, 32                      ; Count >= 32?
+    jz      .0
+    mov     ecx, eax                    ; switch eax & edx if Count >= 32
+    mov     eax, edx
+    mov     edx, ecx
+.0:
+    pop     ebx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/RShiftU64.S b/MdePkg/Library/BaseLib/Ia32/RShiftU64.S
new file mode 100644
index 000000000000..8e1cec882857
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RShiftU64.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   RShiftU64.S
+#
+# Abstract:
+#
+#   64-bit logical right shift function for IA-32
+#
+#------------------------------------------------------------------------------
+
+
+    .code:
+
+ASM_GLOBAL ASM_PFX(InternalMathRShiftU64)
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathRShiftU64 (
+#   IN      UINT64                    Operand,
+#   IN      UINTN                     Count
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMathRShiftU64):
+    movb    12(%esp), %cl               # cl <- Count
+    xorl    %edx, %edx
+    movl    8(%esp), %eax
+    testb   $32, %cl                    # Count >= 32?
+    jnz     L0
+    movl    %eax, %edx
+    movl    0x4(%esp), %eax
+L0:    
+    shrdl   %cl, %edx, %eax
+    shr     %cl, %edx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/RShiftU64.asm b/MdePkg/Library/BaseLib/Ia32/RShiftU64.asm
new file mode 100644
index 000000000000..ad49536209a4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RShiftU64.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   RShiftU64.asm
+;
+; Abstract:
+;
+;   64-bit logical right shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathRShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+InternalMathRShiftU64   PROC
+    mov     cl, [esp + 12]              ; cl <- Count
+    xor     edx, edx
+    mov     eax, [esp + 8]
+    test    cl, 32                      ; Count >= 32?
+    jnz     @F
+    mov     edx, eax
+    mov     eax, [esp + 4]
+@@:    
+    shrd    eax, edx, cl
+    shr     edx, cl
+    ret
+InternalMathRShiftU64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/RShiftU64.c b/MdePkg/Library/BaseLib/Ia32/RShiftU64.c
new file mode 100644
index 000000000000..2db0d9752ff4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RShiftU64.c
@@ -0,0 +1,51 @@
+/** @file
+  64-bit logical right shift function for IA-32
+
+  Copyright (c) 2006 - 2015, 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.
+
+**/
+
+
+
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. This high bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count
+
+**/
+UINT64
+EFIAPI
+InternalMathRShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  _asm {
+    mov     cl, byte ptr [Count]
+    xor     edx, edx
+    mov     eax, dword ptr [Operand + 4]
+    test    cl, 32
+    jnz     L0
+    mov     edx, eax
+    mov     eax, dword ptr [Operand + 0]
+L0:
+    shrd    eax, edx, cl
+    shr     edx, cl
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/RShiftU64.nasm b/MdePkg/Library/BaseLib/Ia32/RShiftU64.nasm
new file mode 100644
index 000000000000..67de7ee38602
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RShiftU64.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   RShiftU64.nasm
+;
+; Abstract:
+;
+;   64-bit logical right shift function for IA-32
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathRShiftU64 (
+;   IN      UINT64                    Operand,
+;   IN      UINTN                     Count
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathRShiftU64)
+ASM_PFX(InternalMathRShiftU64):
+    mov     cl, [esp + 12]              ; cl <- Count
+    xor     edx, edx
+    mov     eax, [esp + 8]
+    test    cl, 32                      ; Count >= 32?
+    jnz     .0
+    mov     edx, eax
+    mov     eax, [esp + 4]
+.0:
+    shrd    eax, edx, cl
+    shr     edx, cl
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/RdRand.S b/MdePkg/Library/BaseLib/Ia32/RdRand.S
new file mode 100644
index 000000000000..92048b32518f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RdRand.S
@@ -0,0 +1,80 @@
+#------------------------------------------------------------------------------ ;
+# Copyright (c) 2015 - 2016, 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.
+#
+# Module Name:
+#
+#   RdRand.S
+#
+# Abstract:
+#
+#   Generates random number through CPU RdRand instruction under 32-bit platform.
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//  Generates a 16 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand16)
+ASM_PFX(InternalX86RdRand16):
+    .byte  0x0f, 0xc7, 0xf0        // rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 // jmp if CF=1
+    xor    %eax, %eax              // reg=0 if CF=0
+    ret                            // return with failure status
+rn16_ok:
+    mov    0x4(%esp), %edx
+    mov    %ax, (%edx)
+    mov    $0x1, %eax
+    ret
+
+//------------------------------------------------------------------------------
+//  Generates a 32 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand32)
+ASM_PFX(InternalX86RdRand32):
+    .byte  0x0f, 0xc7, 0xf0        // rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 // jmp if CF=1
+    xor    %eax, %eax              // reg=0 if CF=0
+    ret                            // return with failure status
+rn32_ok:
+    mov    0x4(%esp), %edx
+    mov    %eax, (%edx)
+    mov    $0x1, %eax
+    ret
+
+//------------------------------------------------------------------------------
+//  Generates a 64 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand64)
+ASM_PFX(InternalX86RdRand64):
+    .byte  0x0f, 0xc7, 0xf0        // rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jnc    rn64_ret                // jmp if CF=0
+    mov    0x4(%esp), %edx
+    mov    %eax, (%edx)
+
+    .byte  0x0f, 0xc7, 0xf0        // generate another 32 bit RN
+    jnc    rn64_ret                // jmp if CF=0
+    mov    %eax, 0x4(%edx)
+
+    mov    $0x1, %eax
+    ret
+rn64_ret:
+    xor    %eax, %eax
+    ret                            // return with failure status
diff --git a/MdePkg/Library/BaseLib/Ia32/RdRand.asm b/MdePkg/Library/BaseLib/Ia32/RdRand.asm
new file mode 100644
index 000000000000..b7af662e0b76
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RdRand.asm
@@ -0,0 +1,94 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2015 - 2016, 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.
+;
+; Module Name:
+;
+;   RdRand.asm
+;
+; Abstract:
+;
+;   Generates random number through CPU RdRand instruction under 32-bit platform.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+.686P
+.model flat, C
+
+.code
+
+;------------------------------------------------------------------------------
+;  Generates a 16 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+;------------------------------------------------------------------------------
+InternalX86RdRand16  PROC
+    ; rdrand   ax                  ; generate a 16 bit RN into ax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0fh, 0c7h, 0f0h         ; rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 ; jmp if CF=1
+    xor    eax, eax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn16_ok:
+    mov    edx, dword ptr [esp + 4]
+    mov    [edx], ax
+    mov    eax,  1
+    ret
+InternalX86RdRand16 ENDP
+
+;------------------------------------------------------------------------------
+;  Generates a 32 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+;------------------------------------------------------------------------------
+InternalX86RdRand32  PROC
+    ; rdrand   eax                 ; generate a 32 bit RN into eax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0fh, 0c7h, 0f0h         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 ; jmp if CF=1
+    xor    eax, eax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn32_ok:
+    mov    edx, dword ptr [esp + 4]
+    mov    [edx], eax
+    mov    eax,  1
+    ret
+InternalX86RdRand32 ENDP
+
+;------------------------------------------------------------------------------
+;  Generates a 64 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Rand);
+;------------------------------------------------------------------------------
+InternalX86RdRand64  PROC
+    ; rdrand   eax                 ; generate a 32 bit RN into eax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0fh, 0c7h, 0f0h         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jnc    rn64_ret                ; jmp if CF=0
+    mov    edx, dword ptr [esp + 4]
+    mov    [edx], eax
+
+    db     0fh, 0c7h, 0f0h         ; generate another 32 bit RN
+    jnc    rn64_ret                ; jmp if CF=0
+    mov    [edx + 4], eax
+
+    mov    eax,  1
+    ret
+rn64_ret:
+    xor    eax, eax
+    ret                            ; return with failure status
+InternalX86RdRand64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/RdRand.nasm b/MdePkg/Library/BaseLib/Ia32/RdRand.nasm
new file mode 100644
index 000000000000..0668f43be967
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/RdRand.nasm
@@ -0,0 +1,90 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2015 - 2016, 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.
+;
+; Module Name:
+;
+;   RdRand.nasm
+;
+; Abstract:
+;
+;   Generates random number through CPU RdRand instruction under 32-bit platform.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+SECTION .text
+
+;------------------------------------------------------------------------------
+;  Generates a 16 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand16)
+ASM_PFX(InternalX86RdRand16):
+    ; rdrand   ax                  ; generate a 16 bit RN into ax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0xf, 0xc7, 0xf0         ; rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 ; jmp if CF=1
+    xor    eax, eax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn16_ok:
+    mov    edx, dword [esp + 4]
+    mov    [edx], ax
+    mov    eax,  1
+    ret
+
+;------------------------------------------------------------------------------
+;  Generates a 32 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand32)
+ASM_PFX(InternalX86RdRand32):
+    ; rdrand   eax                 ; generate a 32 bit RN into eax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0xf, 0xc7, 0xf0         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 ; jmp if CF=1
+    xor    eax, eax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn32_ok:
+    mov    edx, dword [esp + 4]
+    mov    [edx], eax
+    mov    eax,  1
+    ret
+
+;------------------------------------------------------------------------------
+;  Generates a 64 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Rand);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand64)
+ASM_PFX(InternalX86RdRand64):
+    ; rdrand   eax                 ; generate a 32 bit RN into eax
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0xf, 0xc7, 0xf0         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jnc    rn64_ret                ; jmp if CF=0
+    mov    edx, dword [esp + 4]
+    mov    [edx], eax
+
+    db     0xf, 0xc7, 0xf0         ; generate another 32 bit RN
+    jnc    rn64_ret                ; jmp if CF=0
+    mov    [edx + 4], eax
+
+    mov    eax,  1
+    ret
+rn64_ret:
+    xor    eax, eax
+    ret                            ; return with failure status
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr0.asm b/MdePkg/Library/BaseLib/Ia32/ReadCr0.asm
new file mode 100644
index 000000000000..ceb935700e07
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr0.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr0.Asm
+;
+; Abstract:
+;
+;   AsmReadCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr0  PROC
+    mov     eax, cr0
+    ret
+AsmReadCr0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr0.c b/MdePkg/Library/BaseLib/Ia32/ReadCr0.c
new file mode 100644
index 000000000000..0e39ee777613
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr0.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmReadCr0 function
+
+  Copyright (c) 2006 - 2014, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of the Control Register 0 (CR0).
+
+  Reads and returns the current value of CR0. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 0 (CR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr0 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, cr0
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr0.nasm b/MdePkg/Library/BaseLib/Ia32/ReadCr0.nasm
new file mode 100644
index 000000000000..d09ceeac1880
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr0.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr0.Asm
+;
+; Abstract:
+;
+;   AsmReadCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr0)
+ASM_PFX(AsmReadCr0):
+    mov     eax, cr0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr2.asm b/MdePkg/Library/BaseLib/Ia32/ReadCr2.asm
new file mode 100644
index 000000000000..0391aad3d0af
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr2.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr2.Asm
+;
+; Abstract:
+;
+;   AsmReadCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr2  PROC
+    mov     eax, cr2
+    ret
+AsmReadCr2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr2.c b/MdePkg/Library/BaseLib/Ia32/ReadCr2.c
new file mode 100644
index 000000000000..e75b9506e168
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr2.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadCr2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of the Control Register 2 (CR2).
+
+  Reads and returns the current value of CR2. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 2 (CR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr2 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, cr2
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr2.nasm b/MdePkg/Library/BaseLib/Ia32/ReadCr2.nasm
new file mode 100644
index 000000000000..5b83d8946498
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr2.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr2.Asm
+;
+; Abstract:
+;
+;   AsmReadCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr2)
+ASM_PFX(AsmReadCr2):
+    mov     eax, cr2
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr3.asm b/MdePkg/Library/BaseLib/Ia32/ReadCr3.asm
new file mode 100644
index 000000000000..41c5df6a64e1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr3.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr3.Asm
+;
+; Abstract:
+;
+;   AsmReadCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr3  PROC
+    mov     eax, cr3
+    ret
+AsmReadCr3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr3.c b/MdePkg/Library/BaseLib/Ia32/ReadCr3.c
new file mode 100644
index 000000000000..2f01731f75a2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr3.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadCr3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of the Control Register 3 (CR3).
+
+  Reads and returns the current value of CR3. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 3 (CR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr3 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, cr3
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr3.nasm b/MdePkg/Library/BaseLib/Ia32/ReadCr3.nasm
new file mode 100644
index 000000000000..366e4ccd36b9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr3.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr3.Asm
+;
+; Abstract:
+;
+;   AsmReadCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr3)
+ASM_PFX(AsmReadCr3):
+    mov     eax, cr3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr4.asm b/MdePkg/Library/BaseLib/Ia32/ReadCr4.asm
new file mode 100644
index 000000000000..38d1258d9faa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr4.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr4.Asm
+;
+; Abstract:
+;
+;   AsmReadCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr4  PROC
+    mov     eax, cr4
+    ret
+AsmReadCr4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr4.c b/MdePkg/Library/BaseLib/Ia32/ReadCr4.c
new file mode 100644
index 000000000000..d12bf5cb55b7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr4.c
@@ -0,0 +1,40 @@
+/** @file
+  AsmReadCr4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of the Control Register 4 (CR4).
+
+  Reads and returns the current value of CR4. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of the Control Register 4 (CR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr4 (
+  VOID
+  )
+{
+  __asm {
+    _emit  0x0f  // mov  eax, cr4
+    _emit  0x20
+    _emit  0xE0
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCr4.nasm b/MdePkg/Library/BaseLib/Ia32/ReadCr4.nasm
new file mode 100644
index 000000000000..7276092b0dfc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCr4.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr4.Asm
+;
+; Abstract:
+;
+;   AsmReadCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr4)
+ASM_PFX(AsmReadCr4):
+    mov     eax, cr4
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCs.asm b/MdePkg/Library/BaseLib/Ia32/ReadCs.asm
new file mode 100644
index 000000000000..11f205bb46f2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCs.Asm
+;
+; Abstract:
+;
+;   AsmReadCs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadCs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCs   PROC
+    mov     eax, cs
+    ret
+AsmReadCs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCs.c b/MdePkg/Library/BaseLib/Ia32/ReadCs.c
new file mode 100644
index 000000000000..fe107029a172
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadCs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Code Segment Register (CS).
+
+  Reads and returns the current value of CS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of CS.
+
+**/
+UINT16
+EFIAPI
+AsmReadCs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, cs
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadCs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadCs.nasm
new file mode 100644
index 000000000000..3bfa816527ae
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadCs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCs.Asm
+;
+; Abstract:
+;
+;   AsmReadCs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadCs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCs)
+ASM_PFX(AsmReadCs):
+    mov     eax, cs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr0.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr0.asm
new file mode 100644
index 000000000000..6f0d61084ffc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr0.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr0.Asm
+;
+; Abstract:
+;
+;   AsmReadDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr0  PROC
+    mov     eax, dr0
+    ret
+AsmReadDr0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr0.c b/MdePkg/Library/BaseLib/Ia32/ReadDr0.c
new file mode 100644
index 000000000000..a3a9387e3975
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr0.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr0 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 0 (DR0).
+
+  Reads and returns the current value of DR0. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr0 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr0
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr0.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr0.nasm
new file mode 100644
index 000000000000..28a846e60252
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr0.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr0.Asm
+;
+; Abstract:
+;
+;   AsmReadDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr0)
+ASM_PFX(AsmReadDr0):
+    mov     eax, dr0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr1.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr1.asm
new file mode 100644
index 000000000000..e77265677c54
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr1.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr1.Asm
+;
+; Abstract:
+;
+;   AsmReadDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr1  PROC
+    mov     eax, dr1
+    ret
+AsmReadDr1  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr1.c b/MdePkg/Library/BaseLib/Ia32/ReadDr1.c
new file mode 100644
index 000000000000..7adbd78ec1d1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr1.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr1 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 1 (DR1).
+
+  Reads and returns the current value of DR1. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr1 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr1
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr1.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr1.nasm
new file mode 100644
index 000000000000..63c3341582d8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr1.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr1.Asm
+;
+; Abstract:
+;
+;   AsmReadDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr1)
+ASM_PFX(AsmReadDr1):
+    mov     eax, dr1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr2.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr2.asm
new file mode 100644
index 000000000000..cdb2ec6dd94b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr2.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr2.Asm
+;
+; Abstract:
+;
+;   AsmReadDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr2  PROC
+    mov     eax, dr2
+    ret
+AsmReadDr2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr2.c b/MdePkg/Library/BaseLib/Ia32/ReadDr2.c
new file mode 100644
index 000000000000..5ec96951e064
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr2.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 2 (DR2).
+
+  Reads and returns the current value of DR2. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr2 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr2
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr2.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr2.nasm
new file mode 100644
index 000000000000..49f16bba89ad
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr2.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr2.Asm
+;
+; Abstract:
+;
+;   AsmReadDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr2)
+ASM_PFX(AsmReadDr2):
+    mov     eax, dr2
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr3.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr3.asm
new file mode 100644
index 000000000000..807bef9ba794
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr3.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr3.Asm
+;
+; Abstract:
+;
+;   AsmReadDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr3  PROC
+    mov     eax, dr3
+    ret
+AsmReadDr3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr3.c b/MdePkg/Library/BaseLib/Ia32/ReadDr3.c
new file mode 100644
index 000000000000..07b587cbb506
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr3.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 3 (DR3).
+
+  Reads and returns the current value of DR3. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr3 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr3
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr3.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr3.nasm
new file mode 100644
index 000000000000..c09b2a1e1504
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr3.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr3.Asm
+;
+; Abstract:
+;
+;   AsmReadDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr3)
+ASM_PFX(AsmReadDr3):
+    mov     eax, dr3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr4.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr4.asm
new file mode 100644
index 000000000000..47ed5853b398
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr4.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr4.Asm
+;
+; Abstract:
+;
+;   AsmReadDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr4  PROC
+    ;
+    ; DR4 is alias to DR6 only if DE (in CR4) is cleared. Otherwise, reading
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0fh, 21h, 0e0h
+    ret
+AsmReadDr4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr4.c b/MdePkg/Library/BaseLib/Ia32/ReadDr4.c
new file mode 100644
index 000000000000..c42fb1c4c224
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr4.c
@@ -0,0 +1,40 @@
+/** @file
+  AsmReadDr4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 4 (DR4).
+
+  Reads and returns the current value of DR4. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr4 (
+  VOID
+  )
+{
+  __asm {
+    _emit  0x0f
+    _emit  0x21
+    _emit  0xe0
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr4.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr4.nasm
new file mode 100644
index 000000000000..5d784dfe8ae7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr4.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr4.Asm
+;
+; Abstract:
+;
+;   AsmReadDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr4)
+ASM_PFX(AsmReadDr4):
+    ;
+    ; DR4 is alias to DR6 only if DE (in CR4) is cleared. Otherwise, reading
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0xf, 0x21, 0xe0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr5.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr5.asm
new file mode 100644
index 000000000000..09154f663681
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr5.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr5.Asm
+;
+; Abstract:
+;
+;   AsmReadDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr5  PROC
+    ;
+    ; DR5 is alias to DR7 only if DE (in CR4) is cleared. Otherwise, reading
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0fh, 21h, 0e8h
+    ret
+AsmReadDr5  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr5.c b/MdePkg/Library/BaseLib/Ia32/ReadDr5.c
new file mode 100644
index 000000000000..9743fe2cff3e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr5.c
@@ -0,0 +1,40 @@
+/** @file
+  AsmReadDr5 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 5 (DR5).
+
+  Reads and returns the current value of DR5. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr5 (
+  VOID
+  )
+{
+  __asm {
+    _emit  0x0f
+    _emit  0x21
+    _emit  0xe8
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr5.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr5.nasm
new file mode 100644
index 000000000000..a12ecb6a1d15
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr5.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr5.Asm
+;
+; Abstract:
+;
+;   AsmReadDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr5)
+ASM_PFX(AsmReadDr5):
+    ;
+    ; DR5 is alias to DR7 only if DE (in CR4) is cleared. Otherwise, reading
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0xf, 0x21, 0xe8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr6.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr6.asm
new file mode 100644
index 000000000000..5ad9dcbd3339
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr6.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr6.Asm
+;
+; Abstract:
+;
+;   AsmReadDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr6  PROC
+    mov     eax, dr6
+    ret
+AsmReadDr6  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr6.c b/MdePkg/Library/BaseLib/Ia32/ReadDr6.c
new file mode 100644
index 000000000000..da0496531996
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr6.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr6 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 6 (DR6).
+
+  Reads and returns the current value of DR6. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr6 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr6
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr6.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr6.nasm
new file mode 100644
index 000000000000..1daa3612e3a8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr6.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr6.Asm
+;
+; Abstract:
+;
+;   AsmReadDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr6)
+ASM_PFX(AsmReadDr6):
+    mov     eax, dr6
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr7.asm b/MdePkg/Library/BaseLib/Ia32/ReadDr7.asm
new file mode 100644
index 000000000000..215a079f4644
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr7.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr7.Asm
+;
+; Abstract:
+;
+;   AsmReadDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr7  PROC
+    mov     eax, dr7
+    ret
+AsmReadDr7  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr7.c b/MdePkg/Library/BaseLib/Ia32/ReadDr7.c
new file mode 100644
index 000000000000..e3ec1eb347c4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr7.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDr7 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Debug Register 7 (DR7).
+
+  Reads and returns the current value of DR7. This function is only available
+  on IA-32 and x64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  x64.
+
+  @return The value of Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr7 (
+  VOID
+  )
+{
+  __asm {
+    mov     eax, dr7
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDr7.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDr7.nasm
new file mode 100644
index 000000000000..2777a118edd9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDr7.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr7.Asm
+;
+; Abstract:
+;
+;   AsmReadDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr7)
+ASM_PFX(AsmReadDr7):
+    mov     eax, dr7
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDs.asm b/MdePkg/Library/BaseLib/Ia32/ReadDs.asm
new file mode 100644
index 000000000000..68decd33f9fc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDs.Asm
+;
+; Abstract:
+;
+;   AsmReadDs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadDs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDs   PROC
+    mov     eax, ds
+    ret
+AsmReadDs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDs.c b/MdePkg/Library/BaseLib/Ia32/ReadDs.c
new file mode 100644
index 000000000000..a73aa2e1a774
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadDs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Data Segment Register (DS).
+
+  Reads and returns the current value of DS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of DS.
+
+**/
+UINT16
+EFIAPI
+AsmReadDs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, ds
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadDs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadDs.nasm
new file mode 100644
index 000000000000..f9b194c4ab0d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadDs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDs.Asm
+;
+; Abstract:
+;
+;   AsmReadDs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadDs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDs)
+ASM_PFX(AsmReadDs):
+    mov     eax, ds
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEflags.asm b/MdePkg/Library/BaseLib/Ia32/ReadEflags.asm
new file mode 100644
index 000000000000..4ef74e2d06fd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEflags.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEflags.Asm
+;
+; Abstract:
+;
+;   AsmReadEflags function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadEflags (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadEflags   PROC
+    pushfd
+    pop     eax
+    ret
+AsmReadEflags   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEflags.c b/MdePkg/Library/BaseLib/Ia32/ReadEflags.c
new file mode 100644
index 000000000000..f53747442b28
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEflags.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmReadEflags function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of the EFLAGS register.
+
+  Reads and returns the current value of the EFLAGS register. This function is
+  only available on IA-32 and x64. This returns a 32-bit value on IA-32 and a
+  64-bit value on x64.
+
+  @return EFLAGS on IA-32 or RFLAGS on x64.
+
+**/
+UINTN
+EFIAPI
+AsmReadEflags (
+  VOID
+  )
+{
+  __asm {
+    pushfd
+    pop     eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEflags.nasm b/MdePkg/Library/BaseLib/Ia32/ReadEflags.nasm
new file mode 100644
index 000000000000..51c520263709
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEflags.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEflags.Asm
+;
+; Abstract:
+;
+;   AsmReadEflags function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadEflags (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadEflags)
+ASM_PFX(AsmReadEflags):
+    pushfd
+    pop     eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEs.asm b/MdePkg/Library/BaseLib/Ia32/ReadEs.asm
new file mode 100644
index 000000000000..7e5d929be7b2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEs.Asm
+;
+; Abstract:
+;
+;   AsmReadEs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadEs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadEs   PROC
+    mov     eax, es
+    ret
+AsmReadEs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEs.c b/MdePkg/Library/BaseLib/Ia32/ReadEs.c
new file mode 100644
index 000000000000..d537fcd8e5ac
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadEs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of ES Data Segment Register (ES).
+
+  Reads and returns the current value of ES. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of ES.
+
+**/
+UINT16
+EFIAPI
+AsmReadEs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, es
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadEs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadEs.nasm
new file mode 100644
index 000000000000..497c647e3814
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadEs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEs.Asm
+;
+; Abstract:
+;
+;   AsmReadEs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadEs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadEs)
+ASM_PFX(AsmReadEs):
+    mov     eax, es
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadFs.asm b/MdePkg/Library/BaseLib/Ia32/ReadFs.asm
new file mode 100644
index 000000000000..9a5730866226
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadFs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadFs.Asm
+;
+; Abstract:
+;
+;   AsmReadFs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadFs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadFs   PROC
+    mov     eax, fs
+    ret
+AsmReadFs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadFs.c b/MdePkg/Library/BaseLib/Ia32/ReadFs.c
new file mode 100644
index 000000000000..9cc92b559f56
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadFs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadFs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of FS Data Segment Register (FS).
+
+  Reads and returns the current value of FS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of FS.
+
+**/
+UINT16
+EFIAPI
+AsmReadFs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, fs
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadFs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadFs.nasm
new file mode 100644
index 000000000000..2de629679b31
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadFs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadFs.Asm
+;
+; Abstract:
+;
+;   AsmReadFs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadFs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadFs)
+ASM_PFX(AsmReadFs):
+    mov     eax, fs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGdtr.asm b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.asm
new file mode 100644
index 000000000000..b74c50a02e25
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadGdtr (
+;   OUT IA32_DESCRIPTOR  *Gdtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86ReadGdtr   PROC
+    mov     eax, [esp + 4]
+    sgdt    fword ptr [eax]
+    ret
+InternalX86ReadGdtr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGdtr.c b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.c
new file mode 100644
index 000000000000..01d0a7260175
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmReadGdtr function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and x64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadGdtr (
+  OUT IA32_DESCRIPTOR  *Gdtr
+  )
+{
+  _asm {
+    mov     eax, Gdtr
+    sgdt    fword ptr [eax]
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGdtr.nasm b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.nasm
new file mode 100644
index 000000000000..2637cbd14bcd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadGdtr (
+;   OUT IA32_DESCRIPTOR  *Gdtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86ReadGdtr)
+ASM_PFX(InternalX86ReadGdtr):
+    mov     eax, [esp + 4]
+    sgdt    [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGs.asm b/MdePkg/Library/BaseLib/Ia32/ReadGs.asm
new file mode 100644
index 000000000000..99dad143762d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGs.Asm
+;
+; Abstract:
+;
+;   AsmReadGs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadGs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadGs   PROC
+    mov     eax, gs
+    ret
+AsmReadGs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGs.c b/MdePkg/Library/BaseLib/Ia32/ReadGs.c
new file mode 100644
index 000000000000..53eab438c55c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadGs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of GS Data Segment Register (GS).
+
+  Reads and returns the current value of GS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of GS.
+
+**/
+UINT16
+EFIAPI
+AsmReadGs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, gs
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadGs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadGs.nasm
new file mode 100644
index 000000000000..9c6fcee30368
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadGs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGs.Asm
+;
+; Abstract:
+;
+;   AsmReadGs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadGs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadGs)
+ASM_PFX(AsmReadGs):
+    mov     eax, gs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadIdtr.asm b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.asm
new file mode 100644
index 000000000000..803cfa781244
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadIdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadIdtr (
+;   OUT     IA32_DESCRIPTOR           *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86ReadIdtr PROC
+    mov     eax, [esp + 4]
+    sidt    fword ptr [eax]
+    ret
+InternalX86ReadIdtr ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadIdtr.c b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.c
new file mode 100644
index 000000000000..42d9aab2eb17
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadIdtr function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Reads the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and x64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  )
+{
+  _asm {
+    mov     eax, Idtr
+    sidt    fword ptr [eax]
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadIdtr.nasm b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.nasm
new file mode 100644
index 000000000000..3ee40e5d51e7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadIdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadIdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadIdtr (
+;   OUT     IA32_DESCRIPTOR           *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86ReadIdtr)
+ASM_PFX(InternalX86ReadIdtr):
+    mov     eax, [esp + 4]
+    sidt    [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadLdtr.asm b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.asm
new file mode 100644
index 000000000000..19c48d58b54f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadLdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadLdtr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadLdtr PROC
+    sldt    ax
+    ret
+AsmReadLdtr ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadLdtr.c b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.c
new file mode 100644
index 000000000000..d185572ff8e0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmReadLdtr function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current Local Descriptor Table Register(LDTR) selector.
+
+  Reads and returns the current 16-bit LDTR descriptor value. This function is
+  only available on IA-32 and x64.
+
+  @return The current selector of LDT.
+
+**/
+UINT16
+EFIAPI
+AsmReadLdtr (
+  VOID
+  )
+{
+  _asm {
+    sldt    ax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadLdtr.nasm b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.nasm
new file mode 100644
index 000000000000..29eddf2c8a3c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadLdtr.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadLdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadLdtr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadLdtr)
+ASM_PFX(AsmReadLdtr):
+    sldt    ax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm0.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm0.asm
new file mode 100644
index 000000000000..68113d8f9f54
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm0.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm0.Asm
+;
+; Abstract:
+;
+;   AsmReadMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm0  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm0
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm0.c b/MdePkg/Library/BaseLib/Ia32/ReadMm0.c
new file mode 100644
index 000000000000..8db4ca535610
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm0.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm0 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #0 (MM0).
+
+  Reads and returns the current value of MM0. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM0.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm0 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm0
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm0.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm0.nasm
new file mode 100644
index 000000000000..1330c71a6863
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm0.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm0.Asm
+;
+; Abstract:
+;
+;   AsmReadMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm0)
+ASM_PFX(AsmReadMm0):
+    push    eax
+    push    eax
+    movq    [esp], mm0
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm1.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm1.asm
new file mode 100644
index 000000000000..4cc2a36d086d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm1.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm1.Asm
+;
+; Abstract:
+;
+;   AsmReadMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm1  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm1
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm1  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm1.c b/MdePkg/Library/BaseLib/Ia32/ReadMm1.c
new file mode 100644
index 000000000000..f0750f420d92
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm1.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm1 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #1 (MM1).
+
+  Reads and returns the current value of MM1. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM1.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm1 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm1
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm1.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm1.nasm
new file mode 100644
index 000000000000..e411df817f83
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm1.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm1.Asm
+;
+; Abstract:
+;
+;   AsmReadMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm1)
+ASM_PFX(AsmReadMm1):
+    push    eax
+    push    eax
+    movq    [esp], mm1
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm2.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm2.asm
new file mode 100644
index 000000000000..7980b68eb132
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm2.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm2.Asm
+;
+; Abstract:
+;
+;   AsmReadMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm2  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm2
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm2.c b/MdePkg/Library/BaseLib/Ia32/ReadMm2.c
new file mode 100644
index 000000000000..17929b2f6419
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm2.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #2 (MM2).
+
+  Reads and returns the current value of MM2. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM2.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm2 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm2
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm2.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm2.nasm
new file mode 100644
index 000000000000..4190119c399b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm2.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm2.Asm
+;
+; Abstract:
+;
+;   AsmReadMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm2)
+ASM_PFX(AsmReadMm2):
+    push    eax
+    push    eax
+    movq    [esp], mm2
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm3.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm3.asm
new file mode 100644
index 000000000000..d557e4c84dd3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm3.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm3.Asm
+;
+; Abstract:
+;
+;   AsmReadMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm3  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm3
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm3.c b/MdePkg/Library/BaseLib/Ia32/ReadMm3.c
new file mode 100644
index 000000000000..a505f180ec61
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm3.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #3 (MM3).
+
+  Reads and returns the current value of MM3. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM3.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm3 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm3
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm3.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm3.nasm
new file mode 100644
index 000000000000..89125e8d3714
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm3.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm3.Asm
+;
+; Abstract:
+;
+;   AsmReadMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm3)
+ASM_PFX(AsmReadMm3):
+    push    eax
+    push    eax
+    movq    [esp], mm3
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm4.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm4.asm
new file mode 100644
index 000000000000..c1507729ddf7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm4.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm4.Asm
+;
+; Abstract:
+;
+;   AsmReadMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm4  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm4
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm4.c b/MdePkg/Library/BaseLib/Ia32/ReadMm4.c
new file mode 100644
index 000000000000..ecc3896cfc07
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm4.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #4 (MM4).
+
+  Reads and returns the current value of MM4. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM4.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm4 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm4
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm4.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm4.nasm
new file mode 100644
index 000000000000..a0e8d1681e99
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm4.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm4.Asm
+;
+; Abstract:
+;
+;   AsmReadMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm4)
+ASM_PFX(AsmReadMm4):
+    push    eax
+    push    eax
+    movq    [esp], mm4
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm5.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm5.asm
new file mode 100644
index 000000000000..a6cfbf2fd386
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm5.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm5.Asm
+;
+; Abstract:
+;
+;   AsmReadMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm5  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm5
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm5  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm5.c b/MdePkg/Library/BaseLib/Ia32/ReadMm5.c
new file mode 100644
index 000000000000..e97471757e96
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm5.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm5 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #5 (MM5).
+
+  Reads and returns the current value of MM5. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM5.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm5 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm5
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm5.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm5.nasm
new file mode 100644
index 000000000000..2c96bfa20fdc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm5.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm5.Asm
+;
+; Abstract:
+;
+;   AsmReadMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm5)
+ASM_PFX(AsmReadMm5):
+    push    eax
+    push    eax
+    movq    [esp], mm5
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm6.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm6.asm
new file mode 100644
index 000000000000..753670851ff8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm6.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm6.Asm
+;
+; Abstract:
+;
+;   AsmReadMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm6  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm6
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm6  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm6.c b/MdePkg/Library/BaseLib/Ia32/ReadMm6.c
new file mode 100644
index 000000000000..a64cf507a0aa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm6.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm6 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #6 (MM6).
+
+  Reads and returns the current value of MM6. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM6.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm6 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm6
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm6.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm6.nasm
new file mode 100644
index 000000000000..f6a6047a542e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm6.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm6.Asm
+;
+; Abstract:
+;
+;   AsmReadMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm6)
+ASM_PFX(AsmReadMm6):
+    push    eax
+    push    eax
+    movq    [esp], mm6
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm7.asm b/MdePkg/Library/BaseLib/Ia32/ReadMm7.asm
new file mode 100644
index 000000000000..64ad7ab299a0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm7.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm7.Asm
+;
+; Abstract:
+;
+;   AsmReadMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm7  PROC
+    push    eax
+    push    eax
+    movq    [esp], mm7
+    pop     eax
+    pop     edx
+    ret
+AsmReadMm7  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm7.c b/MdePkg/Library/BaseLib/Ia32/ReadMm7.c
new file mode 100644
index 000000000000..0cea21956c12
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm7.c
@@ -0,0 +1,42 @@
+/** @file
+  AsmReadMm7 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of 64-bit MMX Register #7 (MM7).
+
+  Reads and returns the current value of MM7. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of MM7.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm7 (
+  VOID
+  )
+{
+  _asm {
+    push    eax
+    push    eax
+    movq    [esp], mm7
+    pop     eax
+    pop     edx
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMm7.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMm7.nasm
new file mode 100644
index 000000000000..655aa40761b6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMm7.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm7.Asm
+;
+; Abstract:
+;
+;   AsmReadMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm7)
+ASM_PFX(AsmReadMm7):
+    push    eax
+    push    eax
+    movq    [esp], mm7
+    pop     eax
+    pop     edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMsr64.asm b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.asm
new file mode 100644
index 000000000000..e04808937cbf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMsr64.Asm
+;
+; Abstract:
+;
+;   AsmReadMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMsr64 (
+;   IN UINT64  Index
+;   );
+;------------------------------------------------------------------------------
+AsmReadMsr64    PROC
+    mov     ecx, [esp + 4]
+    rdmsr
+    ret
+AsmReadMsr64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMsr64.c b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.c
new file mode 100644
index 000000000000..e16c91744c36
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.c
@@ -0,0 +1,43 @@
+/** @file
+  AsmReadMsr64 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Returns a 64-bit Machine Specific Register(MSR).
+
+  Reads and returns the 64-bit MSR specified by Index. No parameter checking is
+  performed on Index, and some Index values may cause CPU exceptions. The
+  caller must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The value of the MSR identified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr64 (
+  IN UINT32  Index
+  )
+{
+  _asm {
+    mov     ecx, Index
+    rdmsr
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadMsr64.nasm b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.nasm
new file mode 100644
index 000000000000..f1dbd4111401
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadMsr64.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMsr64.Asm
+;
+; Abstract:
+;
+;   AsmReadMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMsr64 (
+;   IN UINT64  Index
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMsr64)
+ASM_PFX(AsmReadMsr64):
+    mov     ecx, [esp + 4]
+    rdmsr
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadPmc.asm b/MdePkg/Library/BaseLib/Ia32/ReadPmc.asm
new file mode 100644
index 000000000000..0e87bfa03cc1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadPmc.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadPmc.Asm
+;
+; Abstract:
+;
+;   AsmReadPmc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadPmc (
+;   IN UINT32   PmcIndex
+;   );
+;------------------------------------------------------------------------------
+AsmReadPmc  PROC
+    mov     ecx, [esp + 4]
+    rdpmc
+    ret
+AsmReadPmc  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadPmc.c b/MdePkg/Library/BaseLib/Ia32/ReadPmc.c
new file mode 100644
index 000000000000..faa1f565810a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadPmc.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmReadPmc function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Reads the current value of a Performance Counter (PMC).
+
+  Reads and returns the current value of performance counter specified by
+  Index. This function is only available on IA-32 and x64.
+
+  @param  Index The 32-bit Performance Counter index to read.
+
+  @return The value of the PMC specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmc (
+  IN UINT32   Index
+  )
+{
+  _asm {
+    mov     ecx, Index
+    rdpmc
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadPmc.nasm b/MdePkg/Library/BaseLib/Ia32/ReadPmc.nasm
new file mode 100644
index 000000000000..8eb0501a6251
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadPmc.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadPmc.Asm
+;
+; Abstract:
+;
+;   AsmReadPmc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadPmc (
+;   IN UINT32   PmcIndex
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadPmc)
+ASM_PFX(AsmReadPmc):
+    mov     ecx, [esp + 4]
+    rdpmc
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadSs.asm b/MdePkg/Library/BaseLib/Ia32/ReadSs.asm
new file mode 100644
index 000000000000..f881751d6dde
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadSs.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadSs.Asm
+;
+; Abstract:
+;
+;   AsmReadSs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadSs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadSs   PROC
+    mov     eax, ss
+    ret
+AsmReadSs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadSs.c b/MdePkg/Library/BaseLib/Ia32/ReadSs.c
new file mode 100644
index 000000000000..f1ced5e0ed49
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadSs.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmReadSs function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Stack Segment Register (SS).
+
+  Reads and returns the current value of SS. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of SS.
+
+**/
+UINT16
+EFIAPI
+AsmReadSs (
+  VOID
+  )
+{
+  __asm {
+    xor     eax, eax
+    mov     ax, ss
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadSs.nasm b/MdePkg/Library/BaseLib/Ia32/ReadSs.nasm
new file mode 100644
index 000000000000..6b3da79270bf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadSs.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadSs.Asm
+;
+; Abstract:
+;
+;   AsmReadSs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadSs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadSs)
+ASM_PFX(AsmReadSs):
+    mov     eax, ss
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTr.asm b/MdePkg/Library/BaseLib/Ia32/ReadTr.asm
new file mode 100644
index 000000000000..703bec7ef6b2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTr.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTr.Asm
+;
+; Abstract:
+;
+;   AsmReadTr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadTr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadTr   PROC
+    str     ax
+    ret
+AsmReadTr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTr.c b/MdePkg/Library/BaseLib/Ia32/ReadTr.c
new file mode 100644
index 000000000000..23273f385356
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTr.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmReadTr function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Task Register (TR).
+
+  Reads and returns the current value of TR. This function is only available on
+  IA-32 and x64.
+
+  @return The current value of TR.
+
+**/
+UINT16
+EFIAPI
+AsmReadTr (
+  VOID
+  )
+{
+  _asm {
+    str     ax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTr.nasm b/MdePkg/Library/BaseLib/Ia32/ReadTr.nasm
new file mode 100644
index 000000000000..811153c418e7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTr.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTr.Asm
+;
+; Abstract:
+;
+;   AsmReadTr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadTr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadTr)
+ASM_PFX(AsmReadTr):
+    str     ax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTsc.asm b/MdePkg/Library/BaseLib/Ia32/ReadTsc.asm
new file mode 100644
index 000000000000..5c2004153a09
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTsc.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTsc.Asm
+;
+; Abstract:
+;
+;   AsmReadTsc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadTsc (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadTsc  PROC
+    rdtsc
+    ret
+AsmReadTsc  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTsc.c b/MdePkg/Library/BaseLib/Ia32/ReadTsc.c
new file mode 100644
index 000000000000..79f676e6d9ee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTsc.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmReadTsc function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Reads the current value of Time Stamp Counter (TSC).
+
+  Reads and returns the current value of TSC. This function is only available
+  on IA-32 and x64.
+
+  @return The current value of TSC
+
+**/
+UINT64
+EFIAPI
+AsmReadTsc (
+  VOID
+  )
+{
+  _asm {
+    rdtsc
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/ReadTsc.nasm b/MdePkg/Library/BaseLib/Ia32/ReadTsc.nasm
new file mode 100644
index 000000000000..f28e20e445d6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/ReadTsc.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTsc.Asm
+;
+; Abstract:
+;
+;   AsmReadTsc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadTsc (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadTsc)
+ASM_PFX(AsmReadTsc):
+    rdtsc
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/SetJump.S b/MdePkg/Library/BaseLib/Ia32/SetJump.S
new file mode 100644
index 000000000000..744a77e7dc79
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SetJump.S
@@ -0,0 +1,44 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetJump.S
+#
+# Abstract:
+#
+#   Implementation of SetJump() on IA-32.
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(SetJump), ASM_PFX(InternalAssertJumpBuffer)
+
+#------------------------------------------------------------------------------
+# UINTN
+# EFIAPI
+# SetJump (
+#   OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(SetJump):
+    pushl   0x4(%esp)
+    call    ASM_PFX(InternalAssertJumpBuffer)               # To validate JumpBuffer
+    pop     %ecx
+    pop     %ecx                                            # ecx <- return address
+    movl    (%esp), %edx
+    movl    %ebx, (%edx)
+    movl    %esi, 4(%edx)
+    movl    %edi, 8(%edx)
+    movl    %ebp, 12(%edx)
+    movl    %esp, 16(%edx)
+    movl    %ecx, 20(%edx)                                  # eip value to restore in LongJump
+    xorl    %eax, %eax
+    jmp     *%ecx
diff --git a/MdePkg/Library/BaseLib/Ia32/SetJump.asm b/MdePkg/Library/BaseLib/Ia32/SetJump.asm
new file mode 100644
index 000000000000..3c078ff97bd7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SetJump.asm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetJump.Asm
+;
+; Abstract:
+;
+;   Implementation of SetJump() on IA-32.
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+InternalAssertJumpBuffer    PROTO   C
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; SetJump (
+;   OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+;   );
+;------------------------------------------------------------------------------
+SetJump     PROC
+    push    DWORD [esp + 4]
+    call    InternalAssertJumpBuffer    ; To validate JumpBuffer
+    pop     ecx
+    pop     ecx                         ; ecx <- return address
+    mov     edx, [esp]
+    mov     [edx], ebx
+    mov     [edx + 4], esi
+    mov     [edx + 8], edi
+    mov     [edx + 12], ebp
+    mov     [edx + 16], esp
+    mov     [edx + 20], ecx             ; eip value to restore in LongJump
+    xor     eax, eax
+    jmp     ecx
+SetJump     ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/SetJump.c b/MdePkg/Library/BaseLib/Ia32/SetJump.c
new file mode 100644
index 000000000000..414c36e0f2d5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SetJump.c
@@ -0,0 +1,74 @@
+/** @file
+  Implementation of SetJump() on IA-32.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Worker function that checks ASSERT condition for JumpBuffer
+
+  Checks ASSERT condition for JumpBuffer.
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+
+**/
+VOID
+EFIAPI
+InternalAssertJumpBuffer (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  );
+
+/**
+  Saves the current CPU context that can be restored with a call to LongJump()
+  and returns 0.
+
+  Saves the current CPU context in the buffer specified by JumpBuffer and
+  returns 0. The initial call to SetJump() must always return 0. Subsequent
+  calls to LongJump() cause a non-zero value to be returned by SetJump().
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  JumpBuffer  A pointer to CPU context buffer.
+
+  @retval 0 Indicates a return from SetJump().
+
+**/
+_declspec (naked)
+UINTN
+EFIAPI
+SetJump (
+  OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  )
+{
+  _asm {
+    push    [esp + 4]
+    call    InternalAssertJumpBuffer
+    pop     ecx
+    pop     ecx
+    mov     edx, [esp]
+    mov     [edx], ebx
+    mov     [edx + 4], esi
+    mov     [edx + 8], edi
+    mov     [edx + 12], ebp
+    mov     [edx + 16], esp
+    mov     [edx + 20], ecx
+    xor     eax, eax
+    jmp     ecx
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/SetJump.nasm b/MdePkg/Library/BaseLib/Ia32/SetJump.nasm
new file mode 100644
index 000000000000..58074b87ccb6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SetJump.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetJump.Asm
+;
+; Abstract:
+;
+;   Implementation of SetJump() on IA-32.
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+extern ASM_PFX(InternalAssertJumpBuffer)
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; SetJump (
+;   OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(SetJump)
+ASM_PFX(SetJump):
+    push    DWORD [esp + 4]
+    call    ASM_PFX(InternalAssertJumpBuffer)    ; To validate JumpBuffer
+    pop     ecx
+    pop     ecx                         ; ecx <- return address
+    mov     edx, [esp]
+    mov     [edx], ebx
+    mov     [edx + 4], esi
+    mov     [edx + 8], edi
+    mov     [edx + 12], ebp
+    mov     [edx + 16], esp
+    mov     [edx + 20], ecx             ; eip value to restore in LongJump
+    xor     eax, eax
+    jmp     ecx
+
diff --git a/MdePkg/Library/BaseLib/Ia32/SwapBytes64.S b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.S
new file mode 100644
index 000000000000..265b6b72fe95
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.S
@@ -0,0 +1,38 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuId.S
+#
+# Abstract:
+#
+#   AsmCpuid function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# UINT64
+# EFIAPI
+# InternalMathSwapBytes64 (
+#   IN      UINT64                    Operand
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMathSwapBytes64)
+ASM_PFX(InternalMathSwapBytes64):
+    movl    8(%esp), %eax               # eax <- upper 32 bits
+    movl    4(%esp), %edx               # edx <- lower 32 bits
+    bswapl  %eax
+    bswapl  %edx
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/SwapBytes64.asm b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.asm
new file mode 100644
index 000000000000..1ab67db482c4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathSwapBytes64 (
+;   IN      UINT64                    Operand
+;   );
+;------------------------------------------------------------------------------
+InternalMathSwapBytes64 PROC
+    mov     eax, [esp + 8]              ; eax <- upper 32 bits
+    mov     edx, [esp + 4]              ; edx <- lower 32 bits
+    bswap   eax
+    bswap   edx
+    ret
+InternalMathSwapBytes64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/SwapBytes64.c b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.c
new file mode 100644
index 000000000000..3e03b6547489
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.c
@@ -0,0 +1,43 @@
+/** @file
+  Implementation of 64-bit swap bytes
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Switches the endianess of a 64-bit integer.
+
+  This function swaps the bytes in a 64-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Operand A 64-bit unsigned value.
+
+  @return The byte swaped Operand.
+
+**/
+UINT64
+EFIAPI
+InternalMathSwapBytes64 (
+  IN      UINT64                    Operand
+  )
+{
+  _asm {
+    mov     eax, dword ptr [Operand + 4]
+    mov     edx, dword ptr [Operand + 0]
+    bswap   eax
+    bswap   edx
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/SwapBytes64.nasm b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.nasm
new file mode 100644
index 000000000000..32fc1a6457b8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/SwapBytes64.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalMathSwapBytes64 (
+;   IN      UINT64                    Operand
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMathSwapBytes64)
+ASM_PFX(InternalMathSwapBytes64):
+    mov     eax, [esp + 8]              ; eax <- upper 32 bits
+    mov     edx, [esp + 4]              ; edx <- lower 32 bits
+    bswap   eax
+    bswap   edx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Thunk16.S b/MdePkg/Library/BaseLib/Ia32/Thunk16.S
new file mode 100644
index 000000000000..f5189d0515e2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Thunk16.S
@@ -0,0 +1,222 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2013, 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.
+#
+# Module Name:
+#
+#   Thunk16.S
+#
+# Abstract:
+#
+#   Real mode thunk
+#
+#------------------------------------------------------------------------------
+
+#include <Library/BaseLib.h>
+
+ASM_GLOBAL ASM_PFX(m16Start), ASM_PFX(m16Size), ASM_PFX(mThunk16Attr), ASM_PFX(m16Gdt), ASM_PFX(m16GdtrBase), ASM_PFX(mTransition)
+ASM_GLOBAL ASM_PFX(InternalAsmThunk16)
+
+# define the structure of IA32_REGS
+.set  _EDI, 0       #size 4
+.set  _ESI, 4       #size 4
+.set  _EBP, 8       #size 4
+.set  _ESP, 12      #size 4
+.set  _EBX, 16      #size 4
+.set  _EDX, 20      #size 4
+.set  _ECX, 24      #size 4
+.set  _EAX, 28      #size 4
+.set  _DS,  32      #size 2
+.set  _ES,  34      #size 2
+.set  _FS,  36      #size 2
+.set  _GS,  38      #size 2
+.set  _EFLAGS, 40   #size 4
+.set  _EIP, 44      #size 4
+.set  _CS, 48       #size 2
+.set  _SS, 50       #size 2
+.set  IA32_REGS_SIZE, 52
+
+    .text
+    .code16
+
+ASM_PFX(m16Start):
+
+SavedGdt:     .space  6
+
+ASM_PFX(BackFromUserCode):
+    push    %ss
+    push    %cs
+
+    calll   L_Base1                     # push eip
+L_Base1:
+    pushfl
+    cli                                 # disable interrupts
+    push    %gs
+    push    %fs
+    push    %es
+    push    %ds
+    pushal
+    .byte   0x66, 0xba                  # mov edx, imm32
+ASM_PFX(ThunkAttr): .space  4
+    testb   $THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15, %dl
+    jz      1f
+    movw    $0x2401, %ax
+    int     $0x15
+    cli                                 # disable interrupts
+    jnc     2f
+1:
+    testb   $THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL, %dl
+    jz      2f
+    inb     $0x92, %al
+    orb     $2, %al
+    outb    %al, $0x92                  # deactivate A20M#
+2:
+    xorl    %eax, %eax
+    movw    %ss, %ax
+    leal    IA32_REGS_SIZE(%esp), %ebp
+    mov     %ebp, (_ESP - IA32_REGS_SIZE)(%bp)
+    mov     (_EIP - IA32_REGS_SIZE)(%bp), %bx
+    shll    $4, %eax
+    addl    %eax, %ebp
+    .byte   0x66, 0xb8                  # mov eax, imm32
+SavedCr4:   .space  4
+    movl    %eax, %cr4
+    lgdtl   %cs:(SavedGdt - L_Base1)(%bx)
+    .byte   0x66, 0xb8                  # mov eax, imm32
+SavedCr0:   .space  4
+    movl    %eax, %cr0
+    .byte   0xb8                        # mov ax, imm16
+SavedSs:    .space  2
+    movl    %eax, %ss
+    .byte   0x66, 0xbc                  # mov esp, imm32
+SavedEsp:   .space  4
+    lretl                               # return to protected mode
+
+_EntryPoint:    .long      ASM_PFX(ToUserCode) - ASM_PFX(m16Start)
+                .word      0x8
+_16Idtr:        .word      0x3ff
+                .long      0
+_16Gdtr:        .word      GdtEnd - _NullSegDesc - 1
+_16GdtrBase:    .long      _NullSegDesc
+
+ASM_PFX(ToUserCode):
+    movw    %ss, %dx
+    movw    %cx, %ss                    # set new segment selectors
+    movw    %cx, %ds
+    movw    %cx, %es
+    movw    %cx, %fs
+    movw    %cx, %gs
+    movl    %eax, %cr0                  # real mode starts at next instruction
+                                        #  which (per SDM) *must* be a far JMP.
+    ljmpw   $0,$0                       # will be filled in by InternalAsmThunk16
+L_Base:                                 #  to point here.
+    movl    %ebp, %cr4
+    movw    %si, %ss                    # set up 16-bit stack segment
+    xchgl   %ebx, %esp                  # set up 16-bit stack pointer
+
+    movw    IA32_REGS_SIZE(%esp), %bp   # get BackToUserCode address from stack
+    mov     %dx, %cs:(SavedSs - ASM_PFX(BackFromUserCode))(%bp)
+    mov     %ebx, %cs:(SavedEsp - ASM_PFX(BackFromUserCode))(%bp)
+    lidtl   %cs:(_16Idtr - ASM_PFX(BackFromUserCode))(%bp)
+    popal
+    pop     %ds
+    pop     %es
+    pop     %fs
+    pop     %gs
+    popfl
+    lretl                               # transfer control to user code
+
+_NullSegDesc:   .quad   0
+_16CsDesc:
+                .word   -1
+                .word   0
+                .byte   0
+                .byte   0x9b
+                .byte   0x8f            # 16-bit segment, 4GB limit
+                .byte   0
+_16DsDesc:
+                .word   -1
+                .word   0
+                .byte   0
+                .byte   0x93
+                .byte   0x8f            # 16-bit segment, 4GB limit
+                .byte   0
+GdtEnd:
+
+    .code32
+#
+#   @param  RegSet  The pointer to a IA32_DWORD_REGS structure
+#   @param  Transition  The pointer to the transition code
+#   @return The address of the 16-bit stack after returning from user code
+#
+ASM_PFX(InternalAsmThunk16):
+    push    %ebp
+    push    %ebx
+    push    %esi
+    push    %edi
+    push    %ds
+    push    %es
+    push    %fs
+    push    %gs
+    movl    36(%esp), %esi              # esi <- RegSet
+    movzwl  _SS(%esi), %edx
+    mov     _ESP(%esi), %edi
+    add     $(-(IA32_REGS_SIZE + 4)), %edi
+    movl    %edi, %ebx                  # ebx <- stack offset
+    imul    $0x10, %edx, %eax
+    push    $(IA32_REGS_SIZE / 4)
+    addl    %eax, %edi                  # edi <- linear address of 16-bit stack
+    pop     %ecx
+    rep
+    movsl                               # copy RegSet
+    movl    40(%esp), %eax              # eax <- address of transition code
+    movl    %edx, %esi                  # esi <- 16-bit stack segment
+    lea     (SavedCr0 - ASM_PFX(m16Start))(%eax), %edx
+    movl    %eax, %ecx
+    andl    $0xf, %ecx
+    shll    $12, %eax
+    lea     (ASM_PFX(BackFromUserCode) - ASM_PFX(m16Start))(%ecx), %ecx
+    movw    %cx, %ax
+    stosl                               # [edi] <- return address of user code
+    addl    $(L_Base - ASM_PFX(BackFromUserCode)), %eax
+    movl    %eax, (L_Base - SavedCr0 - 4)(%edx)
+    sgdtl   (SavedGdt - SavedCr0)(%edx)
+    sidtl   0x24(%esp)
+    movl    %cr0, %eax
+    movl    %eax, (%edx)                # save CR0 in SavedCr0
+    andl    $0x7ffffffe, %eax           # clear PE, PG bits
+    movl    %cr4, %ebp
+    mov     %ebp, (SavedCr4 - SavedCr0)(%edx)
+    andl    $0xffffffcf, %ebp           # clear PAE, PSE bits
+    pushl   $0x10
+    pop     %ecx                        # ecx <- selector for data segments
+    lgdtl   (_16Gdtr - SavedCr0)(%edx)
+    pushfl
+    lcall   *(_EntryPoint - SavedCr0)(%edx)
+    popfl
+    lidtl   0x24(%esp)
+    lea     -IA32_REGS_SIZE(%ebp), %eax
+    pop     %gs
+    pop     %fs
+    pop     %es
+    pop     %ds
+    pop     %edi
+    pop     %esi
+    pop     %ebx
+    pop     %ebp
+    ret
+
+    .const:
+
+ASM_PFX(m16Size):        .word      ASM_PFX(InternalAsmThunk16)  - ASM_PFX(m16Start)
+ASM_PFX(mThunk16Attr):   .word      ASM_PFX(ThunkAttr)          - ASM_PFX(m16Start)
+ASM_PFX(m16Gdt):         .word      _NullSegDesc        - ASM_PFX(m16Start)
+ASM_PFX(m16GdtrBase):    .word      _16GdtrBase         - ASM_PFX(m16Start)
+ASM_PFX(mTransition):    .word      _EntryPoint         - ASM_PFX(m16Start)
diff --git a/MdePkg/Library/BaseLib/Ia32/Thunk16.asm b/MdePkg/Library/BaseLib/Ia32/Thunk16.asm
new file mode 100644
index 000000000000..9311c1161f0e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Thunk16.asm
@@ -0,0 +1,260 @@
+
+#include "BaseLibInternals.h"
+
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   Thunk.asm
+;
+; Abstract:
+;
+;   Real mode thunk
+;
+;------------------------------------------------------------------------------
+
+    .686p
+    .model  flat,C
+
+EXTERNDEF   C   m16Start:BYTE
+EXTERNDEF   C   m16Size:WORD
+EXTERNDEF   C   mThunk16Attr:WORD
+EXTERNDEF   C   m16Gdt:WORD
+EXTERNDEF   C   m16GdtrBase:WORD
+EXTERNDEF   C   mTransition:WORD
+
+;
+; Here is the layout of the real mode stack. _ToUserCode() is responsible for
+; loading all these registers from real mode stack.
+;
+IA32_REGS   STRUC   4t
+_EDI        DD      ?
+_ESI        DD      ?
+_EBP        DD      ?
+_ESP        DD      ?
+_EBX        DD      ?
+_EDX        DD      ?
+_ECX        DD      ?
+_EAX        DD      ?
+_DS         DW      ?
+_ES         DW      ?
+_FS         DW      ?
+_GS         DW      ?
+_EFLAGS     DD      ?
+_EIP        DD      ?
+_CS         DW      ?
+_SS         DW      ?
+IA32_REGS   ENDS
+
+    .const
+
+;
+; These are global constant to convey information to C code.
+;
+m16Size         DW      InternalAsmThunk16 - m16Start
+mThunk16Attr    DW      _ThunkAttr - m16Start
+m16Gdt          DW      _NullSegDesc - m16Start
+m16GdtrBase     DW      _16GdtrBase - m16Start
+mTransition     DW      _EntryPoint - m16Start
+
+    .code
+
+m16Start    LABEL   BYTE
+
+SavedGdt    LABEL   FWORD
+            DW      ?
+            DD      ?
+;------------------------------------------------------------------------------
+; _BackFromUserCode() takes control in real mode after 'retf' has been executed
+; by user code. It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_BackFromUserCode   PROC
+    ;
+    ; The order of saved registers on the stack matches the order they appears
+    ; in IA32_REGS structure. This facilitates wrapper function to extract them
+    ; into that structure.
+    ;
+    push    ss
+    push    cs
+    DB      66h
+    call    @Base                       ; push eip
+@Base:
+    pushf                               ; pushfd actually
+    cli                                 ; disable interrupts
+    push    gs
+    push    fs
+    push    es
+    push    ds
+    pushaw                              ; pushad actually
+    DB      66h, 0bah                   ; mov edx, imm32
+_ThunkAttr  DD      ?
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15
+    jz      @1
+    mov     eax, 15cd2401h              ; mov ax, 2401h & int 15h
+    cli                                 ; disable interrupts
+    jnc     @2
+@1:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL
+    jz      @2
+    in      al, 92h
+    or      al, 2
+    out     92h, al                     ; deactivate A20M#
+@2:
+    xor     ax, ax                      ; xor eax, eax
+    mov     eax, ss                     ; mov ax, ss
+    DB      67h
+    lea     bp, [esp + sizeof (IA32_REGS)]
+    ;
+    ; esi's in the following 2 instructions are indeed bp in 16-bit code. Fact
+    ; is "esi" in 32-bit addressing mode has the same encoding of "bp" in 16-
+    ; bit addressing mode.
+    ;
+    mov     word ptr (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._ESP, bp
+    mov     ebx, (IA32_REGS ptr [esi - sizeof (IA32_REGS)])._EIP
+    shl     ax, 4                       ; shl eax, 4
+    add     bp, ax                      ; add ebp, eax
+    DB      66h, 0b8h                   ; mov eax, imm32
+SavedCr4    DD      ?
+    mov     cr4, eax
+    DB      66h
+    lgdt    fword ptr cs:[edi + (SavedGdt - @Base)]
+    DB      66h, 0b8h                   ; mov eax, imm32
+SavedCr0    DD      ?
+    mov     cr0, eax
+    DB      0b8h                        ; mov ax, imm16
+SavedSs     DW      ?
+    mov     ss, eax
+    DB      66h, 0bch                   ; mov esp, imm32
+SavedEsp    DD      ?
+    DB      66h
+    retf                                ; return to protected mode
+_BackFromUserCode   ENDP
+
+_EntryPoint DD      _ToUserCode - m16Start
+            DW      8h
+_16Idtr     FWORD   (1 SHL 10) - 1
+_16Gdtr     LABEL   FWORD
+            DW      GdtEnd - _NullSegDesc - 1
+_16GdtrBase DD      _NullSegDesc
+
+;------------------------------------------------------------------------------
+; _ToUserCode() takes control in real mode before passing control to user code.
+; It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_ToUserCode PROC
+    mov     edx, ss
+    mov     ss, ecx                     ; set new segment selectors
+    mov     ds, ecx
+    mov     es, ecx
+    mov     fs, ecx
+    mov     gs, ecx
+    mov     cr0, eax                    ; real mode starts at next instruction
+                                        ;  which (per SDM) *must* be a far JMP.
+    DB      0eah
+_RealAddr DW 0,0                       ; filled in by InternalAsmThunk16
+
+    mov     cr4, ebp
+    mov     ss, esi                     ; set up 16-bit stack segment
+    xchg    sp, bx                      ; set up 16-bit stack pointer
+
+;   mov     bp, [esp + sizeof(IA32_REGS)
+    DB      67h
+    mov     ebp, [esp + sizeof(IA32_REGS)] ; BackFromUserCode address from stack
+
+;   mov     cs:[bp + (SavedSs - _BackFromUserCode)], dx
+    mov     cs:[esi + (SavedSs - _BackFromUserCode)], edx
+
+;   mov     cs:[bp + (SavedEsp - _BackFromUserCode)], ebx
+    DB      2eh, 66h, 89h, 9eh
+    DW      SavedEsp - _BackFromUserCode
+
+;   lidt    cs:[bp + (_16Idtr - _BackFromUserCode)]
+    DB      2eh, 66h, 0fh, 01h, 9eh
+    DW      _16Idtr - _BackFromUserCode
+
+    popaw                               ; popad actually
+    pop     ds
+    pop     es
+    pop     fs
+    pop     gs
+    popf                                ; popfd
+    DB      66h                         ; Use 32-bit addressing for "retf" below
+    retf                                ; transfer control to user code
+_ToUserCode ENDP
+
+_NullSegDesc    DQ      0
+_16CsDesc       LABEL   QWORD
+                DW      -1
+                DW      0
+                DB      0
+                DB      9bh
+                DB      8fh             ; 16-bit segment, 4GB limit
+                DB      0
+_16DsDesc       LABEL   QWORD
+                DW      -1
+                DW      0
+                DB      0
+                DB      93h
+                DB      8fh             ; 16-bit segment, 4GB limit
+                DB      0
+GdtEnd          LABEL   QWORD
+
+;------------------------------------------------------------------------------
+; IA32_REGISTER_SET *
+; EFIAPI
+; InternalAsmThunk16 (
+;   IN      IA32_REGISTER_SET         *RegisterSet,
+;   IN OUT  VOID                      *Transition
+;   );
+;------------------------------------------------------------------------------
+InternalAsmThunk16  PROC    USES    ebp ebx esi edi ds  es  fs  gs
+    mov     esi, [esp + 36]             ; esi <- RegSet, the 1st parameter
+    movzx   edx, (IA32_REGS ptr [esi])._SS
+    mov     edi, (IA32_REGS ptr [esi])._ESP
+    add     edi, - (sizeof (IA32_REGS) + 4) ; reserve stack space
+    mov     ebx, edi                    ; ebx <- stack offset
+    imul    eax, edx, 16                ; eax <- edx * 16
+    push    sizeof (IA32_REGS) / 4
+    add     edi, eax                    ; edi <- linear address of 16-bit stack
+    pop     ecx
+    rep     movsd                       ; copy RegSet
+    mov     eax, [esp + 40]             ; eax <- address of transition code
+    mov     esi, edx                    ; esi <- 16-bit stack segment
+    lea     edx, [eax + (SavedCr0 - m16Start)]
+    mov     ecx, eax
+    and     ecx, 0fh
+    shl     eax, 12
+    lea     ecx, [ecx + (_BackFromUserCode - m16Start)]
+    mov     ax, cx
+    stosd                               ; [edi] <- return address of user code
+    add     eax, _RealAddr + 4 - _BackFromUserCode
+    mov     dword ptr [edx + (_RealAddr - SavedCr0)], eax
+    sgdt    fword ptr [edx + (SavedGdt - SavedCr0)]
+    sidt    fword ptr [esp + 36]        ; save IDT stack in argument space
+    mov     eax, cr0
+    mov     [edx], eax                  ; save CR0 in SavedCr0
+    and     eax, 7ffffffeh              ; clear PE, PG bits
+    mov     ebp, cr4
+    mov     [edx + (SavedCr4 - SavedCr0)], ebp
+    and     ebp, NOT 30h                ; clear PAE, PSE bits
+    push    10h
+    pop     ecx                         ; ecx <- selector for data segments
+    lgdt    fword ptr [edx + (_16Gdtr - SavedCr0)]
+    pushfd                              ; Save df/if indeed
+    call    fword ptr [edx + (_EntryPoint - SavedCr0)]
+    popfd
+    lidt    fword ptr [esp + 36]        ; restore protected mode IDTR
+    lea     eax, [ebp - sizeof (IA32_REGS)] ; eax <- the address of IA32_REGS
+    ret
+InternalAsmThunk16  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/Thunk16.nasm b/MdePkg/Library/BaseLib/Ia32/Thunk16.nasm
new file mode 100644
index 000000000000..1c02140595dc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Thunk16.nasm
@@ -0,0 +1,263 @@
+
+#include "BaseLibInternals.h"
+
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   Thunk.asm
+;
+; Abstract:
+;
+;   Real mode thunk
+;
+;------------------------------------------------------------------------------
+
+global ASM_PFX(m16Size)
+global ASM_PFX(mThunk16Attr)
+global ASM_PFX(m16Gdt)
+global ASM_PFX(m16GdtrBase)
+global ASM_PFX(mTransition)
+global ASM_PFX(m16Start)
+
+struc IA32_REGS
+
+  ._EDI:       resd      1
+  ._ESI:       resd      1
+  ._EBP:       resd      1
+  ._ESP:       resd      1
+  ._EBX:       resd      1
+  ._EDX:       resd      1
+  ._ECX:       resd      1
+  ._EAX:       resd      1
+  ._DS:        resw      1
+  ._ES:        resw      1
+  ._FS:        resw      1
+  ._GS:        resw      1
+  ._EFLAGS:    resd      1
+  ._EIP:       resd      1
+  ._CS:        resw      1
+  ._SS:        resw      1
+  .size:
+
+endstruc
+
+;; .const
+
+SECTION .data
+
+;
+; These are global constant to convey information to C code.
+;
+ASM_PFX(m16Size)         DW      ASM_PFX(InternalAsmThunk16) - ASM_PFX(m16Start)
+ASM_PFX(mThunk16Attr)    DW      _BackFromUserCode.ThunkAttrEnd - 4 - ASM_PFX(m16Start)
+ASM_PFX(m16Gdt)          DW      _NullSegDesc - ASM_PFX(m16Start)
+ASM_PFX(m16GdtrBase)     DW      _16GdtrBase - ASM_PFX(m16Start)
+ASM_PFX(mTransition)     DW      _EntryPoint - ASM_PFX(m16Start)
+
+SECTION .text
+
+ASM_PFX(m16Start):
+
+SavedGdt:
+            dw  0
+            dd  0
+
+;------------------------------------------------------------------------------
+; _BackFromUserCode() takes control in real mode after 'retf' has been executed
+; by user code. It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_BackFromUserCode:
+    ;
+    ; The order of saved registers on the stack matches the order they appears
+    ; in IA32_REGS structure. This facilitates wrapper function to extract them
+    ; into that structure.
+    ;
+BITS    16
+    push    ss
+    push    cs
+    ;
+    ; Note: We can't use o32 on the next instruction because of a bug
+    ; in NASM 2.09.04 through 2.10rc1.
+    ;
+    call    dword .Base                 ; push eip
+.Base:
+    pushfd
+    cli                                 ; disable interrupts
+    push    gs
+    push    fs
+    push    es
+    push    ds
+    pushad
+    mov     edx, strict dword 0
+.ThunkAttrEnd:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15
+    jz      .1
+    mov     ax, 2401h
+    int     15h
+    cli                                 ; disable interrupts
+    jnc     .2
+.1:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL
+    jz      .2
+    in      al, 92h
+    or      al, 2
+    out     92h, al                     ; deactivate A20M#
+.2:
+    xor     eax, eax
+    mov     ax, ss
+    lea     ebp, [esp + IA32_REGS.size]
+    mov     [bp - IA32_REGS.size + IA32_REGS._ESP], ebp
+    mov     bx, [bp - IA32_REGS.size + IA32_REGS._EIP]
+    shl     eax, 4                      ; shl eax, 4
+    add     ebp, eax                    ; add ebp, eax
+    mov     eax, strict dword 0
+.SavedCr4End:
+    mov     cr4, eax
+o32 lgdt [cs:bx + (SavedGdt - .Base)]
+    mov     eax, strict dword 0
+.SavedCr0End:
+    mov     cr0, eax
+    mov     ax, strict word 0
+.SavedSsEnd:
+    mov     ss, eax
+    mov     esp, strict dword 0
+.SavedEspEnd:
+o32 retf                                ; return to protected mode
+
+_EntryPoint:
+        DD      _ToUserCode - ASM_PFX(m16Start)
+        DW      8h
+_16Idtr:
+        DW      (1 << 10) - 1
+        DD      0
+_16Gdtr:
+        DW      GdtEnd - _NullSegDesc - 1
+_16GdtrBase:
+        DD      0
+
+;------------------------------------------------------------------------------
+; _ToUserCode() takes control in real mode before passing control to user code.
+; It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_ToUserCode:
+BITS    16
+    mov     dx, ss
+    mov     ss, cx                      ; set new segment selectors
+    mov     ds, cx
+    mov     es, cx
+    mov     fs, cx
+    mov     gs, cx
+    mov     cr0, eax                    ; real mode starts at next instruction
+                                        ;  which (per SDM) *must* be a far JMP.
+    jmp     0:strict word 0
+.RealAddrEnd:
+    mov     cr4, ebp
+    mov     ss, si                      ; set up 16-bit stack segment
+    xchg    esp, ebx                    ; set up 16-bit stack pointer
+    mov     bp, [esp + IA32_REGS.size]
+    mov     [cs:bp + (_BackFromUserCode.SavedSsEnd - 2 - _BackFromUserCode)], dx
+    mov     [cs:bp + (_BackFromUserCode.SavedEspEnd - 4 - _BackFromUserCode)], ebx
+    lidt    [cs:bp + (_16Idtr - _BackFromUserCode)]
+
+    popad
+    pop     ds
+    pop     es
+    pop     fs
+    pop     gs
+    popfd
+
+o32 retf                                ; transfer control to user code
+
+ALIGN   16
+_NullSegDesc    DQ      0
+_16CsDesc:
+                DW      -1
+                DW      0
+                DB      0
+                DB      9bh
+                DB      8fh             ; 16-bit segment, 4GB limit
+                DB      0
+_16DsDesc:
+                DW      -1
+                DW      0
+                DB      0
+                DB      93h
+                DB      8fh             ; 16-bit segment, 4GB limit
+                DB      0
+GdtEnd:
+
+;------------------------------------------------------------------------------
+; IA32_REGISTER_SET *
+; EFIAPI
+; InternalAsmThunk16 (
+;   IN      IA32_REGISTER_SET         *RegisterSet,
+;   IN OUT  VOID                      *Transition
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalAsmThunk16)
+ASM_PFX(InternalAsmThunk16):
+BITS    32
+    push    ebp
+    push    ebx
+    push    esi
+    push    edi
+    push    ds
+    push    es
+    push    fs
+    push    gs
+    mov     esi, [esp + 36]             ; esi <- RegSet, the 1st parameter
+    movzx   edx, word [esi + IA32_REGS._SS]
+    mov     edi, [esi + IA32_REGS._ESP]
+    add     edi, - (IA32_REGS.size + 4) ; reserve stack space
+    mov     ebx, edi                    ; ebx <- stack offset
+    imul    eax, edx, 16                ; eax <- edx * 16
+    push    IA32_REGS.size / 4
+    add     edi, eax                    ; edi <- linear address of 16-bit stack
+    pop     ecx
+    rep     movsd                       ; copy RegSet
+    mov     eax, [esp + 40]             ; eax <- address of transition code
+    mov     esi, edx                    ; esi <- 16-bit stack segment
+    lea     edx, [eax + (_BackFromUserCode.SavedCr0End - ASM_PFX(m16Start))]
+    mov     ecx, eax
+    and     ecx, 0fh
+    shl     eax, 12
+    lea     ecx, [ecx + (_BackFromUserCode - ASM_PFX(m16Start))]
+    mov     ax, cx
+    stosd                               ; [edi] <- return address of user code
+    add     eax, _ToUserCode.RealAddrEnd - _BackFromUserCode
+    mov     [edx + (_ToUserCode.RealAddrEnd - 4 - _BackFromUserCode.SavedCr0End)], eax
+    sgdt    [edx + (SavedGdt - _BackFromUserCode.SavedCr0End)]
+    sidt    [esp + 36]        ; save IDT stack in argument space
+    mov     eax, cr0
+    mov     [edx - 4], eax                  ; save CR0 in _BackFromUserCode.SavedCr0End - 4
+    and     eax, 7ffffffeh              ; clear PE, PG bits
+    mov     ebp, cr4
+    mov     [edx + (_BackFromUserCode.SavedCr4End - 4 - _BackFromUserCode.SavedCr0End)], ebp
+    and     ebp, ~30h                ; clear PAE, PSE bits
+    push    10h
+    pop     ecx                         ; ecx <- selector for data segments
+    lgdt    [edx + (_16Gdtr - _BackFromUserCode.SavedCr0End)]
+    pushfd                              ; Save df/if indeed
+    call    dword far [edx + (_EntryPoint - _BackFromUserCode.SavedCr0End)]
+    popfd
+    lidt    [esp + 36]        ; restore protected mode IDTR
+    lea     eax, [ebp - IA32_REGS.size] ; eax <- the address of IA32_REGS
+    pop     gs
+    pop     fs
+    pop     es
+    pop     ds
+    pop     edi
+    pop     esi
+    pop     ebx
+    pop     ebp
+    ret
diff --git a/MdePkg/Library/BaseLib/Ia32/Wbinvd.asm b/MdePkg/Library/BaseLib/Ia32/Wbinvd.asm
new file mode 100644
index 000000000000..1200101eb0ca
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Wbinvd.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Wbinvd.Asm
+;
+; Abstract:
+;
+;   AsmWbinvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWbinvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmWbinvd   PROC
+    wbinvd
+    ret
+AsmWbinvd   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/Wbinvd.c b/MdePkg/Library/BaseLib/Ia32/Wbinvd.c
new file mode 100644
index 000000000000..16b9cf7baf88
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Wbinvd.c
@@ -0,0 +1,35 @@
+/** @file
+  AsmWbinvd function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Executes a WBINVD instruction.
+
+  Executes a WBINVD instruction. This function is only available on IA-32 and
+  x64.
+
+**/
+VOID
+EFIAPI
+AsmWbinvd (
+  VOID
+  )
+{
+  _asm {
+    wbinvd
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/Wbinvd.nasm b/MdePkg/Library/BaseLib/Ia32/Wbinvd.nasm
new file mode 100644
index 000000000000..7bdf793ebdf8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/Wbinvd.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Wbinvd.Asm
+;
+; Abstract:
+;
+;   AsmWbinvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWbinvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWbinvd)
+ASM_PFX(AsmWbinvd):
+    wbinvd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr0.asm b/MdePkg/Library/BaseLib/Ia32/WriteCr0.asm
new file mode 100644
index 000000000000..d61df0eda1b2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr0.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr0 (
+;   UINTN  Cr0
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr0 PROC
+    mov     eax, [esp + 4]
+    mov     cr0, eax
+    ret
+AsmWriteCr0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr0.c b/MdePkg/Library/BaseLib/Ia32/WriteCr0.c
new file mode 100644
index 000000000000..177da8084498
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr0.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteCr0 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Control Register 0 (CR0).
+
+  Writes and returns a new value to CR0. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to CR0.
+
+  @return The value written to CR0.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr0 (
+  UINTN  Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     cr0, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr0.nasm b/MdePkg/Library/BaseLib/Ia32/WriteCr0.nasm
new file mode 100644
index 000000000000..0c0ea5cca58f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr0.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr0 (
+;   UINTN  Cr0
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr0)
+ASM_PFX(AsmWriteCr0):
+    mov     eax, [esp + 4]
+    mov     cr0, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr2.asm b/MdePkg/Library/BaseLib/Ia32/WriteCr2.asm
new file mode 100644
index 000000000000..27e355033aaa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr2.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr2 (
+;   UINTN  Cr2
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr2 PROC
+    mov     eax, [esp + 4]
+    mov     cr2, eax
+    ret
+AsmWriteCr2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr2.c b/MdePkg/Library/BaseLib/Ia32/WriteCr2.c
new file mode 100644
index 000000000000..efbdf63e14ab
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr2.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteCr2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Control Register 2 (CR2).
+
+  Writes and returns a new value to CR2. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to CR2.
+
+  @return The value written to CR2.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr2 (
+  UINTN  Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     cr2, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr2.nasm b/MdePkg/Library/BaseLib/Ia32/WriteCr2.nasm
new file mode 100644
index 000000000000..2b7afa812c8d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr2.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr2 (
+;   UINTN  Cr2
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr2)
+ASM_PFX(AsmWriteCr2):
+    mov     eax, [esp + 4]
+    mov     cr2, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr3.asm b/MdePkg/Library/BaseLib/Ia32/WriteCr3.asm
new file mode 100644
index 000000000000..8132253b09ee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr3.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr3 (
+;   UINTN  Cr3
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr3 PROC
+    mov     eax, [esp + 4]
+    mov     cr3, eax
+    ret
+AsmWriteCr3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr3.c b/MdePkg/Library/BaseLib/Ia32/WriteCr3.c
new file mode 100644
index 000000000000..6aeb0f277a01
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr3.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteCr3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Control Register 3 (CR3).
+
+  Writes and returns a new value to CR3. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to CR3.
+
+  @return The value written to CR3.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr3 (
+  UINTN  Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     cr3, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr3.nasm b/MdePkg/Library/BaseLib/Ia32/WriteCr3.nasm
new file mode 100644
index 000000000000..90a22198c200
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr3.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr3 (
+;   UINTN  Cr3
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr3)
+ASM_PFX(AsmWriteCr3):
+    mov     eax, [esp + 4]
+    mov     cr3, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr4.asm b/MdePkg/Library/BaseLib/Ia32/WriteCr4.asm
new file mode 100644
index 000000000000..011d511d8043
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr4.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr4 (
+;   UINTN  Cr4
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr4 PROC
+    mov     eax, [esp + 4]
+    mov     cr4, eax
+    ret
+AsmWriteCr4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr4.c b/MdePkg/Library/BaseLib/Ia32/WriteCr4.c
new file mode 100644
index 000000000000..f14556462d3a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr4.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmWriteCr4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Control Register 4 (CR4).
+
+  Writes and returns a new value to CR4. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to CR4.
+
+  @return The value written to CR4.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr4 (
+  UINTN  Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    _emit  0x0f  // mov  cr4, eax
+    _emit  0x22
+    _emit  0xE0
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteCr4.nasm b/MdePkg/Library/BaseLib/Ia32/WriteCr4.nasm
new file mode 100644
index 000000000000..486fe2443084
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteCr4.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr4 (
+;   UINTN  Cr4
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr4)
+ASM_PFX(AsmWriteCr4):
+    mov     eax, [esp + 4]
+    mov     cr4, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr0.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr0.asm
new file mode 100644
index 000000000000..bd426a8cd3ae
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr0.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr0 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr0 PROC
+    mov     eax, [esp + 4]
+    mov     dr0, eax
+    ret
+AsmWriteDr0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr0.c b/MdePkg/Library/BaseLib/Ia32/WriteDr0.c
new file mode 100644
index 000000000000..bd5e10119ac1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr0.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr0 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 0 (DR0).
+
+  Writes and returns a new value to DR0. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr0.
+
+  @return The value written to Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr0 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr0, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr0.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr0.nasm
new file mode 100644
index 000000000000..5c2af942a200
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr0.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr0 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr0)
+ASM_PFX(AsmWriteDr0):
+    mov     eax, [esp + 4]
+    mov     dr0, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr1.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr1.asm
new file mode 100644
index 000000000000..accf95b79359
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr1.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr1.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr1 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr1 PROC
+    mov     eax, [esp + 4]
+    mov     dr1, eax
+    ret
+AsmWriteDr1 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr1.c b/MdePkg/Library/BaseLib/Ia32/WriteDr1.c
new file mode 100644
index 000000000000..695f3460c204
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr1.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr1 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 1 (DR1).
+
+  Writes and returns a new value to DR1. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr1.
+
+  @return The value written to Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr1 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr1, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr1.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr1.nasm
new file mode 100644
index 000000000000..a35389e03862
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr1.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr1.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr1 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr1)
+ASM_PFX(AsmWriteDr1):
+    mov     eax, [esp + 4]
+    mov     dr1, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr2.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr2.asm
new file mode 100644
index 000000000000..d311fb017f6d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr2.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr2 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr2 PROC
+    mov     eax, [esp + 4]
+    mov     dr2, eax
+    ret
+AsmWriteDr2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr2.c b/MdePkg/Library/BaseLib/Ia32/WriteDr2.c
new file mode 100644
index 000000000000..8a24b94a9b56
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr2.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 2 (DR2).
+
+  Writes and returns a new value to DR2. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr2.
+
+  @return The value written to Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr2 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr2, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr2.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr2.nasm
new file mode 100644
index 000000000000..936cefc8857d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr2.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr2 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr2)
+ASM_PFX(AsmWriteDr2):
+    mov     eax, [esp + 4]
+    mov     dr2, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr3.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr3.asm
new file mode 100644
index 000000000000..59282da5ef36
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr3.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr3 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr3 PROC
+    mov     eax, [esp + 4]
+    mov     dr3, eax
+    ret
+AsmWriteDr3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr3.c b/MdePkg/Library/BaseLib/Ia32/WriteDr3.c
new file mode 100644
index 000000000000..3a0921bffa52
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr3.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 3 (DR3).
+
+  Writes and returns a new value to DR3. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr3.
+
+  @return The value written to Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr3 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr3, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr3.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr3.nasm
new file mode 100644
index 000000000000..d7a58cff6401
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr3.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr3 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr3)
+ASM_PFX(AsmWriteDr3):
+    mov     eax, [esp + 4]
+    mov     dr3, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr4.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr4.asm
new file mode 100644
index 000000000000..4d61dc7c68b8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr4.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr4 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr4 PROC
+    mov     eax, [esp + 4]
+    ;
+    ; DR4 is alias to DR6 only if DE (in CR4) is cleared. Otherwise, writing to
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0fh, 23h, 0e0h
+    ret
+AsmWriteDr4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr4.c b/MdePkg/Library/BaseLib/Ia32/WriteDr4.c
new file mode 100644
index 000000000000..acfe93f3569d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr4.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmWriteDr4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 4 (DR4).
+
+  Writes and returns a new value to DR4. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr4.
+
+  @return The value written to Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr4 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    _emit   0x0f         // mov dr4, eax
+    _emit   0x23
+    _emit   0xe0
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr4.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr4.nasm
new file mode 100644
index 000000000000..95c6d06315c8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr4.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr4 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr4)
+ASM_PFX(AsmWriteDr4):
+    mov     eax, [esp + 4]
+    ;
+    ; DR4 is alias to DR6 only if DE (in CR4) is cleared. Otherwise, writing to
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0xf, 0x23, 0xe0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr5.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr5.asm
new file mode 100644
index 000000000000..733f59964dc3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr5.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr5.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr5 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr5 PROC
+    mov     eax, [esp + 4]
+    ;
+    ; DR5 is alias to DR7 only if DE (in CR4) is cleared. Otherwise, writing to
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0fh, 23h, 0e8h
+    ret
+AsmWriteDr5 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr5.c b/MdePkg/Library/BaseLib/Ia32/WriteDr5.c
new file mode 100644
index 000000000000..4e00cebf9f40
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr5.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmWriteDr5 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 5 (DR5).
+
+  Writes and returns a new value to DR5. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr5.
+
+  @return The value written to Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr5 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    _emit   0x0f         // mov dr5, eax
+    _emit   0x23
+    _emit   0xe8
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr5.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr5.nasm
new file mode 100644
index 000000000000..a6256eff1918
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr5.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr5.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr5 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr5)
+ASM_PFX(AsmWriteDr5):
+    mov     eax, [esp + 4]
+    ;
+    ; DR5 is alias to DR7 only if DE (in CR4) is cleared. Otherwise, writing to
+    ; this register will cause a #UD exception.
+    ;
+    ; MS assembler doesn't support this instruction since no one would use it
+    ; under normal circustances. Here opcode is used.
+    ;
+    DB      0xf, 0x23, 0xe8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr6.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr6.asm
new file mode 100644
index 000000000000..132c96015a30
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr6.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr6.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr6 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr6 PROC
+    mov     eax, [esp + 4]
+    mov     dr6, eax
+    ret
+AsmWriteDr6 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr6.c b/MdePkg/Library/BaseLib/Ia32/WriteDr6.c
new file mode 100644
index 000000000000..29ab48318011
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr6.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr6 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 6 (DR6).
+
+  Writes and returns a new value to DR6. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr6.
+
+  @return The value written to Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr6 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr6, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr6.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr6.nasm
new file mode 100644
index 000000000000..75ae84bd2f4d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr6.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr6.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr6 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr6)
+ASM_PFX(AsmWriteDr6):
+    mov     eax, [esp + 4]
+    mov     dr6, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr7.asm b/MdePkg/Library/BaseLib/Ia32/WriteDr7.asm
new file mode 100644
index 000000000000..5978821a53f7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr7.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr7.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr7 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr7 PROC
+    mov     eax, [esp + 4]
+    mov     dr7, eax
+    ret
+AsmWriteDr7 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr7.c b/MdePkg/Library/BaseLib/Ia32/WriteDr7.c
new file mode 100644
index 000000000000..aa2286f4e33b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr7.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteDr7 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Writes a value to Debug Register 7 (DR7).
+
+  Writes and returns a new value to DR7. This function is only available on
+  IA-32 and x64. This writes a 32-bit value on IA-32 and a 64-bit value on x64.
+
+  @param  Value The value to write to Dr7.
+
+  @return The value written to Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr7 (
+  IN UINTN Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    mov     dr7, eax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteDr7.nasm b/MdePkg/Library/BaseLib/Ia32/WriteDr7.nasm
new file mode 100644
index 000000000000..06539e342d5d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteDr7.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr7.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr7 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr7)
+ASM_PFX(AsmWriteDr7):
+    mov     eax, [esp + 4]
+    mov     dr7, eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteGdtr.asm b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.asm
new file mode 100644
index 000000000000..c93b634e8fda
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteGdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteGdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86WriteGdtr  PROC
+    mov     eax, [esp + 4]
+    lgdt    fword ptr [eax]
+    ret
+InternalX86WriteGdtr  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteGdtr.c b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.c
new file mode 100644
index 000000000000..905d585e4a4f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmWriteGdtr function
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  )
+{
+  _asm {
+    mov     eax, Gdtr
+    lgdt    fword ptr [eax]
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteGdtr.nasm b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.nasm
new file mode 100644
index 000000000000..4f4f590ab7ea
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteGdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteGdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteGdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86WriteGdtr)
+ASM_PFX(InternalX86WriteGdtr):
+    mov     eax, [esp + 4]
+    lgdt    [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteIdtr.asm b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.asm
new file mode 100644
index 000000000000..1765b817d14b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2010, 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.
+;
+; Module Name:
+;
+;   WriteIdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteIdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86WriteIdtr  PROC
+    mov     eax, [esp + 4]
+    pushfd
+    cli
+    lidt    fword ptr [eax]
+    popfd
+    ret
+InternalX86WriteIdtr  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteIdtr.c b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.c
new file mode 100644
index 000000000000..ceef0e83aeff
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.c
@@ -0,0 +1,41 @@
+/** @file
+  AsmWriteIdtr function
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Writes the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  )
+{
+  _asm {
+    mov     eax, Idtr
+    pushfd
+    cli
+    lidt    fword ptr [eax]
+    popfd
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteIdtr.nasm b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.nasm
new file mode 100644
index 000000000000..f82f3a8e4f95
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteIdtr.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2010, 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.
+;
+; Module Name:
+;
+;   WriteIdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteIdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86WriteIdtr)
+ASM_PFX(InternalX86WriteIdtr):
+    mov     eax, [esp + 4]
+    pushfd
+    cli
+    lidt    [eax]
+    popfd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteLdtr.asm b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.asm
new file mode 100644
index 000000000000..f5adf84e522e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   WriteLdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386p
+    .model  flat
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteLdtr (
+;   IN UINT16 Ldtr
+;   );
+;------------------------------------------------------------------------------
+AsmWriteLdtr   PROC
+    mov     eax, [esp + 4]
+    lldt    ax
+    ret
+AsmWriteLdtr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteLdtr.c b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.c
new file mode 100644
index 000000000000..fe9ad0f55e5c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  AsmWriteLdtr function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current Local Descriptor Table Register (GDTR) selector.
+
+  Writes and the current LDTR descriptor specified by Ldtr. This function is
+  only available on IA-32 and x64.
+
+  @param  Ldtr  16-bit LDTR selector value.
+
+**/
+VOID
+EFIAPI
+AsmWriteLdtr (
+  IN UINT16 Ldtr
+  )
+{
+  _asm {
+    xor     eax, eax
+    mov     ax, Ldtr
+    lldt    ax
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteLdtr.nasm b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.nasm
new file mode 100644
index 000000000000..e3d9e0d7df8a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteLdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   WriteLdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteLdtr (
+;   IN UINT16 Ldtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteLdtr)
+ASM_PFX(AsmWriteLdtr):
+    mov     eax, [esp + 4]
+    lldt    ax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm0.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm0.asm
new file mode 100644
index 000000000000..dcb42fdedb4a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm0.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm0.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm0 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm0 PROC
+    movq    mm0, [esp + 4]
+    ret
+AsmWriteMm0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm0.c b/MdePkg/Library/BaseLib/Ia32/WriteMm0.c
new file mode 100644
index 000000000000..076ccd98fa8d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm0.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm0 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #0 (MM0).
+
+  Writes the current value of MM0. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM0.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm0 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm0, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm0.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm0.nasm
new file mode 100644
index 000000000000..c43005bb1eee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm0.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm0.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm0 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm0)
+ASM_PFX(AsmWriteMm0):
+    movq    mm0, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm1.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm1.asm
new file mode 100644
index 000000000000..3e3cdc5696fa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm1.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm1.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm1 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm1 PROC
+    movq    mm1, [esp + 4]
+    ret
+AsmWriteMm1 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm1.c b/MdePkg/Library/BaseLib/Ia32/WriteMm1.c
new file mode 100644
index 000000000000..dadf7c1fc493
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm1.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm1 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #1 (MM1).
+
+  Writes the current value of MM1. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM1.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm1 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm1, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm1.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm1.nasm
new file mode 100644
index 000000000000..b3171b64a767
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm1.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm1.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm1 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm1)
+ASM_PFX(AsmWriteMm1):
+    movq    mm1, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm2.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm2.asm
new file mode 100644
index 000000000000..d7c157b722a2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm2.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm2.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm2 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm2 PROC
+    movq    mm2, [esp + 4]
+    ret
+AsmWriteMm2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm2.c b/MdePkg/Library/BaseLib/Ia32/WriteMm2.c
new file mode 100644
index 000000000000..830a03e15470
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm2.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm2 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #2 (MM2).
+
+  Writes the current value of MM2. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM2.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm2 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm2, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm2.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm2.nasm
new file mode 100644
index 000000000000..ff7bcee971e7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm2.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm2.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm2 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm2)
+ASM_PFX(AsmWriteMm2):
+    movq    mm2, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm3.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm3.asm
new file mode 100644
index 000000000000..236517d65b49
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm3.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm3.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm3 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm3 PROC
+    movq    mm3, [esp + 4]
+    ret
+AsmWriteMm3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm3.c b/MdePkg/Library/BaseLib/Ia32/WriteMm3.c
new file mode 100644
index 000000000000..c9c6476faa72
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm3.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm3 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #3 (MM3).
+
+  Writes the current value of MM3. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM3.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm3 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm3, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm3.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm3.nasm
new file mode 100644
index 000000000000..0e60af5620c6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm3.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm3.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm3 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm3)
+ASM_PFX(AsmWriteMm3):
+    movq    mm3, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm4.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm4.asm
new file mode 100644
index 000000000000..96fd73f2942e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm4.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm4.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm4 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm4 PROC
+    movq    mm4, [esp + 4]
+    ret
+AsmWriteMm4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm4.c b/MdePkg/Library/BaseLib/Ia32/WriteMm4.c
new file mode 100644
index 000000000000..18228115a2c1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm4.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteMm4 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #4 (MM4).
+
+  Writes the current value of MM4. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM4.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm4 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm4, qword ptr [Value]
+    emms
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm4.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm4.nasm
new file mode 100644
index 000000000000..26552fb07a20
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm4.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm4.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm4 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm4)
+ASM_PFX(AsmWriteMm4):
+    movq    mm4, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm5.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm5.asm
new file mode 100644
index 000000000000..2bb558eb7191
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm5.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm5.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm5 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm5 PROC
+    movq    mm5, [esp + 4]
+    ret
+AsmWriteMm5 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm5.c b/MdePkg/Library/BaseLib/Ia32/WriteMm5.c
new file mode 100644
index 000000000000..f6ad0e0be10d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm5.c
@@ -0,0 +1,37 @@
+/** @file
+  AsmWriteMm5 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #5 (MM5).
+
+  Writes the current value of MM5. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM5.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm5 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm5, qword ptr [Value]
+    emms
+  }
+}
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm5.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm5.nasm
new file mode 100644
index 000000000000..8bf690c80bd3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm5.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm5.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm5 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm5)
+ASM_PFX(AsmWriteMm5):
+    movq    mm5, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm6.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm6.asm
new file mode 100644
index 000000000000..90d71d636134
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm6.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm6.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm6 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm6 PROC
+    movq    mm6, [esp + 4]
+    ret
+AsmWriteMm6 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm6.c b/MdePkg/Library/BaseLib/Ia32/WriteMm6.c
new file mode 100644
index 000000000000..28e06b5ad0b4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm6.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm6 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #6 (MM6).
+
+  Writes the current value of MM6. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM6.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm6 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm6, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm6.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm6.nasm
new file mode 100644
index 000000000000..6234135a7043
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm6.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm6.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm6 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm6)
+ASM_PFX(AsmWriteMm6):
+    movq    mm6, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm7.asm b/MdePkg/Library/BaseLib/Ia32/WriteMm7.asm
new file mode 100644
index 000000000000..e1065d500b93
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm7.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm7.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm7 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm7 PROC
+    movq    mm7, [esp + 4]
+    ret
+AsmWriteMm7 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm7.c b/MdePkg/Library/BaseLib/Ia32/WriteMm7.c
new file mode 100644
index 000000000000..d7350bf1c808
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm7.c
@@ -0,0 +1,38 @@
+/** @file
+  AsmWriteMm7 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes the current value of 64-bit MMX Register #7 (MM7).
+
+  Writes the current value of MM7. This function is only available on IA32 and
+  x64.
+
+  @param  Value The 64-bit value to write to MM7.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm7 (
+  IN UINT64   Value
+  )
+{
+  _asm {
+    movq    mm7, qword ptr [Value]
+    emms
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMm7.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMm7.nasm
new file mode 100644
index 000000000000..c4afbe5540ff
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMm7.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm7.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm7 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm7)
+ASM_PFX(AsmWriteMm7):
+    movq    mm7, [esp + 4]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMsr64.asm b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.asm
new file mode 100644
index 000000000000..f13ba9b72c38
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMsr64.Asm
+;
+; Abstract:
+;
+;   AsmWriteMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586p
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmWriteMsr64 (
+;   IN UINT32  Index,
+;   IN UINT64  Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMsr64   PROC
+    mov     edx, [esp + 12]
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 4]
+    wrmsr
+    ret
+AsmWriteMsr64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMsr64.c b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.c
new file mode 100644
index 000000000000..39a792b98285
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.c
@@ -0,0 +1,49 @@
+/** @file
+  AsmWriteMsr64 function
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Writes a 64-bit value to a Machine Specific Register(MSR), and returns the
+  value.
+
+  Writes the 64-bit value specified by Value to the MSR specified by Index. The
+  64-bit value written to the MSR is returned. No parameter checking is
+  performed on Index or Value, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and Value are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 64-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr64 (
+  IN UINT32  Index,
+  IN UINT64  Value
+  )
+{
+  _asm {
+    mov     edx, dword ptr [Value + 4]
+    mov     eax, dword ptr [Value + 0]
+    mov     ecx, Index
+    wrmsr
+  }
+}
+
diff --git a/MdePkg/Library/BaseLib/Ia32/WriteMsr64.nasm b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.nasm
new file mode 100644
index 000000000000..4eb9706a3747
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ia32/WriteMsr64.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMsr64.Asm
+;
+; Abstract:
+;
+;   AsmWriteMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmWriteMsr64 (
+;   IN UINT32  Index,
+;   IN UINT64  Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMsr64)
+ASM_PFX(AsmWriteMsr64):
+    mov     edx, [esp + 12]
+    mov     eax, [esp + 8]
+    mov     ecx, [esp + 4]
+    wrmsr
+    ret
+
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessDbr.s b/MdePkg/Library/BaseLib/Ipf/AccessDbr.s
new file mode 100644
index 000000000000..8abd1e8f826b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessDbr.s
@@ -0,0 +1,118 @@
+/// @file
+///  IPF specific Debug Breakpoint Registers accessing functions
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name: AccessDbr.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadDbr
+//
+// This routine is used to Reads the current value of Data Breakpoint Register (DBR).
+//
+// Arguments :
+//
+// On Entry : The 8-bit DBR index to read.
+//
+// Return Value: The current value of DBR by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadDbr, @function
+.proc   AsmReadDbr
+.regstk 1, 0, 0, 0
+
+AsmReadDbr::
+        mov             r8 = dbr[in0];;
+        br.ret.dpnt     b0;;
+.endp   AsmReadDbr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteDbr
+//
+// This routine is used to write the current value to Data Breakpoint Register (DBR).
+//
+// Arguments :
+//
+// On Entry : The 8-bit DBR index to read.
+//            The value should be written to DBR
+//
+// Return Value: The value written to DBR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteDbr, @function
+.proc   AsmWriteDbr
+.regstk 2, 0, 0, 0
+
+AsmWriteDbr::
+        mov             dbr[in0] = in1
+        mov             r8 = in1;;
+        srlz.d;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteDbr
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIbr
+//
+// This routine is used to Reads the current value of Instruction Breakpoint Register (IBR).
+//
+// Arguments :
+//
+// On Entry : The 8-bit IBR index.
+//
+// Return Value: The current value of IBR by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIbr, @function
+.proc   AsmReadIbr
+.regstk 1, 0, 0, 0
+
+AsmReadIbr::
+        mov             r8 = ibr[in0];;
+        br.ret.dpnt     b0;;
+.endp   AsmReadIbr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteIbr
+//
+// This routine is used to write the current value to Instruction Breakpoint Register (IBR).
+//
+// Arguments :
+//
+// On Entry : The 8-bit IBR index.
+//            The value should be written to IBR
+//
+// Return Value: The value written to IBR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteIbr, @function
+.proc   AsmWriteIbr
+.regstk 2, 0, 0, 0
+
+AsmWriteIbr::
+        mov             ibr[in0] = in1
+        mov             r8 = in1;;
+        srlz.i;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteIbr
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessEicr.s b/MdePkg/Library/BaseLib/Ipf/AccessEicr.s
new file mode 100644
index 000000000000..c6925d51a633
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessEicr.s
@@ -0,0 +1,512 @@
+/// @file
+///  IPF specific External Interrupt Control Registers accessing functions
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name: AccessEicr.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadLid
+//
+// This routine is used to read the value of Local Interrupt ID Register (LID).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of LID.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadLid, @function
+.proc   AsmReadLid
+
+AsmReadLid::
+         mov            r8 = cr.lid;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadLid
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteLid
+//
+// This routine is used to write the value to Local Interrupt ID Register (LID).
+//
+// Arguments :
+//
+// On Entry :  The value need to be written to LID.
+//
+// Return Value: The value written to LID.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteLid, @function
+.proc   AsmWriteLid
+.regstk 1, 0, 0, 0
+
+AsmWriteLid::
+         mov            cr.lid = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteLid
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIvr
+//
+// This routine is used to read the value of External Interrupt Vector Register (IVR).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IVR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIvr, @function
+.proc   AsmReadIvr
+
+AsmReadIvr::
+         mov            r8 = cr.ivr;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIvr
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadTpr
+//
+// This routine is used to read the value of Task Priority Register (TPR).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of TPR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadTpr, @function
+.proc   AsmReadTpr
+
+AsmReadTpr::
+         mov            r8 = cr.tpr;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadTpr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteTpr
+//
+// This routine is used to write the value to Task Priority Register (TPR).
+//
+// Arguments :
+//
+// On Entry :  The value need to be written to TPR.
+//
+// Return Value: The value written to TPR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteTpr, @function
+.proc   AsmWriteTpr
+.regstk 1, 0, 0, 0
+
+AsmWriteTpr::
+         mov            cr.tpr = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteTpr
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteEoi
+//
+// This routine is used to write the value to End of External Interrupt Register (EOI).
+//
+// Arguments :
+//
+// On Entry :  The value need to be written to EOI.
+//
+// Return Value: The value written to EOI.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteEoi, @function
+.proc   AsmWriteEoi
+
+AsmWriteEoi::
+         mov            cr.eoi = r0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteEoi
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIrr0
+//
+// This routine is used to Read the value of External Interrupt Request Register 0 (IRR0).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IRR0.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIrr0, @function
+.proc   AsmReadIrr0
+
+AsmReadIrr0::
+         mov            r8 = cr.irr0;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIrr0
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIrr1
+//
+// This routine is used to Read the value of External Interrupt Request Register 1 (IRR1).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IRR1.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIrr1, @function
+.proc   AsmReadIrr1
+
+AsmReadIrr1::
+         mov            r8 = cr.irr1;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIrr1
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIrr2
+//
+// This routine is used to Read the value of External Interrupt Request Register 2 (IRR2).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IRR2.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIrr2, @function
+.proc   AsmReadIrr2
+
+AsmReadIrr2::
+         mov            r8 = cr.irr2;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIrr2
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIrr3
+//
+// This routine is used to Read the value of External Interrupt Request Register 3 (IRR3).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IRR3.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIrr3, @function
+.proc   AsmReadIrr3
+
+AsmReadIrr3::
+         mov            r8 = cr.irr3;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIrr3
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadItv
+//
+// This routine is used to Read the value of Interval Timer Vector Register (ITV).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of ITV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadItv, @function
+.proc   AsmReadItv
+
+AsmReadItv::
+         mov            r8 = cr.itv;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadItv
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteItv
+//
+// This routine is used to write the value to Interval Timer Vector Register (ITV).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to ITV
+//
+// Return Value: The value written to ITV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteItv, @function
+.proc   AsmWriteItv
+.regstk 1, 0, 0, 0
+
+AsmWriteItv::
+         mov            cr.itv = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteItv
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadPmv
+//
+// This routine is used to Read the value of Performance Monitoring Vector Register (PMV).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of PMV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadPmv, @function
+.proc   AsmReadPmv
+
+AsmReadPmv::
+         mov            r8 = cr.pmv;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadPmv
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWritePmv
+//
+// This routine is used to write the value to Performance Monitoring Vector Register (PMV).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to PMV
+//
+// Return Value: The value written to PMV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWritePmv, @function
+.proc   AsmWritePmv
+.regstk 1, 0, 0, 0
+
+AsmWritePmv::
+         mov            cr.pmv = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWritePmv
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadCmcv
+//
+// This routine is used to Read the value of Corrected Machine Check Vector Register (CMCV).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of CMCV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadCmcv, @function
+.proc   AsmReadCmcv
+
+AsmReadCmcv::
+         mov            r8 = cr.cmcv;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadCmcv
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteCmcv
+//
+// This routine is used to write the value to Corrected Machine Check Vector Register (CMCV).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to CMCV
+//
+// Return Value: The value written to CMCV.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteCmcv, @function
+.proc   AsmWriteCmcv
+.regstk 1, 0, 0, 0
+
+AsmWriteCmcv::
+         mov            cr.cmcv = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteCmcv
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadLrr0
+//
+// This routine is used to read the value of Local Redirection Register 0 (LRR0).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of LRR0.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadLrr0, @function
+.proc   AsmReadLrr0
+
+AsmReadLrr0::
+         mov            r8 = cr.lrr0;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadLrr0
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteLrr0
+//
+// This routine is used to write the value to Local Redirection Register 0 (LRR0).
+//
+// Arguments :
+//
+// On Entry :  The value need to be written to LRR0.
+//
+// Return Value: The value written to LRR0.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteLrr0, @function
+.proc   AsmWriteLrr0
+.regstk 1, 0, 0, 0
+
+AsmWriteLrr0::
+         mov            cr.lrr0 = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteLrr0
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadLrr1
+//
+// This routine is used to read the value of Local Redirection Register 1 (LRR1).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of LRR1.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadLrr1, @function
+.proc   AsmReadLrr1
+
+AsmReadLrr1::
+         mov            r8 = cr.lrr1;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadLrr1
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteLrr1
+//
+// This routine is used to write the value to Local Redirection Register 1 (LRR1).
+//
+// Arguments :
+//
+// On Entry :  The value need to be written to LRR1.
+//
+// Return Value: The value written to LRR1.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteLrr1, @function
+.proc   AsmWriteLrr1
+.regstk 1, 0, 0, 0
+
+AsmWriteLrr1::
+         mov            cr.lrr1 = in0
+         mov            r8 = in0;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteLrr1
+
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessGcr.s b/MdePkg/Library/BaseLib/Ipf/AccessGcr.s
new file mode 100644
index 000000000000..3d6958267981
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessGcr.s
@@ -0,0 +1,274 @@
+/// @file
+///  IPF specific Global Control Registers accessing functions
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name: AccessGcr.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadDcr
+//
+// This routine is used to Read the value of Default Control Register (DCR).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of DCR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadDcr, @function
+.proc   AsmReadDcr
+
+AsmReadDcr::
+         mov            r8 = cr.dcr;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadDcr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteDcr
+//
+// This routine is used to write the value to Default Control Register (DCR).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to DCR
+//
+// Return Value: The value written to DCR.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteDcr, @function
+.proc   AsmWriteDcr
+.regstk 1, 0, 0, 0
+
+AsmWriteDcr::
+         mov            cr.dcr = in0
+         mov            r8 = in0;;
+         srlz.i;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteDcr
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadItc
+//
+// This routine is used to Read the value of Interval Timer Counter Register (ITC).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of ITC.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadItc, @function
+.proc   AsmReadItc
+
+AsmReadItc::
+         mov            r8 = ar.itc;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadItc
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteItc
+//
+// This routine is used to write the value to Interval Timer Counter Register (ITC).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to the ITC
+//
+// Return Value: The value written to the ITC.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteItc, @function
+.proc   AsmWriteItc
+.regstk 1, 0, 0, 0
+
+AsmWriteItc::
+         mov            ar.itc = in0
+         mov            r8 = in0;;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteItc
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadItm
+//
+// This routine is used to Read the value of Interval Timer Match Register (ITM).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of ITM.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadItm, @function
+.proc   AsmReadItm
+
+AsmReadItm::
+         mov            r8 = cr.itm;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadItm
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteItm
+//
+// This routine is used to write the value to Interval Timer Match Register (ITM).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to ITM
+//
+// Return Value: The value written to ITM.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteItm, @function
+.proc   AsmWriteItm
+.regstk 1, 0, 0, 0
+
+AsmWriteItm::
+         mov            cr.itm = in0
+         mov            r8 = in0;;
+         srlz.d;
+         br.ret.dpnt    b0;;
+.endp    AsmWriteItm
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadIva
+//
+// This routine is used to read the value of Interruption Vector Address Register (IVA).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of IVA.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadIva, @function
+.proc   AsmReadIva
+
+AsmReadIva::
+         mov            r8 = cr.iva;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadIva
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteIva
+//
+// This routine is used to write the value to Interruption Vector Address Register (IVA).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to IVA
+//
+// Return Value: The value written to IVA.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteIva, @function
+.proc   AsmWriteIva
+.regstk 1, 3, 0, 0
+
+AsmWriteIva::
+        alloc loc1=ar.pfs,1,4,0,0 ;;
+
+        mov         loc2 = psr
+        rsm         0x6000                      // Make sure interrupts are masked
+
+        mov            cr.iva = in0
+        srlz.i;;
+        mov         psr.l = loc2;;
+        srlz.i;;
+        srlz.d;;
+        mov ar.pfs=loc1 ;;
+        mov            r8 = in0;;
+        br.ret.dpnt    b0;;
+.endp   AsmWriteIva
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadPta
+//
+// This routine is used to read the value of Page Table Address Register (PTA).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current value of PTA.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadPta, @function
+.proc   AsmReadPta
+
+AsmReadPta::
+         mov            r8 = cr.pta;;
+         br.ret.dpnt    b0;;
+.endp    AsmReadPta
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWritePta
+//
+// This routine is used to write the value to Page Table Address Register (PTA)).
+//
+// Arguments :
+//
+// On Entry : The value need to be written to PTA
+//
+// Return Value: The value written to PTA.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWritePta, @function
+.proc   AsmWritePta
+.regstk 1, 0, 0, 0
+
+AsmWritePta::
+         mov            cr.pta = in0
+         mov            r8 = in0;;
+         srlz.i;;
+         srlz.d;;
+         br.ret.dpnt    b0;;
+.endp    AsmWritePta
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessGp.s b/MdePkg/Library/BaseLib/Ipf/AccessGp.s
new file mode 100644
index 000000000000..192b7f56118d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessGp.s
@@ -0,0 +1,86 @@
+/// @file
+///  IPF specific Global Pointer and Stack Pointer accessing functions
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name: AccessGp.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadGp
+//
+// This routine is used to read the current value of 64-bit Global Pointer (GP).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current GP value.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadGp, @function
+.proc   AsmReadGp
+
+AsmReadGp::
+        mov             r8 = gp;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadGp
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteGp
+//
+// This routine is used to write the current value of 64-bit Global Pointer (GP).
+//
+// Arguments :
+//
+// On Entry : The value need to be written.
+//
+// Return Value: The value have been written.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteGp, @function
+.proc   AsmWriteGp
+.regstk 1, 0, 0, 0
+
+AsmWriteGp::
+        mov             gp = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteGp
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadSp
+//
+// This routine is used to read the current value of 64-bit Stack Pointer (SP).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current SP value.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadSp, @function
+.proc   AsmReadSp
+
+AsmReadSp::
+        mov             r8 = sp;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadSp
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessKr.s b/MdePkg/Library/BaseLib/Ipf/AccessKr.s
new file mode 100644
index 000000000000..c2070ef7f1b7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessKr.s
@@ -0,0 +1,360 @@
+/// @file
+///  IPF specific AsmReadKrX() and AsmWriteKrX() functions, 'X' is from '0' to '6'
+///
+/// Copyright (c) 2006 - 2009, 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.
+///
+/// Module Name: AccessKr.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr0
+//
+// This routine is used to get KR0.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR0.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr0, @function
+.proc   AsmReadKr0
+
+AsmReadKr0::
+        mov             r8 = ar.k0;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr0
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr0
+//
+// This routine is used to Write KR0.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR0.
+//
+//--
+//----------------------------------------------------------------------------------
+
+.text
+.type   AsmWriteKr0, @function
+.proc   AsmWriteKr0
+.regstk 1, 3, 0, 0
+
+AsmWriteKr0::
+        alloc loc1=ar.pfs,1,4,0,0 ;;
+        mov             loc2 = psr;;
+        rsm             0x6000;;                      // Masking interrupts
+        mov             ar.k0 = in0
+        srlz.i;;
+        mov             psr.l = loc2;;
+        srlz.i;;
+        srlz.d;;
+        mov             r8 = in0;;
+        mov ar.pfs=loc1 ;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr0
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr1
+//
+// This routine is used to get KR1.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR1.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr1, @function
+.proc   AsmReadKr1
+
+AsmReadKr1::
+        mov             r8 = ar.k1;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr1
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr1
+//
+// This routine is used to Write KR1.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR1.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr1, @function
+.proc   AsmWriteKr1
+
+AsmWriteKr1::
+        mov             ar.k1 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr1
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr2
+//
+// This routine is used to get KR2.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR2.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr2, @function
+.proc   AsmReadKr2
+
+AsmReadKr2::
+        mov             r8 = ar.k2;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr2
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr2
+//
+// This routine is used to Write KR2.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR2.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr2, @function
+.proc   AsmWriteKr2
+
+AsmWriteKr2::
+        mov             ar.k2 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr2
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr3
+//
+// This routine is used to get KR3.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR3.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr3, @function
+.proc   AsmReadKr3
+
+AsmReadKr3::
+        mov             r8 = ar.k3;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr3
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr3
+//
+// This routine is used to Write KR3.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR3.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr3, @function
+.proc   AsmWriteKr3
+
+AsmWriteKr3::
+        mov             ar.k3 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr3
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr4
+//
+// This routine is used to get KR4.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR4.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr4, @function
+.proc   AsmReadKr4
+
+AsmReadKr4::
+        mov             r8 = ar.k4;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr4
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr4
+//
+// This routine is used to Write KR4.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR4.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr4, @function
+.proc   AsmWriteKr4
+
+AsmWriteKr4::
+        mov             ar.k4 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr4
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr5
+//
+// This routine is used to get KR5.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR5.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr5, @function
+.proc   AsmReadKr5
+
+AsmReadKr5::
+        mov             r8 = ar.k5;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr5
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr5
+//
+// This routine is used to Write KR5.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR5.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr5, @function
+.proc   AsmWriteKr5
+
+AsmWriteKr5::
+        mov             ar.k5 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr5
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr6
+//
+// This routine is used to get KR6.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR6.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr6, @function
+.proc   AsmReadKr6
+
+AsmReadKr6::
+        mov             r8 = ar.k6;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr6
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr6
+//
+// This routine is used to write KR6.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR6.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr6, @function
+.proc   AsmWriteKr6
+
+AsmWriteKr6::
+        mov             ar.k6 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr6
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessKr7.s b/MdePkg/Library/BaseLib/Ipf/AccessKr7.s
new file mode 100644
index 000000000000..34740e864c95
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessKr7.s
@@ -0,0 +1,63 @@
+/// @file
+///  IPF specific AsmReadKr7() and AsmWriteKr7()
+///
+/// Copyright (c) 2006 - 2009, 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.
+///
+/// Module Name: AccessKr7.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadKr7
+//
+// This routine is used to get KR7.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value store in KR7.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadKr7, @function
+.proc   AsmReadKr7
+
+AsmReadKr7::
+        mov             r8 = ar.k7;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadKr7
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteKr7
+//
+// This routine is used to write KR7.
+//
+// Arguments :
+//
+// On Entry :  None.
+//
+// Return Value: The value written to the KR7.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteKr7, @function
+.proc   AsmWriteKr7
+.regstk 1, 3, 0, 0
+
+AsmWriteKr7::
+        mov             ar.k7 = in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmWriteKr7
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessMsr.s b/MdePkg/Library/BaseLib/Ipf/AccessMsr.s
new file mode 100644
index 000000000000..9a1d504cf082
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessMsr.s
@@ -0,0 +1,79 @@
+/// @file
+///  IPF specific Machine Specific Registers accessing functions.
+///
+/// Copyright (c) 2008, 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.
+///
+///
+///
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadMsr
+//
+// Reads the current value of a Machine Specific Register (MSR).
+//
+// Reads and returns the current value of the Machine Specific Register specified by Index.  No
+// parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+// register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+// Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+// only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The 8-bit Machine Specific Register index to read.
+//
+// Return Value: The current value of the Machine Specific Register specified by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadMsr, @function
+.proc   AsmReadMsr
+.regstk 1, 0, 0, 0
+
+AsmReadMsr::
+  mov    r8=msr[in0];;
+  br.ret.sptk  b0;;
+.endp   AsmReadMsr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteMsr
+//
+// Writes the current value of a Machine Specific Register (MSR).
+//
+// Writes Value to the Machine Specific Register specified by Index.  Value is returned.  No
+// parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+// register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+// Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+// only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The 8-bit Machine Specific Register index to write.
+//            The 64-bit value to write to the Machine Specific Register.
+//
+// Return Value: The 64-bit value to write to the Machine Specific Register.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteMsr, @function
+.proc   AsmWriteMsr
+.regstk 2, 0, 0, 0
+
+AsmWriteMsr::
+  mov             msr[in0] = in1
+  mov             r8 = in1;;
+  srlz.d;;
+  br.ret.sptk     b0;;
+.endp   AsmWriteMsr
+
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessMsrDb.s b/MdePkg/Library/BaseLib/Ipf/AccessMsrDb.s
new file mode 100644
index 000000000000..4392e4299bfe
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessMsrDb.s
@@ -0,0 +1,121 @@
+/// @file
+///  IPF specific Machine Specific Registers accessing functions. 
+///  This implementation uses raw data to prepresent the assembly instruction of 
+/// mov msr[]= and mov =msr[].
+///
+/// Copyright (c) 2008, 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.
+///
+///
+///
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadMsr
+//
+// Reads the current value of a Machine Specific Register (MSR).
+//
+// Reads and returns the current value of the Machine Specific Register specified by Index.  No
+// parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+// register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+// Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+// only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The 8-bit Machine Specific Register index to read.
+//
+// Return Value: The current value of the Machine Specific Register specified by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadMsr, @function
+.proc   AsmReadMsr
+.regstk 1, 0, 0, 0
+
+AsmReadMsr::
+//
+// The follow 16 bytes stand for the bundle of 
+//   mov    r8=msr[in0];;
+// since MSFT tool chain does not support mov =msr[] instruction
+//
+  data1 0x0D
+  data1 0x40
+  data1 0x00
+  data1 0x40
+  data1 0x16
+  data1 0x04
+  data1 0x00
+  data1 0x00
+  data1 0x00
+  data1 0x02
+  data1 0x00
+  data1 0x00
+  data1 0x00
+  data1 0x00
+  data1 0x04
+  data1 0x00
+  br.ret.sptk  b0;;
+.endp   AsmReadMsr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWriteMsr
+//
+// Writes the current value of a Machine Specific Register (MSR).
+//
+// Writes Value to the Machine Specific Register specified by Index.  Value is returned.  No
+// parameter checking is performed on Index, and if the Index value is beyond the implemented MSR
+// register range, a Reserved Register/Field fault may occur.  The caller must either guarantee that
+// Index is valid, or the caller must set up fault handlers to catch the faults.  This function is
+// only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The 8-bit Machine Specific Register index to write.
+//            The 64-bit value to write to the Machine Specific Register.
+//
+// Return Value: The 64-bit value to write to the Machine Specific Register.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWriteMsr, @function
+.proc   AsmWriteMsr
+.regstk 2, 0, 0, 0
+
+AsmWriteMsr::
+//
+// The follow 16 bytes stand for the bundle of 
+//  mov             msr[in0] = in1
+//  mov             r8 = in1;;
+// since MSFT tool chain does not support mov msr[]= instruction
+//
+  data1 0x0D
+  data1 0x00
+  data1 0x84
+  data1 0x40
+  data1 0x06
+  data1 0x04
+  data1 0x00
+  data1 0x00
+  data1 0x00
+  data1 0x02
+  data1 0x00
+  data1 0x00
+  data1 0x01
+  data1 0x08
+  data1 0x01
+  data1 0x84
+  srlz.d;;
+  br.ret.sptk     b0;;
+.endp   AsmWriteMsr
+
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessPmr.s b/MdePkg/Library/BaseLib/Ipf/AccessPmr.s
new file mode 100644
index 000000000000..d559a08273a6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessPmr.s
@@ -0,0 +1,124 @@
+/// @file
+///  IPF specific Performance Monitor Configuration/Data Registers accessing functions
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name: AccessPmr.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadPmc
+//
+// This routine is used to Reads the current value of Performance Monitor Configuration Register (PMC).
+//
+// Arguments :
+//
+// On Entry : The 8-bit PMC index.
+//
+// Return Value: The current value of PMC by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadPmc, @function
+.proc   AsmReadPmc
+.regstk 1, 0, 0, 0
+
+AsmReadPmc::
+        srlz.i;;
+        srlz.d;;
+        mov             r8 = pmc[in0];;
+        br.ret.dpnt     b0;;
+.endp   AsmReadPmc
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWritePmc
+//
+// This routine is used to write the current value to a Performance Monitor Configuration Register (PMC).
+//
+// Arguments :
+//
+// On Entry : The 8-bit PMC index.
+//            The value should be written to PMC
+//
+// Return Value: The value written to PMC.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWritePmc, @function
+.proc   AsmWritePmc
+.regstk 2, 0, 0, 0
+
+AsmWritePmc::
+        mov             pmc[in0] = in1
+        mov             r8 = in1;;
+        srlz.i;;
+        srlz.d;;
+        br.ret.dpnt     b0;;
+.endp   AsmWritePmc
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadPmd
+//
+// This routine is used to Reads the current value of Performance Monitor Data Register (PMD).
+//
+// Arguments :
+//
+// On Entry : The 8-bit PMD index.
+//
+// Return Value: The current value of PMD by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadPmd, @function
+.proc   AsmReadPmd
+.regstk 1, 0, 0, 0
+
+AsmReadPmd::
+        srlz.i;;
+        srlz.d;;
+        mov             r8 = pmd[in0];;
+        br.ret.dpnt     b0;;
+.endp   AsmReadPmd
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWritePmd
+//
+// This routine is used to write the current value to Performance Monitor Data Register (PMD).
+//
+// Arguments :
+//
+// On Entry : The 8-bit PMD index.
+//            The value should be written to PMD
+//
+// Return Value: The value written to PMD.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWritePmd, @function
+.proc   AsmWritePmd
+.regstk 2, 0, 0, 0
+
+AsmWritePmd::
+        mov             pmd[in0] = in1
+        mov             r8 = in1;;
+        srlz.i;;
+        srlz.d;;
+        br.ret.dpnt     b0;;
+.endp   AsmWritePmd
diff --git a/MdePkg/Library/BaseLib/Ipf/AccessPsr.s b/MdePkg/Library/BaseLib/Ipf/AccessPsr.s
new file mode 100644
index 000000000000..03317cfd7369
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AccessPsr.s
@@ -0,0 +1,111 @@
+/// @file
+///  IPF specific Processor Status Register accessing functions
+///
+/// Copyright (c) 2006 - 2010, 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.
+///
+/// Module Name: AccessPsr.s
+///
+///
+
+#define CpuModeMask           0x0000001008020000
+
+#define CpuInVirtualMode             0x1
+#define CpuInPhysicalMode            0x0
+#define CpuInMixMode                 (0x0 - 0x1)
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadPsr
+//
+// This routine is used to read the current value of Processor Status Register (PSR).
+//
+// Arguments :
+//
+// On Entry :
+//
+// Return Value: The current PSR value.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadPsr, @function
+.proc   AsmReadPsr
+
+AsmReadPsr::
+        mov             r8 = psr;;
+        br.ret.dpnt     b0;;
+.endp   AsmReadPsr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmWritePsr
+//
+// This routine is used to write the value of Processor Status Register (PSR).
+//
+// Arguments :
+//
+// On Entry : The value need to be written.
+//
+// Return Value: The value have been written.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmWritePsr, @function
+.proc   AsmWritePsr
+.regstk 1, 0, 0, 0
+
+AsmWritePsr::
+        mov             psr.l = in0
+        mov             r8 = in0;;
+        srlz.d;;
+        srlz.i;;
+        br.ret.dpnt     b0;;
+.endp   AsmWritePsr
+
+//---------------------------------------------------------------------------------
+//++
+// AsmCpuVirtual
+//
+// This routine is used to determines if the CPU is currently executing
+// in virtual, physical, or mixed mode.
+//
+// If the CPU is in virtual mode(PSR.RT=1, PSR.DT=1, PSR.IT=1), then 1 is returned.
+// If the CPU is in physical mode(PSR.RT=0, PSR.DT=0, PSR.IT=0), then 0 is returned.
+// If the CPU is not in physical mode or virtual mode, then it is in mixed mode,
+// and -1 is returned.
+//
+// Arguments:
+//
+// On Entry: None
+//
+// Return Value: The CPU mode flag
+//               return  1  The CPU is in virtual mode.
+//               return  0  The CPU is in physical mode.
+//               return -1  The CPU is in mixed mode.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmCpuVirtual, @function
+.proc   AsmCpuVirtual
+
+AsmCpuVirtual::
+        mov            r29 = psr
+        movl           r30 = CpuModeMask;;
+        and            r28 = r30, r29;;
+        cmp.eq         p6, p7 = r30, r28;;
+(p6)    mov            r8 = CpuInVirtualMode;;
+(p6)    br.ret.dpnt    b0;;
+(p7)    cmp.eq         p6, p7 = 0x0, r28;;
+(p6)    mov            r8 = CpuInPhysicalMode;;
+(p7)    mov            r8 = CpuInMixMode;;
+        br.ret.dpnt    b0;;
+.endp   AsmCpuVirtual
diff --git a/MdePkg/Library/BaseLib/Ipf/Asm.h b/MdePkg/Library/BaseLib/Ipf/Asm.h
new file mode 100644
index 000000000000..c8adac5263e0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/Asm.h
@@ -0,0 +1,27 @@
+/** @file 
+
+    This module contains generic macros for an assembly writer.
+
+Copyright (c) 2006 - 2008, 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 _ASM_H_
+#define _ASM_H_
+
+#define TRUE  1
+#define FALSE 0
+#define PROCEDURE_ENTRY(name)   .##text;            \
+  .##type name, @function; \
+  .##proc name; \
+  name::
+
+#define PROCEDURE_EXIT(name)  .##endp name
+
+#endif // _ASM_H
diff --git a/MdePkg/Library/BaseLib/Ipf/AsmCpuMisc.s b/MdePkg/Library/BaseLib/Ipf/AsmCpuMisc.s
new file mode 100644
index 000000000000..067964b9ecc1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AsmCpuMisc.s
@@ -0,0 +1,79 @@
+/// @file
+///   Contains an implementation of CallPalProcStacked on Itanium-based
+///   architecture.
+///
+/// Copyright (c) 2008, 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.
+///
+/// Module Name:  AsmCpuMisc.s
+///
+///
+
+
+.text
+.proc CpuBreakpoint
+.type CpuBreakpoint, @function
+
+CpuBreakpoint::
+        break.i 0;;
+        br.ret.dpnt    b0;;
+
+.endp CpuBreakpoint
+
+.proc MemoryFence
+.type MemoryFence, @function
+
+MemoryFence::
+        mf;;    // memory access ordering
+
+        // do we need the mf.a also here?
+        mf.a    // wait for any IO to complete?
+        
+        // not sure if we need serialization here, just put it, in case...
+        
+        srlz.d;;
+        srlz.i;;
+        
+        br.ret.dpnt    b0;;
+.endp MemoryFence
+
+.proc DisableInterrupts
+.type DisableInterrupts, @function
+
+DisableInterrupts::
+         rsm      0x4000
+         srlz.d;;
+         br.ret.dpnt    b0;;
+
+.endp DisableInterrupts
+
+.proc EnableInterrupts
+.type EnableInterrupts, @function
+
+EnableInterrupts::
+      ssm     0x4000
+      srlz.d;;
+      br.ret.dpnt    b0;;
+
+.endp EnableInterrupts
+
+.proc EnableDisableInterrupts
+.type EnableDisableInterrupts, @function
+
+EnableDisableInterrupts::
+         ssm      0x4000
+         srlz.d;;
+         srlz.i;;
+         rsm      0x4000
+         srlz.d;;
+
+         br.ret.dpnt    b0;;
+
+.endp EnableDisableInterrupts
+
diff --git a/MdePkg/Library/BaseLib/Ipf/AsmPalCall.s b/MdePkg/Library/BaseLib/Ipf/AsmPalCall.s
new file mode 100644
index 000000000000..51c2dbc71628
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/AsmPalCall.s
@@ -0,0 +1,158 @@
+/// @file
+///   Contains an implementation of CallPalProcStacked on Itanium-based
+///   architecture.
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name:  AsmPalCall.s
+///
+///
+
+
+//-----------------------------------------------------------------------------
+//++
+//  AsmPalCall
+//
+//  Makes a PAL procedure call.
+//  This is function to make a PAL procedure call.  Based on the Index
+//  value this API will make static or stacked PAL call.  The following table
+//  describes the usage of PAL Procedure Index Assignment. Architected procedures
+//  may be designated as required or optional.  If a PAL procedure is specified
+//  as optional, a unique return code of 0xFFFFFFFFFFFFFFFF is returned in the
+//  Status field of the PAL_CALL_RETURN structure.
+//  This indicates that the procedure is not present in this PAL implementation.
+//  It is the caller's responsibility to check for this return code after calling
+//  any optional PAL procedure.
+//  No parameter checking is performed on the 5 input parameters, but there are
+//  some common rules that the caller should follow when making a PAL call.  Any
+//  address passed to PAL as buffers for return parameters must be 8-byte aligned.
+//  Unaligned addresses may cause undefined results.  For those parameters defined
+//  as reserved or some fields defined as reserved must be zero filled or the invalid
+//  argument return value may be returned or undefined result may occur during the
+//  execution of the procedure.  If the PalEntryPoint  does not point to a valid
+//  PAL entry point then the system behavior is undefined.  This function is only
+//  available on IPF.
+//
+//  On Entry :
+//           in0:  PAL_PROC entrypoint
+//           in1-in4 : PAL_PROC arguments
+//
+//  Return Value:
+//
+//  As per stacked calling conventions.
+//
+//--
+//---------------------------------------------------------------------------
+
+//
+// PAL function calls
+//
+#define PAL_MC_CLEAR_LOG               0x0015
+#define PAL_MC_DYNAMIC_STATE           0x0018
+#define PAL_MC_ERROR_INFO              0x0019
+#define PAL_MC_RESUME                  0x001a
+
+
+.text
+.proc AsmPalCall
+.type AsmPalCall, @function
+
+AsmPalCall::
+         alloc          loc1 = ar.pfs,5,8,4,0
+         mov            loc0 = b0
+         mov            loc3 = b5
+         mov            loc4 = r2
+         mov            loc7 = r1
+         mov            r2 = psr;;
+         mov            r28 = in1
+         mov            loc5 = r2;;
+
+         movl           loc6 = 0x100;;
+         cmp.ge         p6,p7 = r28,loc6;;
+
+(p6)     movl           loc6 = 0x1FF;;
+(p7)     br.dpnt.few PalCallStatic;;                  // 0 ~ 255 make a static Pal Call
+(p6)     cmp.le         p6,p7 = r28,loc6;;
+(p6)     br.dpnt.few PalCallStacked;;                 // 256 ~ 511 make a stacked Pal Call
+(p7)     movl           loc6 = 0x300;;
+(p7)     cmp.ge         p6,p7 = r28,loc6;;
+(p7)     br.dpnt.few PalCallStatic;;                  // 512 ~ 767 make a static Pal Call
+(p6)     movl           loc6 = 0x3FF;;
+(p6)     cmp.le         p6,p7 = r28,loc6;;
+(p6)     br.dpnt.few PalCallStacked;;                 // 768 ~ 1023 make a stacked Pal Call
+
+(p7)     mov            r8 = 0xFFFFFFFFFFFFFFFF;;     // > 1024 return invalid
+(p7)     br.dpnt.few    ComeBackFromPALCall;;
+
+PalCallStatic:
+         movl           loc6 = PAL_MC_CLEAR_LOG;;
+         cmp.eq         p6,p7 = r28,loc6;;
+
+(p7)     movl           loc6 = PAL_MC_DYNAMIC_STATE;;
+(p7)     cmp.eq         p6,p7 = r28,loc6;;
+
+(p7)     movl           loc6 = PAL_MC_ERROR_INFO;;
+(p7)     cmp.eq         p6,p7 = r28,loc6;;
+
+(p7)     movl           loc6 = PAL_MC_RESUME;;
+(p7)     cmp.eq         p6,p7 = r28,loc6 ;;
+
+         mov            loc6 = 0x1;;
+(p7)     dep            r2 = loc6,r2,13,1;;           // psr.ic = 1
+
+// p6 will be true, if it is one of the MCHK calls. There has been lots of debate
+// on psr.ic for these values. For now, do not do any thing to psr.ic
+
+         dep            r2 = r0,r2,14,1;;             // psr.i = 0
+
+         mov            psr.l = r2
+         srlz.d                                       // Needs data serailization.
+         srlz.i                                       // Needs instruction serailization.
+
+StaticGetPALLocalIP:
+         mov            loc2 = ip;;
+         add            loc2 = ComeBackFromPALCall - StaticGetPALLocalIP,loc2;;
+         mov            b0 = loc2                     // return address after Pal call
+
+         mov            r29 = in2
+         mov            r30 = in3
+         mov            r31 = in4
+         mov            b5 = in0;;                    // get the PalProcEntrypt from input
+         br.sptk        b5;;                          // Take the plunge.
+
+PalCallStacked:
+         dep            r2 = r0,r2,14,1;;             // psr.i = 0
+         mov            psr.l = r2;;
+         srlz.d                                       // Needs data serailization.
+         srlz.i                                       // Needs instruction serailization.
+
+StackedGetPALLocalIP:
+         mov            out0 = in1
+         mov            out1 = in2
+         mov            out2 = in3
+         mov            out3 = in4
+         mov            b5 =  in0 ;;                  // get the PalProcEntrypt from input
+         br.call.dpnt   b0 = b5 ;;                    // Take the plunge.
+
+ComeBackFromPALCall:
+         mov            psr.l = loc5 ;;
+         srlz.d                                       // Needs data serailization.
+         srlz.i                                       // Needs instruction serailization.
+
+         mov            b5 = loc3
+         mov            r2 = loc4
+         mov            r1 = loc7
+
+         mov            b0 = loc0
+         mov            ar.pfs = loc1;;
+         br.ret.dpnt    b0;;
+
+.endp AsmPalCall
+
diff --git a/MdePkg/Library/BaseLib/Ipf/CpuBreakpoint.c b/MdePkg/Library/BaseLib/Ipf/CpuBreakpoint.c
new file mode 100644
index 000000000000..4d183f7d92b4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/CpuBreakpoint.c
@@ -0,0 +1,96 @@
+/** @file
+  Base Library CPU functions for Itanium
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __break (0);
+}
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+  __mfa ();
+}
+
+/**
+  Disables CPU interrupts.
+
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{
+  _disable ();
+}
+
+/**
+  Enables CPU interrupts.
+
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  _enable ();
+}
+
+/**
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+**/
+VOID
+EFIAPI
+EnableDisableInterrupts (
+  VOID
+  )
+{
+  EnableInterrupts ();
+  DisableInterrupts ();
+}
diff --git a/MdePkg/Library/BaseLib/Ipf/CpuBreakpointMsc.c b/MdePkg/Library/BaseLib/Ipf/CpuBreakpointMsc.c
new file mode 100644
index 000000000000..f735fb336543
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/CpuBreakpointMsc.c
@@ -0,0 +1,102 @@
+/** @file
+  Base Library CPU functions for Itanium
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+#pragma intrinsic (_enable)
+#pragma intrinsic (_disable)
+#pragma intrinsic (__break)
+#pragma intrinsic (__mfa)
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __break (0);
+}
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+  __mfa ();
+}
+
+/**
+  Disables CPU interrupts.
+
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{
+  _disable ();
+}
+
+/**
+  Enables CPU interrupts.
+
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  _enable ();
+}
+
+/**
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+  Enables CPU interrupts for the smallest window required to capture any
+  pending interrupts.
+
+**/
+VOID
+EFIAPI
+EnableDisableInterrupts (
+  VOID
+  )
+{
+  EnableInterrupts ();
+  DisableInterrupts ();
+}
+
diff --git a/MdePkg/Library/BaseLib/Ipf/CpuPause.s b/MdePkg/Library/BaseLib/Ipf/CpuPause.s
new file mode 100644
index 000000000000..c17cf9758968
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/CpuPause.s
@@ -0,0 +1,25 @@
+/// @file
+///   CpuPause() function for Itanium-based architecture.
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name:  CpuPause.s
+///
+///
+
+.auto
+.text
+
+.proc   CpuPause
+.type   CpuPause, @function
+CpuPause::
+        hint.i              @pause
+        br.ret.sptk.many    b0
+.endp
diff --git a/MdePkg/Library/BaseLib/Ipf/ExecFc.s b/MdePkg/Library/BaseLib/Ipf/ExecFc.s
new file mode 100644
index 000000000000..0f61bccc77ea
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/ExecFc.s
@@ -0,0 +1,66 @@
+/// @file
+///  IPF specific AsmFc() and AsmFci () functions
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name: ExecFc.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmFc
+//
+// This routine is used to execute a FC instruction on the specific address.
+//
+// Arguments :
+//
+// On Entry :  The specific address need to execute FC instruction.
+//
+// Return Value: The specific address have been execute FC instruction.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmFc, @function
+.proc   AsmFc
+.regstk 1, 0, 0, 0
+
+AsmFc::
+        fc              in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmFc
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmFci
+//
+// This routine is used to execute a FC.i instruction on the specific address.
+//
+// Arguments :
+//
+// On Entry :  The specific address need to execute FC.i instruction.
+//
+// Return Value: The specific address have been execute FC.i instruction.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmFci, @function
+.proc   AsmFci
+.regstk 1, 0, 0, 0
+
+AsmFci::
+        fc.i            in0
+        mov             r8 = in0;;
+        br.ret.dpnt     b0;;
+.endp   AsmFci
diff --git a/MdePkg/Library/BaseLib/Ipf/FlushCacheRange.c b/MdePkg/Library/BaseLib/Ipf/FlushCacheRange.c
new file mode 100644
index 000000000000..2d7717ba6de1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/FlushCacheRange.c
@@ -0,0 +1,51 @@
+/** @file
+  AsmFlushCacheRange() function for IPF.
+
+  Copyright (c) 2009, 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 "BaseLibInternals.h"
+
+/**
+  Flush a range of  cache lines in the cache coherency domain of the calling
+  CPU.
+
+  Flushes the cache lines specified by Address and Length.  If Address is not aligned 
+  on a cache line boundary, then entire cache line containing Address is flushed.  
+  If Address + Length is not aligned on a cache line boundary, then the entire cache 
+  line containing Address + Length - 1 is flushed.  This function may choose to flush 
+  the entire cache if that is more efficient than flushing the specified range.  If 
+  Length is 0, the no cache lines are flushed.  Address is returned.   
+  This function is only available on IPF.
+
+  If Length is greater than (MAX_ADDRESS - Address + 1), then ASSERT().
+
+  @param  Address The base address of the instruction lines to invalidate. If
+                  the CPU is in a physical addressing mode, then Address is a
+                  physical address. If the CPU is in a virtual addressing mode,
+                  then Address is a virtual address.
+
+  @param  Length  The number of bytes to invalidate from the instruction cache.
+
+  @return Address.
+
+**/
+VOID *
+EFIAPI
+AsmFlushCacheRange (
+  IN      VOID                      *Address,
+  IN      UINTN                     Length
+  )
+{
+  ASSERT (Length <= MAX_ADDRESS - (UINTN)Address + 1);
+  return InternalFlushCacheRange (Address, Length);
+}
diff --git a/MdePkg/Library/BaseLib/Ipf/GetInterruptState.s b/MdePkg/Library/BaseLib/Ipf/GetInterruptState.s
new file mode 100644
index 000000000000..a5ecd6fe30cd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/GetInterruptState.s
@@ -0,0 +1,27 @@
+/// @file
+///   Retrieve of the interrupt state of the running processor for the Itanium
+///   architecture.
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name:  GetInterruptState.s
+///
+///
+
+.auto
+.text
+
+.proc   GetInterruptState
+.type   GetInterruptState, @function
+GetInterruptState::
+        mov                 r8  = psr
+        extr.u              r8  = r8, 14, 1
+        br.ret.sptk.many    b0
+.endp   GetInterruptState
diff --git a/MdePkg/Library/BaseLib/Ipf/Ia64gen.h b/MdePkg/Library/BaseLib/Ipf/Ia64gen.h
new file mode 100644
index 000000000000..5ec13a8d17a5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/Ia64gen.h
@@ -0,0 +1,205 @@
+/** @file 
+
+    Register Definition for IPF.
+ 
+Copyright (c) 2006 - 2008, 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 _IA64GEN_H_
+#define _IA64GEN_H_
+
+#define TT_UNAT           0
+#define C_PSR             0
+#define J_UNAT            0
+#define T_TYPE            0
+#define T_IPSR            0x8
+#define T_ISR             0x10
+#define T_IIP             0x18
+#define T_IFA             0x20
+#define T_IIPA            0x28
+#define T_IFS             0x30
+#define T_IIM             0x38
+#define T_RSC             0x40
+#define T_BSP             0x48
+#define T_BSPSTORE        0x50
+#define T_RNAT            0x58
+#define T_PFS             0x60
+#define T_KBSPSTORE       0x68
+#define T_UNAT            0x70
+#define T_CCV             0x78
+#define T_DCR             0x80
+#define T_PREDS           0x88
+#define T_NATS            0x90
+#define T_R1              0x98
+#define T_GP              0x98
+#define T_R2              0xa0
+#define T_R3              0xa8
+#define T_R4              0xb0
+#define T_R5              0xb8
+#define T_R6              0xc0
+#define T_R7              0xc8
+#define T_R8              0xd0
+#define T_R9              0xd8
+#define T_R10             0xe0
+#define T_R11             0xe8
+#define T_R12             0xf0
+#define T_SP              0xf0
+#define T_R13             0xf8
+#define T_R14             0x100
+#define T_R15             0x108
+#define T_R16             0x110
+#define T_R17             0x118
+#define T_R18             0x120
+#define T_R19             0x128
+#define T_R20             0x130
+#define T_R21             0x138
+#define T_R22             0x140
+#define T_R23             0x148
+#define T_R24             0x150
+#define T_R25             0x158
+#define T_R26             0x160
+#define T_R27             0x168
+#define T_R28             0x170
+#define T_R29             0x178
+#define T_R30             0x180
+#define T_R31             0x188
+#define T_F2              0x1f0
+#define T_F3              0x200
+#define T_F4              0x210
+#define T_F5              0x220
+#define T_F6              0x230
+#define T_F7              0x240
+#define T_F8              0x250
+#define T_F9              0x260
+#define T_F10             0x270
+#define T_F11             0x280
+#define T_F12             0x290
+#define T_F13             0x2a0
+#define T_F14             0x2b0
+#define T_F15             0x2c0
+#define T_F16             0x2d0
+#define T_F17             0x2e0
+#define T_F18             0x2f0
+#define T_F19             0x300
+#define T_F20             0x310
+#define T_F21             0x320
+#define T_F22             0x330
+#define T_F23             0x340
+#define T_F24             0x350
+#define T_F25             0x360
+#define T_F26             0x370
+#define T_F27             0x380
+#define T_F28             0x390
+#define T_F29             0x3a0
+#define T_F30             0x3b0
+#define T_F31             0x3c0
+#define T_FPSR            0x1e0
+#define T_B0              0x190
+#define T_B1              0x198
+#define T_B2              0x1a0
+#define T_B3              0x1a8
+#define T_B4              0x1b0
+#define T_B5              0x1b8
+#define T_B6              0x1c0
+#define T_B7              0x1c8
+#define T_EC              0x1d0
+#define T_LC              0x1d8
+#define J_NATS            0x8
+#define J_PFS             0x10
+#define J_BSP             0x18
+#define J_RNAT            0x20
+#define J_PREDS           0x28
+#define J_LC              0x30
+#define J_R4              0x38
+#define J_R5              0x40
+#define J_R6              0x48
+#define J_R7              0x50
+#define J_SP              0x58
+#define J_F2              0x60
+#define J_F3              0x70
+#define J_F4              0x80
+#define J_F5              0x90
+#define J_F16             0xa0
+#define J_F17             0xb0
+#define J_F18             0xc0
+#define J_F19             0xd0
+#define J_F20             0xe0
+#define J_F21             0xf0
+#define J_F22             0x100
+#define J_F23             0x110
+#define J_F24             0x120
+#define J_F25             0x130
+#define J_F26             0x140
+#define J_F27             0x150
+#define J_F28             0x160
+#define J_F29             0x170
+#define J_F30             0x180
+#define J_F31             0x190
+#define J_FPSR            0x1a0
+#define J_B0              0x1a8
+#define J_B1              0x1b0
+#define J_B2              0x1b8
+#define J_B3              0x1c0
+#define J_B4              0x1c8
+#define J_B5              0x1d0
+#define TRAP_FRAME_LENGTH 0x3d0
+#define C_UNAT            0x28
+#define C_NATS            0x30
+#define C_PFS             0x8
+#define C_BSPSTORE        0x10
+#define C_RNAT            0x18
+#define C_RSC             0x20
+#define C_PREDS           0x38
+#define C_LC              0x40
+#define C_DCR             0x48
+#define C_R1              0x50
+#define C_GP              0x50
+#define C_R4              0x58
+#define C_R5              0x60
+#define C_R6              0x68
+#define C_R7              0x70
+#define C_SP              0x78
+#define C_R13             0x80
+#define C_F2              0x90
+#define C_F3              0xa0
+#define C_F4              0xb0
+#define C_F5              0xc0
+#define C_F16             0xd0
+#define C_F17             0xe0
+#define C_F18             0xf0
+#define C_F19             0x100
+#define C_F20             0x110
+#define C_F21             0x120
+#define C_F22             0x130
+#define C_F23             0x140
+#define C_F24             0x150
+#define C_F25             0x160
+#define C_F26             0x170
+#define C_F27             0x180
+#define C_F28             0x190
+#define C_F29             0x1a0
+#define C_F30             0x1b0
+#define C_F31             0x1c0
+#define C_FPSR            0x1d0
+#define C_B0              0x1d8
+#define C_B1              0x1e0
+#define C_B2              0x1e8
+#define C_B3              0x1f0
+#define C_B4              0x1f8
+#define C_B5              0x200
+#define TT_R2             0x8
+#define TT_R3             0x10
+#define TT_R8             0x18
+#define TT_R9             0x20
+#define TT_R10            0x28
+#define TT_R11            0x30
+#define TT_R14            0x38
+
+#endif _IA64GEN_H
diff --git a/MdePkg/Library/BaseLib/Ipf/InternalFlushCacheRange.s b/MdePkg/Library/BaseLib/Ipf/InternalFlushCacheRange.s
new file mode 100644
index 000000000000..f8da45f79ddd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/InternalFlushCacheRange.s
@@ -0,0 +1,94 @@
+//++
+// Copyright (c) 2006 - 2009, 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.             
+// 
+//  Module Name:
+//    InternalFlushCacheRange.s 
+//
+//  Abstract:
+//    Assemble routine to flush cache lines 
+//
+// Revision History:
+//
+//--
+.file  "IpfCpuCache.s"
+
+#include <IpfMacro.i>
+
+//
+//  Internal worker function to invalidate a range of instruction cache lines
+//  in the cache coherency domain of the calling CPU.
+//
+//  Internal worker function to invalidate the instruction cache lines specified
+//  by Address and Length. If Address is not aligned on a cache line boundary,
+//  then entire instruction cache line containing Address is invalidated. If
+//  Address + Length is not aligned on a cache line boundary, then the entire
+//  instruction cache line containing Address + Length -1 is invalidated. This
+//  function may choose to invalidate the entire instruction cache if that is more
+//  efficient than invalidating the specified range. If Length is 0, the no instruction
+//  cache lines are invalidated. Address is returned.
+//  This function is only available on IPF.
+//
+//  @param  Address The base address of the instruction cache lines to
+//                  invalidate. If the CPU is in a physical addressing mode, then
+//                  Address is a physical address. If the CPU is in a virtual
+//                  addressing mode, then Address is a virtual address.
+//
+//  @param  Length  The number of bytes to invalidate from the instruction cache.
+//
+//  @return Address
+//  
+//  VOID *
+//  EFIAPI
+//  InternalFlushCacheRange (
+//    IN      VOID                      *Address,
+//    IN      UINTN                     Length
+//    );
+//
+PROCEDURE_ENTRY (InternalFlushCacheRange)
+
+      NESTED_SETUP (5,8,0,0)
+            
+      mov         loc2 = ar.lc
+      
+      mov         loc3 = in0                  // Start address.
+      mov         loc4 = in1;;                // Length in bytes.
+      
+      cmp.eq  p6,p7 = loc4, r0;;               // If Length is zero then don't flush any cache
+      (p6)  br.spnt.many DoneFlushingC;;         
+      
+      add         loc4 = loc4,loc3 
+      mov         loc5 = 1;;
+      sub         loc4 = loc4, loc5 ;; // the End address to flush
+                                         
+      dep         loc3 = r0,loc3,0,5          
+      dep         loc4 = r0,loc4,0,5;;         
+      shr         loc3 = loc3,5             
+      shr         loc4 = loc4,5;;    // 32 byte cache line
+      
+      sub         loc4 = loc4,loc3;; // total flush count, It should be add 1 but 
+                                     // the br.cloop will first execute one time 
+      mov         loc3 = in0                  
+      mov         loc5 = 32      
+      mov         ar.lc = loc4;;
+
+StillFlushingC:
+      fc          loc3;; 
+      sync.i;;
+      srlz.i;;
+      add         loc3 = loc5,loc3;;
+      br.cloop.sptk.few StillFlushingC;;
+
+DoneFlushingC:      
+      mov         ar.lc = loc2     
+      mov          r8   = in0       // return *Address
+      NESTED_RETURN
+
+PROCEDURE_EXIT (InternalFlushCacheRange)
+
diff --git a/MdePkg/Library/BaseLib/Ipf/InternalSwitchStack.c b/MdePkg/Library/BaseLib/Ipf/InternalSwitchStack.c
new file mode 100644
index 000000000000..a7371c2b82a0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/InternalSwitchStack.c
@@ -0,0 +1,64 @@
+/** @file
+  SwitchStack() function for IPF.
+
+  Copyright (c) 2007 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.
+  Marker will be ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  Marker      VA_LIST marker for the variable argument list.
+
+**/
+VOID
+EFIAPI
+InternalSwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,   OPTIONAL
+  IN      VOID                      *Context2,   OPTIONAL
+  IN      VOID                      *NewStack,
+  IN      VA_LIST                   Marker
+  )
+{
+  VOID                      *NewBsp;
+
+  //
+  // Get new backing store pointer from variable list
+  //
+  NewBsp   = VA_ARG (Marker, VOID *);
+
+  //
+  // New backing store pointer should be aligned with CPU_STACK_ALIGNMENT
+  //
+  ASSERT (((UINTN)NewBsp & (CPU_STACK_ALIGNMENT - 1)) == 0);
+
+  AsmSwitchStackAndBackingStore (EntryPoint, Context1, Context2, NewStack, NewBsp);
+}
diff --git a/MdePkg/Library/BaseLib/Ipf/LongJmp.s b/MdePkg/Library/BaseLib/Ipf/LongJmp.s
new file mode 100644
index 000000000000..23a1cc12387a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/LongJmp.s
@@ -0,0 +1,121 @@
+/// @file
+///  Contains an implementation of longjmp for the Itanium-based architecture.
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name: longjmp.s
+///
+///
+
+.auto
+.text
+
+.proc   InternalLongJump
+.type   InternalLongJump, @function
+.regstk 2, 0, 0, 0
+InternalLongJump::
+        add                 r10 = 0x10*20 + 8*14, in0
+        movl                r2  = ~((((1 << 14) - 1) << 16) | 3)
+
+        ld8.nt1             r14 = [r10], -8*2       // BSP, skip PFS
+        mov                 r15 = ar.bspstore       // BSPSTORE
+
+        ld8.nt1             r17 = [r10], -8         // UNAT after spill
+        mov                 r16 = ar.rsc            // RSC
+        cmp.leu             p6  = r14, r15
+
+        ld8.nt1             r18 = [r10], -8         // UNAT
+        ld8.nt1             r25 = [r10], -8         // b5
+        and                 r2  = r16, r2
+
+        ldf.fill.nt1        f2  = [in0], 0x10
+        ld8.nt1             r24 = [r10], -8         // b4
+        mov                 b5  = r25
+
+        mov                 ar.rsc = r2
+        ld8.nt1             r23 = [r10], -8         // b3
+        mov                 b4  = r24
+
+        ldf.fill.nt1        f3  = [in0], 0x10
+        mov                 ar.unat = r17
+(p6)    br.spnt.many        _skip_flushrs
+
+        flushrs
+        mov                 r15 = ar.bsp            // New BSPSTORE
+
+_skip_flushrs:
+        mov                 r31 = ar.rnat           // RNAT
+        loadrs
+
+        ldf.fill.nt1        f4  = [in0], 0x10
+        ld8.nt1             r22 = [r10], -8
+        dep                 r2  = -1, r14, 3, 6
+
+        ldf.fill.nt1        f5  = [in0], 0x10
+        ld8.nt1             r21 = [r10], -8
+        cmp.ltu             p6  = r2, r15
+
+        ld8.nt1             r20 = [r10], -0x10      // skip sp
+(p6)    ld8.nta             r31 = [r2]
+        mov                 b3  = r23
+
+        ldf.fill.nt1        f16 = [in0], 0x10
+        ld8.fill.nt1        r7  = [r10], -8
+        mov                 b2  = r22
+
+        ldf.fill.nt1        f17 = [in0], 0x10
+        ld8.fill.nt1        r6  = [r10], -8
+        mov                 b1  = r21
+
+        ldf.fill.nt1        f18 = [in0], 0x10
+        ld8.fill.nt1        r5  = [r10], -8
+        mov                 b0  = r20
+
+        ldf.fill.nt1        f19 = [in0], 0x10
+        ld8.fill.nt1        r4  = [r10], 8*13
+
+        ldf.fill.nt1        f20 = [in0], 0x10
+        ld8.nt1             r19 = [r10], 0x10       // PFS
+
+        ldf.fill.nt1        f21 = [in0], 0x10
+        ld8.nt1             r26 = [r10], 8          // Predicate
+        mov                 ar.pfs = r19
+
+        ldf.fill.nt1        f22 = [in0], 0x10
+        ld8.nt1             r27 = [r10], 8          // LC
+        mov                 pr  = r26, -1
+
+        ldf.fill.nt1        f23 = [in0], 0x10
+        ld8.nt1             r28 = [r10], -17*8 - 0x10
+        mov                 ar.lc = r27
+
+        ldf.fill.nt1        f24 = [in0], 0x10
+        ldf.fill.nt1        f25 = [in0], 0x10
+        mov                 r8  = in1
+
+        ldf.fill.nt1        f26 = [in0], 0x10
+        ldf.fill.nt1        f31 = [r10], -0x10
+
+        ldf.fill.nt1        f27 = [in0], 0x10
+        ldf.fill.nt1        f30 = [r10], -0x10
+
+        ldf.fill.nt1        f28 = [in0]
+        ldf.fill.nt1        f29 = [r10], 0x10*3 + 8*4
+
+        ld8.fill.nt1        sp  = [r10]
+        mov                 ar.unat = r18
+
+        mov                 ar.bspstore = r14
+        mov                 ar.rnat = r31
+
+        invala
+        mov                 ar.rsc = r16
+        br.ret.sptk         b0
+.endp
diff --git a/MdePkg/Library/BaseLib/Ipf/ReadAr.s b/MdePkg/Library/BaseLib/Ipf/ReadAr.s
new file mode 100644
index 000000000000..bcb9c589462f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/ReadAr.s
@@ -0,0 +1,109 @@
+/// @file
+///  IPF specific application register reading functions
+///
+/// Copyright (c) 2008, 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.
+///
+///
+///
+
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadApplicationRegister
+//
+// Reads a 64-bit application register.
+//
+// Reads and returns the application register specified by Index.
+// If Index is invalid then 0xFFFFFFFFFFFFFFFF is returned.  This function is only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The index of the application register to read.
+//
+// Return Value: The application register specified by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadApplicationRegister, @function
+.proc   AsmReadApplicationRegister
+.regstk 1, 0, 0, 0
+
+AsmReadApplicationRegister::
+  //
+  // ARs are defined in the ranges 0-44 and 64-66 (with some holes).
+  // Compact this list by subtracting 16 from the top range.
+  // 0-44, 64-66 -> 0-44, 48-50
+  //
+  mov  r15=2
+  mov  r14=pr                   // save predicates
+  cmp.leu  p6,p7=64,in0         // p6 = AR# >= 64
+  ;;
+  (p7)  cmp.leu  p7,p0=48,in0   // p7 = 32 <= AR# < 64
+  (p6)  add  in0=-16,in0        // if (AR >= 64) AR# -= 16
+  ;;
+  (p7)  mov  r15=0              // if bad range (48-63)
+  ;;
+  mov  ret0=-1                  // in case of illegal AR #
+  shl  r15=r15,in0              // r15 = 0x2 << AR#
+  ;;
+  mov  pr=r15,-1
+  ;;
+  //
+  // At this point the predicates contain a bit field of the
+  // AR desired.  (The bit is the AR+1, since pr0 is always 1.)
+  //
+  .pred.rel "mutex",p1,p2,p3,p4,p5,p6,p7,p8,p17,p18,p19,p20,p22,p25,\
+        p26,p27,p28,p29,p30,p31,p33,p37,p41,p45,p49,p50,p51
+  (p1)  mov  ret0=ar.k0         // ar0
+  (p2)  mov  ret0=ar.k1         // ar1
+  (p3)  mov  ret0=ar.k2         // ar2
+  (p4)  mov  ret0=ar.k3         // ar3
+  (p5)  mov  ret0=ar.k4         // ar4
+  (p6)  mov  ret0=ar.k5         // ar5
+  (p7)  mov  ret0=ar.k6         // ar6
+  (p8)  mov  ret0=ar.k7         // ar7
+
+  (p17)  mov  ret0=ar.rsc       // ar16
+  (p18)  mov  ret0=ar.bsp       // ar17
+  (p19)  mov  ret0=ar.bspstore  // ar18
+  (p20)  mov  ret0=ar.rnat      // ar19
+
+  (p22)  mov  ret0=ar.fcr       // ar21 [iA32]
+
+  (p25)  mov  ret0=ar.eflag     // ar24 [iA32]
+  (p26)  mov  ret0=ar.csd       // ar25 [iA32]
+  (p27)  mov  ret0=ar.ssd       // ar26 [iA32]
+  (p28)  mov  ret0=ar.cflg      // ar27 [iA32]
+  (p29)  mov  ret0=ar.fsr       // ar28 [iA32]
+  (p30)  mov  ret0=ar.fir       // ar29 [iA32]
+  (p31)  mov  ret0=ar.fdr       // ar30 [iA32]
+
+  (p33)  mov  ret0=ar.ccv       // ar32
+
+  (p37)  mov  ret0=ar.unat      // ar36
+
+  (p41)  mov  ret0=ar.fpsr      // ar40
+
+  (p45)  mov  ret0=ar.itc       // ar44
+
+  //
+  // This is the translated (-16) range.
+  //
+  (p49)  mov  ret0=ar.pfs       // ar64
+  (p50)  mov  ret0=ar.lc        // ar65
+  (p51)  mov  ret0=ar.ec        // ar66
+
+  // Restore predicates and return.
+
+  mov  pr=r14,-1
+  br.ret.sptk  b0
+  .endp
diff --git a/MdePkg/Library/BaseLib/Ipf/ReadCpuid.s b/MdePkg/Library/BaseLib/Ipf/ReadCpuid.s
new file mode 100644
index 000000000000..d79a37dd7e03
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/ReadCpuid.s
@@ -0,0 +1,40 @@
+/// @file
+///  IPF specific AsmReadCpuid()function
+///
+/// Copyright (c) 2006, 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.
+///
+/// Module Name: ReadCpuid.s
+///
+///
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadCpuid
+//
+// This routine is used to Reads the current value of Processor Identifier Register (CPUID).
+//
+// Arguments :
+//
+// On Entry : The 8-bit Processor Identifier Register index to read.
+//
+// Return Value: The current value of Processor Identifier Register specified by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadCpuid, @function
+.proc   AsmReadCpuid
+.regstk 1, 0, 0, 0
+
+AsmReadCpuid::
+        mov             r8 = cpuid[in0];;
+        br.ret.dpnt     b0;;
+.endp    AsmReadCpuid
+
diff --git a/MdePkg/Library/BaseLib/Ipf/ReadCr.s b/MdePkg/Library/BaseLib/Ipf/ReadCr.s
new file mode 100644
index 000000000000..d9f8f98eb890
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/ReadCr.s
@@ -0,0 +1,102 @@
+/// @file
+///  IPF specific control register reading functions
+///
+/// Copyright (c) 2008, 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.
+///
+///
+///
+
+
+
+//---------------------------------------------------------------------------------
+//++
+// AsmReadControlRegister
+//
+// Reads a 64-bit control register.
+//
+// Reads and returns the control register specified by Index.
+// If Index is invalid then 0xFFFFFFFFFFFFFFFF is returned.  This function is only available on IPF.
+//
+// Arguments :
+//
+// On Entry : The index of the control register to read.
+//
+// Return Value: The control register specified by Index.
+//
+//--
+//----------------------------------------------------------------------------------
+.text
+.type   AsmReadControlRegister, @function
+.proc   AsmReadControlRegister
+.regstk 1, 0, 0, 0
+
+AsmReadControlRegister::
+  //
+  // CRs are defined in the ranges 0-25 and 64-81 (with some holes).
+  // Compact this list by subtracting 32 from the top range.
+  // 0-25, 64-81 -> 0-25, 32-49
+  //
+  mov  r15=2
+  mov  r14=pr                    // save predicates
+  cmp.leu  p6,p7=64,in0          // p6 = CR# >= 64
+  ;;
+  (p7)  cmp.leu  p7,p0=32,in0    // p7 = 32 <= CR# < 64
+  (p6)  add  in0=-32,in0         // if (CR >= 64) CR# -= 32
+  ;;
+  (p7)  mov  r15=0               // if bad range (32-63)
+  ;;
+  mov  ret0=-1                   // in case of illegal CR #
+  shl  r15=r15,in0               // r15 = 0x2 << CR#
+  ;;
+  mov  pr=r15,-1
+  ;;
+
+  //
+  // At this point the predicates contain a bit field of the
+  // CR desired.  (The bit is the CR+1, since pr0 is always 1.)
+  //
+  .pred.rel "mutex",p1,p2,p3,p9,p17,p18,p20,p21,p22,p23,p24,p25,p26,\
+    p33,p34,p35,p36,p37,p38,p39,p40,p41,p42,p43,p49,p50
+  (p1)  mov  ret0=cr.dcr        // cr0
+  (p2)  mov  ret0=cr.itm        // cr1
+  (p3)  mov  ret0=cr.iva        // cr2
+  (p9)  mov  ret0=cr.pta        // cr8
+  (p17)  mov  ret0=cr.ipsr      // cr16
+  (p18)  mov  ret0=cr.isr       // cr17
+  (p20)  mov  ret0=cr.iip       // cr19
+  (p21)  mov  ret0=cr.ifa       // cr20
+  (p22)  mov  ret0=cr.itir      // cr21
+  (p23)  mov  ret0=cr.iipa      // cr22
+  (p24)  mov  ret0=cr.ifs       // cr23
+  (p25)  mov  ret0=cr.iim       // cr24
+  (p26)  mov  ret0=cr.iha       // cr25
+
+  // This is the translated (-32) range.
+
+  (p33)  mov  ret0=cr.lid       // cr64
+  (p34)  mov  ret0=cr.ivr       // cr65
+  (p35)  mov  ret0=cr.tpr       // cr66
+  (p36)  mov  ret0=cr.eoi       // cr67
+  (p37)  mov  ret0=cr.irr0      // cr68
+  (p38)  mov  ret0=cr.irr1      // cr69
+  (p39)  mov  ret0=cr.irr2      // cr70
+  (p40)  mov  ret0=cr.irr3      // cr71
+  (p41)  mov  ret0=cr.itv       // cr72
+  (p42)  mov  ret0=cr.pmv       // cr73
+  (p43)  mov  ret0=cr.cmcv      // cr74
+  (p49)  mov  ret0=cr.lrr0      // cr80
+  (p50)  mov  ret0=cr.lrr1      // cr81
+  
+  //
+  // Restore predicates and return.
+  //
+  mov  pr=r14,-1
+  br.ret.sptk  b0
+  .endp
diff --git a/MdePkg/Library/BaseLib/Ipf/SetJmp.s b/MdePkg/Library/BaseLib/Ipf/SetJmp.s
new file mode 100644
index 000000000000..2495b33ab722
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/SetJmp.s
@@ -0,0 +1,108 @@
+/// @file
+///  Contains an implementation of longjmp for the Itanium-based architecture.
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name: longjmp.s
+///
+///
+
+.auto
+.text
+
+ASM_GLOBAL InternalAssertJumpBuffer
+.type   InternalAssertJumpBuffer, @function
+
+.proc   SetJump
+.type   SetJump, @function
+SetJump::
+        alloc               loc0 = ar.pfs, 1, 2, 1, 0
+        mov                 loc1 = b0
+        mov                 out0 = in0
+
+        brl.call.sptk.many  b0  = InternalAssertJumpBuffer
+
+        mov                 r14 = ar.unat
+        mov                 r15 = ar.bsp
+        add                 r10 = 0x10*20, in0
+
+        stf.spill.nta       [in0] = f2, 0x10
+        st8.spill.nta       [r10] = r4, 8
+        mov                 r21 = b1
+
+        stf.spill.nta       [in0] = f3, 0x10
+        st8.spill.nta       [r10] = r5, 8
+        mov                 r22 = b2
+
+        stf.spill.nta       [in0] = f4, 0x10
+        st8.spill.nta       [r10] = r6, 8
+        mov                 r23 = b3
+
+        stf.spill.nta       [in0] = f5, 0x10
+        st8.spill.nta       [r10] = r7, 8
+        mov                 r24 = b4
+
+        stf.spill.nta       [in0] = f16, 0x10
+        st8.spill.nta       [r10] = sp, 8
+        mov                 r25 = b5
+
+        stf.spill.nta       [in0] = f17, 0x10
+        st8.nta             [r10] = loc1, 8
+        mov                 r16 = pr
+
+        stf.spill.nta       [in0] = f18, 0x10
+        st8.nta             [r10] = r21, 8
+        mov                 r17 = ar.lc
+
+        stf.spill.nta       [in0] = f19, 0x10
+        st8.nta             [r10] = r22, 8
+
+        stf.spill.nta       [in0] = f20, 0x10
+        st8.nta             [r10] = r23, 8
+
+        stf.spill.nta       [in0] = f21, 0x10
+        st8.nta             [r10] = r24, 8
+
+        stf.spill.nta       [in0] = f22, 0x10
+        st8.nta             [r10] = r25, 8
+
+        stf.spill.nta       [in0] = f23, 0x10
+        mov                 r18 = ar.unat
+
+        stf.spill.nta       [in0] = f24, 0x10
+        st8.nta             [r10] = r14, 8          // UNAT
+
+        stf.spill.nta       [in0] = f25, 0x10
+        st8.nta             [r10] = r18, 8          // UNAT after spill
+
+        stf.spill.nta       [in0] = f26, 0x10
+        st8.nta             [r10] = loc0, 8         // PFS
+
+        stf.spill.nta       [in0] = f27, 0x10
+        st8.nta             [r10] = r15, 8          // BSP
+        mov                 r8  = 0
+
+        stf.spill.nta       [in0] = f28, 0x10
+        mov                 r19 = ar.fpsr
+
+        stf.spill.nta       [in0] = f29, 0x10
+        st8.nta             [r10] = r16, 8          // PR
+        mov                 ar.pfs = loc0
+
+        stf.spill.nta       [in0] = f30, 0x10
+        st8.nta             [r10] = r17, 8          // LC
+        mov                 b0  = loc1
+
+        stf.spill.nta       [in0] = f31, 0x10
+        st8.nta             [r10] = r19             // FPSR
+
+        mov                 ar.unat = r14
+        br.ret.sptk         b0
+.endp   SetJump
diff --git a/MdePkg/Library/BaseLib/Ipf/SwitchStack.s b/MdePkg/Library/BaseLib/Ipf/SwitchStack.s
new file mode 100644
index 000000000000..04394e71b6e9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/SwitchStack.s
@@ -0,0 +1,52 @@
+/// @file
+///  IPF specific SwitchStack() function
+///
+/// Copyright (c) 2006 - 2012, 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.
+///
+/// Module Name: SwitchStack.s
+///
+///
+
+.auto
+.text
+
+.proc   AsmSwitchStackAndBackingStore
+.type   AsmSwitchStackAndBackingStore, @function
+.regstk 5, 0, 0, 0
+AsmSwitchStackAndBackingStore::
+        mov                 r14 = ar.rsc
+        movl                r2  = ~((((1 << 14) - 1) << 16) | 3)
+
+        mov                 r17 = in1
+        mov                 r18 = in2
+        and                 r2  = r14, r2
+        
+        flushrs
+        
+        mov                 ar.rsc = r2
+        mov                 sp  = in3
+        mov                 r19 = in4
+
+        ld8.nt1             r16 = [in0], 8
+        ld8.nta             gp  = [in0]
+        mov                 r3  = -1
+
+        loadrs
+        mov                 ar.bspstore = r19
+        mov                 b7  = r16
+
+        alloc               r2  = ar.pfs, 0, 0, 2, 0
+        mov                 out0 = r17
+        mov                 out1 = r18
+
+        mov                 ar.rnat = r3
+        mov                 ar.rsc = r14
+        br.call.sptk.many   b0  = b7
+.endp   AsmSwitchStackAndBackingStore
diff --git a/MdePkg/Library/BaseLib/Ipf/Unaligned.c b/MdePkg/Library/BaseLib/Ipf/Unaligned.c
new file mode 100644
index 000000000000..817d02c30747
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Ipf/Unaligned.c
@@ -0,0 +1,243 @@
+/** @file
+  Unaligned access functions of BaseLib for IPF.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Reads a 16-bit value from memory that may be unaligned.
+
+  This function returns the 16-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+
+  @return The 16-bit value read from Buffer.
+
+**/
+UINT16
+EFIAPI
+ReadUnaligned16 (
+  IN CONST UINT16              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return (UINT16)(((UINT8*)Buffer)[0] | (((UINT8*)Buffer)[1] << 8));
+}
+
+/**
+  Writes a 16-bit value to memory that may be unaligned.
+
+  This function writes the 16-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 16-bit value that may be unaligned.
+  @param  Value   The 16-bit value to write to Buffer.
+
+  @return The 16-bit value to write to Buffer.
+
+**/
+UINT16
+EFIAPI
+WriteUnaligned16 (
+  OUT UINT16                    *Buffer,
+  IN  UINT16                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  ((UINT8*)Buffer)[0] = (UINT8)Value;
+  ((UINT8*)Buffer)[1] = (UINT8)(Value >> 8);
+
+  return Value;
+}
+
+/**
+  Reads a 24-bit value from memory that may be unaligned.
+
+  This function returns the 24-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+
+  @return The 24-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned24 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return (UINT32)(
+            ReadUnaligned16 ((UINT16*)Buffer) |
+            (((UINT8*)Buffer)[2] << 16)
+            );
+}
+
+/**
+  Writes a 24-bit value to memory that may be unaligned.
+
+  This function writes the 24-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 24-bit value that may be unaligned.
+  @param  Value   The 24-bit value to write to Buffer.
+
+  @return The 24-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned24 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned16 ((UINT16*)Buffer, (UINT16)Value);
+  *(UINT8*)((UINT16*)Buffer + 1) = (UINT8)(Value >> 16);
+  return Value;
+}
+
+/**
+  Reads a 32-bit value from memory that may be unaligned.
+
+  This function returns the 32-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+
+  @return The 32-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned32 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  UINT16  LowerBytes;
+  UINT16  HigherBytes;
+
+  ASSERT (Buffer != NULL);
+
+  LowerBytes  = ReadUnaligned16 ((UINT16*) Buffer);
+  HigherBytes = ReadUnaligned16 ((UINT16*) Buffer + 1);
+
+  return (UINT32) (LowerBytes | (HigherBytes << 16));
+}
+
+/**
+  Writes a 32-bit value to memory that may be unaligned.
+
+  This function writes the 32-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 32-bit value that may be unaligned.
+  @param  Value   The 32-bit value to write to Buffer.
+
+  @return The 32-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned32 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned16 ((UINT16*)Buffer, (UINT16)Value);
+  WriteUnaligned16 ((UINT16*)Buffer + 1, (UINT16)(Value >> 16));
+  return Value;
+}
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  IN CONST UINT64              *Buffer
+  )
+{
+  UINT32  LowerBytes;
+  UINT32  HigherBytes;
+
+  ASSERT (Buffer != NULL);
+
+  LowerBytes  = ReadUnaligned32 ((UINT32*) Buffer);
+  HigherBytes = ReadUnaligned32 ((UINT32*) Buffer + 1);
+
+  return (UINT64) (LowerBytes | LShiftU64 (HigherBytes, 32));
+}
+
+/**
+  Writes a 64-bit value to memory that may be unaligned.
+
+  This function writes the 64-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  The pointer to a 64-bit value that may be unaligned.
+  @param  Value   The 64-bit value to write to Buffer.
+
+  @return The 64-bit value to write to Buffer.
+
+**/
+UINT64
+EFIAPI
+WriteUnaligned64 (
+  OUT UINT64                    *Buffer,
+  IN  UINT64                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  WriteUnaligned32 ((UINT32*)Buffer, (UINT32)Value);
+  WriteUnaligned32 ((UINT32*)Buffer + 1, (UINT32)RShiftU64 (Value, 32));
+  return Value;
+}
diff --git a/MdePkg/Library/BaseLib/LRotU32.c b/MdePkg/Library/BaseLib/LRotU32.c
new file mode 100644
index 000000000000..573c30c21dae
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LRotU32.c
@@ -0,0 +1,42 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Rotates a 32-bit integer left between 0 and 31 bits, filling the low bits
+  with the high bits that were rotated.
+
+  This function rotates the 32-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 31, then ASSERT().
+
+  @param  Operand The 32-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand << Count
+
+**/
+UINT32
+EFIAPI
+LRotU32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 32);
+  return (Operand << Count) | (Operand >> (32 - Count));
+}
diff --git a/MdePkg/Library/BaseLib/LRotU64.c b/MdePkg/Library/BaseLib/LRotU64.c
new file mode 100644
index 000000000000..c9384560e32e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LRotU64.c
@@ -0,0 +1,42 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Rotates a 64-bit integer left between 0 and 63 bits, filling the low bits
+  with the high bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand << Count
+
+**/
+UINT64
+EFIAPI
+LRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 64);
+  return InternalMathLRotU64 (Operand, Count);
+}
diff --git a/MdePkg/Library/BaseLib/LShiftU64.c b/MdePkg/Library/BaseLib/LShiftU64.c
new file mode 100644
index 000000000000..e3be23f4d92b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LShiftU64.c
@@ -0,0 +1,41 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Shifts a 64-bit integer left between 0 and 63 bits. The low bits are filled
+  with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the left by Count bits. The
+  low Count bits are set to zero. The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift left.
+  @param  Count   The number of bits to shift left.
+
+  @return Operand << Count.
+
+**/
+UINT64
+EFIAPI
+LShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 64);
+  return InternalMathLShiftU64 (Operand, Count);
+}
diff --git a/MdePkg/Library/BaseLib/LinkedList.c b/MdePkg/Library/BaseLib/LinkedList.c
new file mode 100644
index 000000000000..8b157da915ac
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LinkedList.c
@@ -0,0 +1,550 @@
+/** @file
+  Linked List Library Functions.
+
+  Copyright (c) 2006 - 2013, 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 "BaseLibInternals.h"
+
+/**
+  Worker function that locates the Node in the List.
+
+  By searching the List, finds the location of the Node in List. At the same time,
+  verifies the validity of this list.
+
+  If List is NULL, then ASSERT().
+  If List->ForwardLink is NULL, then ASSERT().
+  If List->backLink is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and DoMembershipCheck is TRUE and Node 
+  is in not a member of List, then return FALSE
+  If PcdMaximumLinkedListLength is not zero, and List contains more than
+  PcdMaximumLinkedListLength nodes, then ASSERT().
+
+  @param  List              A pointer to a node in a linked list.
+  @param  Node              A pointer to a node in a linked list.
+  @param  VerifyNodeInList  TRUE if a check should be made to see if Node is a 
+                            member of List.  FALSE if no membership test should 
+                            be performed.
+
+  @retval   TRUE if PcdVerifyNodeInList is FALSE
+  @retval   TRUE if DoMembershipCheck is FALSE
+  @retval   TRUE if PcdVerifyNodeInList is TRUE and DoMembershipCheck is TRUE 
+            and Node is a member of List.
+  @retval   FALSE if PcdVerifyNodeInList is TRUE and DoMembershipCheck is TRUE 
+            and Node is in not a member of List.
+
+**/
+BOOLEAN
+EFIAPI
+InternalBaseLibIsNodeInList (
+  IN CONST LIST_ENTRY  *List,
+  IN CONST LIST_ENTRY  *Node,
+  IN BOOLEAN           VerifyNodeInList
+  )
+{
+  UINTN             Count;
+  CONST LIST_ENTRY  *Ptr;
+
+  //
+  // Test the validity of List and Node
+  //
+  ASSERT (List != NULL);
+  ASSERT (List->ForwardLink != NULL);
+  ASSERT (List->BackLink != NULL);
+  ASSERT (Node != NULL);
+
+  Count = 0;
+  Ptr   = List;
+
+  if (FeaturePcdGet (PcdVerifyNodeInList) && VerifyNodeInList) {
+    //
+    // Check to see if Node is a member of List.  
+    // Exit early if the number of nodes in List >= PcdMaximumLinkedListLength
+    //
+    do {
+      Ptr = Ptr->ForwardLink;
+      if (PcdGet32 (PcdMaximumLinkedListLength) > 0) {
+        Count++;
+        //
+        // ASSERT() if the linked list is too long
+        //
+        ASSERT (Count < PcdGet32 (PcdMaximumLinkedListLength));
+
+        //
+        // Return if the linked list is too long
+        //
+        if (Count >= PcdGet32 (PcdMaximumLinkedListLength)) {
+          return (BOOLEAN)(Ptr == Node);
+        }
+      }
+    } while ((Ptr != List) && (Ptr != Node)); 
+
+    if (Ptr != Node) {
+      return FALSE;
+    }
+  }
+
+  if (PcdGet32 (PcdMaximumLinkedListLength) > 0) {
+    //
+    // Count the total number of nodes in List.
+    // Exit early if the number of nodes in List >= PcdMaximumLinkedListLength
+    //
+    do {
+      Ptr = Ptr->ForwardLink;
+      Count++;
+    } while ((Ptr != List) && (Count < PcdGet32 (PcdMaximumLinkedListLength)));
+
+    //
+    // ASSERT() if the linked list is too long
+    //
+    ASSERT (Count < PcdGet32 (PcdMaximumLinkedListLength));
+  }
+
+  return TRUE;
+}
+
+/**
+  Initializes the head node of a doubly-linked list, and returns the pointer to
+  the head node of the doubly-linked list.
+
+  Initializes the forward and backward links of a new linked list. After
+  initializing a linked list with this function, the other linked list
+  functions may be used to add and remove nodes from the linked list. It is up
+  to the caller of this function to allocate the memory for ListHead.
+
+  If ListHead is NULL, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a new doubly-linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InitializeListHead (
+  IN OUT  LIST_ENTRY                *ListHead
+  )
+
+{
+  ASSERT (ListHead != NULL);
+
+  ListHead->ForwardLink = ListHead;
+  ListHead->BackLink = ListHead;
+  return ListHead;
+}
+
+/**
+  Adds a node to the beginning of a doubly-linked list, and returns the pointer
+  to the head node of the doubly-linked list.
+
+  Adds the node Entry at the beginning of the doubly-linked list denoted by
+  ListHead, and returns ListHead.
+
+  If ListHead is NULL, then ASSERT().
+  If Entry is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number
+  of nodes in ListHead, including the ListHead node, is greater than or
+  equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly-linked list.
+  @param  Entry     A pointer to a node that is to be inserted at the beginning
+                    of a doubly-linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InsertHeadList (
+  IN OUT  LIST_ENTRY                *ListHead,
+  IN OUT  LIST_ENTRY                *Entry
+  )
+{
+  //
+  // ASSERT List not too long and Entry is not one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (ListHead, Entry, FALSE));
+  
+  Entry->ForwardLink = ListHead->ForwardLink;
+  Entry->BackLink = ListHead;
+  Entry->ForwardLink->BackLink = Entry;
+  ListHead->ForwardLink = Entry;
+  return ListHead;
+}
+
+/**
+  Adds a node to the end of a doubly-linked list, and returns the pointer to
+  the head node of the doubly-linked list.
+
+  Adds the node Entry to the end of the doubly-linked list denoted by ListHead,
+  and returns ListHead.
+
+  If ListHead is NULL, then ASSERT().
+  If Entry is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number
+  of nodes in ListHead, including the ListHead node, is greater than or
+  equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly-linked list.
+  @param  Entry     A pointer to a node that is to be added at the end of the
+                    doubly-linked list.
+
+  @return ListHead
+
+**/
+LIST_ENTRY *
+EFIAPI
+InsertTailList (
+  IN OUT  LIST_ENTRY                *ListHead,
+  IN OUT  LIST_ENTRY                *Entry
+  )
+{
+  //
+  // ASSERT List not too long and Entry is not one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (ListHead, Entry, FALSE));
+  
+  Entry->ForwardLink = ListHead;
+  Entry->BackLink = ListHead->BackLink;
+  Entry->BackLink->ForwardLink = Entry;
+  ListHead->BackLink = Entry;
+  return ListHead;
+}
+
+/**
+  Retrieves the first node of a doubly-linked list.
+
+  Returns the first node of a doubly-linked list.  List must have been 
+  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+  If List is empty, then List is returned.
+
+  If List is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly-linked list.
+
+  @return The first node of a doubly-linked list.
+  @retval List  The list is empty.
+
+**/
+LIST_ENTRY *
+EFIAPI
+GetFirstNode (
+  IN      CONST LIST_ENTRY          *List
+  )
+{
+  //
+  // ASSERT List not too long
+  //
+  ASSERT (InternalBaseLibIsNodeInList (List, List, FALSE));
+
+  return List->ForwardLink;
+}
+
+/**
+  Retrieves the next node of a doubly-linked list.
+
+  Returns the node of a doubly-linked list that follows Node.  
+  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()
+  or InitializeListHead().  If List is empty, then List is returned.
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and List contains more than
+  PcdMaximumLinkedListLength nodes, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly-linked list.
+  @param  Node  A pointer to a node in the doubly-linked list.
+
+  @return A pointer to the next node if one exists. Otherwise List is returned.
+
+**/
+LIST_ENTRY *
+EFIAPI
+GetNextNode (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  )
+{
+  //
+  // ASSERT List not too long and Node is one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (List, Node, TRUE));
+
+  return Node->ForwardLink;
+}
+
+/**
+  Retrieves the previous node of a doubly-linked list.
+ 
+  Returns the node of a doubly-linked list that precedes Node.  
+  List must have been initialized with INTIALIZE_LIST_HEAD_VARIABLE()
+  or InitializeListHead().  If List is empty, then List is returned.
+ 
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and List contains more than
+  PcdMaximumLinkedListLength nodes, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+ 
+  @param  List  A pointer to the head node of a doubly-linked list.
+  @param  Node  A pointer to a node in the doubly-linked list.
+ 
+  @return A pointer to the previous node if one exists. Otherwise List is returned.
+ 
+**/
+LIST_ENTRY *
+EFIAPI
+GetPreviousNode (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  )
+{
+  //
+  // ASSERT List not too long and Node is one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (List, Node, TRUE));
+ 
+  return Node->BackLink;
+}
+
+/**
+  Checks to see if a doubly-linked list is empty or not.
+
+  Checks to see if the doubly-linked list is empty. If the linked list contains
+  zero nodes, this function returns TRUE. Otherwise, it returns FALSE.
+
+  If ListHead is NULL, then ASSERT().
+  If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  ListHead  A pointer to the head node of a doubly-linked list.
+
+  @retval TRUE  The linked list is empty.
+  @retval FALSE The linked list is not empty.
+
+**/
+BOOLEAN
+EFIAPI
+IsListEmpty (
+  IN      CONST LIST_ENTRY          *ListHead
+  )
+{
+  //
+  // ASSERT List not too long
+  //
+  ASSERT (InternalBaseLibIsNodeInList (ListHead, ListHead, FALSE));
+  
+  return (BOOLEAN)(ListHead->ForwardLink == ListHead);
+}
+
+/**
+  Determines if a node in a doubly-linked list is the head node of a the same
+  doubly-linked list.  This function is typically used to terminate a loop that
+  traverses all the nodes in a doubly-linked list starting with the head node.
+
+  Returns TRUE if Node is equal to List.  Returns FALSE if Node is one of the
+  nodes in the doubly-linked list specified by List.  List must have been
+  initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(), 
+  then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List and Node is not 
+  equal to List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly-linked list.
+  @param  Node  A pointer to a node in the doubly-linked list.
+
+  @retval TRUE  Node is the head of the doubly-linked list pointed by List.
+  @retval FALSE Node is not the head of the doubly-linked list pointed by List.
+
+**/
+BOOLEAN
+EFIAPI
+IsNull (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  )
+{
+  //
+  // ASSERT List not too long and Node is one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (List, Node, TRUE));
+  
+  return (BOOLEAN)(Node == List);
+}
+
+/**
+  Determines if a node the last node in a doubly-linked list.
+
+  Returns TRUE if Node is the last node in the doubly-linked list specified by
+  List. Otherwise, FALSE is returned. List must have been initialized with
+  INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead().
+
+  If List is NULL, then ASSERT().
+  If Node is NULL, then ASSERT().
+  If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or
+  InitializeListHead(), then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes
+  in List, including the List node, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().
+
+  @param  List  A pointer to the head node of a doubly-linked list.
+  @param  Node  A pointer to a node in the doubly-linked list.
+
+  @retval TRUE  Node is the last node in the linked list.
+  @retval FALSE Node is not the last node in the linked list.
+
+**/
+BOOLEAN
+EFIAPI
+IsNodeAtEnd (
+  IN      CONST LIST_ENTRY          *List,
+  IN      CONST LIST_ENTRY          *Node
+  )
+{
+  //
+  // ASSERT List not too long and Node is one of the nodes of List
+  //
+  ASSERT (InternalBaseLibIsNodeInList (List, Node, TRUE));
+  
+  return (BOOLEAN)(!IsNull (List, Node) && List->BackLink == Node);
+}
+
+/**
+  Swaps the location of two nodes in a doubly-linked list, and returns the
+  first node after the swap.
+
+  If FirstEntry is identical to SecondEntry, then SecondEntry is returned.
+  Otherwise, the location of the FirstEntry node is swapped with the location
+  of the SecondEntry node in a doubly-linked list. SecondEntry must be in the
+  same double linked list as FirstEntry and that double linked list must have
+  been initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(). 
+  SecondEntry is returned after the nodes are swapped.
+
+  If FirstEntry is NULL, then ASSERT().
+  If SecondEntry is NULL, then ASSERT().
+  If PcdVerifyNodeInList is TRUE and SecondEntry and FirstEntry are not in the 
+  same linked list, then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes in the
+  linked list containing the FirstEntry and SecondEntry nodes, including
+  the FirstEntry and SecondEntry nodes, is greater than or equal to
+  PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  FirstEntry  A pointer to a node in a linked list.
+  @param  SecondEntry A pointer to another node in the same linked list.
+  
+  @return SecondEntry.
+
+**/
+LIST_ENTRY *
+EFIAPI
+SwapListEntries (
+  IN OUT  LIST_ENTRY                *FirstEntry,
+  IN OUT  LIST_ENTRY                *SecondEntry
+  )
+{
+  LIST_ENTRY                    *Ptr;
+
+  if (FirstEntry == SecondEntry) {
+    return SecondEntry;
+  }
+
+  //
+  // ASSERT Entry1 and Entry2 are in the same linked list
+  //
+  ASSERT (InternalBaseLibIsNodeInList (FirstEntry, SecondEntry, TRUE));
+  
+  //
+  // Ptr is the node pointed to by FirstEntry->ForwardLink
+  //
+  Ptr = RemoveEntryList (FirstEntry);
+
+  //
+  // If FirstEntry immediately follows SecondEntry, FirstEntry will be placed
+  // immediately in front of SecondEntry
+  //
+  if (Ptr->BackLink == SecondEntry) {
+    return InsertTailList (SecondEntry, FirstEntry);
+  }
+
+  //
+  // Ptr == SecondEntry means SecondEntry immediately follows FirstEntry,
+  // then there are no further steps necessary
+  //
+  if (Ptr == InsertHeadList (SecondEntry, FirstEntry)) {
+    return Ptr;
+  }
+
+  //
+  // Move SecondEntry to the front of Ptr
+  //
+  RemoveEntryList (SecondEntry);
+  InsertTailList (Ptr, SecondEntry);
+  return SecondEntry;
+}
+
+/**
+  Removes a node from a doubly-linked list, and returns the node that follows
+  the removed node.
+
+  Removes the node Entry from a doubly-linked list. It is up to the caller of
+  this function to release the memory used by this node if that is required. On
+  exit, the node following Entry in the doubly-linked list is returned. If
+  Entry is the only node in the linked list, then the head node of the linked
+  list is returned.
+
+  If Entry is NULL, then ASSERT().
+  If Entry is the head node of an empty list, then ASSERT().
+  If PcdMaximumLinkedListLength is not zero, and the number of nodes in the
+  linked list containing Entry, including the Entry node, is greater than
+  or equal to PcdMaximumLinkedListLength, then ASSERT().
+
+  @param  Entry A pointer to a node in a linked list.
+
+  @return Entry.
+
+**/
+LIST_ENTRY *
+EFIAPI
+RemoveEntryList (
+  IN      CONST LIST_ENTRY          *Entry
+  )
+{
+  ASSERT (!IsListEmpty (Entry));
+  
+  Entry->ForwardLink->BackLink = Entry->BackLink;
+  Entry->BackLink->ForwardLink = Entry->ForwardLink;
+  return Entry->ForwardLink;
+}
diff --git a/MdePkg/Library/BaseLib/LongJump.c b/MdePkg/Library/BaseLib/LongJump.c
new file mode 100644
index 000000000000..f432cfd45d58
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LongJump.c
@@ -0,0 +1,47 @@
+/** @file
+  Long Jump functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Restores the CPU context that was saved with SetJump().
+
+  Restores the CPU context from the buffer specified by JumpBuffer. This
+  function never returns to the caller. Instead is resumes execution based on
+  the state of JumpBuffer.
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+  If Value is 0, then ASSERT().
+
+  @param  JumpBuffer  A pointer to CPU context buffer.
+  @param  Value       The value to return when the SetJump() context is
+                      restored and must be non-zero.
+
+**/
+VOID
+EFIAPI
+LongJump (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+  IN      UINTN                     Value
+  )
+{
+  InternalAssertJumpBuffer (JumpBuffer);
+  ASSERT (Value != 0);
+
+  InternalLongJump (JumpBuffer, Value);
+}
diff --git a/MdePkg/Library/BaseLib/LowBitSet32.c b/MdePkg/Library/BaseLib/LowBitSet32.c
new file mode 100644
index 000000000000..b613cd2b833b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LowBitSet32.c
@@ -0,0 +1,47 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Returns the bit position of the lowest bit set in a 32-bit value.
+
+  This function computes the bit position of the lowest bit set in the 32-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 31 is returned.
+
+  @param  Operand The 32-bit operand to evaluate.
+
+  @retval 0..31  The lowest bit set in Operand was found.
+  @retval -1     Operand is zero.
+
+**/
+INTN
+EFIAPI
+LowBitSet32 (
+  IN      UINT32                    Operand
+  )
+{
+  INTN                              BitIndex;
+
+  if (Operand == 0) {
+    return -1;
+  }
+
+  for (BitIndex = 0; 0 == (Operand & 1); BitIndex++, Operand >>= 1);
+  return BitIndex;
+}
diff --git a/MdePkg/Library/BaseLib/LowBitSet64.c b/MdePkg/Library/BaseLib/LowBitSet64.c
new file mode 100644
index 000000000000..911fbda13d97
--- /dev/null
+++ b/MdePkg/Library/BaseLib/LowBitSet64.c
@@ -0,0 +1,50 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Returns the bit position of the lowest bit set in a 64-bit value.
+
+  This function computes the bit position of the lowest bit set in the 64-bit
+  value specified by Operand. If Operand is zero, then -1 is returned.
+  Otherwise, a value between 0 and 63 is returned.
+
+  @param  Operand The 64-bit operand to evaluate.
+
+  @retval 0..63  The lowest bit set in Operand was found.
+  @retval -1     Operand is zero.
+
+
+**/
+INTN
+EFIAPI
+LowBitSet64 (
+  IN      UINT64                    Operand
+  )
+{
+  INTN                              BitIndex;
+
+  if (Operand == 0) {
+    return -1;
+  }
+
+  for (BitIndex = 0;
+       (Operand & 1) == 0;
+       BitIndex++, Operand = RShiftU64 (Operand, 1));
+  return BitIndex;
+}
diff --git a/MdePkg/Library/BaseLib/Math64.c b/MdePkg/Library/BaseLib/Math64.c
new file mode 100644
index 000000000000..662d559e0c53
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Math64.c
@@ -0,0 +1,368 @@
+/** @file
+  Leaf math worker functions that require 64-bit arithmetic support from the
+  compiler.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Shifts a 64-bit integer left between 0 and 63 bits. The low bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the left by Count bits. The
+  low Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift left.
+  @param  Count   The number of bits to shift left.
+
+  @return Operand << Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathLShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  return Operand << Count;
+}
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. This high bits
+  are filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to zero. The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathRShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  return Operand >> Count;
+}
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. The high bits
+  are filled with original integer's bit 63. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to bit 63 of Operand.  The shifted value is returned.
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand arithmetically shifted right by Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathARShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  INTN  TestValue;
+
+  //
+  // Test if this compiler supports arithmetic shift
+  //
+  TestValue = (INTN)((INT64)(1ULL << 63) >> 63);
+  if (TestValue == -1) {
+    //
+    // Arithmetic shift is supported
+    //
+    return (UINT64)((INT64)Operand >> Count);
+  }
+
+  //
+  // Arithmetic is not supported
+  //
+  return (Operand >> Count) |
+         ((INTN)Operand < 0 ? ~((UINTN)-1 >> Count) : 0);
+}
+
+
+/**
+  Rotates a 64-bit integer left between 0 and 63 bits, filling
+  the low bits with the high bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the left by Count bits. The
+  low Count bits are fill with the high Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate left.
+  @param  Count   The number of bits to rotate left.
+
+  @return Operand <<< Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathLRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  return (Operand << Count) | (Operand >> (64 - Count));
+}
+
+/**
+  Rotates a 64-bit integer right between 0 and 63 bits, filling
+  the high bits with the high low bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  @param  Operand The 64-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >>> Count.
+
+**/
+UINT64
+EFIAPI
+InternalMathRRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  return (Operand >> Count) | (Operand << (64 - Count));
+}
+
+/**
+  Switches the endianess of a 64-bit integer.
+
+  This function swaps the bytes in a 64-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Operand A 64-bit unsigned value.
+
+  @return The byte swapped Operand.
+
+**/
+UINT64
+EFIAPI
+InternalMathSwapBytes64 (
+  IN      UINT64                    Operand
+  )
+{
+  UINT64  LowerBytes;
+  UINT64  HigherBytes;
+
+  LowerBytes  = (UINT64) SwapBytes32 ((UINT32) Operand);
+  HigherBytes = (UINT64) SwapBytes32 ((UINT32) (Operand >> 32));
+
+  return (LowerBytes << 32 | HigherBytes);
+}
+
+/**
+  Multiplies a 64-bit unsigned integer by a 32-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 32-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 32-bit unsigned value.
+
+  @return Multiplicand * Multiplier
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x32 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT32                    Multiplier
+  )
+{
+  return Multiplicand * Multiplier;
+}
+
+
+/**
+  Multiplies a 64-bit unsigned integer by a 64-bit unsigned integer
+  and generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 64-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 64-bit unsigned value.
+
+  @return Multiplicand * Multiplier.
+
+**/
+UINT64
+EFIAPI
+InternalMathMultU64x64 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT64                    Multiplier
+  )
+{
+  return Multiplicand * Multiplier;
+}
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. This
+  function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend / Divisor.
+
+**/
+UINT64
+EFIAPI
+InternalMathDivU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  return Dividend / Divisor;
+}
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 32-bit remainder. This function
+  returns the 32-bit unsigned remainder.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend % Divisor.
+
+**/
+UINT32
+EFIAPI
+InternalMathModU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  return (UINT32)(Dividend % Divisor);
+}
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result and an optional 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 32-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+  @param  Remainder A pointer to a 32-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor.
+
+**/
+UINT64
+EFIAPI
+InternalMathDivRemU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor,
+  OUT     UINT32                    *Remainder OPTIONAL
+  )
+{
+  if (Remainder != NULL) {
+    *Remainder = (UINT32)(Dividend % Divisor);
+  }
+  return Dividend / Divisor;
+}
+
+/**
+  Divides a 64-bit unsigned integer by a 64-bit unsigned integer and
+  generates a 64-bit unsigned result and an optional 64-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 64-bit
+  unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder
+  is not NULL, then the 64-bit unsigned remainder is returned in Remainder.
+  This function returns the 64-bit unsigned quotient.
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 64-bit unsigned value.
+  @param  Remainder A pointer to a 64-bit unsigned value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor
+
+**/
+UINT64
+EFIAPI
+InternalMathDivRemU64x64 (
+  IN      UINT64                    Dividend,
+  IN      UINT64                    Divisor,
+  OUT     UINT64                    *Remainder OPTIONAL
+  )
+{
+  if (Remainder != NULL) {
+    *Remainder = Dividend % Divisor;
+  }
+  return Dividend / Divisor;
+}
+
+/**
+  Divides a 64-bit signed integer by a 64-bit signed integer and
+  generates a 64-bit signed result and an optional 64-bit signed remainder.
+
+  This function divides the 64-bit signed value Dividend by the 64-bit
+  signed value Divisor and generates a 64-bit signed quotient. If Remainder
+  is not NULL, then the 64-bit signed remainder is returned in Remainder.
+  This function returns the 64-bit signed quotient.
+
+  @param  Dividend  A 64-bit signed value.
+  @param  Divisor   A 64-bit signed value.
+  @param  Remainder A pointer to a 64-bit signed value. This parameter is
+                    optional and may be NULL.
+
+  @return Dividend / Divisor.
+
+**/
+INT64
+EFIAPI
+InternalMathDivRemS64x64 (
+  IN      INT64                     Dividend,
+  IN      INT64                     Divisor,
+  OUT     INT64                     *Remainder  OPTIONAL
+  )
+{
+  if (Remainder != NULL) {
+    *Remainder = Dividend % Divisor;
+  }
+  return Dividend / Divisor;
+}
diff --git a/MdePkg/Library/BaseLib/ModU64x32.c b/MdePkg/Library/BaseLib/ModU64x32.c
new file mode 100644
index 000000000000..57c3e416a00e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/ModU64x32.c
@@ -0,0 +1,45 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Divides a 64-bit unsigned integer by a 32-bit unsigned integer and generates
+  a 32-bit unsigned remainder.
+
+  This function divides the 64-bit unsigned value Dividend by the 32-bit
+  unsigned value Divisor and generates a 32-bit remainder. This function
+  returns the 32-bit unsigned remainder.
+
+  If Divisor is 0, then ASSERT().
+
+  @param  Dividend  A 64-bit unsigned value.
+  @param  Divisor   A 32-bit unsigned value.
+
+  @return Dividend % Divisor.
+
+**/
+UINT32
+EFIAPI
+ModU64x32 (
+  IN      UINT64                    Dividend,
+  IN      UINT32                    Divisor
+  )
+{
+  ASSERT (Divisor != 0);
+  return InternalMathModU64x32 (Dividend, Divisor);
+}
diff --git a/MdePkg/Library/BaseLib/MultS64x64.c b/MdePkg/Library/BaseLib/MultS64x64.c
new file mode 100644
index 000000000000..c953b0d518d7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/MultS64x64.c
@@ -0,0 +1,42 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Multiplies a 64-bit signed integer by a 64-bit signed integer and generates a
+  64-bit signed result.
+
+  This function multiplies the 64-bit signed value Multiplicand by the 64-bit
+  signed value Multiplier and generates a 64-bit signed result. This 64-bit
+  signed result is returned.
+
+  @param  Multiplicand  A 64-bit signed value.
+  @param  Multiplier    A 64-bit signed value.
+
+  @return Multiplicand * Multiplier.
+
+**/
+INT64
+EFIAPI
+MultS64x64 (
+  IN      INT64                     Multiplicand,
+  IN      INT64                     Multiplier
+  )
+{
+  return (INT64)MultU64x64 ((UINT64) Multiplicand, (UINT64) Multiplier);
+}
diff --git a/MdePkg/Library/BaseLib/MultU64x32.c b/MdePkg/Library/BaseLib/MultU64x32.c
new file mode 100644
index 000000000000..1c49106bd8d5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/MultU64x32.c
@@ -0,0 +1,46 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Multiplies a 64-bit unsigned integer by a 32-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 32-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 32-bit unsigned value.
+
+  @return Multiplicand * Multiplier.
+
+**/
+UINT64
+EFIAPI
+MultU64x32 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT32                    Multiplier
+  )
+{
+  UINT64                            Result;
+
+  Result = InternalMathMultU64x32 (Multiplicand, Multiplier);
+
+  return Result;
+}
diff --git a/MdePkg/Library/BaseLib/MultU64x64.c b/MdePkg/Library/BaseLib/MultU64x64.c
new file mode 100644
index 000000000000..fee7f00b22b0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/MultU64x64.c
@@ -0,0 +1,46 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+/**
+  Multiplies a 64-bit unsigned integer by a 64-bit unsigned integer and
+  generates a 64-bit unsigned result.
+
+  This function multiplies the 64-bit unsigned value Multiplicand by the 64-bit
+  unsigned value Multiplier and generates a 64-bit unsigned result. This 64-
+  bit unsigned result is returned.
+
+  @param  Multiplicand  A 64-bit unsigned value.
+  @param  Multiplier    A 64-bit unsigned value.
+
+  @return Multiplicand * Multiplier.
+
+**/
+UINT64
+EFIAPI
+MultU64x64 (
+  IN      UINT64                    Multiplicand,
+  IN      UINT64                    Multiplier
+  )
+{
+  UINT64                            Result;
+
+  Result = InternalMathMultU64x64 (Multiplicand, Multiplier);
+
+  return Result;
+}
diff --git a/MdePkg/Library/BaseLib/RRotU32.c b/MdePkg/Library/BaseLib/RRotU32.c
new file mode 100644
index 000000000000..64fdd7643f3e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/RRotU32.c
@@ -0,0 +1,42 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Rotates a 32-bit integer right between 0 and 31 bits, filling the high bits
+  with the low bits that were rotated.
+
+  This function rotates the 32-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 31, then ASSERT().
+
+  @param  Operand The 32-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >> Count.
+
+**/
+UINT32
+EFIAPI
+RRotU32 (
+  IN      UINT32                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 32);
+  return (Operand >> Count) | (Operand << (32 - Count));
+}
diff --git a/MdePkg/Library/BaseLib/RRotU64.c b/MdePkg/Library/BaseLib/RRotU64.c
new file mode 100644
index 000000000000..28fdf411d54e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/RRotU64.c
@@ -0,0 +1,42 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Rotates a 64-bit integer right between 0 and 63 bits, filling the high bits
+  with the high low bits that were rotated.
+
+  This function rotates the 64-bit value Operand to the right by Count bits.
+  The high Count bits are fill with the low Count bits of Operand. The rotated
+  value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to rotate right.
+  @param  Count   The number of bits to rotate right.
+
+  @return Operand >> Count.
+
+**/
+UINT64
+EFIAPI
+RRotU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 64);
+  return InternalMathRRotU64 (Operand, Count);
+}
diff --git a/MdePkg/Library/BaseLib/RShiftU64.c b/MdePkg/Library/BaseLib/RShiftU64.c
new file mode 100644
index 000000000000..3494c32d9677
--- /dev/null
+++ b/MdePkg/Library/BaseLib/RShiftU64.c
@@ -0,0 +1,41 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Shifts a 64-bit integer right between 0 and 63 bits. This high bits are
+  filled with zeros. The shifted value is returned.
+
+  This function shifts the 64-bit value Operand to the right by Count bits. The
+  high Count bits are set to zero. The shifted value is returned.
+
+  If Count is greater than 63, then ASSERT().
+
+  @param  Operand The 64-bit operand to shift right.
+  @param  Count   The number of bits to shift right.
+
+  @return Operand >> Count.
+
+**/
+UINT64
+EFIAPI
+RShiftU64 (
+  IN      UINT64                    Operand,
+  IN      UINTN                     Count
+  )
+{
+  ASSERT (Count < 64);
+  return InternalMathRShiftU64 (Operand, Count);
+}
diff --git a/MdePkg/Library/BaseLib/SafeString.c b/MdePkg/Library/BaseLib/SafeString.c
new file mode 100644
index 000000000000..67b2cd6618f1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SafeString.c
@@ -0,0 +1,3649 @@
+/** @file
+  Safe String functions.
+
+  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.
+
+  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 "BaseLibInternals.h"
+
+#define RSIZE_MAX  (PcdGet32 (PcdMaximumUnicodeStringLength))
+
+#define ASCII_RSIZE_MAX  (PcdGet32 (PcdMaximumAsciiStringLength))
+
+#define SAFE_STRING_CONSTRAINT_CHECK(Expression, Status)  \
+  do { \
+    ASSERT (Expression); \
+    if (!(Expression)) { \
+      return Status; \
+    } \
+  } while (FALSE)
+
+/**
+  Returns if 2 memory blocks are overlapped.
+
+  @param  Base1  Base address of 1st memory block.
+  @param  Size1  Size of 1st memory block.
+  @param  Base2  Base address of 2nd memory block.
+  @param  Size2  Size of 2nd memory block.
+
+  @retval TRUE  2 memory blocks are overlapped.
+  @retval FALSE 2 memory blocks are not overlapped.
+**/
+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;
+}
+
+/**
+  Returns if 2 Unicode strings are not overlapped.
+
+  @param  Str1   Start address of 1st Unicode string.
+  @param  Size1  The number of char in 1st Unicode string,
+                 including terminating null char.
+  @param  Str2   Start address of 2nd Unicode string.
+  @param  Size2  The number of char in 2nd Unicode string,
+                 including terminating null char.
+
+  @retval TRUE  2 Unicode strings are NOT overlapped.
+  @retval FALSE 2 Unicode strings are overlapped.
+**/
+BOOLEAN
+InternalSafeStringNoStrOverlap (
+  IN CHAR16  *Str1,
+  IN UINTN   Size1,
+  IN CHAR16  *Str2,
+  IN UINTN   Size2
+  )
+{
+  return !InternalSafeStringIsOverlap (Str1, Size1 * sizeof(CHAR16), Str2, Size2 * sizeof(CHAR16));
+}
+
+/**
+  Returns if 2 Ascii strings are not overlapped.
+
+  @param  Str1   Start address of 1st Ascii string.
+  @param  Size1  The number of char in 1st Ascii string,
+                 including terminating null char.
+  @param  Str2   Start address of 2nd Ascii string.
+  @param  Size2  The number of char in 2nd Ascii string,
+                 including terminating null char.
+
+  @retval TRUE  2 Ascii strings are NOT overlapped.
+  @retval FALSE 2 Ascii strings are overlapped.
+**/
+BOOLEAN
+InternalSafeStringNoAsciiStrOverlap (
+  IN CHAR8   *Str1,
+  IN UINTN   Size1,
+  IN CHAR8   *Str2,
+  IN UINTN   Size2
+  )
+{
+  return !InternalSafeStringIsOverlap (Str1, Size1, Str2, Size2);
+}
+
+/**
+  Returns the length of a Null-terminated Unicode string.
+
+  This function is similar as strlen_s defined in C11.
+
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String   A pointer to a Null-terminated Unicode string.
+  @param  MaxSize  The maximum number of Destination Unicode
+                   char, including terminating null char.
+
+  @retval 0        If String is NULL.
+  @retval MaxSize  If there is no null character in the first MaxSize characters of String.
+  @return The number of characters that percede the terminating null character.
+
+**/
+UINTN
+EFIAPI
+StrnLenS (
+  IN CONST CHAR16              *String,
+  IN 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;
+  }
+
+  //
+  // Otherwise, the StrnLenS function returns the number of characters that precede the
+  // terminating null character. If there is no null character in the first MaxSize characters of
+  // String then StrnLenS returns MaxSize. At most the first MaxSize characters of String shall
+  // be accessed by StrnLenS.
+  //
+  Length = 0;
+  while (String[Length] != 0) {
+    if (Length >= MaxSize - 1) {
+      return MaxSize;
+    }
+    Length++;
+  }
+  return Length;
+}
+
+/**
+  Returns the size of a Null-terminated Unicode string in bytes, including the
+  Null terminator.
+
+  This function returns the size of the Null-terminated Unicode string
+  specified by String in bytes, including the Null terminator.
+
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String   A pointer to a Null-terminated Unicode string.
+  @param  MaxSize  The maximum number of Destination Unicode
+                   char, including the Null terminator.
+
+  @retval 0  If String is NULL.
+  @retval (sizeof (CHAR16) * (MaxSize + 1))
+             If there is no Null terminator in the first MaxSize characters of
+             String.
+  @return The size of the Null-terminated Unicode string in bytes, including
+          the Null terminator.
+
+**/
+UINTN
+EFIAPI
+StrnSizeS (
+  IN CONST CHAR16              *String,
+  IN UINTN                     MaxSize
+  )
+{
+  //
+  // If String is a null pointer, then the StrnSizeS function returns zero.
+  //
+  if (String == NULL) {
+    return 0;
+  }
+
+  //
+  // Otherwise, the StrnSizeS function returns the size of the Null-terminated
+  // Unicode string in bytes, including the Null terminator. If there is no
+  // Null terminator in the first MaxSize characters of String, then StrnSizeS
+  // returns (sizeof (CHAR16) * (MaxSize + 1)) to keep a consistent map with
+  // the StrnLenS function.
+  //
+  return (StrnLenS (String, MaxSize) + 1) * sizeof (*String);
+}
+
+/**
+  Copies the string pointed to by Source (including the terminating null char)
+  to the array pointed to by Destination.
+
+  This function is similar as strcpy_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrCpyS (
+  OUT CHAR16       *Destination,
+  IN  UINTN        DestMax,
+  IN  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;
+}
+
+/**
+  Copies not more than Length successive char from the string pointed to by
+  Source to the array pointed to by Destination. If no null char is copied from
+  Source, then Destination[Length] is always set to null.
+
+  This function is similar as strncpy_s defined in C11.
+
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+  @param  Length                   The maximum number of Unicode characters to copy.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than 
+                                   MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrnCpyS (
+  OUT CHAR16       *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR16 *Source,
+  IN  UINTN        Length
+  )
+{
+  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. Neither DestMax nor Length shall be greater than RSIZE_MAX
+  //
+  if (RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. If Length is not less than DestMax, then DestMax shall be greater than StrnLenS(Source, DestMax).
+  //
+  SourceLen = StrnLenS (Source, DestMax);
+  if (Length >= DestMax) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 5. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The StrnCpyS function copies not more than Length successive characters (characters that
+  // follow a null character are not copied) from the array pointed to by Source to the array
+  // pointed to by Destination. If no null character was copied from Source, then Destination[Length] is set to a null
+  // character.
+  //
+  while ((*Source != 0) && (SourceLen > 0)) {
+    *(Destination++) = *(Source++);
+    SourceLen--;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Appends a copy of the string pointed to by Source (including the terminating
+  null char) to the end of the string pointed to by Destination.
+
+  This function is similar as strcat_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than 
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrCatS (
+  IN OUT CHAR16       *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR16 *Source
+  )
+{
+  UINTN               DestLen;
+  UINTN               CopyLen;
+  UINTN               SourceLen;
+  
+  ASSERT (((UINTN) Destination & BIT0) == 0);
+  ASSERT (((UINTN) Source & BIT0) == 0);
+
+  //
+  // Let CopyLen denote the value DestMax - StrnLenS(Destination, DestMax) upon entry to StrCatS.
+  //
+  DestLen = StrnLenS (Destination, DestMax);
+  CopyLen = DestMax - DestLen;
+
+  //
+  // 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. CopyLen shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);
+
+  //
+  // 5. CopyLen shall be greater than StrnLenS(Source, CopyLen).
+  //
+  SourceLen = StrnLenS (Source, CopyLen);
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);
+
+  //
+  // 6. Copying shall not take place between objects that overlap.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The StrCatS function appends a copy of the string pointed to by Source (including the
+  // terminating null character) to the end of the string pointed to by Destination. The initial character
+  // from Source overwrites the null character at the end of Destination.
+  //
+  Destination = Destination + DestLen;
+  while (*Source != 0) {
+    *(Destination++) = *(Source++);
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Appends not more than Length successive char from the string pointed to by
+  Source to the end of the string pointed to by Destination. If no null char is
+  copied from Source, then Destination[StrLen(Destination) + Length] is always
+  set to null.
+
+  This function is similar as strncat_s defined in C11.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Unicode string.
+  @param  DestMax                  The maximum number of Destination Unicode
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Unicode string.
+  @param  Length                   The maximum number of Unicode characters to copy.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+StrnCatS (
+  IN OUT CHAR16       *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR16 *Source,
+  IN     UINTN        Length
+  )
+{
+  UINTN               DestLen;
+  UINTN               CopyLen;
+  UINTN               SourceLen;
+  
+  ASSERT (((UINTN) Destination & BIT0) == 0);
+  ASSERT (((UINTN) Source & BIT0) == 0);
+
+  //
+  // Let CopyLen denote the value DestMax - StrnLenS(Destination, DestMax) upon entry to StrnCatS.
+  //
+  DestLen = StrnLenS (Destination, DestMax);
+  CopyLen = DestMax - DestLen;
+
+  //
+  // 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. Neither DestMax nor Length shall be greater than RSIZE_MAX.
+  //
+  if (RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. CopyLen shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);
+
+  //
+  // 5. If Length is not less than CopyLen, then CopyLen shall be greater than StrnLenS(Source, CopyLen).
+  //
+  SourceLen = StrnLenS (Source, CopyLen);
+  if (Length >= CopyLen) {
+    SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 6. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The StrnCatS function appends not more than Length successive characters (characters
+  // that follow a null character are not copied) from the array pointed to by Source to the end of
+  // the string pointed to by Destination. The initial character from Source overwrites the null character at
+  // the end of Destination. If no null character was copied from Source, then Destination[DestMax-CopyLen+Length] is set to
+  // a null character.
+  //
+  Destination = Destination + DestLen;
+  while ((*Source != 0) && (SourceLen > 0)) {
+    *(Destination++) = *(Source++);
+    SourceLen--;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Unicode decimal 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 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 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
+  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 UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrDecimalToUintnS (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       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
+EFIAPI
+StrDecimalToUint64S (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       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 > DivU64x32 (MAX_UINT64 - (*String - L'0'), 10)) {
+      *Data = MAX_UINT64;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR16 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = MultU64x32 (*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
+EFIAPI
+StrHexToUintnS (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       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;
+}
+
+/**
+  Convert a Null-terminated Unicode hexadecimal 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 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 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
+  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 UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrHexToUint64S (
+  IN  CONST CHAR16             *String,
+  OUT       CHAR16             **EndPointer,  OPTIONAL
+  OUT       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 > RShiftU64 (MAX_UINT64 - InternalHexCharToUintn (*String), 4)) {
+      *Data = MAX_UINT64;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR16 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = LShiftU64 (*Data, 4) + InternalHexCharToUintn (*String);
+    String++;
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR16 *) String;
+  }
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Unicode string to IPv6 address and prefix length.
+
+  This function outputs a value of type IPv6_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the Unicode string specified
+  by String. The format of the input Unicode string String is as follows:
+
+                  X:X:X:X:X:X:X:X[/P]
+
+  X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and
+  [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low
+  memory address and high byte is stored in high memory address. P contains decimal
+  digit characters in the range [0-9]. The running zero in the beginning of P will
+  be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid hexadecimal digit character after eight X's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  "::" can be used to compress one or more groups of X when X contains only 0.
+  The "::" can only appear once in the String.
+
+  If String is NULL, then ASSERT().
+
+  If Address 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 EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan 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  Address                  Pointer to the converted IPv6 address.
+  @param  PrefixLength             Pointer to the converted IPv6 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If X contains more than four hexadecimal
+                                    digit characters.
+                                   If String contains "::" and number of X
+                                    is not less than 8.
+                                   If P starts with character that is not a
+                                    valid decimal digit character.
+                                   If the decimal number converted from P
+                                    exceeds 128.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrToIpv6Address (
+  IN  CONST CHAR16       *String,
+  OUT CHAR16             **EndPointer, OPTIONAL
+  OUT IPv6_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  )
+{
+  RETURN_STATUS          Status;
+  UINTN                  AddressIndex;
+  UINTN                  Uintn;
+  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;
+  }
+  CopyMem (&Address->Addr[0], &LocalAddress.Addr[0], CompressStart);
+  ZeroMem (&Address->Addr[CompressStart], ARRAY_SIZE (Address->Addr) - AddressIndex);
+  if (AddressIndex > CompressStart) {
+    CopyMem (
+      &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;
+}
+
+/**
+  Convert a Null-terminated Unicode string to IPv4 address and prefix length.
+
+  This function outputs a value of type IPv4_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the Unicode string specified
+  by String. The format of the input Unicode string String is as follows:
+
+                  D.D.D.D[/P]
+
+  D and P are decimal digit characters in the range [0-9]. The running zero in
+  the beginning of D and P will be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid decimal digit character after four D's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  If String is NULL, then ASSERT().
+
+  If Address 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 EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan 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  Address                  Pointer to the converted IPv4 address.
+  @param  PrefixLength             Pointer to the converted IPv4 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If String is not in the correct format.
+                                   If any decimal number converted from D
+                                    exceeds 255.
+                                   If the decimal number converted from P
+                                    exceeds 32.
+
+**/
+RETURN_STATUS
+EFIAPI
+StrToIpv4Address (
+  IN  CONST CHAR16       *String,
+  OUT CHAR16             **EndPointer, OPTIONAL
+  OUT IPv4_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  )
+{
+  RETURN_STATUS          Status;
+  UINTN                  AddressIndex;
+  UINTN                  Uintn;
+  IPv4_ADDRESS           LocalAddress;
+  UINT8                  LocalPrefixLength;
+  CHAR16                 *Pointer;
+
+  LocalPrefixLength = MAX_UINT8;
+
+  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;
+  }
+
+  CopyMem (Address, &LocalAddress, sizeof (*Address));
+  if (PrefixLength != NULL) {
+    *PrefixLength = LocalPrefixLength;
+  }
+  if (EndPointer != NULL) {
+    *EndPointer = Pointer;
+  }
+
+  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
+EFIAPI
+StrToGuid (
+  IN  CONST CHAR16       *String,
+  OUT GUID               *Guid
+  )
+{
+  RETURN_STATUS          Status;
+  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;
+}
+
+/**
+  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
+EFIAPI
+StrHexToBytes (
+  IN  CONST CHAR16       *String,
+  IN  UINTN              Length,
+  OUT UINT8              *Buffer,
+  IN  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;
+}
+
+/**
+  Returns the length of a Null-terminated Ascii string.
+
+  This function is similar as strlen_s defined in C11.
+
+  @param  String   A pointer to a Null-terminated Ascii string.
+  @param  MaxSize  The maximum number of Destination Ascii
+                   char, including terminating null char.
+
+  @retval 0        If String is NULL.
+  @retval MaxSize  If there is no null character in the first MaxSize characters of String.
+  @return The number of characters that percede the terminating null character.
+
+**/
+UINTN
+EFIAPI
+AsciiStrnLenS (
+  IN CONST CHAR8               *String,
+  IN UINTN                     MaxSize
+  )
+{
+  UINTN                             Length;
+
+  //
+  // If String is a null pointer or MaxSize is 0, then the AsciiStrnLenS function returns zero.
+  //
+  if ((String == NULL) || (MaxSize == 0)) {
+    return 0;
+  }
+
+  //
+  // Otherwise, the AsciiStrnLenS function returns the number of characters that precede the
+  // terminating null character. If there is no null character in the first MaxSize characters of
+  // String then AsciiStrnLenS returns MaxSize. At most the first MaxSize characters of String shall
+  // be accessed by AsciiStrnLenS.
+  //
+  Length = 0;
+  while (String[Length] != 0) {
+    if (Length >= MaxSize - 1) {
+      return MaxSize;
+    }
+    Length++;
+  }
+  return Length;
+}
+
+/**
+  Returns the size of a Null-terminated Ascii string in bytes, including the
+  Null terminator.
+
+  This function returns the size of the Null-terminated Ascii string specified
+  by String in bytes, including the Null terminator.
+
+  @param  String   A pointer to a Null-terminated Ascii string.
+  @param  MaxSize  The maximum number of Destination Ascii
+                   char, including the Null terminator.
+
+  @retval 0  If String is NULL.
+  @retval (sizeof (CHAR8) * (MaxSize + 1))
+             If there is no Null terminator in the first MaxSize characters of
+             String.
+  @return The size of the Null-terminated Ascii string in bytes, including the
+          Null terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiStrnSizeS (
+  IN CONST CHAR8               *String,
+  IN UINTN                     MaxSize
+  )
+{
+  //
+  // If String is a null pointer, then the AsciiStrnSizeS function returns
+  // zero.
+  //
+  if (String == NULL) {
+    return 0;
+  }
+
+  //
+  // Otherwise, the AsciiStrnSizeS function returns the size of the
+  // Null-terminated Ascii string in bytes, including the Null terminator. If
+  // there is no Null terminator in the first MaxSize characters of String,
+  // then AsciiStrnSizeS returns (sizeof (CHAR8) * (MaxSize + 1)) to keep a
+  // consistent map with the AsciiStrnLenS function.
+  //
+  return (AsciiStrnLenS (String, MaxSize) + 1) * sizeof (*String);
+}
+
+/**
+  Copies the string pointed to by Source (including the terminating null char)
+  to the array pointed to by Destination.
+
+  This function is similar as strcpy_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrCpyS (
+  OUT CHAR8        *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR8  *Source
+  )
+{
+  UINTN            SourceLen;
+  
+  //
+  // 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.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_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 AsciiStrnLenS(Source, DestMax).
+  //
+  SourceLen = AsciiStrnLenS (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 (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The AsciiStrCpyS 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;
+}
+
+/**
+  Copies not more than Length successive char from the string pointed to by
+  Source to the array pointed to by Destination. If no null char is copied from
+  Source, then Destination[Length] is always set to null.
+
+  This function is similar as strncpy_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+  @param  Length                   The maximum number of Ascii characters to copy.
+
+  @retval RETURN_SUCCESS           String is copied.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than 
+                                   MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnCpyS (
+  OUT CHAR8        *Destination,
+  IN  UINTN        DestMax,
+  IN  CONST CHAR8  *Source,
+  IN  UINTN        Length
+  )
+{
+  UINTN            SourceLen;
+
+  //
+  // 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. Neither DestMax nor Length shall be greater than ASCII_RSIZE_MAX
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. If Length is not less than DestMax, then DestMax shall be greater than AsciiStrnLenS(Source, DestMax).
+  //
+  SourceLen = AsciiStrnLenS (Source, DestMax);
+  if (Length >= DestMax) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 5. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The AsciiStrnCpyS function copies not more than Length successive characters (characters that
+  // follow a null character are not copied) from the array pointed to by Source to the array
+  // pointed to by Destination. If no null character was copied from Source, then Destination[Length] is set to a null
+  // character.
+  //
+  while ((*Source != 0) && (SourceLen > 0)) {
+    *(Destination++) = *(Source++);
+    SourceLen--;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Appends a copy of the string pointed to by Source (including the terminating
+  null char) to the end of the string pointed to by Destination.
+
+  This function is similar as strcat_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than 
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrCatS (
+  IN OUT CHAR8        *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR8  *Source
+  )
+{
+  UINTN               DestLen;
+  UINTN               CopyLen;
+  UINTN               SourceLen;
+  
+  //
+  // Let CopyLen denote the value DestMax - AsciiStrnLenS(Destination, DestMax) upon entry to AsciiStrCatS.
+  //
+  DestLen = AsciiStrnLenS (Destination, DestMax);
+  CopyLen = DestMax - DestLen;
+
+  //
+  // 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.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. CopyLen shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);
+
+  //
+  // 5. CopyLen shall be greater than AsciiStrnLenS(Source, CopyLen).
+  //
+  SourceLen = AsciiStrnLenS (Source, CopyLen);
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);
+
+  //
+  // 6. Copying shall not take place between objects that overlap.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The AsciiStrCatS function appends a copy of the string pointed to by Source (including the
+  // terminating null character) to the end of the string pointed to by Destination. The initial character
+  // from Source overwrites the null character at the end of Destination.
+  //
+  Destination = Destination + DestLen;
+  while (*Source != 0) {
+    *(Destination++) = *(Source++);
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Appends not more than Length successive char from the string pointed to by
+  Source to the end of the string pointed to by Destination. If no null char is
+  copied from Source, then Destination[StrLen(Destination) + Length] is always
+  set to null.
+
+  This function is similar as strncat_s defined in C11.
+
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Destination              A pointer to a Null-terminated Ascii string.
+  @param  DestMax                  The maximum number of Destination Ascii
+                                   char, including terminating null char.
+  @param  Source                   A pointer to a Null-terminated Ascii string.
+  @param  Length                   The maximum number of Ascii characters to copy.
+
+  @retval RETURN_SUCCESS           String is appended.
+  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than
+                                   StrLen(Destination).
+  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT
+                                   greater than MIN(StrLen(Source), Length).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than 
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnCatS (
+  IN OUT CHAR8        *Destination,
+  IN     UINTN        DestMax,
+  IN     CONST CHAR8  *Source,
+  IN     UINTN        Length
+  )
+{
+  UINTN               DestLen;
+  UINTN               CopyLen;
+  UINTN               SourceLen;
+  
+  //
+  // Let CopyLen denote the value DestMax - AsciiStrnLenS(Destination, DestMax) upon entry to AsciiStrnCatS.
+  //
+  DestLen = AsciiStrnLenS (Destination, DestMax);
+  CopyLen = DestMax - DestLen;
+
+  //
+  // 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. Neither DestMax nor Length shall be greater than ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. CopyLen shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);
+
+  //
+  // 5. If Length is not less than CopyLen, then CopyLen shall be greater than AsciiStrnLenS(Source, CopyLen).
+  //
+  SourceLen = AsciiStrnLenS (Source, CopyLen);
+  if (Length >= CopyLen) {
+    SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 6. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // The AsciiStrnCatS function appends not more than Length successive characters (characters
+  // that follow a null character are not copied) from the array pointed to by Source to the end of
+  // the string pointed to by Destination. The initial character from Source overwrites the null character at
+  // the end of Destination. If no null character was copied from Source, then Destination[DestMax-CopyLen+Length] is set to
+  // a null character.
+  //
+  Destination = Destination + DestLen;
+  while ((*Source != 0) && (SourceLen > 0)) {
+    *(Destination++) = *(Source++);
+    SourceLen--;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Ascii decimal string to a value of type UINTN.
+
+  This function outputs a value of type UINTN by interpreting the contents of
+  the Ascii string specified by String as a decimal number. The format of the
+  input Ascii 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 PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 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
+  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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrDecimalToUintnS (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  )
+{
+  //
+  // 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 ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+
+  //
+  // Ignore the pad spaces (space or tab)
+  //
+  while ((*String == ' ') || (*String == '\t')) {
+    String++;
+  }
+
+  //
+  // Ignore leading Zeros after the spaces
+  //
+  while (*String == '0') {
+    String++;
+  }
+
+  *Data = 0;
+
+  while (InternalAsciiIsDecimalDigitCharacter (*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 - '0')) / 10)) {
+      *Data = MAX_UINTN;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR8 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = *Data * 10 + (*String - '0');
+    String++;
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Ascii decimal string to a value of type UINT64.
+
+  This function outputs a value of type UINT64 by interpreting the contents of
+  the Ascii string specified by String as a decimal number. The format of the
+  input Ascii 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 PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrDecimalToUint64S (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  )
+{
+  //
+  // 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 ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+
+  //
+  // Ignore the pad spaces (space or tab)
+  //
+  while ((*String == ' ') || (*String == '\t')) {
+    String++;
+  }
+
+  //
+  // Ignore leading Zeros after the spaces
+  //
+  while (*String == '0') {
+    String++;
+  }
+
+  *Data = 0;
+
+  while (InternalAsciiIsDecimalDigitCharacter (*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 > DivU64x32 (MAX_UINT64 - (*String - '0'), 10)) {
+      *Data = MAX_UINT64;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR8 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = MultU64x32 (*Data, 10) + (*String - '0');
+    String++;
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Ascii hexadecimal string to a value of type UINTN.
+
+  This function outputs a value of type UINTN by interpreting the contents of
+  the Ascii string specified by String as a hexadecimal number. The format of
+  the input Ascii 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 digits]. The running zero before [x] or
+  [hexadecimal digits] 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-terminator,
+  whichever on comes first.
+
+  If String is NULL, then ASSERT().
+  If Data is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINTN.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrHexToUintnS (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINTN              *Data
+  )
+{
+  //
+  // 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 ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+
+  //
+  // Ignore the pad spaces (space or tab)
+  //
+  while ((*String == ' ') || (*String == '\t')) {
+    String++;
+  }
+
+  //
+  // Ignore leading Zeros after the spaces
+  //
+  while (*String == '0') {
+    String++;
+  }
+
+  if (InternalBaseLibAsciiToUpper (*String) == 'X') {
+    if (*(String - 1) != '0') {
+      *Data = 0;
+      return RETURN_SUCCESS;
+    }
+    //
+    // Skip the 'X'
+    //
+    String++;
+  }
+
+  *Data = 0;
+
+  while (InternalAsciiIsHexaDecimalDigitCharacter (*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 - InternalAsciiHexCharToUintn (*String)) >> 4)) {
+      *Data = MAX_UINTN;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR8 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = (*Data << 4) + InternalAsciiHexCharToUintn (*String);
+    String++;
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Ascii hexadecimal string to a value of type UINT64.
+
+  This function outputs a value of type UINT64 by interpreting the contents of
+  the Ascii string specified by String as a hexadecimal number. The format of
+  the input Ascii 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 digits]. The running zero before [x] or
+  [hexadecimal digits] 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-terminator,
+  whichever on comes first.
+
+  If String is NULL, then ASSERT().
+  If Data is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength Ascii 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 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
+  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 Ascii 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 PcdMaximumAsciiStringLength is not zero,
+                                   and String contains more than
+                                   PcdMaximumAsciiStringLength Ascii
+                                   characters, not including the
+                                   Null-terminator.
+  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds
+                                   the range defined by UINT64.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrHexToUint64S (
+  IN  CONST CHAR8              *String,
+  OUT       CHAR8              **EndPointer,  OPTIONAL
+  OUT       UINT64             *Data
+  )
+{
+  //
+  // 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 ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+
+  //
+  // Ignore the pad spaces (space or tab)
+  //
+  while ((*String == ' ') || (*String == '\t')) {
+    String++;
+  }
+
+  //
+  // Ignore leading Zeros after the spaces
+  //
+  while (*String == '0') {
+    String++;
+  }
+
+  if (InternalBaseLibAsciiToUpper (*String) == 'X') {
+    if (*(String - 1) != '0') {
+      *Data = 0;
+      return RETURN_SUCCESS;
+    }
+    //
+    // Skip the 'X'
+    //
+    String++;
+  }
+
+  *Data = 0;
+
+  while (InternalAsciiIsHexaDecimalDigitCharacter (*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 > RShiftU64 (MAX_UINT64 - InternalAsciiHexCharToUintn (*String), 4)) {
+      *Data = MAX_UINT64;
+      if (EndPointer != NULL) {
+        *EndPointer = (CHAR8 *) String;
+      }
+      return RETURN_UNSUPPORTED;
+    }
+
+    *Data = LShiftU64 (*Data, 4) + InternalAsciiHexCharToUintn (*String);
+    String++;
+  }
+
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) String;
+  }
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated Unicode string to a Null-terminated
+  ASCII string.
+
+  This function is similar to AsciiStrCpyS.
+
+  This function converts the content of the Unicode string Source
+  to the ASCII string Destination by copying the lower 8 bits of
+  each Unicode character. The function terminates the ASCII string
+  Destination by appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.
+
+  If any Unicode characters in Source contain non-zero value in
+  the upper 8 bits, then ASSERT().
+
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Source        The pointer to a Null-terminated Unicode string.
+  @param  Destination   The pointer to a Null-terminated ASCII string.
+  @param  DestMax       The maximum number of Destination Ascii
+                        char, including terminating null char.
+
+  @retval RETURN_SUCCESS           String is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeStrToAsciiStrS (
+  IN      CONST CHAR16              *Source,
+  OUT     CHAR8                     *Destination,
+  IN      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;
+}
+
+/**
+  Convert not more than Length successive characters from a Null-terminated
+  Unicode string to a Null-terminated Ascii string. If no null char is copied
+  from Source, then Destination[Length] is always set to null.
+
+  This function converts not more than Length successive characters from the
+  Unicode string Source to the Ascii string Destination by copying the lower 8
+  bits of each Unicode character. The function terminates the Ascii string
+  Destination by appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with
+  size not smaller than ((MIN(StrLen(Source), Length) + 1) * sizeof (CHAR8))
+  in bytes.
+
+  If any Unicode characters in Source contain non-zero value in the upper 8
+  bits, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then Destination and DestinationLength are
+  unmodified.
+
+  @param  Source             The pointer to a Null-terminated Unicode string.
+  @param  Length             The maximum number of Unicode characters to
+                             convert.
+  @param  Destination        The pointer to a Null-terminated Ascii string.
+  @param  DestMax            The maximum number of Destination Ascii char,
+                             including terminating null char.
+  @param  DestinationLength  The number of Unicode characters converted.
+
+  @retval RETURN_SUCCESS            String is converted.
+  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.
+                                    If Source is NULL.
+                                    If DestinationLength is NULL.
+                                    If PcdMaximumAsciiStringLength is not zero,
+                                    and Length or DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                    If PcdMaximumUnicodeStringLength is not
+                                    zero, and Length or DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                    If DestMax is 0.
+  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than
+                                    MIN(StrLen(Source), Length).
+  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeStrnToAsciiStrS (
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length,
+  OUT     CHAR8                     *Destination,
+  IN      UINTN                     DestMax,
+  OUT     UINTN                     *DestinationLength
+  )
+{
+  UINTN            SourceLen;
+
+  ASSERT (((UINTN) Source & BIT0) == 0);
+
+  //
+  // 1. None of Destination, Source or DestinationLength shall be a null
+  // pointer.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);
+  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);
+  SAFE_STRING_CONSTRAINT_CHECK ((DestinationLength != NULL), RETURN_INVALID_PARAMETER);
+
+  //
+  // 2. Neither Length nor DestMax shall be greater than ASCII_RSIZE_MAX or
+  // RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+  if (RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    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. If Length is not less than DestMax, then DestMax shall be greater than
+  // StrnLenS(Source, DestMax).
+  //
+  SourceLen = StrnLenS (Source, DestMax);
+  if (Length >= DestMax) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 5. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof(CHAR16)), RETURN_ACCESS_DENIED);
+
+  *DestinationLength = 0;
+
+  //
+  // Convert string
+  //
+  while ((*Source != 0) && (SourceLen > 0)) {
+    //
+    // If any Unicode characters in Source contain non-zero value in the upper
+    // 8 bits, then ASSERT().
+    //
+    ASSERT (*Source < 0x100);
+    *(Destination++) = (CHAR8) *(Source++);
+    SourceLen--;
+    (*DestinationLength)++;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert one Null-terminated ASCII string to a Null-terminated
+  Unicode string.
+
+  This function is similar to StrCpyS.
+
+  This function converts the contents of the ASCII string Source to the Unicode
+  string Destination. The function terminates the Unicode string Destination by
+  appending a Null-terminator character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then the Destination is unmodified.
+
+  @param  Source        The pointer to a Null-terminated ASCII string.
+  @param  Destination   The pointer to a Null-terminated Unicode string.
+  @param  DestMax       The maximum number of Destination Unicode
+                        char, including terminating null char.
+
+  @retval RETURN_SUCCESS           String is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).
+  @retval RETURN_INVALID_PARAMETER If Destination is NULL.
+                                   If Source is NULL.
+                                   If PcdMaximumUnicodeStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                   If PcdMaximumAsciiStringLength is not zero,
+                                    and DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                   If DestMax is 0.
+  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToUnicodeStrS (
+  IN      CONST CHAR8               *Source,
+  OUT     CHAR16                    *Destination,
+  IN      UINTN                     DestMax
+  )
+{
+  UINTN            SourceLen;
+
+  ASSERT (((UINTN) Destination & 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 or ASCII_RSIZE_MAX.
+  //
+  if (RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_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 AsciiStrnLenS(Source, DestMax).
+  //
+  SourceLen = AsciiStrnLenS (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 * sizeof(CHAR16), (VOID *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  //
+  // Convert string
+  //
+  while (*Source != '\0') {
+    *(Destination++) = (CHAR16)*(Source++);
+  }
+  *Destination = '\0';
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert not more than Length successive characters from a Null-terminated
+  Ascii string to a Null-terminated Unicode string. If no null char is copied
+  from Source, then Destination[Length] is always set to null.
+
+  This function converts not more than Length successive characters from the
+  Ascii string Source to the Unicode string Destination. The function
+  terminates the Unicode string Destination by appending a Null-terminator
+  character at the end.
+
+  The caller is responsible to make sure Destination points to a buffer with
+  size not smaller than
+  ((MIN(AsciiStrLen(Source), Length) + 1) * sizeof (CHAR8)) in bytes.
+
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  If an error is returned, then Destination and DestinationLength are
+  unmodified.
+
+  @param  Source             The pointer to a Null-terminated Ascii string.
+  @param  Length             The maximum number of Ascii characters to convert.
+  @param  Destination        The pointer to a Null-terminated Unicode string.
+  @param  DestMax            The maximum number of Destination Unicode char,
+                             including terminating null char.
+  @param  DestinationLength  The number of Ascii characters converted.
+
+  @retval RETURN_SUCCESS            String is converted.
+  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.
+                                    If Source is NULL.
+                                    If DestinationLength is NULL.
+                                    If PcdMaximumUnicodeStringLength is not
+                                    zero, and Length or DestMax is greater than
+                                    PcdMaximumUnicodeStringLength.
+                                    If PcdMaximumAsciiStringLength is not zero,
+                                    and Length or DestMax is greater than
+                                    PcdMaximumAsciiStringLength.
+                                    If DestMax is 0.
+  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than
+                                    MIN(AsciiStrLen(Source), Length).
+  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrnToUnicodeStrS (
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length,
+  OUT     CHAR16                    *Destination,
+  IN      UINTN                     DestMax,
+  OUT     UINTN                     *DestinationLength
+  )
+{
+  UINTN            SourceLen;
+
+  ASSERT (((UINTN) Destination & BIT0) == 0);
+
+  //
+  // 1. None of Destination, Source or DestinationLength shall be a null
+  // pointer.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);
+  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);
+  SAFE_STRING_CONSTRAINT_CHECK ((DestinationLength != NULL), RETURN_INVALID_PARAMETER);
+
+  //
+  // 2. Neither Length nor DestMax shall be greater than ASCII_RSIZE_MAX or
+  // RSIZE_MAX.
+  //
+  if (RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+  }
+
+  //
+  // 3. DestMax shall not equal zero.
+  //
+  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. If Length is not less than DestMax, then DestMax shall be greater than
+  // AsciiStrnLenS(Source, DestMax).
+  //
+  SourceLen = AsciiStrnLenS (Source, DestMax);
+  if (Length >= DestMax) {
+    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);
+  }
+
+  //
+  // 5. Copying shall not take place between objects that overlap.
+  //
+  if (SourceLen > Length) {
+    SourceLen = Length;
+  }
+  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax * sizeof(CHAR16), (VOID *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);
+
+  *DestinationLength = 0;
+
+  //
+  // Convert string
+  //
+  while ((*Source != 0) && (SourceLen > 0)) {
+    *(Destination++) = (CHAR16)*(Source++);
+    SourceLen--;
+    (*DestinationLength)++;
+  }
+  *Destination = 0;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated ASCII string to IPv6 address and prefix length.
+
+  This function outputs a value of type IPv6_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the ASCII string specified
+  by String. The format of the input ASCII string String is as follows:
+
+                  X:X:X:X:X:X:X:X[/P]
+
+  X contains one to four hexadecimal digit characters in the range [0-9], [a-f] and
+  [A-F]. X is converted to a value of type UINT16, whose low byte is stored in low
+  memory address and high byte is stored in high memory address. P contains decimal
+  digit characters in the range [0-9]. The running zero in the beginning of P will
+  be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid hexadecimal digit character after eight X's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  "::" can be used to compress one or more groups of X when X contains only 0.
+  The "::" can only appear once in the String.
+
+  If String is NULL, then ASSERT().
+
+  If Address is NULL, then ASSERT().
+
+  If EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan is stored at the location pointed to
+  by EndPointer.
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  EndPointer               Pointer to character that stops scan.
+  @param  Address                  Pointer to the converted IPv6 address.
+  @param  PrefixLength             Pointer to the converted IPv6 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If X contains more than four hexadecimal
+                                    digit characters.
+                                   If String contains "::" and number of X
+                                    is not less than 8.
+                                   If P starts with character that is not a
+                                    valid decimal digit character.
+                                   If the decimal number converted from P
+                                    exceeds 128.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToIpv6Address (
+  IN  CONST CHAR8        *String,
+  OUT CHAR8              **EndPointer, OPTIONAL
+  OUT IPv6_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  )
+{
+  RETURN_STATUS          Status;
+  UINTN                  AddressIndex;
+  UINTN                  Uintn;
+  IPv6_ADDRESS           LocalAddress;
+  UINT8                  LocalPrefixLength;
+  CONST CHAR8            *Pointer;
+  CHAR8                  *End;
+  UINTN                  CompressStart;
+  BOOLEAN                ExpectPrefix;
+
+  LocalPrefixLength = MAX_UINT8;
+  CompressStart     = ARRAY_SIZE (Address->Addr);
+  ExpectPrefix      = FALSE;
+
+  //
+  // None of String or Address 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 (!InternalAsciiIsHexaDecimalDigitCharacter (*Pointer)) {
+      if (*Pointer != ':') {
+        //
+        // ":" 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 != ':') {
+            //
+            // Single ":" shall not be in the beginning of String.
+            //
+            return RETURN_UNSUPPORTED;
+          }
+          Pointer++;
+        }
+      }
+    }
+
+    if (!InternalAsciiIsHexaDecimalDigitCharacter (*Pointer)) {
+      if (*Pointer == '/') {
+        //
+        // Might be optional "/P" after "::".
+        //
+        if (CompressStart != AddressIndex) {
+          return RETURN_UNSUPPORTED;
+        }
+      } else {
+        break;
+      }
+    } else {
+      if (!ExpectPrefix) {
+        //
+        // Get X.
+        //
+        Status = AsciiStrHexToUintnS (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 = AsciiStrDecimalToUintnS (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 == '/') {
+      ExpectPrefix = TRUE;
+    } else if (*Pointer == ':') {
+      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;
+  }
+  CopyMem (&Address->Addr[0], &LocalAddress.Addr[0], CompressStart);
+  ZeroMem (&Address->Addr[CompressStart], ARRAY_SIZE (Address->Addr) - AddressIndex);
+  if (AddressIndex > CompressStart) {
+    CopyMem (
+      &Address->Addr[CompressStart + ARRAY_SIZE (Address->Addr) - AddressIndex],
+      &LocalAddress.Addr[CompressStart],
+      AddressIndex - CompressStart
+      );
+  }
+
+  if (PrefixLength != NULL) {
+    *PrefixLength = LocalPrefixLength;
+  }
+  if (EndPointer != NULL) {
+    *EndPointer = (CHAR8 *) Pointer;
+  }
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated ASCII string to IPv4 address and prefix length.
+
+  This function outputs a value of type IPv4_ADDRESS and may output a value
+  of type UINT8 by interpreting the contents of the ASCII string specified
+  by String. The format of the input ASCII string String is as follows:
+
+                  D.D.D.D[/P]
+
+  D and P are decimal digit characters in the range [0-9]. The running zero in
+  the beginning of D and P will be ignored. /P is optional.
+
+  When /P is not in the String, the function stops at the first character that is
+  not a valid decimal digit character after four D's are converted.
+
+  When /P is in the String, the function stops at the first character that is not
+  a valid decimal digit character after P is converted.
+
+  If String is NULL, then ASSERT().
+
+  If Address is NULL, then ASSERT().
+
+  If EndPointer is not NULL and Address is translated from String, a pointer
+  to the character that stopped the scan is stored at the location pointed to
+  by EndPointer.
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  EndPointer               Pointer to character that stops scan.
+  @param  Address                  Pointer to the converted IPv4 address.
+  @param  PrefixLength             Pointer to the converted IPv4 address prefix
+                                   length. MAX_UINT8 is returned when /P is
+                                   not in the String.
+
+  @retval RETURN_SUCCESS           Address is translated from String.
+  @retval RETURN_INVALID_PARAMETER If String is NULL.
+                                   If Data is NULL.
+  @retval RETURN_UNSUPPORTED       If String is not in the correct format.
+                                   If any decimal number converted from D
+                                    exceeds 255.
+                                   If the decimal number converted from P
+                                    exceeds 32.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiStrToIpv4Address (
+  IN  CONST CHAR8        *String,
+  OUT CHAR8              **EndPointer, OPTIONAL
+  OUT IPv4_ADDRESS       *Address,
+  OUT UINT8              *PrefixLength OPTIONAL
+  )
+{
+  RETURN_STATUS          Status;
+  UINTN                  AddressIndex;
+  UINTN                  Uintn;
+  IPv4_ADDRESS           LocalAddress;
+  UINT8                  LocalPrefixLength;
+  CHAR8                  *Pointer;
+
+  LocalPrefixLength = MAX_UINT8;
+
+  //
+  // None of String or Address 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 = (CHAR8 *) String, AddressIndex = 0; AddressIndex < ARRAY_SIZE (Address->Addr) + 1;) {
+    if (!InternalAsciiIsDecimalDigitCharacter (*Pointer)) {
+      //
+      // D or P contains invalid characters.
+      //
+      break;
+    }
+
+    //
+    // Get D or P.
+    //
+    Status = AsciiStrDecimalToUintnS ((CONST CHAR8 *) 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 == '/') {
+        //
+        // '/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 == '.') {
+        //
+        // D should be followed by '.'
+        //
+        Pointer++;
+      } else {
+        return RETURN_UNSUPPORTED;
+      }
+    }
+  }
+
+  if (AddressIndex < ARRAY_SIZE (Address->Addr)) {
+    return RETURN_UNSUPPORTED;
+  }
+
+  CopyMem (Address, &LocalAddress, sizeof (*Address));
+  if (PrefixLength != NULL) {
+    *PrefixLength = LocalPrefixLength;
+  }
+  if (EndPointer != NULL) {
+    *EndPointer = Pointer;
+  }
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated ASCII GUID string to a value of type
+  EFI_GUID.
+
+  This function outputs a GUID value by interpreting the contents of
+  the ASCII string specified by String. The format of the input
+  ASCII 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().
+
+  @param  String                   Pointer to a Null-terminated ASCII 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
+EFIAPI
+AsciiStrToGuid (
+  IN  CONST CHAR8        *String,
+  OUT GUID               *Guid
+  )
+{
+  RETURN_STATUS          Status;
+  GUID                   LocalGuid;
+
+  //
+  // 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 = AsciiStrHexToBytes (String, 2 * sizeof (LocalGuid.Data1), (UINT8 *) &LocalGuid.Data1, sizeof (LocalGuid.Data1));
+  if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data1)] != '-') {
+    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 = AsciiStrHexToBytes (String, 2 * sizeof (LocalGuid.Data2), (UINT8 *) &LocalGuid.Data2, sizeof (LocalGuid.Data2));
+  if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data2)] != '-') {
+    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 = AsciiStrHexToBytes (String, 2 * sizeof (LocalGuid.Data3), (UINT8 *) &LocalGuid.Data3, sizeof (LocalGuid.Data3));
+  if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data3)] != '-') {
+    return RETURN_UNSUPPORTED;
+  }
+  //
+  // Convert big-endian to little-endian.
+  //
+  LocalGuid.Data3 = SwapBytes16 (LocalGuid.Data3);
+  String += 2 * sizeof (LocalGuid.Data3) + 1;
+
+  //
+  // Get iijj.
+  //
+  Status = AsciiStrHexToBytes (String, 2 * 2, &LocalGuid.Data4[0], 2);
+  if (RETURN_ERROR (Status) || String[2 * 2] != '-') {
+    return RETURN_UNSUPPORTED;
+  }
+  String += 2 * 2 + 1;
+
+  //
+  // Get kkllmmnnoopp.
+  //
+  Status = AsciiStrHexToBytes (String, 2 * 6, &LocalGuid.Data4[2], 6);
+  if (RETURN_ERROR (Status)) {
+    return RETURN_UNSUPPORTED;
+  }
+
+  CopyGuid (Guid, &LocalGuid);
+  return RETURN_SUCCESS;
+}
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a byte array.
+
+  This function outputs a byte array by interpreting the contents of
+  the ASCII string specified by String in hexadecimal format. The format of
+  the input ASCII 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 NULL, then ASSERT().
+
+  If Buffer is NULL, then ASSERT().
+
+  If Length is not multiple of 2, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero and Length is greater than
+  PcdMaximumAsciiStringLength, then ASSERT().
+
+  If MaxBufferSize is less than (Length / 2), then ASSERT().
+
+  @param  String                   Pointer to a Null-terminated ASCII string.
+  @param  Length                   The number of ASCII 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 PcdMaximumAsciiStringLength is not zero,
+                                    and Length is greater than
+                                    PcdMaximumAsciiStringLength.
+  @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
+EFIAPI
+AsciiStrHexToBytes (
+  IN  CONST CHAR8        *String,
+  IN  UINTN              Length,
+  OUT UINT8              *Buffer,
+  IN  UINTN              MaxBufferSize
+  )
+{
+  UINTN                  Index;
+
+  //
+  // 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 ASCII_RSIZE_MAX.
+  //
+  if (ASCII_RSIZE_MAX != 0) {
+    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_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 (!InternalAsciiIsHexaDecimalDigitCharacter (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) InternalAsciiHexCharToUintn (String[Index]) << 4;
+    } else {
+      Buffer[Index / 2] |= (UINT8) InternalAsciiHexCharToUintn (String[Index]);
+    }
+  }
+  return RETURN_SUCCESS;
+}
+
diff --git a/MdePkg/Library/BaseLib/SetJump.c b/MdePkg/Library/BaseLib/SetJump.c
new file mode 100644
index 000000000000..4e6e00c3db32
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SetJump.c
@@ -0,0 +1,40 @@
+/** @file
+  Internal ASSERT () functions for SetJump.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Worker function that checks ASSERT condition for JumpBuffer
+
+  Checks ASSERT condition for JumpBuffer.
+
+  If JumpBuffer is NULL, then ASSERT().
+  For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  JumpBuffer    A pointer to CPU context buffer.
+
+**/
+VOID
+EFIAPI
+InternalAssertJumpBuffer (
+  IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+  )
+{
+  ASSERT (JumpBuffer != NULL);
+
+  ASSERT (((UINTN)JumpBuffer & (BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT - 1)) == 0);
+}
diff --git a/MdePkg/Library/BaseLib/String.c b/MdePkg/Library/BaseLib/String.c
new file mode 100644
index 000000000000..9dcfb7268832
--- /dev/null
+++ b/MdePkg/Library/BaseLib/String.c
@@ -0,0 +1,1812 @@
+/** @file
+  Unicode and ASCII string primitives.
+
+  Copyright (c) 2006 - 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 "BaseLibInternals.h"
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Copies one Null-terminated Unicode string to another Null-terminated Unicode
+  string and returns the new Unicode string.
+
+  This function copies the contents of the Unicode string Source to the Unicode
+  string Destination, and returns Destination. If Source and Destination
+  overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated Unicode string.
+  @param  Source      A pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrCpy (
+  OUT     CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source
+  )
+{
+  CHAR16                            *ReturnValue;
+
+  //
+  // Destination cannot be NULL
+  //
+  ASSERT (Destination != NULL);
+  ASSERT (((UINTN) Destination & BIT0) == 0);
+
+  //
+  // Destination and source cannot overlap
+  //
+  ASSERT ((UINTN)(Destination - Source) > StrLen (Source));
+  ASSERT ((UINTN)(Source - Destination) > StrLen (Source));
+
+  ReturnValue = Destination;
+  while (*Source != 0) {
+    *(Destination++) = *(Source++);
+  }
+  *Destination = 0;
+  return ReturnValue;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Copies up to a specified length from one Null-terminated Unicode string  to 
+  another Null-terminated Unicode string and returns the new Unicode string.
+
+  This function copies the contents of the Unicode string Source to the Unicode
+  string Destination, and returns Destination. At most, Length Unicode
+  characters are copied from Source to Destination. If Length is 0, then
+  Destination is returned unmodified. If Length is greater that the number of
+  Unicode characters in Source, then Destination is padded with Null Unicode
+  characters. If Source and Destination overlap, then the results are
+  undefined.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Length is greater than 
+  PcdMaximumUnicodeStringLength, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated Unicode string.
+  @param  Source      A pointer to a Null-terminated Unicode string.
+  @param  Length      The maximum number of Unicode characters to copy.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrnCpy (
+  OUT     CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length
+  )
+{
+  CHAR16                            *ReturnValue;
+
+  if (Length == 0) {
+    return Destination;
+  }
+
+  //
+  // Destination cannot be NULL if Length is not zero
+  //
+  ASSERT (Destination != NULL);
+  ASSERT (((UINTN) Destination & BIT0) == 0);
+
+  //
+  // Destination and source cannot overlap
+  //
+  ASSERT ((UINTN)(Destination - Source) > StrLen (Source));
+  ASSERT ((UINTN)(Source - Destination) >= Length);
+
+  if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
+    ASSERT (Length <= PcdGet32 (PcdMaximumUnicodeStringLength));
+  }
+
+  ReturnValue = Destination;
+
+  while ((*Source != L'\0') && (Length > 0)) {
+    *(Destination++) = *(Source++);
+    Length--;
+  }
+
+  ZeroMem (Destination, Length * sizeof (*Destination));
+  return ReturnValue;
+}
+#endif
+
+/**
+  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
+EFIAPI
+StrLen (
+  IN      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
+    //
+    if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
+      ASSERT (Length < PcdGet32 (PcdMaximumUnicodeStringLength));
+    }
+  }
+  return Length;
+}
+
+/**
+  Returns the size of a Null-terminated Unicode string in bytes, including the
+  Null terminator.
+
+  This function returns the size, in bytes, of 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 size of String.
+
+**/
+UINTN
+EFIAPI
+StrSize (
+  IN      CONST CHAR16              *String
+  )
+{
+  return (StrLen (String) + 1) * sizeof (*String);
+}
+
+/**
+  Compares 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. 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 FirstString is NULL, then ASSERT().
+  If FirstString is not aligned on a 16-bit boundary, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If SecondString is not aligned on a 16-bit boundary, 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.
+
+  @retval 0      FirstString is identical to SecondString.
+  @return others FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+StrCmp (
+  IN      CONST CHAR16              *FirstString,
+  IN      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;
+}
+
+/**
+  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
+EFIAPI
+StrnCmp (
+  IN      CONST CHAR16              *FirstString,
+  IN      CONST CHAR16              *SecondString,
+  IN      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);
+
+  if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
+    ASSERT (Length <= PcdGet32 (PcdMaximumUnicodeStringLength));
+  }
+
+  while ((*FirstString != L'\0') &&
+         (*SecondString != L'\0') &&
+         (*FirstString == *SecondString) &&
+         (Length > 1)) {
+    FirstString++;
+    SecondString++;
+    Length--;
+  }
+
+  return *FirstString - *SecondString;
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Concatenates one Null-terminated Unicode string to another Null-terminated
+  Unicode string, and returns the concatenated Unicode string.
+
+  This function concatenates two Null-terminated Unicode strings. The contents
+  of Null-terminated Unicode string Source are concatenated to the end of
+  Null-terminated Unicode string Destination. The Null-terminated concatenated
+  Unicode String is returned. If Source and Destination overlap, then the
+  results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
+  than PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
+  and Source results in a Unicode string with more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated Unicode string.
+  @param  Source      A pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrCat (
+  IN OUT  CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source
+  )
+{
+  StrCpy (Destination + StrLen (Destination), Source);
+
+  //
+  // Size of the resulting string should never be zero.
+  // PcdMaximumUnicodeStringLength is tested inside StrLen().
+  //
+  ASSERT (StrSize (Destination) != 0);
+  return Destination;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Concatenates up to a specified length one Null-terminated Unicode to the end 
+  of another Null-terminated Unicode string, and returns the concatenated 
+  Unicode string.
+
+  This function concatenates two Null-terminated Unicode strings. The contents
+  of Null-terminated Unicode string Source are concatenated to the end of
+  Null-terminated Unicode string Destination, and Destination is returned. At
+  most, Length Unicode characters are concatenated from Source to the end of
+  Destination, and Destination is always Null-terminated. If Length is 0, then
+  Destination is returned unmodified. If Source and Destination overlap, then
+  the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Length is greater than 
+  PcdMaximumUnicodeStringLength, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Destination contains more
+  than PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and concatenating Destination
+  and Source results in a Unicode string with more than PcdMaximumUnicodeStringLength
+  Unicode characters, not including the Null-terminator, then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated Unicode string.
+  @param  Source      A pointer to a Null-terminated Unicode string.
+  @param  Length      The maximum number of Unicode characters to concatenate from
+                      Source.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+StrnCat (
+  IN OUT  CHAR16                    *Destination,
+  IN      CONST CHAR16              *Source,
+  IN      UINTN                     Length
+  )
+{
+  UINTN   DestinationLen;
+
+  DestinationLen = StrLen (Destination);
+  StrnCpy (Destination + DestinationLen, Source, Length);
+  Destination[DestinationLen + Length] = L'\0';
+
+  //
+  // Size of the resulting string should never be zero.
+  // PcdMaximumUnicodeStringLength is tested inside StrLen().
+  //
+  ASSERT (StrSize (Destination) != 0);
+  return Destination;
+}
+#endif
+
+/**
+  Returns the first occurrence of a Null-terminated Unicode sub-string
+  in a Null-terminated Unicode string.
+
+  This function scans the contents of the Null-terminated Unicode string
+  specified by String and returns the first occurrence of SearchString.
+  If SearchString is not found in String, then NULL is returned.  If
+  the length of SearchString is zero, then String is
+  returned.
+
+  If String is NULL, then ASSERT().
+  If String is not aligned on a 16-bit boundary, then ASSERT().
+  If SearchString is NULL, then ASSERT().
+  If SearchString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If PcdMaximumUnicodeStringLength is not zero, and SearchString
+  or String contains more than PcdMaximumUnicodeStringLength Unicode
+  characters, not including the Null-terminator, then ASSERT().
+
+  @param  String          A pointer to a Null-terminated Unicode string.
+  @param  SearchString    A pointer to a Null-terminated Unicode string to search for.
+
+  @retval NULL            If the SearchString does not appear in String.
+  @return others          If there is a match.
+
+**/
+CHAR16 *
+EFIAPI
+StrStr (
+  IN      CONST CHAR16              *String,
+  IN      CONST CHAR16              *SearchString
+  )
+{
+  CONST CHAR16 *FirstMatch;
+  CONST CHAR16 *SearchStringTmp;
+
+  //
+  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.
+  // Length tests are performed inside StrLen().
+  //
+  ASSERT (StrSize (String) != 0);
+  ASSERT (StrSize (SearchString) != 0);
+
+  if (*SearchString == L'\0') {
+    return (CHAR16 *) String;
+  }
+
+  while (*String != L'\0') {
+    SearchStringTmp = SearchString;
+    FirstMatch = String;
+    
+    while ((*String == *SearchStringTmp) 
+            && (*String != L'\0')) {
+      String++;
+      SearchStringTmp++;
+    } 
+    
+    if (*SearchStringTmp == L'\0') {
+      return (CHAR16 *) FirstMatch;
+    }
+
+    if (*String == L'\0') {
+      return NULL;
+    }
+
+    String = FirstMatch + 1;
+  }
+
+  return NULL;
+}
+
+/**
+  Check if a Unicode character is a decimal character.
+
+  This internal function checks if a Unicode character is a 
+  decimal character. The valid decimal character is from
+  L'0' to L'9'.
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a decmial character.
+  @retval FALSE If the Char is not a decmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalIsDecimalDigitCharacter (
+  IN      CHAR16                    Char
+  )
+{
+  return (BOOLEAN) (Char >= L'0' && Char <= L'9');
+}
+
+/**
+  Convert a Unicode character to upper case only if 
+  it maps to a valid small-case ASCII character.
+
+  This internal function only deal with Unicode character
+  which maps to a valid small-case ASCII character, i.e.
+  L'a' to L'z'. For other Unicode character, the input character
+  is returned directly.
+
+  @param  Char  The character to convert.
+
+  @retval LowerCharacter   If the Char is with range L'a' to L'z'.
+  @retval Unchanged        Otherwise.
+
+**/
+CHAR16
+EFIAPI
+InternalCharToUpper (
+  IN      CHAR16                    Char
+  )
+{
+  if (Char >= L'a' && Char <= L'z') {
+    return (CHAR16) (Char - (L'a' - L'A'));
+  }
+
+  return Char;
+}
+
+/**
+  Convert a Unicode character to numerical value.
+
+  This internal function only deal with Unicode character
+  which maps to a valid hexadecimal ASII character, i.e.
+  L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other 
+  Unicode character, the value returned does not make sense.
+
+  @param  Char  The character to convert.
+
+  @return The numerical value converted.
+
+**/
+UINTN
+EFIAPI
+InternalHexCharToUintn (
+  IN      CHAR16                    Char
+  )
+{
+  if (InternalIsDecimalDigitCharacter (Char)) {
+    return Char - L'0';
+  }
+
+  return (10 + InternalCharToUpper (Char) - L'A');
+}
+
+/**
+  Check if a Unicode character is a hexadecimal character.
+
+  This internal function checks if a Unicode character is a 
+  decimal character.  The valid hexadecimal character is 
+  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
+
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a hexadecmial character.
+  @retval FALSE If the Char is not a hexadecmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalIsHexaDecimalDigitCharacter (
+  IN      CHAR16                    Char
+  )
+{
+
+  return (BOOLEAN) (InternalIsDecimalDigitCharacter (Char) ||
+    (Char >= L'A' && Char <= L'F') ||
+    (Char >= L'a' && Char <= L'f'));
+}
+
+/**
+  Convert a Null-terminated Unicode decimal string to a value of
+  type UINTN.
+
+  This function returns a value of type UINTN 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits,
+  then 0 is returned.
+  If the number represented by String overflows according
+  to the range defined by UINTN, then MAX_UINTN is returned.
+
+  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.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+StrDecimalToUintn (
+  IN      CONST CHAR16              *String
+  )
+{
+  UINTN     Result;
+
+  StrDecimalToUintnS (String, (CHAR16 **) NULL, &Result);
+  return Result;
+}
+
+
+/**
+  Convert a Null-terminated Unicode decimal string to a value of
+  type UINT64.
+
+  This function returns 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits,
+  then 0 is returned.
+  If the number represented by String overflows according
+  to the range defined by UINT64, then MAX_UINT64 is returned.
+
+  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.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+StrDecimalToUint64 (
+  IN      CONST CHAR16              *String
+  )
+{
+  UINT64     Result;
+  
+  StrDecimalToUint64S (String, (CHAR16 **) NULL, &Result);
+  return Result;
+}
+
+/**
+  Convert a Null-terminated Unicode hexadecimal string to a value of type UINTN.
+
+  This function returns 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then zero is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
+  then zero is returned.
+  If the number represented by String overflows according to the range defined by
+  UINTN, then MAX_UINTN is returned.
+
+  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.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+StrHexToUintn (
+  IN      CONST CHAR16              *String
+  )
+{
+  UINTN     Result;
+
+  StrHexToUintnS (String, (CHAR16 **) NULL, &Result);
+  return Result;
+}
+
+
+/**
+  Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.
+
+  This function returns a value of type UINT64 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 String is not aligned in a 16-bit boundary, then ASSERT().
+  If String has only pad spaces, then zero is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
+  then zero is returned.
+  If the number represented by String overflows according to the range defined by
+  UINT64, then MAX_UINT64 is returned.
+
+  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.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+StrHexToUint64 (
+  IN      CONST CHAR16             *String
+  )
+{
+  UINT64    Result;
+
+  StrHexToUint64S (String, (CHAR16 **) NULL, &Result);
+  return Result;
+}
+
+/**
+  Check if a ASCII character is a decimal character.
+
+  This internal function checks if a Unicode character is a 
+  decimal character. The valid decimal character is from
+  '0' to '9'.
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a decmial character.
+  @retval FALSE If the Char is not a decmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalAsciiIsDecimalDigitCharacter (
+  IN      CHAR8                     Char
+  )
+{
+  return (BOOLEAN) (Char >= '0' && Char <= '9');
+}
+
+/**
+  Check if a ASCII character is a hexadecimal character.
+
+  This internal function checks if a ASCII character is a 
+  decimal character.  The valid hexadecimal character is 
+  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
+
+
+  @param  Char  The character to check against.
+
+  @retval TRUE  If the Char is a hexadecmial character.
+  @retval FALSE If the Char is not a hexadecmial character.
+
+**/
+BOOLEAN
+EFIAPI
+InternalAsciiIsHexaDecimalDigitCharacter (
+  IN      CHAR8                    Char
+  )
+{
+
+  return (BOOLEAN) (InternalAsciiIsDecimalDigitCharacter (Char) ||
+    (Char >= 'A' && Char <= 'F') ||
+    (Char >= 'a' && Char <= 'f'));
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Convert a Null-terminated Unicode string to a Null-terminated
+  ASCII string and returns the ASCII string.
+
+  This function converts the content of the Unicode string Source
+  to the ASCII string Destination by copying the lower 8 bits of
+  each Unicode character. It returns Destination.
+
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.
+
+  If any Unicode characters in Source contain non-zero value in
+  the upper 8 bits, then ASSERT().
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source is not aligned on a 16-bit boundary, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains
+  more than PcdMaximumUnicodeStringLength Unicode characters, not including
+  the Null-terminator, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more
+  than PcdMaximumAsciiStringLength Unicode characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  Source        A pointer to a Null-terminated Unicode string.
+  @param  Destination   A pointer to a Null-terminated ASCII string.
+
+  @return Destination.
+
+**/
+CHAR8 *
+EFIAPI
+UnicodeStrToAsciiStr (
+  IN      CONST CHAR16              *Source,
+  OUT     CHAR8                     *Destination
+  )
+{
+  CHAR8                               *ReturnValue;
+
+  ASSERT (Destination != NULL);
+
+  //
+  // ASSERT if Source is long than PcdMaximumUnicodeStringLength.
+  // Length tests are performed inside StrLen().
+  //
+  ASSERT (StrSize (Source) != 0);
+
+  //
+  // Source and Destination should not overlap
+  //
+  ASSERT ((UINTN) (Destination - (CHAR8 *) Source) >= StrSize (Source));
+  ASSERT ((UINTN) ((CHAR8 *) Source - Destination) > StrLen (Source));
+
+
+  ReturnValue = Destination;
+  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';
+
+  //
+  // ASSERT Original Destination is less long than PcdMaximumAsciiStringLength.
+  // Length tests are performed inside AsciiStrLen().
+  //
+  ASSERT (AsciiStrSize (ReturnValue) != 0);
+
+  return ReturnValue;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Copies one Null-terminated ASCII string to another Null-terminated ASCII
+  string and returns the new ASCII string.
+
+  This function copies the contents of the ASCII string Source to the ASCII
+  string Destination, and returns Destination. If Source and Destination
+  overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated ASCII string.
+  @param  Source      A pointer to a Null-terminated ASCII string.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrCpy (
+  OUT     CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source
+  )
+{
+  CHAR8                             *ReturnValue;
+
+  //
+  // Destination cannot be NULL
+  //
+  ASSERT (Destination != NULL);
+
+  //
+  // Destination and source cannot overlap
+  //
+  ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));
+  ASSERT ((UINTN)(Source - Destination) > AsciiStrLen (Source));
+
+  ReturnValue = Destination;
+  while (*Source != 0) {
+    *(Destination++) = *(Source++);
+  }
+  *Destination = 0;
+  return ReturnValue;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Copies up to a specified length one Null-terminated ASCII string to another 
+  Null-terminated ASCII string and returns the new ASCII string.
+
+  This function copies the contents of the ASCII string Source to the ASCII
+  string Destination, and returns Destination. At most, Length ASCII characters
+  are copied from Source to Destination. If Length is 0, then Destination is
+  returned unmodified. If Length is greater that the number of ASCII characters
+  in Source, then Destination is padded with Null ASCII characters. If Source
+  and Destination overlap, then the results are undefined.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than 
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated ASCII string.
+  @param  Source      A pointer to a Null-terminated ASCII string.
+  @param  Length      The maximum number of ASCII characters to copy.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrnCpy (
+  OUT     CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length
+  )
+{
+  CHAR8                             *ReturnValue;
+
+  if (Length == 0) {
+    return Destination;
+  }
+
+  //
+  // Destination cannot be NULL
+  //
+  ASSERT (Destination != NULL);
+
+  //
+  // Destination and source cannot overlap
+  //
+  ASSERT ((UINTN)(Destination - Source) > AsciiStrLen (Source));
+  ASSERT ((UINTN)(Source - Destination) >= Length);
+
+  if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
+    ASSERT (Length <= PcdGet32 (PcdMaximumAsciiStringLength));
+  }
+
+  ReturnValue = Destination;
+
+  while (*Source != 0 && Length > 0) {
+    *(Destination++) = *(Source++);
+    Length--;
+  }
+
+  ZeroMem (Destination, Length * sizeof (*Destination));
+  return ReturnValue;
+}
+#endif
+
+/**
+  Returns the length of a Null-terminated ASCII string.
+
+  This function returns the number of ASCII characters in the Null-terminated
+  ASCII string specified by String.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  String  A pointer to a Null-terminated ASCII string.
+
+  @return The length of String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrLen (
+  IN      CONST CHAR8               *String
+  )
+{
+  UINTN                             Length;
+
+  ASSERT (String != NULL);
+
+  for (Length = 0; *String != '\0'; String++, Length++) {
+    //
+    // If PcdMaximumUnicodeStringLength is not zero,
+    // length should not more than PcdMaximumUnicodeStringLength
+    //
+    if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
+      ASSERT (Length < PcdGet32 (PcdMaximumAsciiStringLength));
+    }
+  }
+  return Length;
+}
+
+/**
+  Returns the size of a Null-terminated ASCII string in bytes, including the
+  Null terminator.
+
+  This function returns the size, in bytes, of the Null-terminated ASCII string
+  specified by String.
+
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  String  A pointer to a Null-terminated ASCII string.
+
+  @return The size of String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrSize (
+  IN      CONST CHAR8               *String
+  )
+{
+  return (AsciiStrLen (String) + 1) * sizeof (*String);
+}
+
+/**
+  Compares two Null-terminated ASCII strings, and returns the difference
+  between the first mismatched ASCII characters.
+
+  This function compares the Null-terminated ASCII string FirstString to the
+  Null-terminated ASCII string SecondString. If FirstString is identical to
+  SecondString, then 0 is returned. Otherwise, the value returned is the first
+  mismatched ASCII character in SecondString subtracted from the first
+  mismatched ASCII character in FirstString.
+
+  If FirstString is NULL, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and SecondString contains more
+  than PcdMaximumAsciiStringLength ASCII characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  FirstString   A pointer to a Null-terminated ASCII string.
+  @param  SecondString  A pointer to a Null-terminated ASCII string.
+
+  @retval ==0      FirstString is identical to SecondString.
+  @retval !=0      FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+AsciiStrCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString
+  )
+{
+  //
+  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
+  //
+  ASSERT (AsciiStrSize (FirstString));
+  ASSERT (AsciiStrSize (SecondString));
+
+  while ((*FirstString != '\0') && (*FirstString == *SecondString)) {
+    FirstString++;
+    SecondString++;
+  }
+
+  return *FirstString - *SecondString;
+}
+
+/**
+  Converts a lowercase Ascii character to upper one.
+
+  If Chr is lowercase Ascii character, then converts it to upper one.
+
+  If Value >= 0xA0, then ASSERT().
+  If (Value & 0x0F) >= 0x0A, then ASSERT().
+
+  @param  Chr   one Ascii character
+
+  @return The uppercase value of Ascii character 
+
+**/
+CHAR8
+EFIAPI
+InternalBaseLibAsciiToUpper (
+  IN      CHAR8                     Chr
+  )
+{
+  return (UINT8) ((Chr >= 'a' && Chr <= 'z') ? Chr - ('a' - 'A') : Chr);
+}
+
+/**
+  Convert a ASCII character to numerical value.
+
+  This internal function only deal with Unicode character
+  which maps to a valid hexadecimal ASII character, i.e.
+  '0' to '9', 'a' to 'f' or 'A' to 'F'. For other 
+  ASCII character, the value returned does not make sense.
+
+  @param  Char  The character to convert.
+
+  @return The numerical value converted.
+
+**/
+UINTN
+EFIAPI
+InternalAsciiHexCharToUintn (
+  IN      CHAR8                    Char
+  )
+{
+  if (InternalIsDecimalDigitCharacter (Char)) {
+    return Char - '0';
+  }
+
+  return (10 + InternalBaseLibAsciiToUpper (Char) - 'A');
+}
+
+
+/**
+  Performs a case insensitive comparison of two Null-terminated ASCII strings,
+  and returns the difference between the first mismatched ASCII characters.
+
+  This function performs a case insensitive comparison of the Null-terminated
+  ASCII string FirstString to the Null-terminated ASCII string SecondString. If
+  FirstString is identical to SecondString, then 0 is returned. Otherwise, the
+  value returned is the first mismatched lower case ASCII character in
+  SecondString subtracted from the first mismatched lower case ASCII character
+  in FirstString.
+
+  If FirstString is NULL, then ASSERT().
+  If SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and SecondString contains more
+  than PcdMaximumAsciiStringLength ASCII characters, not including the
+  Null-terminator, then ASSERT().
+
+  @param  FirstString   A pointer to a Null-terminated ASCII string.
+  @param  SecondString  A pointer to a Null-terminated ASCII string.
+
+  @retval ==0    FirstString is identical to SecondString using case insensitive
+                 comparisons.
+  @retval !=0    FirstString is not identical to SecondString using case
+                 insensitive comparisons.
+
+**/
+INTN
+EFIAPI
+AsciiStriCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString
+  )
+{
+  CHAR8  UpperFirstString;
+  CHAR8  UpperSecondString;
+
+  //
+  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
+  //
+  ASSERT (AsciiStrSize (FirstString));
+  ASSERT (AsciiStrSize (SecondString));
+
+  UpperFirstString  = InternalBaseLibAsciiToUpper (*FirstString);
+  UpperSecondString = InternalBaseLibAsciiToUpper (*SecondString);
+  while ((*FirstString != '\0') && (UpperFirstString == UpperSecondString)) {
+    FirstString++;
+    SecondString++;
+    UpperFirstString  = InternalBaseLibAsciiToUpper (*FirstString);
+    UpperSecondString = InternalBaseLibAsciiToUpper (*SecondString);
+  }
+
+  return UpperFirstString - UpperSecondString;
+}
+
+/**
+  Compares two Null-terminated ASCII strings with maximum lengths, and returns
+  the difference between the first mismatched ASCII characters.
+
+  This function compares the Null-terminated ASCII string FirstString to the
+  Null-terminated ASCII  string SecondString. At most, Length ASCII 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 ASCII character in SecondString subtracted from the
+  first mismatched ASCII character in FirstString.
+
+  If Length > 0 and FirstString is NULL, then ASSERT().
+  If Length > 0 and SecondString is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than 
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and FirstString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and SecondString contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+
+  @param  FirstString   A pointer to a Null-terminated ASCII string.
+  @param  SecondString  A pointer to a Null-terminated ASCII string.
+  @param  Length        The maximum number of ASCII characters for compare.
+  
+  @retval ==0       FirstString is identical to SecondString.
+  @retval !=0       FirstString is not identical to SecondString.
+
+**/
+INTN
+EFIAPI
+AsciiStrnCmp (
+  IN      CONST CHAR8               *FirstString,
+  IN      CONST CHAR8               *SecondString,
+  IN      UINTN                     Length
+  )
+{
+  if (Length == 0) {
+    return 0;
+  }
+
+  //
+  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
+  //
+  ASSERT (AsciiStrSize (FirstString));
+  ASSERT (AsciiStrSize (SecondString));
+
+  if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
+    ASSERT (Length <= PcdGet32 (PcdMaximumAsciiStringLength));
+  }
+
+  while ((*FirstString != '\0') &&
+         (*SecondString != '\0') &&
+         (*FirstString == *SecondString) &&
+         (Length > 1)) {
+    FirstString++;
+    SecondString++;
+    Length--;
+  }
+  return *FirstString - *SecondString;
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Concatenates one Null-terminated ASCII string to another Null-terminated
+  ASCII string, and returns the concatenated ASCII string.
+
+  This function concatenates two Null-terminated ASCII strings. The contents of
+  Null-terminated ASCII string Source are concatenated to the end of Null-
+  terminated ASCII string Destination. The Null-terminated concatenated ASCII
+  String is returned.
+
+  If Destination is NULL, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Destination contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero and concatenating Destination and
+  Source results in a ASCII string with more than PcdMaximumAsciiStringLength
+  ASCII characters, then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated ASCII string.
+  @param  Source      A pointer to a Null-terminated ASCII string.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrCat (
+  IN OUT CHAR8    *Destination,
+  IN CONST CHAR8  *Source
+  )
+{
+  AsciiStrCpy (Destination + AsciiStrLen (Destination), Source);
+
+  //
+  // Size of the resulting string should never be zero.
+  // PcdMaximumUnicodeStringLength is tested inside StrLen().
+  //
+  ASSERT (AsciiStrSize (Destination) != 0);
+  return Destination;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Concatenates up to a specified length one Null-terminated ASCII string to 
+  the end of another Null-terminated ASCII string, and returns the 
+  concatenated ASCII string.
+
+  This function concatenates two Null-terminated ASCII strings. The contents
+  of Null-terminated ASCII string Source are concatenated to the end of Null-
+  terminated ASCII string Destination, and Destination is returned. At most,
+  Length ASCII characters are concatenated from Source to the end of
+  Destination, and Destination is always Null-terminated. If Length is 0, then
+  Destination is returned unmodified. If Source and Destination overlap, then
+  the results are undefined.
+
+  If Length > 0 and Destination is NULL, then ASSERT().
+  If Length > 0 and Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Length is greater than
+  PcdMaximumAsciiStringLength, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Destination contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and concatenating Destination and
+  Source results in a ASCII string with more than PcdMaximumAsciiStringLength
+  ASCII characters, not including the Null-terminator, then ASSERT().
+
+  @param  Destination A pointer to a Null-terminated ASCII string.
+  @param  Source      A pointer to a Null-terminated ASCII string.
+  @param  Length      The maximum number of ASCII characters to concatenate from
+                      Source.
+
+  @return Destination
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrnCat (
+  IN OUT  CHAR8                     *Destination,
+  IN      CONST CHAR8               *Source,
+  IN      UINTN                     Length
+  )
+{
+  UINTN   DestinationLen;
+
+  DestinationLen = AsciiStrLen (Destination);
+  AsciiStrnCpy (Destination + DestinationLen, Source, Length);
+  Destination[DestinationLen + Length] = '\0';
+
+  //
+  // Size of the resulting string should never be zero.
+  // PcdMaximumUnicodeStringLength is tested inside StrLen().
+  //
+  ASSERT (AsciiStrSize (Destination) != 0);
+  return Destination;
+}
+#endif
+
+/**
+  Returns the first occurrence of a Null-terminated ASCII sub-string
+  in a Null-terminated ASCII string.
+
+  This function scans the contents of the ASCII string specified by String
+  and returns the first occurrence of SearchString. If SearchString is not
+  found in String, then NULL is returned. If the length of SearchString is zero,
+  then String is returned.
+
+  If String is NULL, then ASSERT().
+  If SearchString is NULL, then ASSERT().
+
+  If PcdMaximumAsciiStringLength is not zero, and SearchString or
+  String contains more than PcdMaximumAsciiStringLength Unicode characters
+  not including the Null-terminator, then ASSERT().
+
+  @param  String          A pointer to a Null-terminated ASCII string.
+  @param  SearchString    A pointer to a Null-terminated ASCII string to search for.
+
+  @retval NULL            If the SearchString does not appear in String.
+  @retval others          If there is a match return the first occurrence of SearchingString.
+                          If the length of SearchString is zero,return String.
+
+**/
+CHAR8 *
+EFIAPI
+AsciiStrStr (
+  IN      CONST CHAR8               *String,
+  IN      CONST CHAR8               *SearchString
+  )
+{
+  CONST CHAR8 *FirstMatch;
+  CONST CHAR8 *SearchStringTmp;
+
+  //
+  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
+  //
+  ASSERT (AsciiStrSize (String) != 0);
+  ASSERT (AsciiStrSize (SearchString) != 0);
+
+  if (*SearchString == '\0') {
+    return (CHAR8 *) String;
+  }
+
+  while (*String != '\0') {
+    SearchStringTmp = SearchString;
+    FirstMatch = String;
+    
+    while ((*String == *SearchStringTmp) 
+            && (*String != '\0')) {
+      String++;
+      SearchStringTmp++;
+    } 
+    
+    if (*SearchStringTmp == '\0') {
+      return (CHAR8 *) FirstMatch;
+    }
+
+    if (*String == '\0') {
+      return NULL;
+    }
+
+    String = FirstMatch + 1;
+  }
+
+  return NULL;
+}
+
+/**
+  Convert a Null-terminated ASCII decimal string to a value of type
+  UINTN.
+
+  This function returns a value of type UINTN by interpreting the contents
+  of the ASCII string String as a decimal number. The format of the input
+  ASCII 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 the 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
+  Null-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits, then 0 is returned.
+  If the number represented by String overflows according to the range defined by
+  UINTN, then MAX_UINTN is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          A pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrDecimalToUintn (
+  IN      CONST CHAR8               *String
+  )
+{
+  UINTN     Result;
+  
+  AsciiStrDecimalToUintnS (String, (CHAR8 **) NULL, &Result);
+  return Result;
+}
+
+
+/**
+  Convert a Null-terminated ASCII decimal string to a value of type
+  UINT64.
+
+  This function returns a value of type UINT64 by interpreting the contents
+  of the ASCII string String as a decimal number. The format of the input
+  ASCII 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 the 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
+  Null-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no pad spaces or valid decimal digits, then 0 is returned.
+  If the number represented by String overflows according to the range defined by
+  UINT64, then MAX_UINT64 is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and String contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+
+  @param  String          A pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+AsciiStrDecimalToUint64 (
+  IN      CONST CHAR8               *String
+  )
+{
+  UINT64     Result;
+  
+  AsciiStrDecimalToUint64S (String, (CHAR8 **) NULL, &Result);
+  return Result;
+}
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a value of type UINTN.
+
+  This function returns a value of type UINTN by interpreting the contents of
+  the ASCII string String as a hexadecimal number. The format of the input ASCII
+  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 digits]. The running zero before [x] or [hexadecimal digits]
+  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-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then
+  0 is returned.
+
+  If the number represented by String overflows according to the range defined by UINTN,
+  then MAX_UINTN is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero,
+  and String contains more than PcdMaximumAsciiStringLength ASCII characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String          A pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINTN
+EFIAPI
+AsciiStrHexToUintn (
+  IN      CONST CHAR8               *String
+  )
+{
+  UINTN     Result;
+
+  AsciiStrHexToUintnS (String, (CHAR8 **) NULL, &Result);
+  return Result;
+}
+
+
+/**
+  Convert a Null-terminated ASCII hexadecimal string to a value of type UINT64.
+
+  This function returns a value of type UINT64 by interpreting the contents of
+  the ASCII string String as a hexadecimal number. The format of the input ASCII
+  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 digits]. The running zero before [x] or [hexadecimal digits]
+  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-terminator, whichever on comes first.
+
+  If String has only pad spaces, then 0 is returned.
+  If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then
+  0 is returned.
+
+  If the number represented by String overflows according to the range defined by UINT64,
+  then MAX_UINT64 is returned.
+  If String is NULL, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero,
+  and String contains more than PcdMaximumAsciiStringLength ASCII characters not including
+  the Null-terminator, then ASSERT().
+
+  @param  String          A pointer to a Null-terminated ASCII string.
+
+  @retval Value translated from String.
+
+**/
+UINT64
+EFIAPI
+AsciiStrHexToUint64 (
+  IN      CONST CHAR8                *String
+  )
+{
+  UINT64    Result;
+
+  AsciiStrHexToUint64S (String, (CHAR8 **) NULL, &Result);
+  return Result;
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Convert one Null-terminated ASCII string to a Null-terminated
+  Unicode string and returns the Unicode string.
+
+  This function converts the contents of the ASCII string Source to the Unicode
+  string Destination, and returns Destination.  The function terminates the
+  Unicode string Destination by appending a Null-terminator character at the end.
+  The caller is responsible to make sure Destination points to a buffer with size
+  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.
+
+  If Destination is NULL, then ASSERT().
+  If Destination is not aligned on a 16-bit boundary, then ASSERT().
+  If Source is NULL, then ASSERT().
+  If Source and Destination overlap, then ASSERT().
+  If PcdMaximumAsciiStringLength is not zero, and Source contains more than
+  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,
+  then ASSERT().
+  If PcdMaximumUnicodeStringLength is not zero, and Source contains more than
+  PcdMaximumUnicodeStringLength ASCII characters not including the
+  Null-terminator, then ASSERT().
+
+  @param  Source        A pointer to a Null-terminated ASCII string.
+  @param  Destination   A pointer to a Null-terminated Unicode string.
+
+  @return Destination.
+
+**/
+CHAR16 *
+EFIAPI
+AsciiStrToUnicodeStr (
+  IN      CONST CHAR8               *Source,
+  OUT     CHAR16                    *Destination
+  )
+{
+  CHAR16                            *ReturnValue;
+
+  ASSERT (Destination != NULL);
+
+  //
+  // ASSERT Source is less long than PcdMaximumAsciiStringLength
+  //
+  ASSERT (AsciiStrSize (Source) != 0);
+
+  //
+  // Source and Destination should not overlap
+  //
+  ASSERT ((UINTN) ((CHAR8 *) Destination - Source) > AsciiStrLen (Source));
+  ASSERT ((UINTN) (Source - (CHAR8 *) Destination) >= (AsciiStrSize (Source) * sizeof (CHAR16)));
+
+
+  ReturnValue = Destination;
+  while (*Source != '\0') {
+    *(Destination++) = (CHAR16) *(Source++);
+  }
+  //
+  // End the Destination with a NULL.
+  //
+  *Destination = '\0';
+
+  //
+  // ASSERT Original Destination is less long than PcdMaximumUnicodeStringLength
+  //
+  ASSERT (StrSize (ReturnValue) != 0);
+
+  return ReturnValue;
+}
+
+#endif
+
+/**
+  Converts an 8-bit value to an 8-bit BCD value.
+
+  Converts the 8-bit value specified by Value to BCD. The BCD value is
+  returned.
+
+  If Value >= 100, then ASSERT().
+
+  @param  Value The 8-bit value to convert to BCD. Range 0..99.
+
+  @return The BCD value.
+
+**/
+UINT8
+EFIAPI
+DecimalToBcd8 (
+  IN      UINT8                     Value
+  )
+{
+  ASSERT (Value < 100);
+  return (UINT8) (((Value / 10) << 4) | (Value % 10));
+}
+
+/**
+  Converts an 8-bit BCD value to an 8-bit value.
+
+  Converts the 8-bit BCD value specified by Value to an 8-bit value. The 8-bit
+  value is returned.
+
+  If Value >= 0xA0, then ASSERT().
+  If (Value & 0x0F) >= 0x0A, then ASSERT().
+
+  @param  Value The 8-bit BCD value to convert to an 8-bit value.
+
+  @return The 8-bit value is returned.
+
+**/
+UINT8
+EFIAPI
+BcdToDecimal8 (
+  IN      UINT8                     Value
+  )
+{
+  ASSERT (Value < 0xa0);
+  ASSERT ((Value & 0xf) < 0xa);
+  return (UINT8) ((Value >> 4) * 10 + (Value & 0xf));
+}
diff --git a/MdePkg/Library/BaseLib/SwapBytes16.c b/MdePkg/Library/BaseLib/SwapBytes16.c
new file mode 100644
index 000000000000..39373bd8d94b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SwapBytes16.c
@@ -0,0 +1,39 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Switches the endianess of a 16-bit integer.
+
+  This function swaps the bytes in a 16-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 16-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT16
+EFIAPI
+SwapBytes16 (
+  IN      UINT16                    Value
+  )
+{
+  return (UINT16) ((Value<< 8) | (Value>> 8));
+}
diff --git a/MdePkg/Library/BaseLib/SwapBytes32.c b/MdePkg/Library/BaseLib/SwapBytes32.c
new file mode 100644
index 000000000000..a0aecf5d431b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SwapBytes32.c
@@ -0,0 +1,45 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Switches the endianess of a 32-bit integer.
+
+  This function swaps the bytes in a 32-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 32-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT32
+EFIAPI
+SwapBytes32 (
+  IN      UINT32                    Value
+  )
+{
+  UINT32  LowerBytes;
+  UINT32  HigherBytes;
+
+  LowerBytes  = (UINT32) SwapBytes16 ((UINT16) Value);
+  HigherBytes = (UINT32) SwapBytes16 ((UINT16) (Value >> 16));
+
+  return (LowerBytes << 16 | HigherBytes);
+}
diff --git a/MdePkg/Library/BaseLib/SwapBytes64.c b/MdePkg/Library/BaseLib/SwapBytes64.c
new file mode 100644
index 000000000000..946fc83485db
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SwapBytes64.c
@@ -0,0 +1,39 @@
+/** @file
+  Math worker functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Switches the endianess of a 64-bit integer.
+
+  This function swaps the bytes in a 64-bit unsigned value to switch the value
+  from little endian to big endian or vice versa. The byte swapped value is
+  returned.
+
+  @param  Value A 64-bit unsigned value.
+
+  @return The byte swapped Value.
+
+**/
+UINT64
+EFIAPI
+SwapBytes64 (
+  IN      UINT64                    Value
+  )
+{
+  return InternalMathSwapBytes64 (Value);
+}
diff --git a/MdePkg/Library/BaseLib/SwitchStack.c b/MdePkg/Library/BaseLib/SwitchStack.c
new file mode 100644
index 000000000000..5bf9b1528867
--- /dev/null
+++ b/MdePkg/Library/BaseLib/SwitchStack.c
@@ -0,0 +1,76 @@
+/** @file
+  Switch Stack functions.
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the
+  new stack specified by NewStack and passing in the parameters specified
+  by Context1 and Context2.  Context1 and Context2 are optional and may
+  be NULL.  The function EntryPoint must never return.  This function
+  supports a variable number of arguments following the NewStack parameter.
+  These additional arguments are ignored on IA-32, x64, and EBC.
+  IPF CPUs expect one additional parameter of type VOID * that specifies
+  the new backing store pointer.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+  @param  ...         This variable argument list is ignored for IA32, x64, and EBC.  
+                      For IPF, this variable argument list is expected to contain 
+                      a single parameter of type VOID * that specifies the new backing 
+                      store pointer.
+
+
+**/
+VOID
+EFIAPI
+SwitchStack (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack,
+  ...
+  )
+{
+  VA_LIST    Marker;
+
+  ASSERT (EntryPoint != NULL);
+  ASSERT (NewStack != NULL);
+
+  //
+  // New stack must be aligned with CPU_STACK_ALIGNMENT
+  //
+  ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0);
+
+  VA_START (Marker, NewStack);
+
+  InternalSwitchStack (EntryPoint, Context1, Context2, NewStack, Marker);
+
+  VA_END (Marker);
+
+  //
+  // InternalSwitchStack () will never return
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/BaseLib/Unaligned.c b/MdePkg/Library/BaseLib/Unaligned.c
new file mode 100644
index 000000000000..04249c8f07b1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/Unaligned.c
@@ -0,0 +1,222 @@
+/** @file
+  Unaligned access functions of BaseLib.
+
+  Copyright (c) 2006 - 2010, 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 "BaseLibInternals.h"
+
+
+/**
+  Reads a 16-bit value from memory that may be unaligned.
+
+  This function returns the 16-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 16-bit value that may be unaligned.
+
+  @return The 16-bit value read from Buffer.
+
+**/
+UINT16
+EFIAPI
+ReadUnaligned16 (
+  IN CONST UINT16              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer;
+}
+
+/**
+  Writes a 16-bit value to memory that may be unaligned.
+
+  This function writes the 16-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 16-bit value that may be unaligned.
+  @param  Value   16-bit value to write to Buffer.
+
+  @return The 16-bit value to write to Buffer.
+
+**/
+UINT16
+EFIAPI
+WriteUnaligned16 (
+  OUT UINT16                    *Buffer,
+  IN  UINT16                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer = Value;
+}
+
+/**
+  Reads a 24-bit value from memory that may be unaligned.
+
+  This function returns the 24-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 24-bit value that may be unaligned.
+
+  @return The 24-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned24 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer & 0xffffff;
+}
+
+/**
+  Writes a 24-bit value to memory that may be unaligned.
+
+  This function writes the 24-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 24-bit value that may be unaligned.
+  @param  Value   24-bit value to write to Buffer.
+
+  @return The 24-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned24 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  *Buffer = BitFieldWrite32 (*Buffer, 0, 23, Value);
+  return Value;
+}
+
+/**
+  Reads a 32-bit value from memory that may be unaligned.
+
+  This function returns the 32-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 32-bit value that may be unaligned.
+
+  @return The 32-bit value read from Buffer.
+
+**/
+UINT32
+EFIAPI
+ReadUnaligned32 (
+  IN CONST UINT32              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer;
+}
+
+/**
+  Writes a 32-bit value to memory that may be unaligned.
+
+  This function writes the 32-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 32-bit value that may be unaligned.
+  @param  Value   The 32-bit value to write to Buffer.
+
+  @return The 32-bit value to write to Buffer.
+
+**/
+UINT32
+EFIAPI
+WriteUnaligned32 (
+  OUT UINT32                    *Buffer,
+  IN  UINT32                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer = Value;
+}
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  IN CONST UINT64              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer;
+}
+
+/**
+  Writes a 64-bit value to memory that may be unaligned.
+
+  This function writes the 64-bit value specified by Value to Buffer. Value is
+  returned. The function guarantees that the write operation does not produce
+  an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  A pointer to a 64-bit value that may be unaligned.
+  @param  Value   The 64-bit value to write to Buffer.
+
+  @return The 64-bit value to write to Buffer.
+
+**/
+UINT64
+EFIAPI
+WriteUnaligned64 (
+  OUT UINT64                    *Buffer,
+  IN  UINT64                    Value
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer = Value;
+}
diff --git a/MdePkg/Library/BaseLib/X64/CpuBreakpoint.asm b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.asm
new file mode 100644
index 000000000000..3370df4e1f0d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuBreakpoint.Asm
+;
+; Abstract:
+;
+;   CpuBreakpoint function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuBreakpoint (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuBreakpoint   PROC
+    int  3
+    ret
+CpuBreakpoint   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/CpuBreakpoint.c b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.c
new file mode 100644
index 000000000000..1e53141b4aa5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.c
@@ -0,0 +1,39 @@
+/** @file
+  CpuBreakpoint function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+void __debugbreak ();
+
+#pragma intrinsic(__debugbreak)
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __debugbreak ();
+}
+
diff --git a/MdePkg/Library/BaseLib/X64/CpuBreakpoint.nasm b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.nasm
new file mode 100644
index 000000000000..d39f8fe8317d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuBreakpoint.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuBreakpoint.Asm
+;
+; Abstract:
+;
+;   CpuBreakpoint function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuBreakpoint (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuBreakpoint)
+ASM_PFX(CpuBreakpoint):
+    int  3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/CpuId.S b/MdePkg/Library/BaseLib/X64/CpuId.S
new file mode 100644
index 000000000000..19ae1c796905
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuId.S
@@ -0,0 +1,60 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuId.S
+#
+# Abstract:
+#
+#   AsmCpuid function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+#  VOID
+#  EFIAPI
+#  AsmCpuid (
+#    IN   UINT32  RegisterInEax,
+#    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmCpuid)
+ASM_PFX(AsmCpuid):
+    push    %rbx
+    mov     %ecx, %eax
+    push    %rax                         # save Index on stack
+    push    %rdx
+    cpuid
+    test    %r9, %r9
+    jz      L1
+    mov     %ecx, (%r9)
+L1:
+    pop     %rcx
+    jrcxz   L2
+    mov     %eax, (%rcx)
+L2:
+    mov     %r8, %rcx
+    jrcxz   L3
+    mov     %ebx, (%rcx)
+L3:
+    mov     0x38(%rsp), %rcx
+    jrcxz   L4
+    mov     %edx, (%rcx)
+L4:
+    pop     %rax                         # restore Index to rax as return value
+    pop     %rbx
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/CpuId.asm b/MdePkg/Library/BaseLib/X64/CpuId.asm
new file mode 100644
index 000000000000..f38725453afd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuId.asm
@@ -0,0 +1,62 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  AsmCpuid (
+;    IN   UINT32  RegisterInEax,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+AsmCpuid    PROC    USES    rbx
+    mov     eax, ecx
+    push    rax                         ; save Index on stack
+    push    rdx
+    cpuid
+    test    r9, r9
+    jz      @F
+    mov     [r9], ecx
+@@:
+    pop     rcx
+    jrcxz   @F
+    mov     [rcx], eax
+@@:
+    mov     rcx, r8
+    jrcxz   @F
+    mov     [rcx], ebx
+@@:
+    mov     rcx, [rsp + 38h]
+    jrcxz   @F
+    mov     [rcx], edx
+@@:
+    pop     rax                         ; restore Index to rax as return value
+    ret
+AsmCpuid    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/CpuId.nasm b/MdePkg/Library/BaseLib/X64/CpuId.nasm
new file mode 100644
index 000000000000..3f3060f12be6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuId.nasm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CpuId.Asm
+;
+; Abstract:
+;
+;   AsmCpuid function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID
+;  EFIAPI
+;  AsmCpuid (
+;    IN   UINT32  RegisterInEax,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmCpuid)
+ASM_PFX(AsmCpuid):
+    push    rbx
+    mov     eax, ecx
+    push    rax                         ; save Index on stack
+    push    rdx
+    cpuid
+    test    r9, r9
+    jz      .0
+    mov     [r9], ecx
+.0:
+    pop     rcx
+    jrcxz   .1
+    mov     [rcx], eax
+.1:
+    mov     rcx, r8
+    jrcxz   .2
+    mov     [rcx], ebx
+.2:
+    mov     rcx, [rsp + 0x38]
+    jrcxz   .3
+    mov     [rcx], edx
+.3:
+    pop     rax                         ; restore Index to rax as return value
+    pop     rbx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/CpuIdEx.S b/MdePkg/Library/BaseLib/X64/CpuIdEx.S
new file mode 100644
index 000000000000..257120490584
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuIdEx.S
@@ -0,0 +1,62 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CpuIdEx.S
+#
+# Abstract:
+#
+#   AsmCpuidEx function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+#  UINT32
+#  EFIAPI
+#  AsmCpuidEx (
+#    IN   UINT32  RegisterInEax,
+#    IN   UINT32  RegisterInEcx,
+#    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+#    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmCpuidEx)
+ASM_PFX(AsmCpuidEx):
+    push    %rbx
+    movl    %ecx,%eax
+    movl    %edx,%ecx
+    push    %rax                  # save Index on stack
+    cpuid
+    mov     0x38(%rsp), %r10
+    test    %r10, %r10
+    jz      L1
+    mov     %ecx,(%r10)
+L1: 
+    mov     %r8, %rcx
+    jrcxz   L2
+    movl    %eax,(%rcx)
+L2: 
+    mov     %r9, %rcx
+    jrcxz   L3
+    mov     %ebx, (%rcx)
+L3: 
+    mov     0x40(%rsp), %rcx
+    jrcxz   L4
+    mov     %edx, (%rcx)
+L4: 
+    pop     %rax                  # restore Index to rax as return value
+    pop     %rbx
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/CpuIdEx.asm b/MdePkg/Library/BaseLib/X64/CpuIdEx.asm
new file mode 100644
index 000000000000..f4ea23ceabd0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuIdEx.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CpuIdEx.Asm
+;
+; Abstract:
+;
+;   AsmCpuidEx function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  UINT32
+;  EFIAPI
+;  AsmCpuidEx (
+;    IN   UINT32  RegisterInEax,
+;    IN   UINT32  RegisterInEcx,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+AsmCpuidEx  PROC    USES    rbx
+    mov     eax, ecx
+    mov     ecx, edx
+    push    rax                         ; save Index on stack
+    cpuid
+    mov     r10, [rsp + 38h]
+    test    r10, r10
+    jz      @F
+    mov     [r10], ecx
+@@:
+    mov     rcx, r8
+    jrcxz   @F
+    mov     [rcx], eax
+@@:
+    mov     rcx, r9
+    jrcxz   @F
+    mov     [rcx], ebx
+@@:
+    mov     rcx, [rsp + 40h]
+    jrcxz   @F
+    mov     [rcx], edx
+@@:
+    pop     rax                         ; restore Index to rax as return value
+    ret
+AsmCpuidEx  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/CpuIdEx.nasm b/MdePkg/Library/BaseLib/X64/CpuIdEx.nasm
new file mode 100644
index 000000000000..624b8dfb9a45
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuIdEx.nasm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CpuIdEx.Asm
+;
+; Abstract:
+;
+;   AsmCpuidEx function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  UINT32
+;  EFIAPI
+;  AsmCpuidEx (
+;    IN   UINT32  RegisterInEax,
+;    IN   UINT32  RegisterInEcx,
+;    OUT  UINT32  *RegisterOutEax  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEbx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEcx  OPTIONAL,
+;    OUT  UINT32  *RegisterOutEdx  OPTIONAL
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmCpuidEx)
+ASM_PFX(AsmCpuidEx):
+    push    rbx
+    mov     eax, ecx
+    mov     ecx, edx
+    push    rax                         ; save Index on stack
+    cpuid
+    mov     r10, [rsp + 0x38]
+    test    r10, r10
+    jz      .0
+    mov     [r10], ecx
+.0:
+    mov     rcx, r8
+    jrcxz   .1
+    mov     [rcx], eax
+.1:
+    mov     rcx, r9
+    jrcxz   .2
+    mov     [rcx], ebx
+.2:
+    mov     rcx, [rsp + 0x40]
+    jrcxz   .3
+    mov     [rcx], edx
+.3:
+    pop     rax                         ; restore Index to rax as return value
+    pop     rbx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/CpuPause.asm b/MdePkg/Library/BaseLib/X64/CpuPause.asm
new file mode 100644
index 000000000000..efb803441da1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuPause.asm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuPause.Asm
+;
+; Abstract:
+;
+;   CpuPause function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuPause (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+CpuPause    PROC
+    pause
+    ret
+CpuPause    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/CpuPause.nasm b/MdePkg/Library/BaseLib/X64/CpuPause.nasm
new file mode 100644
index 000000000000..83efe572a936
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/CpuPause.nasm
@@ -0,0 +1,37 @@
+;------------------------------------------------------------------------------ ;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CpuPause.Asm
+;
+; Abstract:
+;
+;   CpuPause function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; CpuPause (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(CpuPause)
+ASM_PFX(CpuPause):
+    pause
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/DisableCache.S b/MdePkg/Library/BaseLib/X64/DisableCache.S
new file mode 100644
index 000000000000..45c1a2220d2c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisableCache.S
@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   DisableCache.S
+#
+# Abstract:
+#
+#   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+#   WBINVD instruction.
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# AsmDisableCache (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmDisableCache)
+ASM_PFX(AsmDisableCache):
+    movq    %cr0, %rax
+    btsq    $30, %rax
+    btrq    $29, %rax
+    movq    %rax, %cr0
+    wbinvd
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/DisableCache.asm b/MdePkg/Library/BaseLib/X64/DisableCache.asm
new file mode 100644
index 000000000000..25c3c35c9b9e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisableCache.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisableCache.Asm
+;
+; Abstract:
+;
+;   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+;   WBINVD instruction.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmDisableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmDisableCache PROC
+    mov     rax, cr0
+    bts     rax, 30
+    btr     rax, 29
+    mov     cr0, rax
+    wbinvd
+    ret
+AsmDisableCache ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/DisableCache.nasm b/MdePkg/Library/BaseLib/X64/DisableCache.nasm
new file mode 100644
index 000000000000..9f565b1ec3c8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisableCache.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisableCache.Asm
+;
+; Abstract:
+;
+;   Set the CD bit of CR0 to 1, clear the NW bit of CR0 to 0, and flush all caches with a
+;   WBINVD instruction.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmDisableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmDisableCache)
+ASM_PFX(AsmDisableCache):
+    mov     rax, cr0
+    bts     rax, 30
+    btr     rax, 29
+    mov     cr0, rax
+    wbinvd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/DisableInterrupts.asm b/MdePkg/Library/BaseLib/X64/DisableInterrupts.asm
new file mode 100644
index 000000000000..b158fe83e77d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisableInterrupts.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisableInterrupts.Asm
+;
+; Abstract:
+;
+;   DisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; DisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+DisableInterrupts   PROC
+    cli
+    ret
+DisableInterrupts   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/DisableInterrupts.nasm b/MdePkg/Library/BaseLib/X64/DisableInterrupts.nasm
new file mode 100644
index 000000000000..eb11e14d3f35
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisableInterrupts.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   DisableInterrupts.Asm
+;
+; Abstract:
+;
+;   DisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; DisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(DisableInterrupts)
+ASM_PFX(DisableInterrupts):
+    cli
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/DisablePaging64.S b/MdePkg/Library/BaseLib/X64/DisablePaging64.S
new file mode 100644
index 000000000000..66d57f68bd74
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisablePaging64.S
@@ -0,0 +1,82 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   DisablePaging64.S
+#
+# Abstract:
+#
+#   AsmDisablePaging64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+    
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalX86DisablePaging64 (
+#   IN      UINT16                    Cs,
+#   IN      UINT32                    EntryPoint,
+#   IN      UINT32                    Context1,  OPTIONAL
+#   IN      UINT32                    Context2,  OPTIONAL
+#   IN      UINT32                    NewStack
+#   );
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalX86DisablePaging64)
+ASM_PFX(InternalX86DisablePaging64):
+    cli    
+    lea    L1(%rip), %rsi                 # rsi <- The start address of transition code
+    mov    0x28(%rsp), %edi               # rdi <- New stack
+    lea    _mTransitionEnd(%rip), %rax    # rax <- end of transition code
+    sub    %rsi, %rax                     # rax <- The size of transition piece code
+    add    $4, %rax                       # round rax up to the next 4 byte boundary
+    and    $0xfc, %al
+    sub    %rax, %rdi                     # rdi <- use stack to hold transition code 
+    mov    %edi, %r10d                    # r10 <- The start address of transicition code below 4G
+    push   %rcx                           # save rcx to stack
+    mov    %rax, %rcx                     # rcx <- The size of transition piece code
+    rep
+    movsb                                 # copy transition code to (new stack - 64byte) below 4G
+    pop    %rcx                           # restore rcx
+   
+    mov    %r8d, %esi 
+    mov    %r9d, %edi 
+    mov    %r10d, %eax
+    sub    $4, %eax
+    push   %rcx                           # push Cs to stack
+    push   %r10                           # push address of transition code on stack  
+    .byte  0x48, 0xcb                     # retq: Use far return to load CS register from stack
+                                          # (Use raw byte code since some GNU assemblers generates incorrect code for "retq")  
+L1:
+    mov    %eax,%esp                      # set up new stack
+    mov    %cr0,%rax
+    btr    $0x1f,%eax                     # clear CR0.PG
+    mov    %rax,%cr0                      # disable paging
+
+    mov    %edx,%ebx                      # save EntryPoint to ebx, for rdmsr will overwrite edx
+    mov    $0xc0000080,%ecx
+    rdmsr  
+    and    $0xfe,%ah                      # clear LME
+    wrmsr  
+    mov    %cr4,%rax
+    and    $0xdf,%al                      # clear PAE
+    mov    %rax,%cr4
+    push   %rdi                           # push Context2
+    push   %rsi                           # push Context1
+    callq  *%rbx                          # transfer control to EntryPoint
+    jmp    .                              # no one should get here
+
+_mTransitionEnd :
diff --git a/MdePkg/Library/BaseLib/X64/DisablePaging64.asm b/MdePkg/Library/BaseLib/X64/DisablePaging64.asm
new file mode 100644
index 000000000000..6772af80df64
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisablePaging64.asm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisablePaging64.Asm
+;
+; Abstract:
+;
+;   AsmDisablePaging64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86DisablePaging64 (
+;   IN      UINT16                    Cs,
+;   IN      UINT32                    EntryPoint,
+;   IN      UINT32                    Context1,  OPTIONAL
+;   IN      UINT32                    Context2,  OPTIONAL
+;   IN      UINT32                    NewStack
+;   );
+;------------------------------------------------------------------------------
+InternalX86DisablePaging64    PROC
+    cli
+    lea     rsi, @F                     ; rsi <- The start address of transition code
+    mov     edi, [rsp + 28h]            ; rdi <- New stack
+    lea     rax, mTransitionEnd         ; rax <- end of transition code
+    sub     rax, rsi                    ; rax <- The size of transition piece code 
+    add     rax, 4                      ; Round RAX up to the next 4 byte boundary
+    and     al, 0fch
+    sub     rdi, rax                    ; rdi <- Use stack to hold transition code
+    mov     r10d, edi                   ; r10 <- The start address of transicition code below 4G
+    push    rcx                         ; save rcx to stack
+    mov     rcx, rax                    ; rcx <- The size of transition piece code
+    rep     movsb                       ; copy transition code to top of new stack which must be below 4GB
+    pop     rcx                         ; restore rcx
+    
+    mov     esi, r8d
+    mov     edi, r9d
+    mov     eax, r10d                   ; eax <- start of the transition code on the stack
+    sub     eax, 4                      ; eax <- One slot below transition code on the stack
+    push    rcx                         ; push Cs to stack
+    push    r10                         ; push address of tansition code on stack
+    DB      48h                         ; prefix to composite "retq" with next "retf"
+    retf                                ; Use far return to load CS register from stack
+
+; Start of transition code
+@@:
+    mov     esp, eax                    ; set up new stack
+    mov     rax, cr0
+    btr     eax, 31                     ; Clear CR0.PG
+    mov     cr0, rax                    ; disable paging and caches
+    
+    mov     ebx, edx                    ; save EntryPoint to rbx, for rdmsr will overwrite rdx
+    mov     ecx, 0c0000080h
+    rdmsr
+    and     ah, NOT 1                   ; clear LME
+    wrmsr
+    mov     rax, cr4
+    and     al, NOT (1 SHL 5)           ; clear PAE
+    mov     cr4, rax
+    push    rdi                         ; push Context2
+    push    rsi                         ; push Context1
+    call    rbx                         ; transfer control to EntryPoint
+    hlt                                 ; no one should get here
+InternalX86DisablePaging64    ENDP
+
+mTransitionEnd LABEL    BYTE
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/DisablePaging64.nasm b/MdePkg/Library/BaseLib/X64/DisablePaging64.nasm
new file mode 100644
index 000000000000..9410b3503ec8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/DisablePaging64.nasm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   DisablePaging64.Asm
+;
+; Abstract:
+;
+;   AsmDisablePaging64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86DisablePaging64 (
+;   IN      UINT16                    Cs,
+;   IN      UINT32                    EntryPoint,
+;   IN      UINT32                    Context1,  OPTIONAL
+;   IN      UINT32                    Context2,  OPTIONAL
+;   IN      UINT32                    NewStack
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86DisablePaging64)
+ASM_PFX(InternalX86DisablePaging64):
+    cli
+    lea     rsi, [.0]                     ; rsi <- The start address of transition code
+    mov     edi, [rsp + 0x28]            ; rdi <- New stack
+    lea     rax, [mTransitionEnd]         ; rax <- end of transition code
+    sub     rax, rsi                    ; rax <- The size of transition piece code
+    add     rax, 4                      ; Round RAX up to the next 4 byte boundary
+    and     al, 0xfc
+    sub     rdi, rax                    ; rdi <- Use stack to hold transition code
+    mov     r10d, edi                   ; r10 <- The start address of transicition code below 4G
+    push    rcx                         ; save rcx to stack
+    mov     rcx, rax                    ; rcx <- The size of transition piece code
+    rep     movsb                       ; copy transition code to top of new stack which must be below 4GB
+    pop     rcx                         ; restore rcx
+
+    mov     esi, r8d
+    mov     edi, r9d
+    mov     eax, r10d                   ; eax <- start of the transition code on the stack
+    sub     eax, 4                      ; eax <- One slot below transition code on the stack
+    push    rcx                         ; push Cs to stack
+    push    r10                         ; push address of tansition code on stack
+    DB      0x48                         ; prefix to composite "retq" with next "retf"
+    retf                                ; Use far return to load CS register from stack
+
+; Start of transition code
+.0:
+    mov     esp, eax                    ; set up new stack
+    mov     rax, cr0
+    btr     eax, 31                     ; Clear CR0.PG
+    mov     cr0, rax                    ; disable paging and caches
+
+    mov     ebx, edx                    ; save EntryPoint to rbx, for rdmsr will overwrite rdx
+    mov     ecx, 0xc0000080
+    rdmsr
+    and     ah, ~ 1                   ; clear LME
+    wrmsr
+    mov     rax, cr4
+    and     al, ~ (1 << 5)           ; clear PAE
+    mov     cr4, rax
+    push    rdi                         ; push Context2
+    push    rsi                         ; push Context1
+    call    rbx                         ; transfer control to EntryPoint
+    hlt                                 ; no one should get here
+
+mTransitionEnd:
+
diff --git a/MdePkg/Library/BaseLib/X64/EnableCache.S b/MdePkg/Library/BaseLib/X64/EnableCache.S
new file mode 100644
index 000000000000..fe2bb1089e47
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableCache.S
@@ -0,0 +1,39 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   EnableCache.S
+#
+# Abstract:
+#
+#   Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear 
+#   the NW bit of CR0 to 0
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# AsmEnableCache (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(AsmEnableCache)
+ASM_PFX(AsmEnableCache):
+    wbinvd
+    movq    %cr0, %rax
+    btrq    $30, %rax
+    btrq    $29, %rax
+    movq    %rax, %cr0
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/EnableCache.asm b/MdePkg/Library/BaseLib/X64/EnableCache.asm
new file mode 100644
index 000000000000..9dd30d58798a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableCache.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   EnableCache.Asm
+;
+; Abstract:
+;
+;  Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear 
+;  the NW bit of CR0 to 0
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmEnableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmEnableCache PROC
+    wbinvd
+    mov     rax, cr0
+    btr     rax, 29
+    btr     rax, 30
+    mov     cr0, rax
+    ret
+AsmEnableCache ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/EnableCache.nasm b/MdePkg/Library/BaseLib/X64/EnableCache.nasm
new file mode 100644
index 000000000000..317ee8c859c2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableCache.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   EnableCache.Asm
+;
+; Abstract:
+;
+;  Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear
+;  the NW bit of CR0 to 0
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmEnableCache (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmEnableCache)
+ASM_PFX(AsmEnableCache):
+    wbinvd
+    mov     rax, cr0
+    btr     rax, 29
+    btr     rax, 30
+    mov     cr0, rax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.S b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.S
new file mode 100644
index 000000000000..0ffc6e9d6496
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.S
@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   EnableDisableInterrupts.S
+#
+# Abstract:
+#
+#   EnableDisableInterrupts function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# EnableDisableInterrupts (
+#   VOID
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(EnableDisableInterrupts)
+ASM_PFX(EnableDisableInterrupts):
+    sti
+    cli
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.asm b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.asm
new file mode 100644
index 000000000000..274acfbce39e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnableDisableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableDisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableDisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+EnableDisableInterrupts PROC
+    sti
+    cli
+    ret
+EnableDisableInterrupts ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.nasm b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.nasm
new file mode 100644
index 000000000000..ad90580c8b2d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableDisableInterrupts.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnableDisableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableDisableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableDisableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(EnableDisableInterrupts)
+ASM_PFX(EnableDisableInterrupts):
+    sti
+    cli
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/EnableInterrupts.asm b/MdePkg/Library/BaseLib/X64/EnableInterrupts.asm
new file mode 100644
index 000000000000..84954ad45831
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableInterrupts.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+EnableInterrupts    PROC
+    sti
+    ret
+EnableInterrupts    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/EnableInterrupts.nasm b/MdePkg/Library/BaseLib/X64/EnableInterrupts.nasm
new file mode 100644
index 000000000000..2b9f67c52f18
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/EnableInterrupts.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   EnableInterrupts.Asm
+;
+; Abstract:
+;
+;   EnableInterrupts function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; EnableInterrupts (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(EnableInterrupts)
+ASM_PFX(EnableInterrupts):
+    sti
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/FlushCacheLine.asm b/MdePkg/Library/BaseLib/X64/FlushCacheLine.asm
new file mode 100644
index 000000000000..b5823308be1b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FlushCacheLine.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FlushCacheLine.Asm
+;
+; Abstract:
+;
+;   AsmFlushCacheLine function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI 
+; AsmFlushCacheLine (
+;   IN      VOID                      *LinearAddress
+;   );
+;------------------------------------------------------------------------------
+AsmFlushCacheLine   PROC
+    clflush [rcx]
+    mov     rax, rcx
+    ret
+AsmFlushCacheLine   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/FlushCacheLine.nasm b/MdePkg/Library/BaseLib/X64/FlushCacheLine.nasm
new file mode 100644
index 000000000000..6fff99395059
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FlushCacheLine.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FlushCacheLine.Asm
+;
+; Abstract:
+;
+;   AsmFlushCacheLine function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; AsmFlushCacheLine (
+;   IN      VOID                      *LinearAddress
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmFlushCacheLine)
+ASM_PFX(AsmFlushCacheLine):
+    clflush [rcx]
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/FxRestore.asm b/MdePkg/Library/BaseLib/X64/FxRestore.asm
new file mode 100644
index 000000000000..337df3c32ebf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FxRestore.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxRestore.Asm
+;
+; Abstract:
+;
+;   AsmFxRestore function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxRestore (
+;   IN CONST IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+InternalX86FxRestore  PROC
+    fxrstor [rcx]
+    ret
+InternalX86FxRestore  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/FxRestore.nasm b/MdePkg/Library/BaseLib/X64/FxRestore.nasm
new file mode 100644
index 000000000000..6b2db0e80c45
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FxRestore.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxRestore.Asm
+;
+; Abstract:
+;
+;   AsmFxRestore function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxRestore (
+;   IN CONST IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86FxRestore)
+ASM_PFX(InternalX86FxRestore):
+    fxrstor [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/FxSave.asm b/MdePkg/Library/BaseLib/X64/FxSave.asm
new file mode 100644
index 000000000000..484c8644cbc9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FxSave.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxSave.Asm
+;
+; Abstract:
+;
+;   AsmFxSave function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxSave (
+;   OUT IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+InternalX86FxSave PROC
+    fxsave  [rcx]
+    ret
+InternalX86FxSave ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/FxSave.nasm b/MdePkg/Library/BaseLib/X64/FxSave.nasm
new file mode 100644
index 000000000000..f729b3af0f71
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/FxSave.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   FxSave.Asm
+;
+; Abstract:
+;
+;   AsmFxSave function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86FxSave (
+;   OUT IA32_FX_BUFFER *Buffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86FxSave)
+ASM_PFX(InternalX86FxSave):
+    fxsave  [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/GccInline.c b/MdePkg/Library/BaseLib/X64/GccInline.c
new file mode 100644
index 000000000000..c519a0fa9cd5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/GccInline.c
@@ -0,0 +1,1806 @@
+/** @file
+  GCC inline implementation of BaseLib processor specific functions.
+  
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BaseLibInternals.h"
+
+
+
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+  // This is a little bit of overkill and it is more about the compiler that it is
+  // actually processor synchronization. This is like the _ReadWriteBarrier 
+  // Microsoft specific intrinsic
+  __asm__ __volatile__ ("":::"memory");
+}
+
+
+/**
+  Enables CPU interrupts.
+
+  Enables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+EnableInterrupts (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("sti"::: "memory");
+}
+
+
+/**
+  Disables CPU interrupts.
+
+  Disables CPU interrupts.
+
+**/
+VOID
+EFIAPI
+DisableInterrupts (
+  VOID
+  )
+{  
+  __asm__ __volatile__ ("cli"::: "memory");
+}
+
+
+
+
+/**
+  Requests CPU to pause for a short period of time.
+
+  Requests CPU to pause for a short period of time. Typically used in MP
+  systems to prevent memory starvation while waiting for a spin lock.
+
+**/
+VOID
+EFIAPI
+CpuPause (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("pause");
+}
+
+
+/**
+  Generates a breakpoint on the CPU.
+
+  Generates a breakpoint on the CPU. The breakpoint must be implemented such
+  that code can resume normal execution after the breakpoint.
+
+**/
+VOID
+EFIAPI
+CpuBreakpoint (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("int $3");
+}
+
+
+
+/**
+  Returns a 64-bit Machine Specific Register(MSR).
+
+  Reads and returns the 64-bit MSR specified by Index. No parameter checking is
+  performed on Index, and some Index values may cause CPU exceptions. The
+  caller must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and X64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The value of the MSR identified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr64 (
+  IN      UINT32                    Index
+  )
+{
+  UINT32 LowData;
+  UINT32 HighData;
+  
+  __asm__ __volatile__ (
+    "rdmsr"
+    : "=a" (LowData),   // %0
+      "=d" (HighData)   // %1
+    : "c"  (Index)      // %2
+    );
+    
+  return (((UINT64)HighData) << 32) | LowData;
+}
+
+/**
+  Writes a 64-bit value to a Machine Specific Register(MSR), and returns the
+  value.
+
+  Writes the 64-bit value specified by Value to the MSR specified by Index. The
+  64-bit value written to the MSR is returned. No parameter checking is
+  performed on Index or Value, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and Value are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and X64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 64-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    Value
+  )
+{
+  UINT32 LowData;
+  UINT32 HighData;
+
+  LowData  = (UINT32)(Value);
+  HighData = (UINT32)(Value >> 32);
+  
+  __asm__ __volatile__ (
+    "wrmsr"
+    :
+    : "c" (Index),
+      "a" (LowData),
+      "d" (HighData)
+    );
+    
+  return Value;
+}
+
+
+
+/**
+  Reads the current value of the EFLAGS register.
+
+  Reads and returns the current value of the EFLAGS register. This function is
+  only available on IA-32 and X64. This returns a 32-bit value on IA-32 and a
+  64-bit value on X64.
+
+  @return EFLAGS on IA-32 or RFLAGS on X64.
+
+**/
+UINTN
+EFIAPI
+AsmReadEflags (
+  VOID
+  )
+{
+  UINTN Eflags;
+  
+  __asm__ __volatile__ (
+    "pushfq         \n\t"
+    "pop     %0         "
+    : "=r" (Eflags)       // %0
+    );
+    
+  return Eflags;
+}
+
+
+
+/**
+  Reads the current value of the Control Register 0 (CR0).
+
+  Reads and returns the current value of CR0. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 0 (CR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr0 (
+  VOID
+  )
+{
+  UINTN   Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%cr0,%0" 
+    : "=r" (Data)           // %0
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of the Control Register 2 (CR2).
+
+  Reads and returns the current value of CR2. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 2 (CR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr2 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%cr2,  %0" 
+    : "=r" (Data)           // %0
+    );
+  
+  return Data;
+}
+
+/**
+  Reads the current value of the Control Register 3 (CR3).
+
+  Reads and returns the current value of CR3. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 3 (CR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr3 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%cr3,  %0" 
+    : "=r" (Data)           // %0
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of the Control Register 4 (CR4).
+
+  Reads and returns the current value of CR4. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of the Control Register 4 (CR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadCr4 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%cr4,  %0" 
+    : "=r" (Data)           // %0
+    );
+  
+  return Data;
+}
+
+
+/**
+  Writes a value to Control Register 0 (CR0).
+
+  Writes and returns a new value to CR0. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr0 The value to write to CR0.
+
+  @return The value written to CR0.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr0 (
+  UINTN  Cr0
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%cr0"
+    :
+    : "r" (Cr0)
+    );
+  return Cr0;
+}
+
+
+/**
+  Writes a value to Control Register 2 (CR2).
+
+  Writes and returns a new value to CR2. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr2 The value to write to CR2.
+
+  @return The value written to CR2.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr2 (
+  UINTN  Cr2
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%cr2"
+    :
+    : "r" (Cr2)
+    );
+  return Cr2;
+}
+
+
+/**
+  Writes a value to Control Register 3 (CR3).
+
+  Writes and returns a new value to CR3. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr3 The value to write to CR3.
+
+  @return The value written to CR3.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr3 (
+  UINTN  Cr3
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%cr3"
+    :
+    : "r" (Cr3)
+    );
+  return Cr3;
+}
+
+
+/**
+  Writes a value to Control Register 4 (CR4).
+
+  Writes and returns a new value to CR4. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Cr4 The value to write to CR4.
+
+  @return The value written to CR4.
+
+**/
+UINTN
+EFIAPI
+AsmWriteCr4 (
+  UINTN  Cr4
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%cr4"
+    :
+    : "r" (Cr4)
+    );
+  return Cr4;
+}
+
+
+/**
+  Reads the current value of Debug Register 0 (DR0).
+
+  Reads and returns the current value of DR0. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr0 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr0, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 1 (DR1).
+
+  Reads and returns the current value of DR1. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr1 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr1, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 2 (DR2).
+
+  Reads and returns the current value of DR2. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr2 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr2, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 3 (DR3).
+
+  Reads and returns the current value of DR3. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr3 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr3, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 4 (DR4).
+
+  Reads and returns the current value of DR4. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr4 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr4, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 5 (DR5).
+
+  Reads and returns the current value of DR5. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr5 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr5, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 6 (DR6).
+
+  Reads and returns the current value of DR6. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr6 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr6, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Reads the current value of Debug Register 7 (DR7).
+
+  Reads and returns the current value of DR7. This function is only available
+  on IA-32 and X64. This returns a 32-bit value on IA-32 and a 64-bit value on
+  X64.
+
+  @return The value of Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmReadDr7 (
+  VOID
+  )
+{
+  UINTN Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%dr7, %0"
+    : "=r" (Data)
+    );
+  
+  return Data;
+}
+
+
+/**
+  Writes a value to Debug Register 0 (DR0).
+
+  Writes and returns a new value to DR0. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr0 The value to write to Dr0.
+
+  @return The value written to Debug Register 0 (DR0).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr0 (
+  UINTN  Dr0
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr0"
+    :
+    : "r" (Dr0)
+    );
+  return Dr0;
+}
+
+
+/**
+  Writes a value to Debug Register 1 (DR1).
+
+  Writes and returns a new value to DR1. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr1 The value to write to Dr1.
+
+  @return The value written to Debug Register 1 (DR1).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr1 (
+  UINTN  Dr1
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr1"
+    :
+    : "r" (Dr1)
+    );
+  return Dr1;
+}
+
+
+/**
+  Writes a value to Debug Register 2 (DR2).
+
+  Writes and returns a new value to DR2. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr2 The value to write to Dr2.
+
+  @return The value written to Debug Register 2 (DR2).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr2 (
+  UINTN  Dr2
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr2"
+    :
+    : "r" (Dr2)
+    );
+  return Dr2;
+}
+
+
+/**
+  Writes a value to Debug Register 3 (DR3).
+
+  Writes and returns a new value to DR3. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr3 The value to write to Dr3.
+
+  @return The value written to Debug Register 3 (DR3).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr3 (
+  UINTN  Dr3
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr3"
+    :
+    : "r" (Dr3)
+    );
+  return Dr3;
+}
+
+
+/**
+  Writes a value to Debug Register 4 (DR4).
+
+  Writes and returns a new value to DR4. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr4 The value to write to Dr4.
+
+  @return The value written to Debug Register 4 (DR4).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr4 (
+  UINTN  Dr4
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr4"
+    :
+    : "r" (Dr4)
+    );
+  return Dr4;
+}
+
+
+/**
+  Writes a value to Debug Register 5 (DR5).
+
+  Writes and returns a new value to DR5. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr5 The value to write to Dr5.
+
+  @return The value written to Debug Register 5 (DR5).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr5 (
+  UINTN  Dr5
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr5"
+    :
+    : "r" (Dr5)
+    );
+  return Dr5;
+}
+
+
+/**
+  Writes a value to Debug Register 6 (DR6).
+
+  Writes and returns a new value to DR6. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr6 The value to write to Dr6.
+
+  @return The value written to Debug Register 6 (DR6).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr6 (
+  UINTN  Dr6
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr6"
+    :
+    : "r" (Dr6)
+    );
+  return Dr6;
+}
+
+
+/**
+  Writes a value to Debug Register 7 (DR7).
+
+  Writes and returns a new value to DR7. This function is only available on
+  IA-32 and X64. This writes a 32-bit value on IA-32 and a 64-bit value on X64.
+
+  @param  Dr7 The value to write to Dr7.
+
+  @return The value written to Debug Register 7 (DR7).
+
+**/
+UINTN
+EFIAPI
+AsmWriteDr7 (
+  UINTN  Dr7
+  )
+{
+  __asm__ __volatile__ (
+    "mov  %0, %%dr7"
+    :
+    : "r" (Dr7)
+    );
+  return Dr7;
+}
+
+
+/**
+  Reads the current value of Code Segment Register (CS).
+
+  Reads and returns the current value of CS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of CS.
+
+**/
+UINT16
+EFIAPI
+AsmReadCs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov   %%cs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Data Segment Register (DS).
+
+  Reads and returns the current value of DS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of DS.
+
+**/
+UINT16
+EFIAPI
+AsmReadDs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%ds, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Extra Segment Register (ES).
+
+  Reads and returns the current value of ES. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of ES.
+
+**/
+UINT16
+EFIAPI
+AsmReadEs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%es, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of FS Data Segment Register (FS).
+
+  Reads and returns the current value of FS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of FS.
+
+**/
+UINT16
+EFIAPI
+AsmReadFs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%fs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of GS Data Segment Register (GS).
+
+  Reads and returns the current value of GS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of GS.
+
+**/
+UINT16
+EFIAPI
+AsmReadGs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%gs, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Stack Segment Register (SS).
+
+  Reads and returns the current value of SS. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of SS.
+
+**/
+UINT16
+EFIAPI
+AsmReadSs (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "mov  %%ds, %0"
+    :"=a" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of Task Register (TR).
+
+  Reads and returns the current value of TR. This function is only available on
+  IA-32 and X64.
+
+  @return The current value of TR.
+
+**/
+UINT16
+EFIAPI
+AsmReadTr (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "str  %0"
+    : "=r" (Data)
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and X64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadGdtr (
+  OUT     IA32_DESCRIPTOR           *Gdtr
+  )
+{
+  __asm__ __volatile__ (
+    "sgdt %0"
+    : "=m" (*Gdtr)
+    );
+}
+
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  )
+{
+  __asm__ __volatile__ (
+    "lgdt %0"
+    :
+    : "m" (*Gdtr)
+    );
+    
+}
+
+
+/**
+  Reads the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and X64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86ReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  )
+{
+  __asm__ __volatile__ (
+    "sidt  %0"
+    : "=m" (*Idtr)
+    );
+}
+
+
+/**
+  Writes the current Interrupt Descriptor Table Register(GDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+InternalX86WriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  )
+{
+  __asm__ __volatile__ (
+    "lidt %0"
+    :
+    : "m" (*Idtr)
+    );
+}
+
+
+/**
+  Reads the current Local Descriptor Table Register(LDTR) selector.
+
+  Reads and returns the current 16-bit LDTR descriptor value. This function is
+  only available on IA-32 and X64.
+
+  @return The current selector of LDT.
+
+**/
+UINT16
+EFIAPI
+AsmReadLdtr (
+  VOID
+  )
+{
+  UINT16  Data;
+  
+  __asm__ __volatile__ (
+    "sldt  %0"
+    : "=g" (Data)   // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Writes the current Local Descriptor Table Register (GDTR) selector.
+
+  Writes and the current LDTR descriptor specified by Ldtr. This function is
+  only available on IA-32 and X64.
+
+  @param  Ldtr  16-bit LDTR selector value.
+
+**/
+VOID
+EFIAPI
+AsmWriteLdtr (
+  IN      UINT16                    Ldtr
+  )
+{
+  __asm__ __volatile__ (
+    "lldtw  %0"
+    :
+    : "g" (Ldtr)   // %0
+    );
+}
+
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and X64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxSave (
+  OUT     IA32_FX_BUFFER            *Buffer
+  )
+{
+  __asm__ __volatile__ (
+    "fxsave %0"
+    :
+    : "m" (*Buffer)  // %0
+    );    
+}
+
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and X64.
+
+  @param  Buffer  The pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+InternalX86FxRestore (
+  IN      CONST IA32_FX_BUFFER      *Buffer
+  )
+{
+  __asm__ __volatile__ (
+    "fxrstor %0"
+    :
+    : "m" (*Buffer)  // %0
+    );
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #0 (MM0).
+
+  Reads and returns the current value of MM0. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM0.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm0 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd   %%mm0,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #1 (MM1).
+
+  Reads and returns the current value of MM1. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM1.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm1 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd   %%mm1,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #2 (MM2).
+
+  Reads and returns the current value of MM2. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM2.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm2 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm2,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #3 (MM3).
+
+  Reads and returns the current value of MM3. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM3.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm3 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm3,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #4 (MM4).
+
+  Reads and returns the current value of MM4. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM4.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm4 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm4,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #5 (MM5).
+
+  Reads and returns the current value of MM5. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM5.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm5 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm5,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #6 (MM6).
+
+  Reads and returns the current value of MM6. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM6.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm6 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm6,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Reads the current value of 64-bit MMX Register #7 (MM7).
+
+  Reads and returns the current value of MM7. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of MM7.
+
+**/
+UINT64
+EFIAPI
+AsmReadMm7 (
+  VOID
+  )
+{
+  UINT64  Data;
+
+  __asm__ __volatile__ (
+    "movd  %%mm7,  %0    \n\t"
+    : "=r"  (Data)       // %0
+    );
+    
+  return Data;
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #0 (MM0).
+
+  Writes the current value of MM0. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM0.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm0 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm0"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #1 (MM1).
+
+  Writes the current value of MM1. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM1.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm1 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm1"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #2 (MM2).
+
+  Writes the current value of MM2. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM2.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm2 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm2"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #3 (MM3).
+
+  Writes the current value of MM3. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM3.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm3 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm3"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #4 (MM4).
+
+  Writes the current value of MM4. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM4.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm4 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm4"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #5 (MM5).
+
+  Writes the current value of MM5. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM5.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm5 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm5"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #6 (MM6).
+
+  Writes the current value of MM6. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM6.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm6 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm6"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Writes the current value of 64-bit MMX Register #7 (MM7).
+
+  Writes the current value of MM7. This function is only available on IA32 and
+  X64.
+
+  @param  Value The 64-bit value to write to MM7.
+
+**/
+VOID
+EFIAPI
+AsmWriteMm7 (
+  IN      UINT64                    Value
+  )
+{
+  __asm__ __volatile__ (
+    "movd  %0, %%mm7"  // %0
+    :  
+    : "m" (Value)
+    );
+}
+
+
+/**
+  Reads the current value of Time Stamp Counter (TSC).
+
+  Reads and returns the current value of TSC. This function is only available
+  on IA-32 and X64.
+
+  @return The current value of TSC
+
+**/
+UINT64
+EFIAPI
+AsmReadTsc (
+  VOID
+  )
+{
+  UINT32  LowData;
+  UINT32  HiData;
+  
+  __asm__ __volatile__ (
+    "rdtsc"
+    : "=a" (LowData),
+      "=d" (HiData)
+    );
+  
+  return (((UINT64)HiData) << 32) | LowData;  
+}
+
+
+/**
+  Reads the current value of a Performance Counter (PMC).
+
+  Reads and returns the current value of performance counter specified by
+  Index. This function is only available on IA-32 and X64.
+
+  @param  Index The 32-bit Performance Counter index to read.
+
+  @return The value of the PMC specified by Index.
+
+**/
+UINT64
+EFIAPI
+AsmReadPmc (
+  IN      UINT32                    Index
+  )
+{
+  UINT32  LowData;
+  UINT32  HiData;
+  
+  __asm__ __volatile__ (
+    "rdpmc"
+    : "=a" (LowData),
+      "=d" (HiData)
+    : "c"  (Index)
+    );
+  
+  return (((UINT64)HiData) << 32) | LowData;  
+}
+
+
+/**
+  Sets up a monitor buffer that is used by AsmMwait().
+
+  Executes a MONITOR instruction with the register state specified by Eax, Ecx
+  and Edx. Returns Eax. This function is only available on IA-32 and X64.
+
+  @param  Eax The value to load into EAX or RAX before executing the MONITOR
+              instruction.
+  @param  Ecx The value to load into ECX or RCX before executing the MONITOR
+              instruction.
+  @param  Edx The value to load into EDX or RDX before executing the MONITOR
+              instruction.
+
+  @return Eax
+
+**/
+UINTN
+EFIAPI
+AsmMonitor (
+  IN      UINTN                     Eax,
+  IN      UINTN                     Ecx,
+  IN      UINTN                     Edx
+  )
+{
+  __asm__ __volatile__ (
+    "monitor"
+    :
+    : "a" (Eax),
+      "c" (Ecx),
+      "d" (Edx)
+    );
+    
+  return Eax;
+}
+
+
+/**
+  Executes an MWAIT instruction.
+
+  Executes an MWAIT instruction with the register state specified by Eax and
+  Ecx. Returns Eax. This function is only available on IA-32 and X64.
+
+  @param  Eax The value to load into EAX or RAX before executing the MONITOR
+              instruction.
+  @param  Ecx The value to load into ECX or RCX before executing the MONITOR
+              instruction.
+
+  @return Eax
+
+**/
+UINTN
+EFIAPI
+AsmMwait (
+  IN      UINTN                     Eax,
+  IN      UINTN                     Ecx
+  )
+{
+  __asm__ __volatile__ (
+    "mwait"
+    : 
+    : "a"  (Eax),
+      "c"  (Ecx)
+    );
+    
+  return Eax;    
+}
+
+
+/**
+  Executes a WBINVD instruction.
+
+  Executes a WBINVD instruction. This function is only available on IA-32 and
+  X64.
+
+**/
+VOID
+EFIAPI
+AsmWbinvd (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("wbinvd":::"memory");
+}
+
+
+/**
+  Executes a INVD instruction.
+
+  Executes a INVD instruction. This function is only available on IA-32 and
+  X64.
+
+**/
+VOID
+EFIAPI
+AsmInvd (
+  VOID
+  )
+{
+  __asm__ __volatile__ ("invd":::"memory");
+    
+}
+
+
+/**
+  Flushes a cache line from all the instruction and data caches within the
+  coherency domain of the CPU.
+
+  Flushed the cache line specified by LinearAddress, and returns LinearAddress.
+  This function is only available on IA-32 and X64.
+
+  @param  LinearAddress The address of the cache line to flush. If the CPU is
+                        in a physical addressing mode, then LinearAddress is a
+                        physical address. If the CPU is in a virtual
+                        addressing mode, then LinearAddress is a virtual
+                        address.
+
+  @return LinearAddress
+**/
+VOID *
+EFIAPI
+AsmFlushCacheLine (
+  IN      VOID                      *LinearAddress
+  )
+{
+  __asm__ __volatile__ (
+    "clflush (%0)"
+    :
+    : "r" (LinearAddress) 
+    : "memory"
+    );
+    
+    return LinearAddress;
+}
+
+
diff --git a/MdePkg/Library/BaseLib/X64/Invd.asm b/MdePkg/Library/BaseLib/X64/Invd.asm
new file mode 100644
index 000000000000..765a2e6de6da
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Invd.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Invd.Asm
+;
+; Abstract:
+;
+;   AsmInvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmInvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmInvd PROC
+    invd
+    ret
+AsmInvd ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/Invd.nasm b/MdePkg/Library/BaseLib/X64/Invd.nasm
new file mode 100644
index 000000000000..8fcd18794f6e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Invd.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Invd.Asm
+;
+; Abstract:
+;
+;   AsmInvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmInvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmInvd)
+ASM_PFX(AsmInvd):
+    invd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/LongJump.S b/MdePkg/Library/BaseLib/X64/LongJump.S
new file mode 100644
index 000000000000..a210068aaa1e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/LongJump.S
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   LongJump.S
+#
+# Abstract:
+#
+#   Implementation of _LongJump() on x64.
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# VOID
+# EFIAPI
+# InternalLongJump (
+#   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+#   IN      UINTN                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalLongJump)
+ASM_PFX(InternalLongJump):
+    mov     (%rcx), %rbx
+    mov     0x8(%rcx), %rsp
+    mov     0x10(%rcx), %rbp
+    mov     0x18(%rcx), %rdi
+    mov     0x20(%rcx), %rsi
+    mov     0x28(%rcx), %r12
+    mov     0x30(%rcx), %r13
+    mov     0x38(%rcx), %r14
+    mov     0x40(%rcx), %r15
+    # load non-volatile fp registers
+    ldmxcsr 0x50(%rcx)
+    movdqu  0x58(%rcx), %xmm6
+    movdqu  0x68(%rcx), %xmm7
+    movdqu  0x78(%rcx), %xmm8
+    movdqu  0x88(%rcx), %xmm9
+    movdqu  0x98(%rcx), %xmm10
+    movdqu  0xA8(%rcx), %xmm11
+    movdqu  0xB8(%rcx), %xmm12
+    movdqu  0xC8(%rcx), %xmm13
+    movdqu  0xD8(%rcx), %xmm14
+    movdqu  0xE8(%rcx), %xmm15  
+    mov     %rdx, %rax          # set return value
+    jmp     *0x48(%rcx)
diff --git a/MdePkg/Library/BaseLib/X64/LongJump.asm b/MdePkg/Library/BaseLib/X64/LongJump.asm
new file mode 100644
index 000000000000..40d77bd8b1ee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/LongJump.asm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   LongJump.Asm
+;
+; Abstract:
+;
+;   Implementation of _LongJump() on x64.
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalLongJump (
+;   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+;   IN      UINTN                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalLongJump    PROC
+    mov     rbx, [rcx]
+    mov     rsp, [rcx + 8]
+    mov     rbp, [rcx + 10h]
+    mov     rdi, [rcx + 18h]
+    mov     rsi, [rcx + 20h]
+    mov     r12, [rcx + 28h]
+    mov     r13, [rcx + 30h]
+    mov     r14, [rcx + 38h]
+    mov     r15, [rcx + 40h]
+    ; load non-volatile fp registers
+    ldmxcsr [rcx + 50h]
+    movdqu  xmm6,  [rcx + 58h]
+    movdqu  xmm7,  [rcx + 68h]
+    movdqu  xmm8,  [rcx + 78h]
+    movdqu  xmm9,  [rcx + 88h]
+    movdqu  xmm10, [rcx + 98h]
+    movdqu  xmm11, [rcx + 0A8h]
+    movdqu  xmm12, [rcx + 0B8h]
+    movdqu  xmm13, [rcx + 0C8h]
+    movdqu  xmm14, [rcx + 0D8h]
+    movdqu  xmm15, [rcx + 0E8h]
+    mov     rax, rdx               ; set return value
+    jmp     qword ptr [rcx + 48h]
+InternalLongJump    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/LongJump.nasm b/MdePkg/Library/BaseLib/X64/LongJump.nasm
new file mode 100644
index 000000000000..ea6b4d5ba29d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/LongJump.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   LongJump.Asm
+;
+; Abstract:
+;
+;   Implementation of _LongJump() on x64.
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalLongJump (
+;   IN      BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer,
+;   IN      UINTN                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalLongJump)
+ASM_PFX(InternalLongJump):
+    mov     rbx, [rcx]
+    mov     rsp, [rcx + 8]
+    mov     rbp, [rcx + 0x10]
+    mov     rdi, [rcx + 0x18]
+    mov     rsi, [rcx + 0x20]
+    mov     r12, [rcx + 0x28]
+    mov     r13, [rcx + 0x30]
+    mov     r14, [rcx + 0x38]
+    mov     r15, [rcx + 0x40]
+    ; load non-volatile fp registers
+    ldmxcsr [rcx + 0x50]
+    movdqu  xmm6,  [rcx + 0x58]
+    movdqu  xmm7,  [rcx + 0x68]
+    movdqu  xmm8,  [rcx + 0x78]
+    movdqu  xmm9,  [rcx + 0x88]
+    movdqu  xmm10, [rcx + 0x98]
+    movdqu  xmm11, [rcx + 0xA8]
+    movdqu  xmm12, [rcx + 0xB8]
+    movdqu  xmm13, [rcx + 0xC8]
+    movdqu  xmm14, [rcx + 0xD8]
+    movdqu  xmm15, [rcx + 0xE8]
+    mov     rax, rdx               ; set return value
+    jmp     qword [rcx + 0x48]
+
diff --git a/MdePkg/Library/BaseLib/X64/Monitor.asm b/MdePkg/Library/BaseLib/X64/Monitor.asm
new file mode 100644
index 000000000000..d20591c7dbac
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Monitor.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Monitor.Asm
+;
+; Abstract:
+;
+;   AsmMonitor function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmMonitor (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx,
+;   IN      UINTN                     Edx
+;   );
+;------------------------------------------------------------------------------
+AsmMonitor  PROC
+    mov     eax, ecx
+    mov     ecx, edx
+    mov     edx, r8d
+    DB      0fh, 1, 0c8h                ; monitor
+    ret
+AsmMonitor  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/Monitor.nasm b/MdePkg/Library/BaseLib/X64/Monitor.nasm
new file mode 100644
index 000000000000..980678a61659
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Monitor.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Monitor.Asm
+;
+; Abstract:
+;
+;   AsmMonitor function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmMonitor (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx,
+;   IN      UINTN                     Edx
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmMonitor)
+ASM_PFX(AsmMonitor):
+    mov     eax, ecx
+    mov     ecx, edx
+    mov     edx, r8d
+    DB      0xf, 1, 0xc8                ; monitor
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/Mwait.asm b/MdePkg/Library/BaseLib/X64/Mwait.asm
new file mode 100644
index 000000000000..d98eea54a4c2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Mwait.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Mwait.Asm
+;
+; Abstract:
+;
+;   AsmMwait function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmMwait (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx
+;   );
+;------------------------------------------------------------------------------
+AsmMwait    PROC
+    mov     eax, ecx
+    mov     ecx, edx
+    DB      0fh, 1, 0c9h                ; mwait
+    ret
+AsmMwait    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/Mwait.nasm b/MdePkg/Library/BaseLib/X64/Mwait.nasm
new file mode 100644
index 000000000000..912d7a294c07
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Mwait.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Mwait.Asm
+;
+; Abstract:
+;
+;   AsmMwait function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmMwait (
+;   IN      UINTN                     Eax,
+;   IN      UINTN                     Ecx
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmMwait)
+ASM_PFX(AsmMwait):
+    mov     eax, ecx
+    mov     ecx, edx
+    DB      0xf, 1, 0xc9                ; mwait
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/Non-existing.c b/MdePkg/Library/BaseLib/X64/Non-existing.c
new file mode 100644
index 000000000000..76503e37a8ee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Non-existing.c
@@ -0,0 +1,153 @@
+/** @file
+  Non-existing BaseLib functions on x64
+
+  Copyright (c) 2006 - 2008, 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 <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Enables the 32-bit paging mode on the CPU.
+
+  Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode. This function is
+  only available on IA-32. After the 32-bit paging mode is enabled, control is
+  transferred to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit protected mode with flat descriptors. This
+      means all descriptors must have a base of 0 and a limit of 4GB.
+  3)  CR0 and CR4 must be compatible with 32-bit protected mode with flat
+      descriptors.
+  4)  CR3 must point to valid page tables that will be used once the transition
+      is complete, and those page tables must guarantee that the pages for this
+      function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is enabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is enabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is enabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+InternalX86EnablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  //
+  // This function cannot work on x64 platform
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Disables the 32-bit paging mode on the CPU.
+
+  Disables the 32-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 32-paged protected
+  mode. This function is only available on IA-32. After the 32-bit paging mode
+  is disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be NULL. The function EntryPoint must never return.
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit paged mode.
+  3)  CR0, CR3, and CR4 must be compatible with 32-bit paged mode.
+  4)  CR3 must point to valid page tables that guarantee that the pages for
+      this function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is disabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is disabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is
+                      disabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+InternalX86DisablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  //
+  // This function cannot work on x64 platform
+  //
+  ASSERT (FALSE);
+}
+
+
+/**
+  Enables the 64-bit paging mode on the CPU.
+
+  Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode with flat
+  descriptors. This function is only available on IA-32. After the 64-bit
+  paging mode is enabled, control is transferred to the function specified by
+  EntryPoint using the new stack specified by NewStack and passing in the
+  parameters specified by Context1 and Context2. Context1 and Context2 are
+  optional and may be 0. The function EntryPoint must never return.
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for long mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is enabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is enabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is enabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+InternalX86EnablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT64                    EntryPoint,
+  IN      UINT64                    Context1,  OPTIONAL
+  IN      UINT64                    Context2,  OPTIONAL
+  IN      UINT64                    NewStack
+  )
+{
+  //
+  // This function cannot work on x64 platform.
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/BaseLib/X64/RdRand.S b/MdePkg/Library/BaseLib/X64/RdRand.S
new file mode 100644
index 000000000000..0556979c25e1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/RdRand.S
@@ -0,0 +1,72 @@
+#------------------------------------------------------------------------------ ;
+# Copyright (c) 2015 - 2016, 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.
+#
+# Module Name:
+#
+#   RdRand.S
+#
+# Abstract:
+#
+#   Generates random number through CPU RdRand instruction under 64-bit platform.
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//  Generates a 16 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand16)
+ASM_PFX(InternalX86RdRand16):
+    .byte  0x0f, 0xc7, 0xf0        // rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 // jmp if CF=1
+    xor    %rax, %rax              // reg=0 if CF=0
+    ret                            // return with failure status
+rn16_ok:
+    mov    %ax, (%rcx)
+    mov    $0x1, %rax
+    ret
+
+//------------------------------------------------------------------------------
+//  Generates a 32 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand32)
+ASM_PFX(InternalX86RdRand32):
+    .byte  0x0f, 0xc7, 0xf0        // rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 // jmp if CF=1
+    xor    %rax, %rax              // reg=0 if CF=0
+    ret                            // return with failure status
+rn32_ok:
+    mov    %eax, (%rcx)
+    mov    $0x1, %rax
+    ret
+
+//------------------------------------------------------------------------------
+//  Generates a 64 bit random number through RDRAND instruction.
+//  Return TRUE if Rand generated successfully, or FALSE if not.
+//
+//  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Rand);
+//------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalX86RdRand64)
+ASM_PFX(InternalX86RdRand64):
+    .byte  0x48, 0x0f, 0xc7, 0xf0  // rdrand r64: "REX.W + 0f c7 /6 ModRM:r/m(w)"
+    jc     rn64_ok                 // jmp if CF=1
+    xor    %rax, %rax              // reg=0 if CF=0
+    ret                            // return with failure status
+rn64_ok:
+    mov    %rax, (%rcx)
+    mov    $0x1, %rax
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/RdRand.asm b/MdePkg/Library/BaseLib/X64/RdRand.asm
new file mode 100644
index 000000000000..e378ba05965f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/RdRand.asm
@@ -0,0 +1,83 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2015 - 2016, 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.
+;
+; Module Name:
+;
+;   RdRand.asm
+;
+; Abstract:
+;
+;   Generates random number through CPU RdRand instruction under 64-bit platform.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  Generates a 16 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+;------------------------------------------------------------------------------
+InternalX86RdRand16  PROC
+    ; rdrand   ax                  ; generate a 16 bit RN into eax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0fh, 0c7h, 0f0h         ; rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn16_ok:
+    mov    [rcx], ax
+    mov    rax,  1
+    ret
+InternalX86RdRand16 ENDP
+
+;------------------------------------------------------------------------------
+;  Generates a 32 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+;------------------------------------------------------------------------------
+InternalX86RdRand32  PROC
+    ; rdrand   eax                 ; generate a 32 bit RN into eax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0fh, 0c7h, 0f0h         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn32_ok:
+    mov    [rcx], eax
+    mov    rax,  1
+    ret
+InternalX86RdRand32 ENDP
+
+;------------------------------------------------------------------------------
+;  Generates a 64 bit random number through one RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Random);
+;------------------------------------------------------------------------------
+InternalX86RdRand64  PROC
+    ; rdrand   rax                 ; generate a 64 bit RN into rax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     048h, 0fh, 0c7h, 0f0h   ; rdrand r64: "REX.W + 0f c7 /6 ModRM:r/m(w)"
+    jc     rn64_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn64_ok:
+    mov    [rcx], rax
+    mov    rax, 1
+    ret
+InternalX86RdRand64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/RdRand.nasm b/MdePkg/Library/BaseLib/X64/RdRand.nasm
new file mode 100644
index 000000000000..e1a21eb70521
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/RdRand.nasm
@@ -0,0 +1,83 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2015 - 2016, 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.
+;
+; Module Name:
+;
+;   RdRand.nasm
+;
+; Abstract:
+;
+;   Generates random number through CPU RdRand instruction under 64-bit platform.
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  Generates a 16 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand16 (UINT16 *Rand);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand16)
+ASM_PFX(InternalX86RdRand16):
+    ; rdrand   ax                  ; generate a 16 bit RN into eax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0xf, 0xc7, 0xf0         ; rdrand r16: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn16_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn16_ok:
+    mov    [rcx], ax
+    mov    rax,  1
+    ret
+
+;------------------------------------------------------------------------------
+;  Generates a 32 bit random number through RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand32 (UINT32 *Rand);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand32)
+ASM_PFX(InternalX86RdRand32):
+    ; rdrand   eax                 ; generate a 32 bit RN into eax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0xf, 0xc7, 0xf0         ; rdrand r32: "0f c7 /6  ModRM:r/m(w)"
+    jc     rn32_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn32_ok:
+    mov    [rcx], eax
+    mov    rax,  1
+    ret
+
+;------------------------------------------------------------------------------
+;  Generates a 64 bit random number through one RDRAND instruction.
+;  Return TRUE if Rand generated successfully, or FALSE if not.
+;
+;  BOOLEAN EFIAPI InternalX86RdRand64 (UINT64 *Random);
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86RdRand64)
+ASM_PFX(InternalX86RdRand64):
+    ; rdrand   rax                 ; generate a 64 bit RN into rax,
+                                   ; CF=1 if RN generated ok, otherwise CF=0
+    db     0x48, 0xf, 0xc7, 0xf0   ; rdrand r64: "REX.W + 0f c7 /6 ModRM:r/m(w)"
+    jc     rn64_ok                 ; jmp if CF=1
+    xor    rax, rax                ; reg=0 if CF=0
+    ret                            ; return with failure status
+rn64_ok:
+    mov    [rcx], rax
+    mov    rax, 1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr0.asm b/MdePkg/Library/BaseLib/X64/ReadCr0.asm
new file mode 100644
index 000000000000..dc038a9bd1f4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr0.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr0.Asm
+;
+; Abstract:
+;
+;   AsmReadCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr0  PROC
+    mov     rax, cr0
+    ret
+AsmReadCr0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr0.nasm b/MdePkg/Library/BaseLib/X64/ReadCr0.nasm
new file mode 100644
index 000000000000..0c6e2f97dbfa
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr0.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr0.Asm
+;
+; Abstract:
+;
+;   AsmReadCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr0)
+ASM_PFX(AsmReadCr0):
+    mov     rax, cr0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr2.asm b/MdePkg/Library/BaseLib/X64/ReadCr2.asm
new file mode 100644
index 000000000000..ad7e866a2b07
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr2.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr2.Asm
+;
+; Abstract:
+;
+;   AsmReadCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr2  PROC
+    mov     rax, cr2
+    ret
+AsmReadCr2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr2.nasm b/MdePkg/Library/BaseLib/X64/ReadCr2.nasm
new file mode 100644
index 000000000000..45055ec162b1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr2.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr2.Asm
+;
+; Abstract:
+;
+;   AsmReadCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr2)
+ASM_PFX(AsmReadCr2):
+    mov     rax, cr2
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr3.asm b/MdePkg/Library/BaseLib/X64/ReadCr3.asm
new file mode 100644
index 000000000000..f5328e498d2c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr3.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr3.Asm
+;
+; Abstract:
+;
+;   AsmReadCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr3  PROC
+    mov     rax, cr3
+    ret
+AsmReadCr3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr3.nasm b/MdePkg/Library/BaseLib/X64/ReadCr3.nasm
new file mode 100644
index 000000000000..3a3a93586858
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr3.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr3.Asm
+;
+; Abstract:
+;
+;   AsmReadCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr3)
+ASM_PFX(AsmReadCr3):
+    mov     rax, cr3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr4.asm b/MdePkg/Library/BaseLib/X64/ReadCr4.asm
new file mode 100644
index 000000000000..89c6729ecb76
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr4.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr4.Asm
+;
+; Abstract:
+;
+;   AsmReadCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCr4  PROC
+    mov     rax, cr4
+    ret
+AsmReadCr4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadCr4.nasm b/MdePkg/Library/BaseLib/X64/ReadCr4.nasm
new file mode 100644
index 000000000000..68b6028e7194
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCr4.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCr4.Asm
+;
+; Abstract:
+;
+;   AsmReadCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadCr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCr4)
+ASM_PFX(AsmReadCr4):
+    mov     rax, cr4
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadCs.asm b/MdePkg/Library/BaseLib/X64/ReadCs.asm
new file mode 100644
index 000000000000..00d435d33c32
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCs.Asm
+;
+; Abstract:
+;
+;   AsmReadCs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadCs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadCs   PROC
+    mov     eax, cs
+    ret
+AsmReadCs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadCs.nasm b/MdePkg/Library/BaseLib/X64/ReadCs.nasm
new file mode 100644
index 000000000000..e5d09cb95858
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadCs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadCs.Asm
+;
+; Abstract:
+;
+;   AsmReadCs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadCs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadCs)
+ASM_PFX(AsmReadCs):
+    mov     eax, cs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr0.asm b/MdePkg/Library/BaseLib/X64/ReadDr0.asm
new file mode 100644
index 000000000000..8f5f1d4814c7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr0.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr0.Asm
+;
+; Abstract:
+;
+;   AsmReadDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr0  PROC
+    mov     rax, dr0
+    ret
+AsmReadDr0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr0.nasm b/MdePkg/Library/BaseLib/X64/ReadDr0.nasm
new file mode 100644
index 000000000000..bf5955a7a9cc
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr0.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr0.Asm
+;
+; Abstract:
+;
+;   AsmReadDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr0)
+ASM_PFX(AsmReadDr0):
+    mov     rax, dr0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr1.asm b/MdePkg/Library/BaseLib/X64/ReadDr1.asm
new file mode 100644
index 000000000000..1bc00731605d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr1.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr1.Asm
+;
+; Abstract:
+;
+;   AsmReadDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr1  PROC
+    mov     rax, dr1
+    ret
+AsmReadDr1  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr1.nasm b/MdePkg/Library/BaseLib/X64/ReadDr1.nasm
new file mode 100644
index 000000000000..a797490a8007
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr1.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr1.Asm
+;
+; Abstract:
+;
+;   AsmReadDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr1)
+ASM_PFX(AsmReadDr1):
+    mov     rax, dr1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr2.asm b/MdePkg/Library/BaseLib/X64/ReadDr2.asm
new file mode 100644
index 000000000000..b6162de8e26b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr2.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr2.Asm
+;
+; Abstract:
+;
+;   AsmReadDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr2  PROC
+    mov     rax, dr2
+    ret
+AsmReadDr2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr2.nasm b/MdePkg/Library/BaseLib/X64/ReadDr2.nasm
new file mode 100644
index 000000000000..2ef64f45249c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr2.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr2.Asm
+;
+; Abstract:
+;
+;   AsmReadDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr2)
+ASM_PFX(AsmReadDr2):
+    mov     rax, dr2
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr3.asm b/MdePkg/Library/BaseLib/X64/ReadDr3.asm
new file mode 100644
index 000000000000..7bcd2abb0f27
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr3.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr3.Asm
+;
+; Abstract:
+;
+;   AsmReadDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr3  PROC
+    mov     rax, dr3
+    ret
+AsmReadDr3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr3.nasm b/MdePkg/Library/BaseLib/X64/ReadDr3.nasm
new file mode 100644
index 000000000000..1222185d4491
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr3.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr3.Asm
+;
+; Abstract:
+;
+;   AsmReadDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr3)
+ASM_PFX(AsmReadDr3):
+    mov     rax, dr3
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr4.asm b/MdePkg/Library/BaseLib/X64/ReadDr4.asm
new file mode 100644
index 000000000000..79133141bbbf
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr4.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr4.Asm
+;
+; Abstract:
+;
+;   AsmReadDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr4  PROC
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0fh, 21h, 0e0h
+    ret
+AsmReadDr4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr4.nasm b/MdePkg/Library/BaseLib/X64/ReadDr4.nasm
new file mode 100644
index 000000000000..c8d158195647
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr4.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr4.Asm
+;
+; Abstract:
+;
+;   AsmReadDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr4)
+ASM_PFX(AsmReadDr4):
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0xf, 0x21, 0xe0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr5.asm b/MdePkg/Library/BaseLib/X64/ReadDr5.asm
new file mode 100644
index 000000000000..a54ab7974acb
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr5.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr5.Asm
+;
+; Abstract:
+;
+;   AsmReadDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr5  PROC
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0fh, 21h, 0e8h
+    ret
+AsmReadDr5  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr5.nasm b/MdePkg/Library/BaseLib/X64/ReadDr5.nasm
new file mode 100644
index 000000000000..771e71c4bc87
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr5.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr5.Asm
+;
+; Abstract:
+;
+;   AsmReadDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr5)
+ASM_PFX(AsmReadDr5):
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0xf, 0x21, 0xe8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr6.asm b/MdePkg/Library/BaseLib/X64/ReadDr6.asm
new file mode 100644
index 000000000000..770f377d9c6e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr6.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr6.Asm
+;
+; Abstract:
+;
+;   AsmReadDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr6  PROC
+    mov     rax, dr6
+    ret
+AsmReadDr6  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr6.nasm b/MdePkg/Library/BaseLib/X64/ReadDr6.nasm
new file mode 100644
index 000000000000..a75656d2e0b7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr6.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr6.Asm
+;
+; Abstract:
+;
+;   AsmReadDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr6)
+ASM_PFX(AsmReadDr6):
+    mov     rax, dr6
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr7.asm b/MdePkg/Library/BaseLib/X64/ReadDr7.asm
new file mode 100644
index 000000000000..e2806824d748
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr7.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr7.Asm
+;
+; Abstract:
+;
+;   AsmReadDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDr7  PROC
+    mov     rax, dr7
+    ret
+AsmReadDr7  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDr7.nasm b/MdePkg/Library/BaseLib/X64/ReadDr7.nasm
new file mode 100644
index 000000000000..65d8f76bcf5e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDr7.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDr7.Asm
+;
+; Abstract:
+;
+;   AsmReadDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadDr7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDr7)
+ASM_PFX(AsmReadDr7):
+    mov     rax, dr7
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadDs.asm b/MdePkg/Library/BaseLib/X64/ReadDs.asm
new file mode 100644
index 000000000000..8d3161daf47b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDs.Asm
+;
+; Abstract:
+;
+;   AsmReadDs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadDs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadDs   PROC
+    mov     eax, ds
+    ret
+AsmReadDs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadDs.nasm b/MdePkg/Library/BaseLib/X64/ReadDs.nasm
new file mode 100644
index 000000000000..6eba940ad7f1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadDs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadDs.Asm
+;
+; Abstract:
+;
+;   AsmReadDs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadDs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadDs)
+ASM_PFX(AsmReadDs):
+    mov     eax, ds
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadEflags.asm b/MdePkg/Library/BaseLib/X64/ReadEflags.asm
new file mode 100644
index 000000000000..2b61ab25e675
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadEflags.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEflags.Asm
+;
+; Abstract:
+;
+;   AsmReadEflags function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadEflags (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadEflags   PROC
+    pushfq
+    pop     rax
+    ret
+AsmReadEflags   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadEflags.nasm b/MdePkg/Library/BaseLib/X64/ReadEflags.nasm
new file mode 100644
index 000000000000..98d4b49fc67b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadEflags.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEflags.Asm
+;
+; Abstract:
+;
+;   AsmReadEflags function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmReadEflags (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadEflags)
+ASM_PFX(AsmReadEflags):
+    pushfq
+    pop     rax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadEs.asm b/MdePkg/Library/BaseLib/X64/ReadEs.asm
new file mode 100644
index 000000000000..2ea99466b867
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadEs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEs.Asm
+;
+; Abstract:
+;
+;   AsmReadEs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadEs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadEs   PROC
+    mov     eax, es
+    ret
+AsmReadEs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadEs.nasm b/MdePkg/Library/BaseLib/X64/ReadEs.nasm
new file mode 100644
index 000000000000..ea016d88042e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadEs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadEs.Asm
+;
+; Abstract:
+;
+;   AsmReadEs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadEs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadEs)
+ASM_PFX(AsmReadEs):
+    mov     eax, es
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadFs.asm b/MdePkg/Library/BaseLib/X64/ReadFs.asm
new file mode 100644
index 000000000000..665835fe3158
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadFs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadFs.Asm
+;
+; Abstract:
+;
+;   AsmReadFs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadFs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadFs   PROC
+    mov     eax, fs
+    ret
+AsmReadFs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadFs.nasm b/MdePkg/Library/BaseLib/X64/ReadFs.nasm
new file mode 100644
index 000000000000..123790e41417
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadFs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadFs.Asm
+;
+; Abstract:
+;
+;   AsmReadFs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadFs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadFs)
+ASM_PFX(AsmReadFs):
+    mov     eax, fs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadGdtr.asm b/MdePkg/Library/BaseLib/X64/ReadGdtr.asm
new file mode 100644
index 000000000000..d5ff99810737
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadGdtr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadGdtr (
+;   OUT IA32_DESCRIPTOR  *Gdtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86ReadGdtr   PROC
+    sgdt    fword ptr [rcx]
+    ret
+InternalX86ReadGdtr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadGdtr.nasm b/MdePkg/Library/BaseLib/X64/ReadGdtr.nasm
new file mode 100644
index 000000000000..0f51605c7585
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadGdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadGdtr (
+;   OUT IA32_DESCRIPTOR  *Gdtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86ReadGdtr)
+ASM_PFX(InternalX86ReadGdtr):
+    sgdt    [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadGs.asm b/MdePkg/Library/BaseLib/X64/ReadGs.asm
new file mode 100644
index 000000000000..b3b12131484c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadGs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGs.Asm
+;
+; Abstract:
+;
+;   AsmReadGs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadGs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadGs   PROC
+    mov     eax, gs
+    ret
+AsmReadGs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadGs.nasm b/MdePkg/Library/BaseLib/X64/ReadGs.nasm
new file mode 100644
index 000000000000..87864547f9f3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadGs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadGs.Asm
+;
+; Abstract:
+;
+;   AsmReadGs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadGs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadGs)
+ASM_PFX(AsmReadGs):
+    mov     eax, gs
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadIdtr.asm b/MdePkg/Library/BaseLib/X64/ReadIdtr.asm
new file mode 100644
index 000000000000..8ebe348f38c7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadIdtr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadIdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadIdtr (
+;   OUT     IA32_DESCRIPTOR           *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86ReadIdtr   PROC
+    sidt    fword ptr [rcx]
+    ret
+InternalX86ReadIdtr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadIdtr.nasm b/MdePkg/Library/BaseLib/X64/ReadIdtr.nasm
new file mode 100644
index 000000000000..cfc32c7ae5ad
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadIdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadIdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86ReadIdtr (
+;   OUT     IA32_DESCRIPTOR           *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86ReadIdtr)
+ASM_PFX(InternalX86ReadIdtr):
+    sidt    [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadLdtr.asm b/MdePkg/Library/BaseLib/X64/ReadLdtr.asm
new file mode 100644
index 000000000000..6b656f56a387
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadLdtr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadLdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadLdtr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadLdtr PROC
+    sldt    eax
+    ret
+AsmReadLdtr ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadLdtr.nasm b/MdePkg/Library/BaseLib/X64/ReadLdtr.nasm
new file mode 100644
index 000000000000..9fbf5ac57495
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadLdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadLdtr.Asm
+;
+; Abstract:
+;
+;   AsmReadLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadLdtr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadLdtr)
+ASM_PFX(AsmReadLdtr):
+    sldt    eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm0.asm b/MdePkg/Library/BaseLib/X64/ReadMm0.asm
new file mode 100644
index 000000000000..881597f22411
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm0.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm0.Asm
+;
+; Abstract:
+;
+;   AsmReadMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm0  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0c0h
+    ret
+AsmReadMm0  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm0.nasm b/MdePkg/Library/BaseLib/X64/ReadMm0.nasm
new file mode 100644
index 000000000000..a69149bcb315
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm0.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm0.Asm
+;
+; Abstract:
+;
+;   AsmReadMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm0 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm0)
+ASM_PFX(AsmReadMm0):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xc0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm1.asm b/MdePkg/Library/BaseLib/X64/ReadMm1.asm
new file mode 100644
index 000000000000..d3fa0edf388d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm1.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm1.Asm
+;
+; Abstract:
+;
+;   AsmReadMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm1  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0c8h
+    ret
+AsmReadMm1  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm1.nasm b/MdePkg/Library/BaseLib/X64/ReadMm1.nasm
new file mode 100644
index 000000000000..917494cc0b9f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm1.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm1.Asm
+;
+; Abstract:
+;
+;   AsmReadMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm1 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm1)
+ASM_PFX(AsmReadMm1):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xc8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm2.asm b/MdePkg/Library/BaseLib/X64/ReadMm2.asm
new file mode 100644
index 000000000000..552789b3934b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm2.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm2.Asm
+;
+; Abstract:
+;
+;   AsmReadMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm2  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0d0h
+    ret
+AsmReadMm2  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm2.nasm b/MdePkg/Library/BaseLib/X64/ReadMm2.nasm
new file mode 100644
index 000000000000..d31c34aee396
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm2.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm2.Asm
+;
+; Abstract:
+;
+;   AsmReadMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm2 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm2)
+ASM_PFX(AsmReadMm2):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xd0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm3.asm b/MdePkg/Library/BaseLib/X64/ReadMm3.asm
new file mode 100644
index 000000000000..473b42edfe87
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm3.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm3.Asm
+;
+; Abstract:
+;
+;   AsmReadMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm3  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0d8h
+    ret
+AsmReadMm3  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm3.nasm b/MdePkg/Library/BaseLib/X64/ReadMm3.nasm
new file mode 100644
index 000000000000..9cabaa220019
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm3.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm3.Asm
+;
+; Abstract:
+;
+;   AsmReadMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm3 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm3)
+ASM_PFX(AsmReadMm3):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xd8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm4.asm b/MdePkg/Library/BaseLib/X64/ReadMm4.asm
new file mode 100644
index 000000000000..23f54818cdd4
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm4.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm4.Asm
+;
+; Abstract:
+;
+;   AsmReadMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm4  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0e0h
+    ret
+AsmReadMm4  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm4.nasm b/MdePkg/Library/BaseLib/X64/ReadMm4.nasm
new file mode 100644
index 000000000000..7eae1fdfc206
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm4.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm4.Asm
+;
+; Abstract:
+;
+;   AsmReadMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm4 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm4)
+ASM_PFX(AsmReadMm4):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xe0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm5.asm b/MdePkg/Library/BaseLib/X64/ReadMm5.asm
new file mode 100644
index 000000000000..c6bdaa362084
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm5.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm5.Asm
+;
+; Abstract:
+;
+;   AsmReadMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm5  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0e8h
+    ret
+AsmReadMm5  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm5.nasm b/MdePkg/Library/BaseLib/X64/ReadMm5.nasm
new file mode 100644
index 000000000000..4784d6a12e12
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm5.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm5.Asm
+;
+; Abstract:
+;
+;   AsmReadMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm5 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm5)
+ASM_PFX(AsmReadMm5):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xe8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm6.asm b/MdePkg/Library/BaseLib/X64/ReadMm6.asm
new file mode 100644
index 000000000000..fc9d4023899e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm6.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm6.Asm
+;
+; Abstract:
+;
+;   AsmReadMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm6  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0f0h
+    ret
+AsmReadMm6  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm6.nasm b/MdePkg/Library/BaseLib/X64/ReadMm6.nasm
new file mode 100644
index 000000000000..58f8b98874c3
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm6.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm6.Asm
+;
+; Abstract:
+;
+;   AsmReadMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm6 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm6)
+ASM_PFX(AsmReadMm6):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xf0
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm7.asm b/MdePkg/Library/BaseLib/X64/ReadMm7.asm
new file mode 100644
index 000000000000..1700a08be95f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm7.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm7.Asm
+;
+; Abstract:
+;
+;   AsmReadMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadMm7  PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 7eh, 0f8h
+    ret
+AsmReadMm7  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMm7.nasm b/MdePkg/Library/BaseLib/X64/ReadMm7.nasm
new file mode 100644
index 000000000000..46e480777f3d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMm7.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMm7.Asm
+;
+; Abstract:
+;
+;   AsmReadMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMm7 (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMm7)
+ASM_PFX(AsmReadMm7):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x7e, 0xf8
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMsr64.asm b/MdePkg/Library/BaseLib/X64/ReadMsr64.asm
new file mode 100644
index 000000000000..8f63932667ad
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMsr64.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMsr64.Asm
+;
+; Abstract:
+;
+;   AsmReadMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMsr64 (
+;   IN UINT32  Index
+;   );
+;------------------------------------------------------------------------------
+AsmReadMsr64    PROC
+    rdmsr                               ; edx & eax are zero extended
+    shl     rdx, 20h
+    or      rax, rdx
+    ret
+AsmReadMsr64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadMsr64.c b/MdePkg/Library/BaseLib/X64/ReadMsr64.c
new file mode 100644
index 000000000000..06a9dbc7a10a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMsr64.c
@@ -0,0 +1,39 @@
+/** @file
+  CpuBreakpoint function.
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+unsigned __int64 __readmsr (int register);
+
+#pragma intrinsic(__readmsr)
+
+/**
+  Read data to MSR.
+
+  @param  Index                Register index of MSR.
+
+  @return Value read from MSR.
+
+**/
+UINT64
+EFIAPI
+AsmReadMsr64 (
+  IN UINT32  Index
+  )
+{
+  return __readmsr (Index);
+}
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadMsr64.nasm b/MdePkg/Library/BaseLib/X64/ReadMsr64.nasm
new file mode 100644
index 000000000000..650be2c5d308
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadMsr64.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadMsr64.Asm
+;
+; Abstract:
+;
+;   AsmReadMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadMsr64 (
+;   IN UINT32  Index
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadMsr64)
+ASM_PFX(AsmReadMsr64):
+    rdmsr                               ; edx & eax are zero extended
+    shl     rdx, 0x20
+    or      rax, rdx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadPmc.asm b/MdePkg/Library/BaseLib/X64/ReadPmc.asm
new file mode 100644
index 000000000000..dcdf7effb6cd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadPmc.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadPmc.Asm
+;
+; Abstract:
+;
+;   AsmReadPmc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadPmc (
+;   IN UINT32   PmcIndex
+;   );
+;------------------------------------------------------------------------------
+AsmReadPmc  PROC
+    rdpmc
+    shl     rdx, 20h
+    or      rax, rdx
+    ret
+AsmReadPmc  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadPmc.nasm b/MdePkg/Library/BaseLib/X64/ReadPmc.nasm
new file mode 100644
index 000000000000..507e9b61521d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadPmc.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadPmc.Asm
+;
+; Abstract:
+;
+;   AsmReadPmc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadPmc (
+;   IN UINT32   PmcIndex
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadPmc)
+ASM_PFX(AsmReadPmc):
+    rdpmc
+    shl     rdx, 0x20
+    or      rax, rdx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadSs.asm b/MdePkg/Library/BaseLib/X64/ReadSs.asm
new file mode 100644
index 000000000000..a845f3e2700d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadSs.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadSs.Asm
+;
+; Abstract:
+;
+;   AsmReadSs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadSs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadSs   PROC
+    mov     eax, ss
+    ret
+AsmReadSs   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadSs.nasm b/MdePkg/Library/BaseLib/X64/ReadSs.nasm
new file mode 100644
index 000000000000..be764baee9ee
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadSs.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadSs.Asm
+;
+; Abstract:
+;
+;   AsmReadSs function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadSs (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadSs)
+ASM_PFX(AsmReadSs):
+    mov     eax, ss
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadTr.asm b/MdePkg/Library/BaseLib/X64/ReadTr.asm
new file mode 100644
index 000000000000..e7a6349b2526
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadTr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTr.Asm
+;
+; Abstract:
+;
+;   AsmReadTr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadTr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadTr   PROC
+    str     eax
+    ret
+AsmReadTr   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadTr.nasm b/MdePkg/Library/BaseLib/X64/ReadTr.nasm
new file mode 100644
index 000000000000..df2f7d773680
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadTr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTr.Asm
+;
+; Abstract:
+;
+;   AsmReadTr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; AsmReadTr (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadTr)
+ASM_PFX(AsmReadTr):
+    str     eax
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/ReadTsc.asm b/MdePkg/Library/BaseLib/X64/ReadTsc.asm
new file mode 100644
index 000000000000..0d51ca451223
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadTsc.asm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTsc.Asm
+;
+; Abstract:
+;
+;   AsmReadTsc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadTsc (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmReadTsc  PROC
+    rdtsc
+    shl     rdx, 20h
+    or      rax, rdx
+    ret
+AsmReadTsc  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/ReadTsc.nasm b/MdePkg/Library/BaseLib/X64/ReadTsc.nasm
new file mode 100644
index 000000000000..61fa2f0f38a7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/ReadTsc.nasm
@@ -0,0 +1,40 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ReadTsc.Asm
+;
+; Abstract:
+;
+;   AsmReadTsc function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmReadTsc (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmReadTsc)
+ASM_PFX(AsmReadTsc):
+    rdtsc
+    shl     rdx, 0x20
+    or      rax, rdx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/SetJump.S b/MdePkg/Library/BaseLib/X64/SetJump.S
new file mode 100644
index 000000000000..57fe094c4e41
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SetJump.S
@@ -0,0 +1,53 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetJump.S
+#
+# Abstract:
+#
+#   Implementation of SetJump() on x86_64
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(SetJump)
+ASM_PFX(SetJump):
+    push   %rcx
+    add    $0xffffffffffffffe0,%rsp
+    call   ASM_PFX(InternalAssertJumpBuffer)
+    add    $0x20,%rsp
+    pop    %rcx
+    pop    %rdx
+    mov    %rbx,(%rcx)
+    mov    %rsp,0x8(%rcx)
+    mov    %rbp,0x10(%rcx)
+    mov    %rdi,0x18(%rcx)
+    mov    %rsi,0x20(%rcx)
+    mov    %r12,0x28(%rcx)
+    mov    %r13,0x30(%rcx)
+    mov    %r14,0x38(%rcx)
+    mov    %r15,0x40(%rcx)
+    mov    %rdx,0x48(%rcx)
+    # save non-volatile fp registers
+    stmxcsr 0x50(%rcx)
+    movdqu  %xmm6, 0x58(%rcx) 
+    movdqu  %xmm7, 0x68(%rcx)
+    movdqu  %xmm8, 0x78(%rcx)
+    movdqu  %xmm9, 0x88(%rcx)
+    movdqu  %xmm10, 0x98(%rcx)
+    movdqu  %xmm11, 0xA8(%rcx)
+    movdqu  %xmm12, 0xB8(%rcx)
+    movdqu  %xmm13, 0xC8(%rcx)
+    movdqu  %xmm14, 0xD8(%rcx)
+    movdqu  %xmm15, 0xE8(%rcx)     
+    xor    %rax,%rax
+    jmpq   *%rdx
diff --git a/MdePkg/Library/BaseLib/X64/SetJump.asm b/MdePkg/Library/BaseLib/X64/SetJump.asm
new file mode 100644
index 000000000000..9564d6b1ffc5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SetJump.asm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetJump.Asm
+;
+; Abstract:
+;
+;   Implementation of SetJump() on x64.
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+EXTERN   InternalAssertJumpBuffer:PROC
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; SetJump (
+;   OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+;   );
+;------------------------------------------------------------------------------
+SetJump     PROC
+    push    rcx
+    add     rsp, -20h
+    call    InternalAssertJumpBuffer
+    add     rsp, 20h
+    pop     rcx
+    pop     rdx
+    mov     [rcx], rbx
+    mov     [rcx + 8], rsp
+    mov     [rcx + 10h], rbp
+    mov     [rcx + 18h], rdi
+    mov     [rcx + 20h], rsi
+    mov     [rcx + 28h], r12
+    mov     [rcx + 30h], r13
+    mov     [rcx + 38h], r14
+    mov     [rcx + 40h], r15
+    mov     [rcx + 48h], rdx
+    ; save non-volatile fp registers
+    stmxcsr [rcx + 50h]
+    movdqu  [rcx + 58h], xmm6
+    movdqu  [rcx + 68h], xmm7
+    movdqu  [rcx + 78h], xmm8
+    movdqu  [rcx + 88h], xmm9
+    movdqu  [rcx + 98h], xmm10
+    movdqu  [rcx + 0A8h], xmm11
+    movdqu  [rcx + 0B8h], xmm12
+    movdqu  [rcx + 0C8h], xmm13
+    movdqu  [rcx + 0D8h], xmm14
+    movdqu  [rcx + 0E8h], xmm15
+    xor     rax, rax
+    jmp     rdx
+SetJump     ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/SetJump.nasm b/MdePkg/Library/BaseLib/X64/SetJump.nasm
new file mode 100644
index 000000000000..530b89b8ce74
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SetJump.nasm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetJump.Asm
+;
+; Abstract:
+;
+;   Implementation of SetJump() on x64.
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+extern ASM_PFX(InternalAssertJumpBuffer)
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; SetJump (
+;   OUT     BASE_LIBRARY_JUMP_BUFFER  *JumpBuffer
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(SetJump)
+ASM_PFX(SetJump):
+    push    rcx
+    add     rsp, -0x20
+    call    ASM_PFX(InternalAssertJumpBuffer)
+    add     rsp, 0x20
+    pop     rcx
+    pop     rdx
+    mov     [rcx], rbx
+    mov     [rcx + 8], rsp
+    mov     [rcx + 0x10], rbp
+    mov     [rcx + 0x18], rdi
+    mov     [rcx + 0x20], rsi
+    mov     [rcx + 0x28], r12
+    mov     [rcx + 0x30], r13
+    mov     [rcx + 0x38], r14
+    mov     [rcx + 0x40], r15
+    mov     [rcx + 0x48], rdx
+    ; save non-volatile fp registers
+    stmxcsr [rcx + 0x50]
+    movdqu  [rcx + 0x58], xmm6
+    movdqu  [rcx + 0x68], xmm7
+    movdqu  [rcx + 0x78], xmm8
+    movdqu  [rcx + 0x88], xmm9
+    movdqu  [rcx + 0x98], xmm10
+    movdqu  [rcx + 0xA8], xmm11
+    movdqu  [rcx + 0xB8], xmm12
+    movdqu  [rcx + 0xC8], xmm13
+    movdqu  [rcx + 0xD8], xmm14
+    movdqu  [rcx + 0xE8], xmm15
+    xor     rax, rax
+    jmp     rdx
+
diff --git a/MdePkg/Library/BaseLib/X64/SwitchStack.S b/MdePkg/Library/BaseLib/X64/SwitchStack.S
new file mode 100644
index 000000000000..705c7c8d6a0e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SwitchStack.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SwitchStack.S
+#
+# Abstract:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# Routine Description:
+#
+#   Routine for switching stacks with 2 parameters
+#
+# Arguments:
+#
+#   (rcx) EntryPoint    - Entry point with new stack.
+#   (rdx) Context1      - Parameter1 for entry point.
+#   (r8)  Context2      - Parameter2 for entry point.
+#   (r9)  NewStack      - The pointer to new stack.
+#
+# Returns:
+#
+#   None
+#
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalSwitchStack)
+ASM_PFX(InternalSwitchStack):
+	  pushq   %rbp            
+  	movq    %rsp, %rbp
+    
+    mov     %rcx, %rax  // Shift registers for new call
+    mov     %rdx, %rcx
+    mov     %r8, %rdx
+    #
+    # Reserve space for register parameters (rcx, rdx, r8 & r9) on the stack,
+    # in case the callee wishes to spill them.
+    #
+    lea     -0x20(%r9), %rsp
+    pushq   $0        // stop gdb stack unwind
+    jmp     *%rax     // call EntryPoint ()
diff --git a/MdePkg/Library/BaseLib/X64/SwitchStack.asm b/MdePkg/Library/BaseLib/X64/SwitchStack.asm
new file mode 100644
index 000000000000..999a6fb6d373
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SwitchStack.asm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SwitchStack.Asm
+;
+; Abstract:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; Routine Description:
+;
+;   Routine for switching stacks with 2 parameters
+;
+; Arguments:
+;
+;   (rcx) EntryPoint    - Entry point with new stack.
+;   (rdx) Context1      - Parameter1 for entry point.
+;   (r8)  Context2      - Parameter2 for entry point.
+;   (r9)  NewStack      - The pointer to new stack.
+;
+; Returns:
+;
+;   None
+;
+;------------------------------------------------------------------------------
+InternalSwitchStack PROC
+    mov     rax, rcx
+    mov     rcx, rdx
+    mov     rdx, r8
+    ;
+    ; Reserve space for register parameters (rcx, rdx, r8 & r9) on the stack,
+    ; in case the callee wishes to spill them.
+    ;
+    lea     rsp, [r9 - 20h]
+    call    rax
+InternalSwitchStack ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/SwitchStack.nasm b/MdePkg/Library/BaseLib/X64/SwitchStack.nasm
new file mode 100644
index 000000000000..652baf6b0f35
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/SwitchStack.nasm
@@ -0,0 +1,51 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SwitchStack.Asm
+;
+; Abstract:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; Routine Description:
+;
+;   Routine for switching stacks with 2 parameters
+;
+; Arguments:
+;
+;   (rcx) EntryPoint    - Entry point with new stack.
+;   (rdx) Context1      - Parameter1 for entry point.
+;   (r8)  Context2      - Parameter2 for entry point.
+;   (r9)  NewStack      - The pointer to new stack.
+;
+; Returns:
+;
+;   None
+;
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSwitchStack)
+ASM_PFX(InternalSwitchStack):
+    mov     rax, rcx
+    mov     rcx, rdx
+    mov     rdx, r8
+    ;
+    ; Reserve space for register parameters (rcx, rdx, r8 & r9) on the stack,
+    ; in case the callee wishes to spill them.
+    ;
+    lea     rsp, [r9 - 0x20]
+    call    rax
+
diff --git a/MdePkg/Library/BaseLib/X64/Thunk16.S b/MdePkg/Library/BaseLib/X64/Thunk16.S
new file mode 100644
index 000000000000..823e927dd445
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Thunk16.S
@@ -0,0 +1,334 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2013, 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.
+#
+# Module Name:
+#
+#   Thunk16.S
+#
+# Abstract:
+#
+#   Real mode thunk
+#
+#------------------------------------------------------------------------------
+
+#include <Library/BaseLib.h>
+
+ASM_GLOBAL ASM_PFX(m16Start)
+ASM_GLOBAL ASM_PFX(m16Size)
+ASM_GLOBAL ASM_PFX(mThunk16Attr)
+ASM_GLOBAL ASM_PFX(m16Gdt)
+ASM_GLOBAL ASM_PFX(m16GdtrBase)
+ASM_GLOBAL ASM_PFX(mTransition)
+ASM_GLOBAL ASM_PFX(InternalAsmThunk16)
+
+# define the structure of IA32_REGS
+.set  _EDI, 0       #size 4
+.set  _ESI, 4       #size 4
+.set  _EBP, 8       #size 4
+.set  _ESP, 12      #size 4
+.set  _EBX, 16      #size 4
+.set  _EDX, 20      #size 4
+.set  _ECX, 24      #size 4
+.set  _EAX, 28      #size 4
+.set  _DS,  32      #size 2
+.set  _ES,  34      #size 2
+.set  _FS,  36      #size 2
+.set  _GS,  38      #size 2
+.set  _EFLAGS, 40   #size 8
+.set  _EIP, 48      #size 4
+.set  _CS, 52       #size 2
+.set  _SS, 54       #size 2
+.set  IA32_REGS_SIZE, 56
+
+    .data
+    
+.set Lm16Size, ASM_PFX(InternalAsmThunk16) - ASM_PFX(m16Start)
+ASM_PFX(m16Size):         .word      Lm16Size
+.set  LmThunk16Attr, L_ThunkAttr - ASM_PFX(m16Start)
+ASM_PFX(mThunk16Attr):    .word      LmThunk16Attr
+.set Lm16Gdt, ASM_PFX(NullSeg) - ASM_PFX(m16Start)
+ASM_PFX(m16Gdt):          .word      Lm16Gdt
+.set Lm16GdtrBase, _16GdtrBase - ASM_PFX(m16Start)
+ASM_PFX(m16GdtrBase):     .word      Lm16GdtrBase
+.set LmTransition, _EntryPoint - ASM_PFX(m16Start)
+ASM_PFX(mTransition):     .word      LmTransition
+
+    .text
+
+ASM_PFX(m16Start):
+
+SavedGdt:    .space 10
+
+#------------------------------------------------------------------------------
+# _BackFromUserCode() takes control in real mode after 'retf' has been executed
+# by user code. It will be shadowed to somewhere in memory below 1MB.
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(BackFromUserCode)
+ASM_PFX(BackFromUserCode):
+    #
+    # The order of saved registers on the stack matches the order they appears
+    # in IA32_REGS structure. This facilitates wrapper function to extract them
+    # into that structure.
+    #
+    # Some instructions for manipulation of segment registers have to be written
+    # in opcode since 64-bit MASM prevents accesses to those registers.
+    #
+    .byte 0x16                          # push ss
+    .byte 0xe                           # push cs
+    .byte 0x66
+    call    L_Base                       # push eip
+L_Base: 
+    .byte 0x66
+    pushq   $0                          # reserved high order 32 bits of EFlags
+    .byte 0x66, 0x9c                    # pushfd actually
+    cli                                 # disable interrupts
+    push    %gs
+    push    %fs
+    .byte 6                             # push es
+    .byte 0x1e                          # push ds
+    .byte 0x66,0x60                     # pushad
+    .byte 0x66,0xba                     # mov edx, imm32
+L_ThunkAttr:  .space  4
+    testb   $THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15, %dl
+    jz      L_1
+    movl    $0x15cd2401,%eax            # mov ax, 2401h & int 15h
+    cli                                 # disable interrupts
+    jnc     L_2
+L_1: 
+    testb   $THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL, %dl
+    jz      L_2
+    inb     $0x92,%al
+    orb     $2,%al
+    outb    %al, $0x92                   # deactivate A20M#
+L_2: 
+    xorw    %ax, %ax                     # xor eax, eax
+    movl    %ss, %eax                    # mov ax, ss
+    lea     IA32_REGS_SIZE(%esp), %bp
+    #
+    # rsi in the following 2 instructions is indeed bp in 16-bit code
+    #
+    movw    %bp, (_ESP - IA32_REGS_SIZE)(%rsi)
+    .byte 0x66
+    movl    (_EIP - IA32_REGS_SIZE)(%rsi), %ebx
+    shlw    $4,%ax                      # shl eax, 4
+    addw    %ax,%bp                     # add ebp, eax
+    movw    %cs,%ax
+    shlw    $4,%ax
+    lea     (L_64BitCode - L_Base)(%ebx, %eax), %ax
+    .byte 0x66,0x2e,0x89,0x87           # mov cs:[bx + (L_64Eip - L_Base)], eax
+    .word   L_64Eip - L_Base
+    .byte 0x66,0xb8                     # mov eax, imm32
+L_SavedCr4: .space      4
+    movq    %rax, %cr4
+    #
+    # rdi in the instruction below is indeed bx in 16-bit code
+    #
+    .byte 0x66,0x2e                     # 2eh is "cs:" segment override
+    lgdt    (SavedGdt - L_Base)(%rdi)
+    .byte 0x66
+    movl    $0xc0000080,%ecx
+    rdmsr
+    orb     $1,%ah
+    wrmsr
+    .byte 0x66,0xb8                     # mov eax, imm32
+L_SavedCr0: .space      4
+    movq    %rax, %cr0
+    .byte 0x66,0xea                     # jmp far cs:L_64Bit
+L_64Eip:    .space      4
+L_SavedCs:  .space      2
+L_64BitCode:
+    .byte   0x90
+    .byte   0x48,0xbc                  # mov rsp, imm64
+L_SavedSp:  .space      8              # restore stack
+    nop
+    ret
+
+_EntryPoint: .long      ASM_PFX(ToUserCode) - ASM_PFX(m16Start)
+             .word      CODE16
+_16Gdtr:     .word      GDT_SIZE - 1
+_16GdtrBase: .quad      0
+_16Idtr:     .word      0x3ff
+             .long      0
+
+#------------------------------------------------------------------------------
+# _ToUserCode() takes control in real mode before passing control to user code.
+# It will be shadowed to somewhere in memory below 1MB.
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(ToUserCode)
+ASM_PFX(ToUserCode):
+    movl    %edx,%ss                    # set new segment selectors
+    movl    %edx,%ds
+    movl    %edx,%es
+    movl    %edx,%fs
+    movl    %edx,%gs
+    .byte 0x66
+    movl    $0xc0000080,%ecx
+    movq    %rax, %cr0
+    rdmsr
+    andb    $0xfe, %ah                  # $0b11111110
+    wrmsr
+    movq    %rbp, %cr4
+    movl    %esi,%ss                    # set up 16-bit stack segment
+    movw    %bx,%sp                     # set up 16-bit stack pointer
+    .byte 0x66                          # make the following call 32-bit
+    call    L_Base1                       # push eip
+L_Base1: 
+    popw    %bp                         # ebp <- address of L_Base1
+    pushq   (IA32_REGS_SIZE + 2)(%esp)
+    lea     0x0c(%rsi), %eax
+    pushq   %rax
+    lret                                # execution begins at next instruction
+L_RealMode: 
+    .byte 0x66,0x2e                     # CS and operand size override
+    lidt    (_16Idtr - L_Base1)(%rsi)
+    .byte 0x66,0x61                     # popad
+    .byte 0x1f                          # pop ds
+    .byte 0x7                           # pop es
+    .byte 0x0f, 0xa1                    # pop fs
+    .byte 0x0f, 0xa9                    # pop gs
+    .byte 0x66, 0x9d                    # popfd
+    leaw    4(%esp),%sp                 # skip high order 32 bits of EFlags
+    .byte 0x66                          # make the following retf 32-bit
+    lret                                # transfer control to user code
+
+.set  CODE16,  ASM_PFX(_16Code) - .
+.set  DATA16,  ASM_PFX(_16Data) - .
+.set  DATA32,  ASM_PFX(_32Data) - .
+
+ASM_PFX(NullSeg):   .quad      0
+ASM_PFX(_16Code):
+            .word -1
+            .word 0
+            .byte 0
+            .byte 0x9b
+            .byte 0x8f                  # 16-bit segment, 4GB limit
+            .byte 0
+ASM_PFX(_16Data):
+            .word -1
+            .word 0
+            .byte 0
+            .byte 0x93
+            .byte 0x8f                  # 16-bit segment, 4GB limit
+            .byte 0
+ASM_PFX(_32Data):
+            .word -1
+            .word 0
+            .byte 0
+            .byte 0x93
+            .byte 0xcf                  # 16-bit segment, 4GB limit
+            .byte 0
+
+.set  GDT_SIZE, . - ASM_PFX(NullSeg)
+
+#------------------------------------------------------------------------------
+# IA32_REGISTER_SET *
+# EFIAPI
+# InternalAsmThunk16 (
+#   IN      IA32_REGISTER_SET         *RegisterSet,
+#   IN OUT  VOID                      *Transition
+#   );
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalAsmThunk16)
+ASM_PFX(InternalAsmThunk16):
+    pushq   %rbp
+    pushq   %rbx
+    pushq   %rsi
+    pushq   %rdi
+    
+    movl    %ds, %ebx
+    pushq   %rbx      # Save ds segment register on the stack
+    movl    %es, %ebx
+    pushq   %rbx      # Save es segment register on the stack
+    movl    %ss, %ebx
+    pushq   %rbx      # Save ss segment register on the stack
+
+    .byte   0x0f, 0xa0                  #push   fs
+    .byte   0x0f, 0xa8                  #push   gs
+    movq    %rcx, %rsi
+    movzwl  _SS(%rsi), %r8d
+    movl    _ESP(%rsi), %edi
+    lea     -(IA32_REGS_SIZE + 4)(%edi), %rdi
+    imul    $16, %r8d, %eax 
+    movl    %edi,%ebx                   # ebx <- stack for 16-bit code
+    pushq   $(IA32_REGS_SIZE / 4)
+    addl    %eax,%edi                   # edi <- linear address of 16-bit stack
+    popq    %rcx
+    rep
+    movsl                               # copy RegSet
+    lea     (L_SavedCr4 - ASM_PFX(m16Start))(%rdx), %ecx
+    movl    %edx,%eax                   # eax <- transition code address
+    andl    $0xf,%edx
+    shll    $12,%eax                    # segment address in high order 16 bits
+    .set LBackFromUserCodeDelta, ASM_PFX(BackFromUserCode) - ASM_PFX(m16Start) 
+    lea     (LBackFromUserCodeDelta)(%rdx), %ax
+    stosl                               # [edi] <- return address of user code
+    sgdt    0x60(%rsp)                  # save GDT stack in argument space
+    movzwq  0x60(%rsp), %r10            # r10 <- GDT limit 
+    lea     ((ASM_PFX(InternalAsmThunk16) - L_SavedCr4) + 0xf)(%rcx), %r11 
+    andq    $0xfffffffffffffff0, %r11   # r11 <- 16-byte aligned shadowed GDT table in real mode buffer      
+    
+    movw    %r10w, (SavedGdt - L_SavedCr4)(%rcx)       # save the limit of shadowed GDT table
+    movq    %r11, (SavedGdt - L_SavedCr4 + 0x2)(%rcx)  # save the base address of shadowed GDT table
+    
+    movq    0x62(%rsp) ,%rsi            # rsi <- the original GDT base address
+    xchg   %r10, %rcx                   # save rcx to r10 and initialize rcx to be the limit of GDT table 
+    incq   %rcx                         # rcx <- the size of memory to copy
+    xchg   %r11, %rdi                   # save rdi to r11 and initialize rdi to the base address of shadowed GDT table
+    rep
+    movsb                               # perform memory copy to shadow GDT table
+    movq   %r10, %rcx                   # restore the orignal rcx before memory copy
+    movq   %r11, %rdi                   # restore the original rdi before memory copy
+       
+    sidt    0x50(%rsp)
+    movq    %cr0, %rax
+    .set LSavedCrDelta, L_SavedCr0 - L_SavedCr4
+    movl    %eax, (LSavedCrDelta)(%rcx)
+    andl    $0x7ffffffe,%eax            # clear PE, PG bits
+    movq    %cr4, %rbp
+    movl    %ebp, (%rcx)                # save CR4 in SavedCr4
+    andl    $0xffffffcf,%ebp            # clear PAE, PSE bits
+    movl    %r8d, %esi                  # esi <- 16-bit stack segment
+    .byte      0x6a, DATA32
+    popq    %rdx
+    lgdt    (_16Gdtr - L_SavedCr4)(%rcx)
+    movl    %edx,%ss
+    pushfq
+    lea     -8(%rdx), %edx
+    lea     L_RetFromRealMode(%rip), %r8
+    pushq   %r8
+    movl    %cs, %r8d
+    movw    %r8w, (L_SavedCs - L_SavedCr4)(%rcx)
+    movq    %rsp, (L_SavedSp - L_SavedCr4)(%rcx)
+    .byte   0xff, 0x69                  #  jmp (_EntryPoint - L_SavedCr4)(%rcx)
+    .set    Ltemp1, _EntryPoint - L_SavedCr4
+    .byte   Ltemp1
+L_RetFromRealMode: 
+    popfq
+    lgdt    0x60(%rsp)                  # restore protected mode GDTR
+    lidt    0x50(%rsp)                  # restore protected mode IDTR
+    lea     -IA32_REGS_SIZE(%rbp), %eax
+    .byte 0x0f, 0xa9                    # pop gs
+    .byte 0x0f, 0xa1                    # pop fs
+    
+    popq     %rbx
+    movl     %ebx, %ss
+    popq     %rbx
+    movl     %ebx, %es
+    popq     %rbx
+    movl     %ebx, %ds
+    
+    popq    %rdi
+    popq    %rsi
+    popq    %rbx
+    popq    %rbp
+
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/Thunk16.asm b/MdePkg/Library/BaseLib/X64/Thunk16.asm
new file mode 100644
index 000000000000..c1a981104089
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Thunk16.asm
@@ -0,0 +1,315 @@
+
+#include "BaseLibInternals.h"
+
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   Thunk.asm
+;
+; Abstract:
+;
+;   Real mode thunk
+;
+;------------------------------------------------------------------------------
+
+EXTERNDEF   m16Start:BYTE
+EXTERNDEF   m16Size:WORD
+EXTERNDEF   mThunk16Attr:WORD
+EXTERNDEF   m16Gdt:WORD
+EXTERNDEF   m16GdtrBase:WORD
+EXTERNDEF   mTransition:WORD
+
+IA32_REGS   STRUC   4t
+_EDI        DD      ?
+_ESI        DD      ?
+_EBP        DD      ?
+_ESP        DD      ?
+_EBX        DD      ?
+_EDX        DD      ?
+_ECX        DD      ?
+_EAX        DD      ?
+_DS         DW      ?
+_ES         DW      ?
+_FS         DW      ?
+_GS         DW      ?
+_EFLAGS     DQ      ?
+_EIP        DD      ?
+_CS         DW      ?
+_SS         DW      ?
+IA32_REGS   ENDS
+
+    .const
+
+m16Size         DW      InternalAsmThunk16 - m16Start
+mThunk16Attr    DW      _ThunkAttr - m16Start
+m16Gdt          DW      _NullSeg - m16Start
+m16GdtrBase     DW      _16GdtrBase - m16Start
+mTransition     DW      _EntryPoint - m16Start
+
+    .code
+
+m16Start    LABEL   BYTE
+
+SavedGdt    LABEL   FWORD
+            DW      ?
+            DQ      ?
+
+;------------------------------------------------------------------------------
+; _BackFromUserCode() takes control in real mode after 'retf' has been executed
+; by user code. It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_BackFromUserCode   PROC
+    ;
+    ; The order of saved registers on the stack matches the order they appears
+    ; in IA32_REGS structure. This facilitates wrapper function to extract them
+    ; into that structure.
+    ;
+    ; Some instructions for manipulation of segment registers have to be written
+    ; in opcode since 64-bit MASM prevents accesses to those registers.
+    ;
+    DB      16h                         ; push ss
+    DB      0eh                         ; push cs
+    DB      66h
+    call    @Base                       ; push eip
+@Base:
+    DB      66h
+    push    0                           ; reserved high order 32 bits of EFlags
+    pushf                               ; pushfd actually
+    cli                                 ; disable interrupts
+    push    gs
+    push    fs
+    DB      6                           ; push es
+    DB      1eh                         ; push ds
+    DB      66h, 60h                    ; pushad
+    DB      66h, 0bah                   ; mov edx, imm32
+_ThunkAttr  DD      ?
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15
+    jz      @1
+    mov     eax, 15cd2401h              ; mov ax, 2401h & int 15h
+    cli                                 ; disable interrupts
+    jnc     @2
+@1:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL
+    jz      @2
+    in      al, 92h
+    or      al, 2
+    out     92h, al                     ; deactivate A20M#
+@2:
+    xor     ax, ax                      ; xor eax, eax
+    mov     eax, ss                     ; mov ax, ss
+    lea     bp, [esp + sizeof (IA32_REGS)]
+    ;
+    ; rsi in the following 2 instructions is indeed bp in 16-bit code
+    ;
+    mov     word ptr (IA32_REGS ptr [rsi - sizeof (IA32_REGS)])._ESP, bp
+    DB      66h
+    mov     ebx, (IA32_REGS ptr [rsi - sizeof (IA32_REGS)])._EIP
+    shl     ax, 4                       ; shl eax, 4
+    add     bp, ax                      ; add ebp, eax
+    mov     ax, cs
+    shl     ax, 4
+    lea     ax, [eax + ebx + (@64BitCode - @Base)]
+    DB      66h, 2eh, 89h, 87h          ; mov cs:[bx + (@64Eip - @Base)], eax
+    DW      @64Eip - @Base
+    DB      66h, 0b8h                   ; mov eax, imm32
+SavedCr4    DD      ?
+    mov     cr4, rax
+    ;
+    ; rdi in the instruction below is indeed bx in 16-bit code
+    ;
+    DB      66h, 2eh                    ; 2eh is "cs:" segment override
+    lgdt    fword ptr [rdi + (SavedGdt - @Base)]
+    DB      66h
+    mov     ecx, 0c0000080h
+    rdmsr
+    or      ah, 1
+    wrmsr
+    DB      66h, 0b8h                   ; mov eax, imm32
+SavedCr0    DD      ?
+    mov     cr0, rax
+    DB      66h, 0eah                   ; jmp far cs:@64Bit
+@64Eip      DD      ?
+SavedCs     DW      ?
+@64BitCode:
+    db      090h 
+    db      048h, 0bch                 ; mov rsp, imm64
+SavedSp     DQ   ?                     ; restore stack
+    nop
+    ret
+_BackFromUserCode   ENDP
+
+_EntryPoint DD      _ToUserCode - m16Start
+            DW      CODE16
+_16Gdtr     LABEL   FWORD
+            DW      GDT_SIZE - 1
+_16GdtrBase DQ      _NullSeg
+_16Idtr     FWORD   (1 SHL 10) - 1
+
+;------------------------------------------------------------------------------
+; _ToUserCode() takes control in real mode before passing control to user code.
+; It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_ToUserCode PROC
+    mov     ss, edx                     ; set new segment selectors
+    mov     ds, edx
+    mov     es, edx
+    mov     fs, edx
+    mov     gs, edx
+    DB      66h
+    mov     ecx, 0c0000080h
+    mov     cr0, rax                    ; real mode starts at next instruction
+    rdmsr
+    and     ah, NOT 1
+    wrmsr
+    mov     cr4, rbp
+    mov     ss, esi                     ; set up 16-bit stack segment
+    mov     sp, bx                      ; set up 16-bit stack pointer
+    DB      66h                         ; make the following call 32-bit
+    call    @Base                       ; push eip
+@Base:
+    pop     bp                          ; ebp <- address of @Base
+    push    [esp + sizeof (IA32_REGS) + 2]
+    lea     eax, [rsi + (@RealMode - @Base)]    ; rsi is "bp" in 16-bit code
+    push    rax
+    retf                                ; execution begins at next instruction
+@RealMode:
+    DB      66h, 2eh                    ; CS and operand size override
+    lidt    fword ptr [rsi + (_16Idtr - @Base)]
+    DB      66h, 61h                    ; popad
+    DB      1fh                         ; pop ds
+    DB      07h                         ; pop es
+    pop     fs
+    pop     gs
+    popf                                ; popfd
+    lea     sp, [esp + 4]               ; skip high order 32 bits of EFlags
+    DB      66h                         ; make the following retf 32-bit
+    retf                                ; transfer control to user code
+_ToUserCode ENDP
+
+CODE16  = _16Code - $
+DATA16  = _16Data - $
+DATA32  = _32Data - $
+
+_NullSeg    DQ      0
+_16Code     LABEL   QWORD
+            DW      -1
+            DW      0
+            DB      0
+            DB      9bh
+            DB      8fh                 ; 16-bit segment, 4GB limit
+            DB      0
+_16Data     LABEL   QWORD
+            DW      -1
+            DW      0
+            DB      0
+            DB      93h
+            DB      8fh                 ; 16-bit segment, 4GB limit
+            DB      0
+_32Data     LABEL   QWORD
+            DW      -1
+            DW      0
+            DB      0
+            DB      93h
+            DB      0cfh                ; 16-bit segment, 4GB limit
+            DB      0
+
+GDT_SIZE = $ - _NullSeg
+
+;------------------------------------------------------------------------------
+; IA32_REGISTER_SET *
+; EFIAPI
+; InternalAsmThunk16 (
+;   IN      IA32_REGISTER_SET         *RegisterSet,
+;   IN OUT  VOID                      *Transition
+;   );
+;------------------------------------------------------------------------------
+InternalAsmThunk16  PROC    USES    rbp rbx rsi rdi
+    mov     rbx, ds
+    push    rbx          ; Save ds segment register on the stack
+    mov     rbx, es
+    push    rbx          ; Save es segment register on the stack
+    mov     rbx, ss
+    push    rbx          ; Save ss segment register on the stack
+    
+    push    fs
+    push    gs
+    mov     rsi, rcx
+    movzx   r8d, (IA32_REGS ptr [rsi])._SS
+    mov     edi, (IA32_REGS ptr [rsi])._ESP
+    lea     rdi, [edi - (sizeof (IA32_REGS) + 4)]
+    imul    eax, r8d, 16                ; eax <- r8d(stack segment) * 16
+    mov     ebx, edi                    ; ebx <- stack for 16-bit code
+    push    sizeof (IA32_REGS) / 4
+    add     edi, eax                    ; edi <- linear address of 16-bit stack
+    pop     rcx
+    rep     movsd                       ; copy RegSet
+    lea     ecx, [rdx + (SavedCr4 - m16Start)]
+    mov     eax, edx                    ; eax <- transition code address
+    and     edx, 0fh
+    shl     eax, 12                     ; segment address in high order 16 bits
+    lea     ax, [rdx + (_BackFromUserCode - m16Start)]  ; offset address
+    stosd                               ; [edi] <- return address of user code
+  
+    sgdt    fword ptr [rsp + 60h]       ; save GDT stack in argument space
+    movzx   r10, word ptr [rsp + 60h]   ; r10 <- GDT limit 
+    lea     r11, [rcx + (InternalAsmThunk16 - SavedCr4) + 0xf]
+    and     r11, 0xfffffff0             ; r11 <- 16-byte aligned shadowed GDT table in real mode buffer
+    
+    mov     word ptr [rcx + (SavedGdt - SavedCr4)], r10w      ; save the limit of shadowed GDT table
+    mov     qword ptr [rcx + (SavedGdt - SavedCr4) + 2], r11  ; save the base address of shadowed GDT table
+    
+    mov     rsi, qword ptr [rsp + 62h]  ; rsi <- the original GDT base address
+    xchg    rcx, r10                    ; save rcx to r10 and initialize rcx to be the limit of GDT table
+    inc     rcx                         ; rcx <- the size of memory to copy
+    xchg    rdi, r11                    ; save rdi to r11 and initialize rdi to the base address of shadowed GDT table
+    rep     movsb                       ; perform memory copy to shadow GDT table
+    mov     rcx, r10                    ; restore the orignal rcx before memory copy
+    mov     rdi, r11                    ; restore the original rdi before memory copy
+    
+    sidt    fword ptr [rsp + 50h]       ; save IDT stack in argument space
+    mov     rax, cr0
+    mov     [rcx + (SavedCr0 - SavedCr4)], eax
+    and     eax, 7ffffffeh              ; clear PE, PG bits
+    mov     rbp, cr4
+    mov     [rcx], ebp                  ; save CR4 in SavedCr4
+    and     ebp, NOT 30h                ; clear PAE, PSE bits
+    mov     esi, r8d                    ; esi <- 16-bit stack segment
+    DB      6ah, DATA32                 ; push DATA32
+    pop     rdx                         ; rdx <- 32-bit data segment selector
+    lgdt    fword ptr [rcx + (_16Gdtr - SavedCr4)]
+    mov     ss, edx
+    pushfq
+    lea     edx, [rdx + DATA16 - DATA32]
+    lea     r8, @RetFromRealMode
+    push    r8
+    mov     r8d, cs
+    mov     [rcx + (SavedCs - SavedCr4)], r8w
+    mov     [rcx + (SavedSp - SavedCr4)], rsp
+    jmp     fword ptr [rcx + (_EntryPoint - SavedCr4)]
+@RetFromRealMode:
+    popfq
+    lgdt    fword ptr [rsp + 60h]       ; restore protected mode GDTR
+    lidt    fword ptr [rsp + 50h]       ; restore protected mode IDTR
+    lea     eax, [rbp - sizeof (IA32_REGS)]
+    pop     gs
+    pop     fs
+    pop     rbx
+    mov     ss, rbx
+    pop     rbx
+    mov     es, rbx
+    pop     rbx
+    mov     ds, rbx
+    ret
+InternalAsmThunk16  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/Thunk16.nasm b/MdePkg/Library/BaseLib/X64/Thunk16.nasm
new file mode 100644
index 000000000000..6d8a649d8e88
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Thunk16.nasm
@@ -0,0 +1,325 @@
+
+#include "BaseLibInternals.h"
+
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2013, 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.
+;
+; Module Name:
+;
+;   Thunk.asm
+;
+; Abstract:
+;
+;   Real mode thunk
+;
+;------------------------------------------------------------------------------
+
+global ASM_PFX(m16Size)
+global ASM_PFX(mThunk16Attr)
+global ASM_PFX(m16Gdt)
+global ASM_PFX(m16GdtrBase)
+global ASM_PFX(mTransition)
+global ASM_PFX(m16Start)
+
+struc IA32_REGS
+
+  ._EDI:       resd      1
+  ._ESI:       resd      1
+  ._EBP:       resd      1
+  ._ESP:       resd      1
+  ._EBX:       resd      1
+  ._EDX:       resd      1
+  ._ECX:       resd      1
+  ._EAX:       resd      1
+  ._DS:        resw      1
+  ._ES:        resw      1
+  ._FS:        resw      1
+  ._GS:        resw      1
+  ._EFLAGS:    resq      1
+  ._EIP:       resd      1
+  ._CS:        resw      1
+  ._SS:        resw      1
+  .size:
+
+endstruc
+
+SECTION .data
+
+;
+; These are global constant to convey information to C code.
+;
+ASM_PFX(m16Size)         DW      ASM_PFX(InternalAsmThunk16) - ASM_PFX(m16Start)
+ASM_PFX(mThunk16Attr)    DW      _BackFromUserCode.ThunkAttrEnd - 4 - ASM_PFX(m16Start)
+ASM_PFX(m16Gdt)          DW      _NullSeg - ASM_PFX(m16Start)
+ASM_PFX(m16GdtrBase)     DW      _16GdtrBase - ASM_PFX(m16Start)
+ASM_PFX(mTransition)     DW      _EntryPoint - ASM_PFX(m16Start)
+
+SECTION .text
+
+ASM_PFX(m16Start):
+
+SavedGdt:
+            dw  0
+            dq  0
+
+;------------------------------------------------------------------------------
+; _BackFromUserCode() takes control in real mode after 'retf' has been executed
+; by user code. It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_BackFromUserCode:
+    ;
+    ; The order of saved registers on the stack matches the order they appears
+    ; in IA32_REGS structure. This facilitates wrapper function to extract them
+    ; into that structure.
+    ;
+BITS    16
+    push    ss
+    push    cs
+    ;
+    ; Note: We can't use o32 on the next instruction because of a bug
+    ; in NASM 2.09.04 through 2.10rc1.
+    ;
+    call    dword .Base                 ; push eip
+.Base:
+    push    dword 0                     ; reserved high order 32 bits of EFlags
+    pushfd
+    cli                                 ; disable interrupts
+    push    gs
+    push    fs
+    push    es
+    push    ds
+    pushad
+    mov     edx, strict dword 0
+.ThunkAttrEnd:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15
+    jz      .1
+    mov     ax, 2401h
+    int     15h
+    cli                                 ; disable interrupts
+    jnc     .2
+.1:
+    test    dl, THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL
+    jz      .2
+    in      al, 92h
+    or      al, 2
+    out     92h, al                     ; deactivate A20M#
+.2:
+    xor     eax, eax
+    mov     ax, ss
+    lea     ebp, [esp + IA32_REGS.size]
+    mov     [bp - IA32_REGS.size + IA32_REGS._ESP], ebp
+    mov     ebx, [bp - IA32_REGS.size + IA32_REGS._EIP]
+    shl     eax, 4                      ; shl eax, 4
+    add     ebp, eax                    ; add ebp, eax
+    mov     eax, cs
+    shl     eax, 4
+    lea     eax, [eax + ebx + (.X64JmpEnd - .Base)]
+    mov     [cs:bx + (.X64JmpEnd - 6 - .Base)], eax
+    mov     eax, strict dword 0
+.SavedCr4End:
+    mov     cr4, eax
+o32 lgdt [cs:bx + (SavedGdt - .Base)]
+    mov     ecx, 0c0000080h
+    rdmsr
+    or      ah, 1
+    wrmsr
+    mov     eax, strict dword 0
+.SavedCr0End:
+    mov     cr0, eax
+    jmp     0:strict dword 0
+.X64JmpEnd:
+BITS    64
+    nop
+    mov rsp, strict qword 0
+.SavedSpEnd:
+    nop
+    ret
+
+_EntryPoint:
+        DD      _ToUserCode - ASM_PFX(m16Start)
+        DW      CODE16
+_16Gdtr:
+        DW      GDT_SIZE - 1
+_16GdtrBase:
+        DQ      0
+_16Idtr:
+        DW      (1 << 10) - 1
+        DD      0
+
+;------------------------------------------------------------------------------
+; _ToUserCode() takes control in real mode before passing control to user code.
+; It will be shadowed to somewhere in memory below 1MB.
+;------------------------------------------------------------------------------
+_ToUserCode:
+BITS    16
+    mov     ss, dx                      ; set new segment selectors
+    mov     ds, dx
+    mov     es, dx
+    mov     fs, dx
+    mov     gs, dx
+    mov     ecx, 0c0000080h
+    mov     cr0, eax                    ; real mode starts at next instruction
+    rdmsr
+    and     ah, ~1
+    wrmsr
+    mov     cr4, ebp
+    mov     ss, si                      ; set up 16-bit stack segment
+    mov     esp, ebx                    ; set up 16-bit stack pointer
+    call    dword .Base                 ; push eip
+.Base:
+    pop     ebp                         ; ebp <- address of .Base
+    push    word [dword esp + IA32_REGS.size + 2]
+    lea     ax, [bp + (.RealMode - .Base)]
+    push    ax
+    retf                                ; execution begins at next instruction
+.RealMode:
+
+o32 lidt    [cs:bp + (_16Idtr - .Base)]
+
+    popad
+    pop     ds
+    pop     es
+    pop     fs
+    pop     gs
+    popfd
+    lea     esp, [esp + 4]        ; skip high order 32 bits of EFlags
+
+o32 retf                                ; transfer control to user code
+
+ALIGN   8
+
+CODE16  equ _16Code - $
+DATA16  equ _16Data - $
+DATA32  equ _32Data - $
+
+_NullSeg    DQ      0
+_16Code:
+            DW      -1
+            DW      0
+            DB      0
+            DB      9bh
+            DB      8fh                 ; 16-bit segment, 4GB limit
+            DB      0
+_16Data:
+            DW      -1
+            DW      0
+            DB      0
+            DB      93h
+            DB      8fh                 ; 16-bit segment, 4GB limit
+            DB      0
+_32Data:
+            DW      -1
+            DW      0
+            DB      0
+            DB      93h
+            DB      0cfh                ; 16-bit segment, 4GB limit
+            DB      0
+
+GDT_SIZE equ $ - _NullSeg
+
+;------------------------------------------------------------------------------
+; IA32_REGISTER_SET *
+; EFIAPI
+; InternalAsmThunk16 (
+;   IN      IA32_REGISTER_SET         *RegisterSet,
+;   IN OUT  VOID                      *Transition
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalAsmThunk16)
+ASM_PFX(InternalAsmThunk16):
+BITS    64
+    push    rbp
+    push    rbx
+    push    rsi
+    push    rdi
+    
+    mov     ebx, ds
+    push    rbx          ; Save ds segment register on the stack
+    mov     ebx, es
+    push    rbx          ; Save es segment register on the stack
+    mov     ebx, ss
+    push    rbx          ; Save ss segment register on the stack
+    
+    push    fs
+    push    gs
+    mov     rsi, rcx
+    movzx   r8d, word [rsi + IA32_REGS._SS]
+    mov     edi, [rsi + IA32_REGS._ESP]
+    lea     rdi, [edi - (IA32_REGS.size + 4)]
+    imul    eax, r8d, 16                ; eax <- r8d(stack segment) * 16
+    mov     ebx, edi                    ; ebx <- stack for 16-bit code
+    push    IA32_REGS.size / 4
+    add     edi, eax                    ; edi <- linear address of 16-bit stack
+    pop     rcx
+    rep     movsd                       ; copy RegSet
+    lea     ecx, [rdx + (_BackFromUserCode.SavedCr4End - ASM_PFX(m16Start))]
+    mov     eax, edx                    ; eax <- transition code address
+    and     edx, 0fh
+    shl     eax, 12                     ; segment address in high order 16 bits
+    lea     ax, [rdx + (_BackFromUserCode - ASM_PFX(m16Start))]  ; offset address
+    stosd                               ; [edi] <- return address of user code
+  
+    sgdt    [rsp + 60h]       ; save GDT stack in argument space
+    movzx   r10, word [rsp + 60h]   ; r10 <- GDT limit 
+    lea     r11, [rcx + (ASM_PFX(InternalAsmThunk16) - _BackFromUserCode.SavedCr4End) + 0xf]
+    and     r11, ~0xf            ; r11 <- 16-byte aligned shadowed GDT table in real mode buffer
+    
+    mov     [rcx + (SavedGdt - _BackFromUserCode.SavedCr4End)], r10w      ; save the limit of shadowed GDT table
+    mov     [rcx + (SavedGdt - _BackFromUserCode.SavedCr4End) + 2], r11  ; save the base address of shadowed GDT table
+    
+    mov     rsi, [rsp + 62h]  ; rsi <- the original GDT base address
+    xchg    rcx, r10                    ; save rcx to r10 and initialize rcx to be the limit of GDT table
+    inc     rcx                         ; rcx <- the size of memory to copy
+    xchg    rdi, r11                    ; save rdi to r11 and initialize rdi to the base address of shadowed GDT table
+    rep     movsb                       ; perform memory copy to shadow GDT table
+    mov     rcx, r10                    ; restore the orignal rcx before memory copy
+    mov     rdi, r11                    ; restore the original rdi before memory copy
+    
+    sidt    [rsp + 50h]       ; save IDT stack in argument space
+    mov     rax, cr0
+    mov     [rcx + (_BackFromUserCode.SavedCr0End - 4 - _BackFromUserCode.SavedCr4End)], eax
+    and     eax, 7ffffffeh              ; clear PE, PG bits
+    mov     rbp, cr4
+    mov     [rcx - 4], ebp              ; save CR4 in _BackFromUserCode.SavedCr4End - 4
+    and     ebp, ~30h                ; clear PAE, PSE bits
+    mov     esi, r8d                    ; esi <- 16-bit stack segment
+    push    DATA32
+    pop     rdx                         ; rdx <- 32-bit data segment selector
+    lgdt    [rcx + (_16Gdtr - _BackFromUserCode.SavedCr4End)]
+    mov     ss, edx
+    pushfq
+    lea     edx, [rdx + DATA16 - DATA32]
+    lea     r8, [REL .RetFromRealMode]
+    push    r8
+    mov     r8d, cs
+    mov     [rcx + (_BackFromUserCode.X64JmpEnd - 2 - _BackFromUserCode.SavedCr4End)], r8w
+    mov     [rcx + (_BackFromUserCode.SavedSpEnd - 8 - _BackFromUserCode.SavedCr4End)], rsp
+    jmp     dword far [rcx + (_EntryPoint - _BackFromUserCode.SavedCr4End)]
+.RetFromRealMode:
+    popfq
+    lgdt    [rsp + 60h]       ; restore protected mode GDTR
+    lidt    [rsp + 50h]       ; restore protected mode IDTR
+    lea     eax, [rbp - IA32_REGS.size]
+    pop     gs
+    pop     fs
+    pop     rbx
+    mov     ss, ebx
+    pop     rbx
+    mov     es, ebx
+    pop     rbx
+    mov     ds, ebx
+
+    pop     rdi
+    pop     rsi
+    pop     rbx
+    pop     rbp
+
+    ret
diff --git a/MdePkg/Library/BaseLib/X64/Wbinvd.asm b/MdePkg/Library/BaseLib/X64/Wbinvd.asm
new file mode 100644
index 000000000000..01a2d8cf11a6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Wbinvd.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Wbinvd.Asm
+;
+; Abstract:
+;
+;   AsmWbinvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWbinvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+AsmWbinvd   PROC
+    wbinvd
+    ret
+AsmWbinvd   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/Wbinvd.nasm b/MdePkg/Library/BaseLib/X64/Wbinvd.nasm
new file mode 100644
index 000000000000..6f7e03e73742
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/Wbinvd.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   Wbinvd.Asm
+;
+; Abstract:
+;
+;   AsmWbinvd function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWbinvd (
+;   VOID
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWbinvd)
+ASM_PFX(AsmWbinvd):
+    wbinvd
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr0.asm b/MdePkg/Library/BaseLib/X64/WriteCr0.asm
new file mode 100644
index 000000000000..407df2a4a126
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr0.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr0 (
+;   UINTN  Cr0
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr0 PROC
+    mov     cr0, rcx
+    mov     rax, rcx
+    ret
+AsmWriteCr0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr0.nasm b/MdePkg/Library/BaseLib/X64/WriteCr0.nasm
new file mode 100644
index 000000000000..245d64e31c46
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr0.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr0 (
+;   UINTN  Cr0
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr0)
+ASM_PFX(AsmWriteCr0):
+    mov     cr0, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr2.asm b/MdePkg/Library/BaseLib/X64/WriteCr2.asm
new file mode 100644
index 000000000000..e477259d7f2e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr2.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr2 (
+;   UINTN  Cr2
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr2 PROC
+    mov     cr2, rcx
+    mov     rax, rcx
+    ret
+AsmWriteCr2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr2.nasm b/MdePkg/Library/BaseLib/X64/WriteCr2.nasm
new file mode 100644
index 000000000000..b85864e34947
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr2.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr2 (
+;   UINTN  Cr2
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr2)
+ASM_PFX(AsmWriteCr2):
+    mov     cr2, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr3.asm b/MdePkg/Library/BaseLib/X64/WriteCr3.asm
new file mode 100644
index 000000000000..3182d4578212
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr3.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr3 (
+;   UINTN  Cr3
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr3 PROC
+    mov     cr3, rcx
+    mov     rax, rcx
+    ret
+AsmWriteCr3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr3.nasm b/MdePkg/Library/BaseLib/X64/WriteCr3.nasm
new file mode 100644
index 000000000000..3297fd94a447
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr3.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr3 (
+;   UINTN  Cr3
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr3)
+ASM_PFX(AsmWriteCr3):
+    mov     cr3, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr4.asm b/MdePkg/Library/BaseLib/X64/WriteCr4.asm
new file mode 100644
index 000000000000..cb3786bf5f9a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr4.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr4 (
+;   UINTN  Cr4
+;   );
+;------------------------------------------------------------------------------
+AsmWriteCr4 PROC
+    mov     cr4, rcx
+    mov     rax, rcx
+    ret
+AsmWriteCr4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteCr4.nasm b/MdePkg/Library/BaseLib/X64/WriteCr4.nasm
new file mode 100644
index 000000000000..426e27ed2538
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteCr4.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteCr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteCr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteCr4 (
+;   UINTN  Cr4
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteCr4)
+ASM_PFX(AsmWriteCr4):
+    mov     cr4, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr0.asm b/MdePkg/Library/BaseLib/X64/WriteDr0.asm
new file mode 100644
index 000000000000..112cfcc30688
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr0.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr0 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr0 PROC
+    mov     dr0, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr0.nasm b/MdePkg/Library/BaseLib/X64/WriteDr0.nasm
new file mode 100644
index 000000000000..e6ffa1642321
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr0.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr0.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr0 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr0)
+ASM_PFX(AsmWriteDr0):
+    mov     dr0, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr1.asm b/MdePkg/Library/BaseLib/X64/WriteDr1.asm
new file mode 100644
index 000000000000..598c1d2f4ff1
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr1.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr1.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr1 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr1 PROC
+    mov     dr1, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr1 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr1.nasm b/MdePkg/Library/BaseLib/X64/WriteDr1.nasm
new file mode 100644
index 000000000000..59db62dae7e7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr1.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr1.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr1 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr1)
+ASM_PFX(AsmWriteDr1):
+    mov     dr1, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr2.asm b/MdePkg/Library/BaseLib/X64/WriteDr2.asm
new file mode 100644
index 000000000000..8c75c56baa7d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr2.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr2 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr2 PROC
+    mov     dr2, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr2.nasm b/MdePkg/Library/BaseLib/X64/WriteDr2.nasm
new file mode 100644
index 000000000000..c7562d8729f2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr2.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr2.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr2 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr2)
+ASM_PFX(AsmWriteDr2):
+    mov     dr2, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr3.asm b/MdePkg/Library/BaseLib/X64/WriteDr3.asm
new file mode 100644
index 000000000000..e8ef57403d7b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr3.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr3 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr3 PROC
+    mov     dr3, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr3.nasm b/MdePkg/Library/BaseLib/X64/WriteDr3.nasm
new file mode 100644
index 000000000000..3b36fb6d548b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr3.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr3.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr3 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr3)
+ASM_PFX(AsmWriteDr3):
+    mov     dr3, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr4.asm b/MdePkg/Library/BaseLib/X64/WriteDr4.asm
new file mode 100644
index 000000000000..6e7bca9b9994
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr4.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr4 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr4 PROC
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR6 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0fh, 23h, 0e1h
+    mov     rax, rcx
+    ret
+AsmWriteDr4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr4.nasm b/MdePkg/Library/BaseLib/X64/WriteDr4.nasm
new file mode 100644
index 000000000000..09277a49125b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr4.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr4.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr4 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr4)
+ASM_PFX(AsmWriteDr4):
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR6 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0xf, 0x23, 0xe1
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr5.asm b/MdePkg/Library/BaseLib/X64/WriteDr5.asm
new file mode 100644
index 000000000000..afaaec50c30e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr5.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   WriteDr5.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr5 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr5 PROC
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0fh, 23h, 0e9h
+    mov     rax, rcx
+    ret
+AsmWriteDr5 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr5.nasm b/MdePkg/Library/BaseLib/X64/WriteDr5.nasm
new file mode 100644
index 000000000000..9461613492a6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr5.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   WriteDr5.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr5 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr5)
+ASM_PFX(AsmWriteDr5):
+    ;
+    ; There's no obvious reason to access this register, since it's aliased to
+    ; DR7 when DE=0 or an exception generated when DE=1
+    ;
+    DB      0xf, 0x23, 0xe9
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr6.asm b/MdePkg/Library/BaseLib/X64/WriteDr6.asm
new file mode 100644
index 000000000000..de1803787763
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr6.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr6.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr6 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr6 PROC
+    mov     dr6, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr6 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr6.nasm b/MdePkg/Library/BaseLib/X64/WriteDr6.nasm
new file mode 100644
index 000000000000..315bf9fbecda
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr6.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr6.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr6 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr6)
+ASM_PFX(AsmWriteDr6):
+    mov     dr6, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr7.asm b/MdePkg/Library/BaseLib/X64/WriteDr7.asm
new file mode 100644
index 000000000000..565e94e43249
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr7.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr7.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr7 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteDr7 PROC
+    mov     dr7, rcx
+    mov     rax, rcx
+    ret
+AsmWriteDr7 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteDr7.nasm b/MdePkg/Library/BaseLib/X64/WriteDr7.nasm
new file mode 100644
index 000000000000..5dc76137bcf2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteDr7.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteDr7.Asm
+;
+; Abstract:
+;
+;   AsmWriteDr7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINTN
+; EFIAPI
+; AsmWriteDr7 (
+;   IN UINTN Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteDr7)
+ASM_PFX(AsmWriteDr7):
+    mov     dr7, rcx
+    mov     rax, rcx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteGdtr.asm b/MdePkg/Library/BaseLib/X64/WriteGdtr.asm
new file mode 100644
index 000000000000..bd19d7725e1f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteGdtr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteGdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteGdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86WriteGdtr  PROC
+    lgdt    fword ptr [rcx]
+    ret
+InternalX86WriteGdtr  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteGdtr.nasm b/MdePkg/Library/BaseLib/X64/WriteGdtr.nasm
new file mode 100644
index 000000000000..b2671a3e9e1e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteGdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteGdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteGdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteGdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86WriteGdtr)
+ASM_PFX(InternalX86WriteGdtr):
+    lgdt    [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteIdtr.asm b/MdePkg/Library/BaseLib/X64/WriteIdtr.asm
new file mode 100644
index 000000000000..f8fec3bcdf73
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteIdtr.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2010, 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.
+;
+; Module Name:
+;
+;   WriteIdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteIdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+InternalX86WriteIdtr  PROC
+    pushfq
+    cli
+    lidt    fword ptr [rcx]
+    popfq
+    ret
+InternalX86WriteIdtr  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteIdtr.nasm b/MdePkg/Library/BaseLib/X64/WriteIdtr.nasm
new file mode 100644
index 000000000000..12d2e2dfc3be
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteIdtr.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2010, 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.
+;
+; Module Name:
+;
+;   WriteIdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteIdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; InternalX86WriteIdtr (
+;   IN      CONST IA32_DESCRIPTOR     *Idtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalX86WriteIdtr)
+ASM_PFX(InternalX86WriteIdtr):
+    pushfq
+    cli
+    lidt    [rcx]
+    popfq
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteLdtr.asm b/MdePkg/Library/BaseLib/X64/WriteLdtr.asm
new file mode 100644
index 000000000000..5ff0a8e277a2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteLdtr.asm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteLdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteLdtr (
+;   IN UINT16 Ldtr
+;   );
+;------------------------------------------------------------------------------
+AsmWriteLdtr    PROC
+    lldt    cx
+    ret
+AsmWriteLdtr    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteLdtr.nasm b/MdePkg/Library/BaseLib/X64/WriteLdtr.nasm
new file mode 100644
index 000000000000..f29e0a1d71d8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteLdtr.nasm
@@ -0,0 +1,38 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteLdtr.Asm
+;
+; Abstract:
+;
+;   AsmWriteLdtr function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteLdtr (
+;   IN UINT16 Ldtr
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteLdtr)
+ASM_PFX(AsmWriteLdtr):
+    lldt    cx
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm0.asm b/MdePkg/Library/BaseLib/X64/WriteMm0.asm
new file mode 100644
index 000000000000..15d7e9e896f8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm0.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm0.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm0 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm0 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0c1h
+    ret
+AsmWriteMm0 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm0.nasm b/MdePkg/Library/BaseLib/X64/WriteMm0.nasm
new file mode 100644
index 000000000000..0fcd95d7e00c
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm0.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm0.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm0 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm0 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm0)
+ASM_PFX(AsmWriteMm0):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xc1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm1.asm b/MdePkg/Library/BaseLib/X64/WriteMm1.asm
new file mode 100644
index 000000000000..b751d91f03c6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm1.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm1.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm1 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm1 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0c9h
+    ret
+AsmWriteMm1 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm1.nasm b/MdePkg/Library/BaseLib/X64/WriteMm1.nasm
new file mode 100644
index 000000000000..ed767862bea9
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm1.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm1.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm1 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm1 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm1)
+ASM_PFX(AsmWriteMm1):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xc9
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm2.asm b/MdePkg/Library/BaseLib/X64/WriteMm2.asm
new file mode 100644
index 000000000000..67f9e5966508
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm2.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm2.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm2 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm2 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0d1h
+    ret
+AsmWriteMm2 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm2.nasm b/MdePkg/Library/BaseLib/X64/WriteMm2.nasm
new file mode 100644
index 000000000000..ccdcbbcc7140
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm2.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm2.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm2 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm2 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm2)
+ASM_PFX(AsmWriteMm2):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xd1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm3.asm b/MdePkg/Library/BaseLib/X64/WriteMm3.asm
new file mode 100644
index 000000000000..6e9daf50fc8a
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm3.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm3.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm3 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm3 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0d9h
+    ret
+AsmWriteMm3 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm3.nasm b/MdePkg/Library/BaseLib/X64/WriteMm3.nasm
new file mode 100644
index 000000000000..7f6a6d3e13e2
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm3.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm3.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm3 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm3 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm3)
+ASM_PFX(AsmWriteMm3):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xd9
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm4.asm b/MdePkg/Library/BaseLib/X64/WriteMm4.asm
new file mode 100644
index 000000000000..1fe0fbe80589
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm4.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm4.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm4 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm4 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0e1h
+    ret
+AsmWriteMm4 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm4.nasm b/MdePkg/Library/BaseLib/X64/WriteMm4.nasm
new file mode 100644
index 000000000000..3ea63e7ab8a0
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm4.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm4.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm4 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm4 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm4)
+ASM_PFX(AsmWriteMm4):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xe1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm5.asm b/MdePkg/Library/BaseLib/X64/WriteMm5.asm
new file mode 100644
index 000000000000..bdd7419f81de
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm5.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm5.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm5 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm5 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0e9h
+    ret
+AsmWriteMm5 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm5.nasm b/MdePkg/Library/BaseLib/X64/WriteMm5.nasm
new file mode 100644
index 000000000000..4b99ed42b49f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm5.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm5.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm5 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm5 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm5)
+ASM_PFX(AsmWriteMm5):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xe9
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm6.asm b/MdePkg/Library/BaseLib/X64/WriteMm6.asm
new file mode 100644
index 000000000000..852756a68d7e
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm6.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm6.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm6 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm6 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0f1h
+    ret
+AsmWriteMm6 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm6.nasm b/MdePkg/Library/BaseLib/X64/WriteMm6.nasm
new file mode 100644
index 000000000000..24a715b68e54
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm6.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm6.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm6 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm6 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm6)
+ASM_PFX(AsmWriteMm6):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xf1
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm7.asm b/MdePkg/Library/BaseLib/X64/WriteMm7.asm
new file mode 100644
index 000000000000..9760584b5899
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm7.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm7.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm7 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMm7 PROC
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      48h, 0fh, 6eh, 0f9h
+    ret
+AsmWriteMm7 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMm7.nasm b/MdePkg/Library/BaseLib/X64/WriteMm7.nasm
new file mode 100644
index 000000000000..0696c6d05201
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMm7.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMm7.Asm
+;
+; Abstract:
+;
+;   AsmWriteMm7 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID
+; EFIAPI
+; AsmWriteMm7 (
+;   IN UINT64   Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMm7)
+ASM_PFX(AsmWriteMm7):
+    ;
+    ; 64-bit MASM doesn't support MMX instructions, so use opcode here
+    ;
+    DB      0x48, 0xf, 0x6e, 0xf9
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMsr64.asm b/MdePkg/Library/BaseLib/X64/WriteMsr64.asm
new file mode 100644
index 000000000000..976439f7d1de
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMsr64.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMsr64.Asm
+;
+; Abstract:
+;
+;   AsmWriteMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmWriteMsr64 (
+;   IN UINT32  Index,
+;   IN UINT64  Value
+;   );
+;------------------------------------------------------------------------------
+AsmWriteMsr64   PROC
+    mov     rax, rdx                    ; meanwhile, rax <- return value
+    shr     rdx, 20h                    ; edx:eax contains the value to write
+    wrmsr
+    ret
+AsmWriteMsr64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseLib/X64/WriteMsr64.c b/MdePkg/Library/BaseLib/X64/WriteMsr64.c
new file mode 100644
index 000000000000..7099e2a6d49d
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMsr64.c
@@ -0,0 +1,42 @@
+/** @file
+  CpuBreakpoint function.
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+void __writemsr (unsigned long Register, unsigned __int64 Value);
+
+#pragma intrinsic(__writemsr)
+
+/**
+  Write data to MSR.
+
+  @param  Index                The register index of MSR.
+  @param  Value                Data wants to be written.
+
+  @return Value written to MSR.
+
+**/
+UINT64
+EFIAPI
+AsmWriteMsr64 (
+  IN UINT32  Index,
+  IN UINT64  Value
+  )
+{
+  __writemsr (Index, Value);
+  return Value;
+}
+
diff --git a/MdePkg/Library/BaseLib/X64/WriteMsr64.nasm b/MdePkg/Library/BaseLib/X64/WriteMsr64.nasm
new file mode 100644
index 000000000000..feec7e892803
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X64/WriteMsr64.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   WriteMsr64.Asm
+;
+; Abstract:
+;
+;   AsmWriteMsr64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; AsmWriteMsr64 (
+;   IN UINT32  Index,
+;   IN UINT64  Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(AsmWriteMsr64)
+ASM_PFX(AsmWriteMsr64):
+    mov     rax, rdx                    ; meanwhile, rax <- return value
+    shr     rdx, 0x20                    ; edx:eax contains the value to write
+    wrmsr
+    ret
+
diff --git a/MdePkg/Library/BaseLib/X86DisablePaging32.c b/MdePkg/Library/BaseLib/X86DisablePaging32.c
new file mode 100644
index 000000000000..77466b379a76
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86DisablePaging32.c
@@ -0,0 +1,66 @@
+/** @file
+  IA-32/x64 AsmDisablePaging32()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Disables the 32-bit paging mode on the CPU.
+
+  Disables the 32-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 32-paged protected
+  mode. This function is only available on IA-32. After the 32-bit paging mode
+  is disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be NULL. The function EntryPoint must never return.
+
+  If the current execution mode is not 32-bit paged mode, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit paged mode.
+  3)  CR0, CR3, and CR4 must be compatible with 32-bit paged mode.
+  4)  CR3 must point to valid page tables that guarantee that the pages for
+      this function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is disabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is disabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is
+                      disabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+AsmDisablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  ASSERT (EntryPoint != NULL);
+  ASSERT (NewStack != NULL);
+  InternalX86DisablePaging32 (EntryPoint, Context1, Context2, NewStack);
+}
diff --git a/MdePkg/Library/BaseLib/X86DisablePaging64.c b/MdePkg/Library/BaseLib/X86DisablePaging64.c
new file mode 100644
index 000000000000..4f248ce3ce09
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86DisablePaging64.c
@@ -0,0 +1,63 @@
+/** @file
+  IA-32/x64 AsmDisablePaging64()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Disables the 64-bit paging mode on the CPU.
+
+  Disables the 64-bit paging mode on the CPU and returns to 32-bit protected
+  mode. This function assumes the current execution mode is 64-paging mode.
+  This function is only available on x64. After the 64-bit paging mode is
+  disabled, control is transferred to the function specified by EntryPoint
+  using the new stack specified by NewStack and passing in the parameters
+  specified by Context1 and Context2. Context1 and Context2 are optional and
+  may be 0. The function EntryPoint must never return.
+
+  If the current execution mode is not 64-bit paged mode, then ASSERT().
+  If EntryPoint is 0, then ASSERT().
+  If NewStack is 0, then ASSERT().
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for 32-bit protected mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is disabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is disabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is disabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is disabled.
+
+**/
+VOID
+EFIAPI
+AsmDisablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT32                    EntryPoint,
+  IN      UINT32                    Context1,  OPTIONAL
+  IN      UINT32                    Context2,  OPTIONAL
+  IN      UINT32                    NewStack
+  )
+{
+  ASSERT (EntryPoint != 0);
+  ASSERT (NewStack != 0);
+  InternalX86DisablePaging64 (Cs, EntryPoint, Context1, Context2, NewStack);
+}
diff --git a/MdePkg/Library/BaseLib/X86EnablePaging32.c b/MdePkg/Library/BaseLib/X86EnablePaging32.c
new file mode 100644
index 000000000000..a596662335e5
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86EnablePaging32.c
@@ -0,0 +1,69 @@
+/** @file
+  IA-32/x64 AsmEnablePaging32()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Enables the 32-bit paging mode on the CPU.
+
+  Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode. This function is
+  only available on IA-32. After the 32-bit paging mode is enabled, control is
+  transferred to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  If the current execution mode is not 32-bit protected mode, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  There are a number of constraints that must be followed before calling this
+  function:
+  1)  Interrupts must be disabled.
+  2)  The caller must be in 32-bit protected mode with flat descriptors. This
+      means all descriptors must have a base of 0 and a limit of 4GB.
+  3)  CR0 and CR4 must be compatible with 32-bit protected mode with flat
+      descriptors.
+  4)  CR3 must point to valid page tables that will be used once the transition
+      is complete, and those page tables must guarantee that the pages for this
+      function and the stack are identity mapped.
+
+  @param  EntryPoint  A pointer to function to call with the new stack after
+                      paging is enabled.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function as the first parameter after paging is enabled.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function as the second parameter after paging is enabled.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+AsmEnablePaging32 (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  ASSERT (EntryPoint != NULL);
+  ASSERT (NewStack != NULL);
+  InternalX86EnablePaging32 (EntryPoint, Context1, Context2, NewStack);
+}
diff --git a/MdePkg/Library/BaseLib/X86EnablePaging64.c b/MdePkg/Library/BaseLib/X86EnablePaging64.c
new file mode 100644
index 000000000000..4a96a842a2c6
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86EnablePaging64.c
@@ -0,0 +1,65 @@
+/** @file
+  IA-32/x64 AsmEnablePaging64()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Enables the 64-bit paging mode on the CPU.
+
+  Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables
+  must be properly initialized prior to calling this service. This function
+  assumes the current execution mode is 32-bit protected mode with flat
+  descriptors. This function is only available on IA-32. After the 64-bit
+  paging mode is enabled, control is transferred to the function specified by
+  EntryPoint using the new stack specified by NewStack and passing in the
+  parameters specified by Context1 and Context2. Context1 and Context2 are
+  optional and may be 0. The function EntryPoint must never return.
+
+  If the current execution mode is not 32-bit protected mode with flat
+  descriptors, then ASSERT().
+  If EntryPoint is 0, then ASSERT().
+  If NewStack is 0, then ASSERT().
+
+  @param  Cs          The 16-bit selector to load in the CS before EntryPoint
+                      is called. The descriptor in the GDT that this selector
+                      references must be setup for long mode.
+  @param  EntryPoint  The 64-bit virtual address of the function to call with
+                      the new stack after paging is enabled.
+  @param  Context1    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the first parameter after
+                      paging is enabled.
+  @param  Context2    The 64-bit virtual address of the context to pass into
+                      the EntryPoint function as the second parameter after
+                      paging is enabled.
+  @param  NewStack    The 64-bit virtual address of the new stack to use for
+                      the EntryPoint function after paging is enabled.
+
+**/
+VOID
+EFIAPI
+AsmEnablePaging64 (
+  IN      UINT16                    Cs,
+  IN      UINT64                    EntryPoint,
+  IN      UINT64                    Context1,  OPTIONAL
+  IN      UINT64                    Context2,  OPTIONAL
+  IN      UINT64                    NewStack
+  )
+{
+  ASSERT (EntryPoint != 0);
+  ASSERT (NewStack != 0);
+  InternalX86EnablePaging64 (Cs, EntryPoint, Context1, Context2, NewStack);
+}
diff --git a/MdePkg/Library/BaseLib/X86FxRestore.c b/MdePkg/Library/BaseLib/X86FxRestore.c
new file mode 100644
index 000000000000..39ba95c724bd
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86FxRestore.c
@@ -0,0 +1,49 @@
+/** @file
+  IA-32/x64 AsmFxRestore()
+
+  Copyright (c) 2006 - 2012, 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 "BaseLibInternals.h"
+
+/**
+  Restores the current floating point/SSE/SSE2 context from a buffer.
+
+  Restores the current floating point/SSE/SSE2 state from the buffer specified
+  by Buffer. Buffer must be aligned on a 16-byte boundary. This function is
+  only available on IA-32 and x64.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-byte boundary, then ASSERT().
+  If Buffer was not saved with AsmFxSave(), then ASSERT().
+
+  @param  Buffer  A pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+AsmFxRestore (
+  IN      CONST IA32_FX_BUFFER      *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (0 == ((UINTN)Buffer & 0xf));
+
+  //
+  // Check the flag recorded by AsmFxSave()
+  //
+  ASSERT (0xAA5555AA == *(UINT32 *) (&Buffer->Buffer[sizeof (Buffer->Buffer) - 4]));
+
+  InternalX86FxRestore (Buffer);
+}
diff --git a/MdePkg/Library/BaseLib/X86FxSave.c b/MdePkg/Library/BaseLib/X86FxSave.c
new file mode 100644
index 000000000000..270b1fd10039
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86FxSave.c
@@ -0,0 +1,48 @@
+/** @file
+  IA-32/x64 AsmFxSave()
+
+  Copyright (c) 2006 - 2012, 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 "BaseLibInternals.h"
+
+/**
+  Save the current floating point/SSE/SSE2 context to a buffer.
+
+  Saves the current floating point/SSE/SSE2 state to the buffer specified by
+  Buffer. Buffer must be aligned on a 16-byte boundary. This function is only
+  available on IA-32 and x64.
+
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-byte boundary, then ASSERT().
+
+  @param  Buffer  A pointer to a buffer to save the floating point/SSE/SSE2 context.
+
+**/
+VOID
+EFIAPI
+AsmFxSave (
+  OUT     IA32_FX_BUFFER            *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (0 == ((UINTN)Buffer & 0xf));
+
+  InternalX86FxSave (Buffer);
+
+  //
+  // Mark one flag at end of Buffer, it will be check by AsmFxRestor()
+  //
+  *(UINT32 *) (&Buffer->Buffer[sizeof (Buffer->Buffer) - 4]) = 0xAA5555AA;
+}
diff --git a/MdePkg/Library/BaseLib/X86GetInterruptState.c b/MdePkg/Library/BaseLib/X86GetInterruptState.c
new file mode 100644
index 000000000000..51166e52076f
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86GetInterruptState.c
@@ -0,0 +1,41 @@
+/** @file
+  IA-32/x64 GetInterruptState()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+
+/**
+  Retrieves the current CPU interrupt state.
+
+  Returns TRUE is interrupts are currently enabled. Otherwise
+  returns FALSE.
+
+  @retval TRUE  CPU interrupts are enabled.
+  @retval FALSE CPU interrupts are disabled.
+
+**/
+BOOLEAN
+EFIAPI
+GetInterruptState (
+  VOID
+  )
+{
+  IA32_EFLAGS32                     EFlags;
+
+  EFlags.UintN = AsmReadEflags ();
+  return (BOOLEAN)(1 == EFlags.Bits.IF);
+}
+
+
diff --git a/MdePkg/Library/BaseLib/X86MemoryFence.c b/MdePkg/Library/BaseLib/X86MemoryFence.c
new file mode 100644
index 000000000000..8c3d094a83b7
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86MemoryFence.c
@@ -0,0 +1,32 @@
+/** @file
+  IA-32/x64 MemoryFence().
+
+  Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+
+
+/**
+  Used to serialize load and store operations.
+
+  All loads and stores that proceed calls to this function are guaranteed to be
+  globally visible when this function returns.
+
+**/
+VOID
+EFIAPI
+MemoryFence (
+  VOID
+  )
+{
+  return;
+}
diff --git a/MdePkg/Library/BaseLib/X86Msr.c b/MdePkg/Library/BaseLib/X86Msr.c
new file mode 100644
index 000000000000..7ad3a2f15c08
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86Msr.c
@@ -0,0 +1,660 @@
+/** @file
+  IA-32/x64 MSR functions.
+
+  Copyright (c) 2006 - 2012, 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 "BaseLibInternals.h"
+
+
+/**
+  Returns the lower 32-bits of a Machine Specific Register(MSR).
+
+  Reads and returns the lower 32-bits of the MSR specified by Index.
+  No parameter checking is performed on Index, and some Index values may cause
+  CPU exceptions. The caller must either guarantee that Index is valid, or the
+  caller must set up exception handlers to catch the exceptions. This function
+  is only available on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to read.
+
+  @return The lower 32 bits of the MSR identified by Index.
+
+**/
+UINT32
+EFIAPI
+AsmReadMsr32 (
+  IN      UINT32                    Index
+  )
+{
+  return (UINT32)AsmReadMsr64 (Index);
+}
+
+/**
+  Writes a 32-bit value to a Machine Specific Register(MSR), and returns the value.
+  The upper 32-bits of the MSR are set to zero.
+
+  Writes the 32-bit value specified by Value to the MSR specified by Index. The
+  upper 32-bits of the MSR write are set to zero. The 32-bit value written to
+  the MSR is returned. No parameter checking is performed on Index or Value,
+  and some of these may cause CPU exceptions. The caller must either guarantee
+  that Index and Value are valid, or the caller must establish proper exception
+  handlers. This function is only available on IA-32 and x64.
+
+  @param  Index The 32-bit MSR index to write.
+  @param  Value The 32-bit value to write to the MSR.
+
+  @return Value
+
+**/
+UINT32
+EFIAPI
+AsmWriteMsr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    Value
+  )
+{
+  return (UINT32)AsmWriteMsr64 (Index, Value);
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise OR on the lower 32-bits, and
+  writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the lower 32-bits of the read result and the value specified by
+  OrData, and writes the result to the 64-bit MSR specified by Index. The lower
+  32-bits of the value written to the MSR is returned. No parameter checking is
+  performed on Index or OrData, and some of these may cause CPU exceptions. The
+  caller must either guarantee that Index and OrData are valid, or the caller
+  must establish proper exception handlers. This function is only available on
+  IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  OrData  The value to OR with the read value from the MSR.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrOr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    OrData
+  )
+{
+  return (UINT32)AsmMsrOr64 (Index, OrData);
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND on the lower 32-bits, and writes
+  the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  lower 32-bits of the read result and the value specified by AndData, and
+  writes the result to the 64-bit MSR specified by Index. The lower 32-bits of
+  the value written to the MSR is returned. No parameter checking is performed
+  on Index or AndData, and some of these may cause CPU exceptions. The caller
+  must either guarantee that Index and AndData are valid, or the caller must
+  establish proper exception handlers. This function is only available on IA-32
+  and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrAnd32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    AndData
+  )
+{
+  return (UINT32)AsmMsrAnd64 (Index, AndData);
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise OR
+  on the lower 32-bits, and writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  lower 32-bits of the read result and the value specified by AndData
+  preserving the upper 32-bits, performs a bitwise OR between the
+  result of the AND operation and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Address. The lower 32-bits of the value
+  written to the MSR is returned. No parameter checking is performed on Index,
+  AndData, or OrData, and some of these may cause CPU exceptions. The caller
+  must either guarantee that Index, AndData, and OrData are valid, or the
+  caller must establish proper exception handlers. This function is only
+  available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The lower 32-bit value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrAndThenOr32 (
+  IN      UINT32                    Index,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return (UINT32)AsmMsrAndThenOr64 (Index, AndData, OrData);
+}
+
+/**
+  Reads a bit field of an MSR.
+
+  Reads the bit field in the lower 32-bits of a 64-bit MSR. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned. The caller must either guarantee that Index is valid, or the caller
+  must set up exception handlers to catch the exceptions. This function is only
+  available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The bit field read from the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldRead32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (AsmReadMsr32 (Index), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an MSR.
+
+  Writes Value to a bit field in the lower 32-bits of a 64-bit MSR. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination MSR are preserved. The lower 32-bits of the MSR written is
+  returned. The caller must either guarantee that Index and the data written 
+  is valid, or the caller must set up exception handlers to catch the exceptions. 
+  This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldWrite32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT (EndBit < sizeof (Value) * 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)AsmMsrBitFieldWrite64 (Index, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The lower 32-bits of the value
+  written to the MSR are returned. Extra left bits in OrData are stripped. The
+  caller must either guarantee that Index and the data written is valid, or
+  the caller must set up exception handlers to catch the exceptions. This
+  function is only available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the MSR.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldOr32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT (EndBit < sizeof (OrData) * 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)AsmMsrBitFieldOr64 (Index, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by AndData, and writes the result to the
+  64-bit MSR specified by Index. The lower 32-bits of the value written to the
+  MSR are returned. Extra left bits in AndData are stripped. The caller must
+  either guarantee that Index and the data written is valid, or the caller must
+  set up exception handlers to catch the exceptions. This function is only
+  available on IA-32 and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the MSR.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldAnd32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  ASSERT (EndBit < sizeof (AndData) * 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)AsmMsrBitFieldAnd64 (Index, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by a
+  bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit MSR specified by Index. The
+  lower 32-bits of the value written to the MSR are returned. Extra left bits
+  in both AndData and OrData are stripped. The caller must either guarantee
+  that Index and the data written is valid, or the caller must set up exception
+  handlers to catch the exceptions. This function is only available on IA-32
+  and x64.
+
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the MSR.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The lower 32-bit of the value written to the MSR.
+
+**/
+UINT32
+EFIAPI
+AsmMsrBitFieldAndThenOr32 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT (EndBit < sizeof (AndData) * 8);
+  ASSERT (StartBit <= EndBit);
+  return (UINT32)AsmMsrBitFieldAndThenOr64 (
+                   Index,
+                   StartBit,
+                   EndBit,
+                   AndData,
+                   OrData
+                   );
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise OR, and writes the result
+  back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The value written to the MSR is
+  returned. No parameter checking is performed on Index or OrData, and some of
+  these may cause CPU exceptions. The caller must either guarantee that Index
+  and OrData are valid, or the caller must establish proper exception handlers.
+  This function is only available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  OrData  The value to OR with the read value from the MSR.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrOr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    OrData
+  )
+{
+  return AsmWriteMsr64 (Index, AsmReadMsr64 (Index) | OrData);
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND, and writes the result back to the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by OrData, and writes the result to the
+  64-bit MSR specified by Index. The value written to the MSR is returned. No
+  parameter checking is performed on Index or OrData, and some of these may
+  cause CPU exceptions. The caller must either guarantee that Index and OrData
+  are valid, or the caller must establish proper exception handlers. This
+  function is only available on IA-32 and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrAnd64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    AndData
+  )
+{
+  return AsmWriteMsr64 (Index, AsmReadMsr64 (Index) & AndData);
+}
+
+/**
+  Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between read
+  result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit MSR specified by Index. The value written
+  to the MSR is returned. No parameter checking is performed on Index, AndData,
+  or OrData, and some of these may cause CPU exceptions. The caller must either
+  guarantee that Index, AndData, and OrData are valid, or the caller must
+  establish proper exception handlers. This function is only available on IA-32
+  and x64.
+
+  @param  Index   The 32-bit MSR index to write.
+  @param  AndData The value to AND with the read value from the MSR.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrAndThenOr64 (
+  IN      UINT32                    Index,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return AsmWriteMsr64 (Index, (AsmReadMsr64 (Index) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an MSR.
+
+  Reads the bit field in the 64-bit MSR. The bit field is specified by the
+  StartBit and the EndBit. The value of the bit field is returned. The caller
+  must either guarantee that Index is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read from the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldRead64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (AsmReadMsr64 (Index), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an MSR.
+
+  Writes Value to a bit field in a 64-bit MSR. The bit field is specified by
+  the StartBit and the EndBit. All other bits in the destination MSR are
+  preserved. The MSR written is returned. The caller must either guarantee 
+  that Index and the data written is valid, or the caller must set up exception 
+  handlers to catch the exceptions. This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldWrite64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return AsmWriteMsr64 (
+           Index,
+           BitFieldWrite64 (AsmReadMsr64 (Index), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit MSR specified by Index. The value written to the MSR is
+  returned. Extra left bits in OrData are stripped. The caller must either
+  guarantee that Index and the data written is valid, or the caller must set up
+  exception handlers to catch the exceptions. This function is only available
+  on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldOr64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return AsmWriteMsr64 (
+           Index,
+           BitFieldOr64 (AsmReadMsr64 (Index), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
+  read result and the value specified by AndData, and writes the result to the
+  64-bit MSR specified by Index. The value written to the MSR is returned.
+  Extra left bits in AndData are stripped. The caller must either guarantee
+  that Index and the data written is valid, or the caller must set up exception
+  handlers to catch the exceptions. This function is only available on IA-32
+  and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the bit field.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldAnd64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return AsmWriteMsr64 (
+           Index,
+           BitFieldAnd64 (AsmReadMsr64 (Index), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit MSR.
+
+  Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by
+  a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit MSR specified by Index. The
+  value written to the MSR is returned. Extra left bits in both AndData and
+  OrData are stripped. The caller must either guarantee that Index and the data
+  written is valid, or the caller must set up exception handlers to catch the
+  exceptions. This function is only available on IA-32 and x64.
+
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Index     The 32-bit MSR index to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the bit field.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MSR.
+
+**/
+UINT64
+EFIAPI
+AsmMsrBitFieldAndThenOr64 (
+  IN      UINT32                    Index,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return AsmWriteMsr64 (
+           Index,
+           BitFieldAndThenOr64 (
+             AsmReadMsr64 (Index),
+             StartBit,
+             EndBit,
+             AndData,
+             OrData
+             )
+           );
+}
diff --git a/MdePkg/Library/BaseLib/X86RdRand.c b/MdePkg/Library/BaseLib/X86RdRand.c
new file mode 100644
index 000000000000..5aaab4ec4d81
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86RdRand.c
@@ -0,0 +1,79 @@
+/** @file
+  IA-32/x64 AsmRdRandxx()
+  Generates random number through CPU RdRand instruction.
+
+  Copyright (c) 2016, 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 "BaseLibInternals.h"
+
+/**
+  Generates a 16-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+ **/
+BOOLEAN
+EFIAPI
+AsmRdRand16 (
+  OUT     UINT16                    *Rand
+  )
+{
+  ASSERT (Rand != NULL);
+  return InternalX86RdRand16 (Rand);
+}
+
+/**
+  Generates a 32-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+AsmRdRand32 (
+  OUT     UINT32                    *Rand
+  )
+{
+  ASSERT (Rand != NULL);
+  return InternalX86RdRand32 (Rand);
+}
+
+/**
+  Generates a 64-bit random number through RDRAND instruction.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out]  Rand     Buffer pointer to store the random result.
+
+  @retval TRUE          RDRAND call was successful.
+  @retval FALSE         Failed attempts to call RDRAND.
+
+**/
+BOOLEAN
+EFIAPI
+AsmRdRand64  (
+  OUT     UINT64                    *Rand
+  )
+{
+  ASSERT (Rand != NULL);
+  return InternalX86RdRand64 (Rand);
+}
diff --git a/MdePkg/Library/BaseLib/X86ReadGdtr.c b/MdePkg/Library/BaseLib/X86ReadGdtr.c
new file mode 100644
index 000000000000..d0a59193f30b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86ReadGdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  IA-32/x64 AsmReadGdtr()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Reads the current Global Descriptor Table Register(GDTR) descriptor.
+
+  Reads and returns the current GDTR descriptor and returns it in Gdtr. This
+  function is only available on IA-32 and x64.
+
+  If Gdtr is NULL, then ASSERT().
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmReadGdtr (
+  OUT     IA32_DESCRIPTOR           *Gdtr
+  )
+{
+  ASSERT (Gdtr != NULL);
+  InternalX86ReadGdtr (Gdtr);
+}
diff --git a/MdePkg/Library/BaseLib/X86ReadIdtr.c b/MdePkg/Library/BaseLib/X86ReadIdtr.c
new file mode 100644
index 000000000000..8a550115f254
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86ReadIdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  IA-32/x64 AsmReadIdtr()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Reads the current Interrupt Descriptor Table Register(IDTR) descriptor.
+
+  Reads and returns the current IDTR descriptor and returns it in Idtr. This
+  function is only available on IA-32 and x64.
+
+  If Idtr is NULL, then ASSERT().
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmReadIdtr (
+  OUT     IA32_DESCRIPTOR           *Idtr
+  )
+{
+  ASSERT (Idtr != NULL);
+  InternalX86ReadIdtr (Idtr);
+}
diff --git a/MdePkg/Library/BaseLib/X86Thunk.c b/MdePkg/Library/BaseLib/X86Thunk.c
new file mode 100644
index 000000000000..f0f801ed126b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86Thunk.c
@@ -0,0 +1,268 @@
+/** @file
+  Real Mode Thunk Functions for IA32 and x64.
+
+  Copyright (c) 2006 - 2012, 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 "BaseLibInternals.h"
+
+extern CONST UINT8                  m16Start;
+extern CONST UINT16                 m16Size;
+extern CONST UINT16                 mThunk16Attr;
+extern CONST UINT16                 m16Gdt;
+extern CONST UINT16                 m16GdtrBase;
+extern CONST UINT16                 mTransition;
+
+/**
+  Invokes 16-bit code in big real mode and returns the updated register set.
+
+  This function transfers control to the 16-bit code specified by CS:EIP using
+  the stack specified by SS:ESP in RegisterSet. The updated registers are saved
+  on the real mode stack and the starting address of the save area is returned.
+
+  @param  RegisterSet Values of registers before invocation of 16-bit code.
+  @param  Transition  The pointer to the transition code under 1MB.
+
+  @return The pointer to a IA32_REGISTER_SET structure containing the updated
+          register values.
+
+**/
+IA32_REGISTER_SET *
+EFIAPI
+InternalAsmThunk16 (
+  IN      IA32_REGISTER_SET         *RegisterSet,
+  IN OUT  VOID                      *Transition
+  );
+
+/**
+  Retrieves the properties for 16-bit thunk functions.
+
+  Computes the size of the buffer and stack below 1MB required to use the
+  AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
+  buffer size is returned in RealModeBufferSize, and the stack size is returned
+  in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
+  then the actual minimum stack size is ExtraStackSize plus the maximum number
+  of bytes that need to be passed to the 16-bit real mode code.
+
+  If RealModeBufferSize is NULL, then ASSERT().
+  If ExtraStackSize is NULL, then ASSERT().
+
+  @param  RealModeBufferSize  A pointer to the size of the buffer below 1MB
+                              required to use the 16-bit thunk functions.
+  @param  ExtraStackSize      A pointer to the extra size of stack below 1MB
+                              that the 16-bit thunk functions require for
+                              temporary storage in the transition to and from
+                              16-bit real mode.
+
+**/
+VOID
+EFIAPI
+AsmGetThunk16Properties (
+  OUT     UINT32                    *RealModeBufferSize,
+  OUT     UINT32                    *ExtraStackSize
+  )
+{
+  ASSERT (RealModeBufferSize != NULL);
+  ASSERT (ExtraStackSize != NULL);
+
+  *RealModeBufferSize = m16Size;
+
+  //
+  // Extra 4 bytes for return address, and another 4 bytes for mode transition
+  //
+  *ExtraStackSize = sizeof (IA32_DWORD_REGS) + 8;
+}
+
+/**
+  Prepares all structures a code required to use AsmThunk16().
+
+  Prepares all structures and code required to use AsmThunk16().
+  
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1.
+
+  If ThunkContext is NULL, then ASSERT().
+
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmPrepareThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  )
+{
+  IA32_SEGMENT_DESCRIPTOR           *RealModeGdt;
+
+  ASSERT (ThunkContext != NULL);
+  ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
+  ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
+  ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
+
+  CopyMem (ThunkContext->RealModeBuffer, &m16Start, m16Size);
+
+  //
+  // Point RealModeGdt to the GDT to be used in transition
+  //
+  // RealModeGdt[0]: Reserved as NULL descriptor
+  // RealModeGdt[1]: Code Segment
+  // RealModeGdt[2]: Data Segment
+  // RealModeGdt[3]: Call Gate
+  //
+  RealModeGdt = (IA32_SEGMENT_DESCRIPTOR*)(
+                  (UINTN)ThunkContext->RealModeBuffer + m16Gdt);
+
+  //
+  // Update Code & Data Segment Descriptor
+  //
+  RealModeGdt[1].Bits.BaseLow =
+    (UINT32)(UINTN)ThunkContext->RealModeBuffer & ~0xf;
+  RealModeGdt[1].Bits.BaseMid =
+    (UINT32)(UINTN)ThunkContext->RealModeBuffer >> 16;
+
+  //
+  // Update transition code entry point offset
+  //
+  *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mTransition) +=
+    (UINT32)(UINTN)ThunkContext->RealModeBuffer & 0xf;
+
+  //
+  // Update Segment Limits for both Code and Data Segment Descriptors
+  //
+  if ((ThunkContext->ThunkAttributes & THUNK_ATTRIBUTE_BIG_REAL_MODE) == 0) {
+    //
+    // Set segment limits to 64KB
+    //
+    RealModeGdt[1].Bits.LimitHigh = 0;
+    RealModeGdt[1].Bits.G = 0;
+    RealModeGdt[2].Bits.LimitHigh = 0;
+    RealModeGdt[2].Bits.G = 0;
+  }
+
+  //
+  // Update GDTBASE for this thunk context
+  //
+  *(VOID**)((UINTN)ThunkContext->RealModeBuffer + m16GdtrBase) = RealModeGdt;
+
+  //
+  // Update Thunk Attributes
+  //
+  *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mThunk16Attr) =
+    ThunkContext->ThunkAttributes;
+}
+
+/**
+  Transfers control to a 16-bit real mode entry point and returns the results.
+
+  Transfers control to a 16-bit real mode entry point and returns the results.
+  AsmPrepareThunk16() must be called with ThunkContext before this function is used.
+  This function must be called with interrupts disabled.
+
+  The register state from the RealModeState field of ThunkContext is restored just prior 
+  to calling the 16-bit real mode entry point.  This includes the EFLAGS field of RealModeState, 
+  which is used to set the interrupt state when a 16-bit real mode entry point is called.
+  Control is transferred to the 16-bit real mode entry point specified by the CS and Eip fields of RealModeState.
+  The stack is initialized to the SS and ESP fields of RealModeState.  Any parameters passed to 
+  the 16-bit real mode code must be populated by the caller at SS:ESP prior to calling this function.  
+  The 16-bit real mode entry point is invoked with a 16-bit CALL FAR instruction,
+  so when accessing stack contents, the 16-bit real mode code must account for the 16-bit segment 
+  and 16-bit offset of the return address that were pushed onto the stack. The 16-bit real mode entry 
+  point must exit with a RETF instruction. The register state is captured into RealModeState immediately 
+  after the RETF instruction is executed.
+  
+  If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, 
+  or any of the 16-bit real mode code makes a SW interrupt, then the caller is responsible for making sure 
+  the IDT at address 0 is initialized to handle any HW or SW interrupts that may occur while in 16-bit real mode. 
+  
+  If EFLAGS specifies interrupts enabled, or any of the 16-bit real mode code enables interrupts, 
+  then the caller is responsible for making sure the 8259 PIC is in a state compatible with 16-bit real mode.  
+  This includes the base vectors, the interrupt masks, and the edge/level trigger mode.
+  
+  If THUNK_ATTRIBUTE_BIG_REAL_MODE is set in the ThunkAttributes field of ThunkContext, then the user code 
+  is invoked in big real mode.  Otherwise, the user code is invoked in 16-bit real mode with 64KB segment limits.
+  
+  If neither THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 nor THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in 
+  ThunkAttributes, then it is assumed that the user code did not enable the A20 mask, and no attempt is made to 
+  disable the A20 mask.
+  
+  If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is set and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is clear in 
+  ThunkAttributes, then attempt to use the INT 15 service to disable the A20 mask.  If this INT 15 call fails, 
+  then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports.
+  
+  If THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 is clear and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL is set in 
+  ThunkAttributes, then attempt to disable the A20 mask by directly accessing the 8042 keyboard controller I/O ports.
+    
+  If ThunkContext is NULL, then ASSERT().
+  If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
+  If both THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 and THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL are set in 
+  ThunkAttributes, then ASSERT().
+
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1.
+  
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  )
+{
+  IA32_REGISTER_SET                 *UpdatedRegs;
+
+  ASSERT (ThunkContext != NULL);
+  ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
+  ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
+  ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
+  ASSERT (((ThunkContext->ThunkAttributes & (THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 | THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL)) != \
+           (THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15 | THUNK_ATTRIBUTE_DISABLE_A20_MASK_KBD_CTRL)));
+           
+  UpdatedRegs = InternalAsmThunk16 (
+                  ThunkContext->RealModeState,
+                  ThunkContext->RealModeBuffer
+                  );
+
+  CopyMem (ThunkContext->RealModeState, UpdatedRegs, sizeof (*UpdatedRegs));
+}
+
+/**
+  Prepares all structures and code for a 16-bit real mode thunk, transfers
+  control to a 16-bit real mode entry point, and returns the results.
+
+  Prepares all structures and code for a 16-bit real mode thunk, transfers
+  control to a 16-bit real mode entry point, and returns the results. If the
+  caller only need to perform a single 16-bit real mode thunk, then this
+  service should be used. If the caller intends to make more than one 16-bit
+  real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
+  once and AsmThunk16() can be called for each 16-bit real mode thunk.
+
+  This interface is limited to be used in either physical mode or virtual modes with paging enabled where the
+  virtual to physical mappings for ThunkContext.RealModeBuffer is mapped 1:1.
+  
+  See AsmPrepareThunk16() and AsmThunk16() for the detailed description and ASSERT() conditions.
+
+  @param  ThunkContext  A pointer to the context structure that describes the
+                        16-bit real mode code to call.
+
+**/
+VOID
+EFIAPI
+AsmPrepareAndThunk16 (
+  IN OUT  THUNK_CONTEXT             *ThunkContext
+  )
+{
+  AsmPrepareThunk16 (ThunkContext);
+  AsmThunk16 (ThunkContext);
+}
diff --git a/MdePkg/Library/BaseLib/X86WriteGdtr.c b/MdePkg/Library/BaseLib/X86WriteGdtr.c
new file mode 100644
index 000000000000..7544e8a0d0a8
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86WriteGdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  IA-32/x64 AsmWriteGdtr()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Writes the current Global Descriptor Table Register (GDTR) descriptor.
+
+  Writes and the current GDTR descriptor specified by Gdtr. This function is
+  only available on IA-32 and x64.
+
+  If Gdtr is NULL, then ASSERT().
+
+  @param  Gdtr  The pointer to a GDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmWriteGdtr (
+  IN      CONST IA32_DESCRIPTOR     *Gdtr
+  )
+{
+  ASSERT (Gdtr != NULL);
+  InternalX86WriteGdtr (Gdtr);
+}
diff --git a/MdePkg/Library/BaseLib/X86WriteIdtr.c b/MdePkg/Library/BaseLib/X86WriteIdtr.c
new file mode 100644
index 000000000000..9060a925d00b
--- /dev/null
+++ b/MdePkg/Library/BaseLib/X86WriteIdtr.c
@@ -0,0 +1,39 @@
+/** @file
+  IA-32/x64 AsmWriteIdtr()
+
+  Copyright (c) 2006 - 2008, 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 "BaseLibInternals.h"
+
+/**
+  Writes the current Interrupt Descriptor Table Register(IDTR) descriptor.
+
+  Writes the current IDTR descriptor and returns it in Idtr. This function is
+  only available on IA-32 and x64.
+
+  If Idtr is NULL, then ASSERT().
+
+  @param  Idtr  The pointer to a IDTR descriptor.
+
+**/
+VOID
+EFIAPI
+AsmWriteIdtr (
+  IN      CONST IA32_DESCRIPTOR     *Idtr
+  )
+{
+  ASSERT (Idtr != NULL);
+  InternalX86WriteIdtr (Idtr);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf b/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
new file mode 100644
index 000000000000..ffe81eda7845
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
@@ -0,0 +1,57 @@
+## @file
+#  Instance of Base Memory Library without assembly.
+#
+#  Base Memory Library implementation - no ASM.
+#
+#  Copyright (c) 2007 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLib
+  MODULE_UNI_FILE                = BaseMemoryLib.uni
+  FILE_GUID                      = fd44e603-002a-4b29-9f5f-529e815b6165
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources]
+  SetMem.c
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGeneric.c
+  MemLibGuid.c
+  CopyMem.c
+  MemLibInternals.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.uni b/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.uni
new file mode 100644
index 000000000000..458e262f8a7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Base Memory Library without assembly.
+//
+// Base Memory Library implementation - no ASM.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library without assembly"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library implementation - no ASM."
+
diff --git a/MdePkg/Library/BaseMemoryLib/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLib/CompareMemWrapper.c
new file mode 100644
index 000000000000..25a299fb2e3b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer A pointer to the destination buffer to compare.
+  @param  SourceBuffer      A pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/CopyMem.c b/MdePkg/Library/BaseMemoryLib/CopyMem.c
new file mode 100644
index 000000000000..0bd481df1728
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/CopyMem.c
@@ -0,0 +1,154 @@
+/** @file
+  Implementation of the InternalMemCopyMem routine. This function is broken
+  out into its own source file so that it can be excluded from a build for a
+  particular platform easily if an optimized version is desired.
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2012 - 2013, ARM Ltd. All rights reserved.<BR>
+  Copyright (c) 2016, Linaro Ltd. 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 "MemLibInternals.h"
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer The target of the copy request.
+  @param  SourceBuffer      The place to copy from.
+  @param  Length            The number of bytes to copy.
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  )
+{
+  //
+  // Declare the local variables that actually move the data elements as
+  // volatile to prevent the optimizer from replacing this function with
+  // the intrinsic memcpy()
+  //
+  volatile UINT8                    *Destination8;
+  CONST UINT8                       *Source8;
+  volatile UINT32                   *Destination32;
+  CONST UINT32                      *Source32;
+  volatile UINT64                   *Destination64;
+  CONST UINT64                      *Source64;
+  UINTN                             Alignment;
+
+  if ((((UINTN)DestinationBuffer & 0x7) == 0) && (((UINTN)SourceBuffer & 0x7) == 0) && (Length >= 8)) {
+    if (SourceBuffer > DestinationBuffer) {
+      Destination64 = (UINT64*)DestinationBuffer;
+      Source64 = (CONST UINT64*)SourceBuffer;
+      while (Length >= 8) {
+        *(Destination64++) = *(Source64++);
+        Length -= 8;
+      }
+
+      // Finish if there are still some bytes to copy
+      Destination8 = (UINT8*)Destination64;
+      Source8 = (CONST UINT8*)Source64;
+      while (Length-- != 0) {
+        *(Destination8++) = *(Source8++);
+      }
+    } else if (SourceBuffer < DestinationBuffer) {
+      Destination64 = (UINT64*)((UINTN)DestinationBuffer + Length);
+      Source64 = (CONST UINT64*)((UINTN)SourceBuffer + Length);
+
+      // Destination64 and Source64 were aligned on a 64-bit boundary
+      // but if length is not a multiple of 8 bytes then they won't be
+      // anymore.
+
+      Alignment = Length & 0x7;
+      if (Alignment != 0) {
+        Destination8 = (UINT8*)Destination64;
+        Source8 = (CONST UINT8*)Source64;
+
+        while (Alignment-- != 0) {
+          *(--Destination8) = *(--Source8);
+          --Length;
+        }
+        Destination64 = (UINT64*)Destination8;
+        Source64 = (CONST UINT64*)Source8;
+      }
+
+      while (Length > 0) {
+        *(--Destination64) = *(--Source64);
+        Length -= 8;
+      }
+    }
+  } else if ((((UINTN)DestinationBuffer & 0x3) == 0) && (((UINTN)SourceBuffer & 0x3) == 0) && (Length >= 4)) {
+    if (SourceBuffer > DestinationBuffer) {
+      Destination32 = (UINT32*)DestinationBuffer;
+      Source32 = (CONST UINT32*)SourceBuffer;
+      while (Length >= 4) {
+        *(Destination32++) = *(Source32++);
+        Length -= 4;
+      }
+
+      // Finish if there are still some bytes to copy
+      Destination8 = (UINT8*)Destination32;
+      Source8 = (CONST UINT8*)Source32;
+      while (Length-- != 0) {
+        *(Destination8++) = *(Source8++);
+      }
+    } else if (SourceBuffer < DestinationBuffer) {
+      Destination32 = (UINT32*)((UINTN)DestinationBuffer + Length);
+      Source32 = (CONST UINT32*)((UINTN)SourceBuffer + Length);
+
+      // Destination32 and Source32 were aligned on a 32-bit boundary
+      // but if length is not a multiple of 4 bytes then they won't be
+      // anymore.
+
+      Alignment = Length & 0x3;
+      if (Alignment != 0) {
+        Destination8 = (UINT8*)Destination32;
+        Source8 = (CONST UINT8*)Source32;
+
+        while (Alignment-- != 0) {
+          *(--Destination8) = *(--Source8);
+          --Length;
+        }
+        Destination32 = (UINT32*)Destination8;
+        Source32 = (CONST UINT32*)Source8;
+      }
+
+      while (Length > 0) {
+        *(--Destination32) = *(--Source32);
+        Length -= 4;
+      }
+    }
+  } else {
+    if (SourceBuffer > DestinationBuffer) {
+      Destination8 = (UINT8*)DestinationBuffer;
+      Source8 = (CONST UINT8*)SourceBuffer;
+      while (Length-- != 0) {
+        *(Destination8++) = *(Source8++);
+      }
+    } else if (SourceBuffer < DestinationBuffer) {
+      Destination8 = (UINT8*)DestinationBuffer + (Length - 1);
+      Source8 = (CONST UINT8*)SourceBuffer + (Length - 1);
+      while (Length-- != 0) {
+        *(Destination8--) = *(Source8--);
+      }
+    }
+  }
+  return DestinationBuffer;
+}
diff --git a/MdePkg/Library/BaseMemoryLib/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLib/CopyMemWrapper.c
new file mode 100644
index 000000000000..b89dc6d29c08
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   A pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        A pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLib/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/MemLibGeneric.c b/MdePkg/Library/BaseMemoryLib/MemLibGeneric.c
new file mode 100644
index 000000000000..f16755bfa6fd
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/MemLibGeneric.c
@@ -0,0 +1,293 @@
+/** @file
+  Architecture Independent Base Memory Library Implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT16*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT32*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT64*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer Memory to set.
+  @param  Length The number of bytes to set.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  return InternalMemSetMem (Buffer, Length, 0);
+}
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            Length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  )
+{
+  while ((--Length != 0) &&
+         (*(INT8*)DestinationBuffer == *(INT8*)SourceBuffer)) {
+    DestinationBuffer = (INT8*)DestinationBuffer + 1;
+    SourceBuffer = (INT8*)SourceBuffer + 1;
+  }
+  return (INTN)*(UINT8*)DestinationBuffer - (INTN)*(UINT8*)SourceBuffer;
+}
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  )
+{
+  CONST UINT8                       *Pointer;
+
+  Pointer = (CONST UINT8*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  CONST UINT16                      *Pointer;
+
+  Pointer = (CONST UINT16*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  CONST UINT32                      *Pointer;
+
+  Pointer = (CONST UINT32*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  CONST UINT64                      *Pointer;
+
+  Pointer = (CONST UINT64*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  CONST UINT8 *BufferData;
+  UINTN       Index;
+
+  BufferData = Buffer;
+  for (Index = 0; Index < Length; Index++) {
+    if (BufferData[Index] != 0) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
diff --git a/MdePkg/Library/BaseMemoryLib/MemLibGuid.c b/MdePkg/Library/BaseMemoryLib/MemLibGuid.c
new file mode 100644
index 000000000000..58b252d5ea6e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   A pointer to the destination GUID.
+  @param  SourceGuid        A pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/MemLibInternals.h b/MdePkg/Library/BaseMemoryLib/MemLibInternals.h
new file mode 100644
index 000000000000..87b4b644e5e0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer Target of copy
+  @param  SourceBuffer      Place to copy from
+  @param  Length            The number of bytes to copy
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The calue to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLib/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLib/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLib/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..a3243a67089c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLib/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLib/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..9e36070f696d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer, or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLib/SetMem.c b/MdePkg/Library/BaseMemoryLib/SetMem.c
new file mode 100644
index 000000000000..49a5fdee12ae
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/SetMem.c
@@ -0,0 +1,87 @@
+/** @file
+  Implementation of the EfiSetMem routine. This function is broken
+  out into its own source file so that it can be excluded from a
+  build for a particular platform easily if an optimized version
+  is desired.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2012 - 2013, ARM Ltd. All rights reserved.<BR>
+  Copyright (c) 2016, Linaro Ltd. 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 "MemLibInternals.h"
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set.
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  )
+{
+  //
+  // Declare the local variables that actually move the data elements as
+  // volatile to prevent the optimizer from replacing this function with
+  // the intrinsic memset()
+  //
+  volatile UINT8                    *Pointer8;
+  volatile UINT32                   *Pointer32;
+  volatile UINT64                   *Pointer64;
+  UINT32                            Value32;
+  UINT64                            Value64;
+
+  if ((((UINTN)Buffer & 0x7) == 0) && (Length >= 8)) {
+    // Generate the 64bit value
+    Value32 = (Value << 24) | (Value << 16) | (Value << 8) | Value;
+    Value64 = LShiftU64 (Value32, 32) | Value32;
+
+    Pointer64 = (UINT64*)Buffer;
+    while (Length >= 8) {
+      *(Pointer64++) = Value64;
+      Length -= 8;
+    }
+
+    // Finish with bytes if needed
+    Pointer8 = (UINT8*)Pointer64;
+  } else if ((((UINTN)Buffer & 0x3) == 0) && (Length >= 4)) {
+    // Generate the 32bit value
+    Value32 = (Value << 24) | (Value << 16) | (Value << 8) | Value;
+
+    Pointer32 = (UINT32*)Buffer;
+    while (Length >= 4) {
+      *(Pointer32++) = Value32;
+      Length -= 4;
+    }
+
+    // Finish with bytes if needed
+    Pointer8 = (UINT8*)Pointer32;
+  } else {
+    Pointer8 = (UINT8*)Buffer;
+  }
+  while (Length-- > 0) {
+    *(Pointer8++) = Value;
+  }
+  return Buffer;
+}
diff --git a/MdePkg/Library/BaseMemoryLib/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLib/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLib/SetMem32Wrapper.c
new file mode 100644
index 000000000000..7758e1f438db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLib/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLib/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLib/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLib/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLib/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLib/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.inf b/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.inf
new file mode 100644
index 000000000000..1c096fd7d7bc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.inf
@@ -0,0 +1,151 @@
+## @file
+#  Instance of Base Memory Library using MMX registers.
+#
+#  Base Memory Library that uses MMX registers for high performance.
+#  Optimized for use in DXE.
+#
+#  Copyright (c) 2006 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLibMmx
+  MODULE_UNI_FILE                = BaseMemoryLibMmx.uni
+  FILE_GUID                      = d458a654-f64c-49db-b8d1-3821306bf1f6
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[Sources]
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGuid.c
+  MemLibInternals.h
+
+[Sources.Ia32]
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.S
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.S
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.S
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.S
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.S
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.S
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.S
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.S
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.S
+  Ia32/SetMem.nasm
+  Ia32/SetMem.S
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.S
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.asm
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.asm
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.asm
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.asm
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.asm
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.asm
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.asm
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.asm
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.asm
+  Ia32/SetMem.nasm
+  Ia32/SetMem.asm
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.asm
+  Ia32/IsZeroBuffer.nasm
+
+[Sources.X64]
+  X64/ZeroMem.nasm
+  X64/ZeroMem.asm
+  X64/ScanMem64.nasm
+  X64/ScanMem64.asm
+  X64/ScanMem32.nasm
+  X64/ScanMem32.asm
+  X64/ScanMem16.nasm
+  X64/ScanMem16.asm
+  X64/ScanMem8.nasm
+  X64/ScanMem8.asm
+  X64/CompareMem.nasm
+  X64/CompareMem.asm
+  X64/SetMem64.nasm
+  X64/SetMem64.asm
+  X64/SetMem32.nasm
+  X64/SetMem32.asm
+  X64/SetMem16.nasm
+  X64/SetMem16.asm
+  X64/SetMem.nasm
+  X64/SetMem.asm
+  X64/CopyMem.nasm
+  X64/CopyMem.asm
+  X64/ScanMem64.nasm
+  X64/ScanMem64.S
+  X64/ScanMem32.nasm
+  X64/ScanMem32.S
+  X64/ScanMem16.nasm
+  X64/ScanMem16.S
+  X64/ScanMem8.nasm
+  X64/ScanMem8.S
+  X64/CompareMem.nasm
+  X64/CompareMem.S
+  X64/SetMem64.nasm
+  X64/SetMem64.S
+  X64/SetMem32.nasm
+  X64/SetMem32.S
+  X64/SetMem16.nasm
+  X64/SetMem16.S
+  X64/ZeroMem.nasm
+  X64/ZeroMem.S
+  X64/SetMem.nasm
+  X64/SetMem.S
+  X64/CopyMem.nasm
+  X64/CopyMem.S
+  X64/IsZeroBuffer.nasm
+
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.uni b/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.uni
new file mode 100644
index 000000000000..6bc43ba5ded9
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library using MMX registers.
+//
+// Base Memory Library that uses MMX registers for high performance.
+// Optimized for use in DXE.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library using MMX registers"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library that uses MMX registers for high performance. Optimized for use in DXE."
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLibMmx/CompareMemWrapper.c
new file mode 100644
index 000000000000..aa7c2aab812c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLibMmx/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.S
new file mode 100644
index 000000000000..1c9239eb3d09
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.S
@@ -0,0 +1,55 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CompareMem.Asm
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCompareMem):
+    push    %esi
+    push    %edi
+    movl    12(%esp), %esi
+    movl    16(%esp), %edi
+    movl    20(%esp), %ecx
+    repe    cmpsb
+    movzbl  -1(%esi), %eax
+    movzbl  -1(%edi), %edx
+    subl    %edx, %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.asm
new file mode 100644
index 000000000000..ba31a1875712
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    esi edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte ptr [esi - 1]
+    movzx   edx, byte ptr [edi - 1]
+    sub     eax, edx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.nasm
new file mode 100644
index 000000000000..e8d1abdc17fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CompareMem.nasm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte [esi - 1]
+    movzx   edx, byte [edi - 1]
+    sub     eax, edx
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.S
new file mode 100644
index 000000000000..0c204a3ac318
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.S
@@ -0,0 +1,86 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   CopyMem.asm
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCopyMem):
+    push    %esi
+    push    %edi
+    movl    16(%esp), %esi              # esi <- Source
+    movl    12(%esp), %edi              # edi <- Destination
+    movl    20(%esp), %edx              # edx <- Count
+    leal    -1(%esi,%edx,), %eax        # eax <- End of Source
+    cmpl    %edi, %esi
+    jae     L0
+    cmpl    %edi, %eax                  # Overlapped?
+    jae     L_CopyBackward              # Copy backward if overlapped
+L0:
+    xorl    %ecx, %ecx
+    subl    %esi, %ecx
+    andl    $7, %ecx                    # ecx + esi aligns on 8-byte boundary
+    jz      L1
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx                  # edx <- remaining bytes to copy
+    rep
+    movsb
+L1:
+    movl    %edx, %ecx
+    andl    $7, %edx
+    shrl    $3, %ecx                    # ecx <- # of Qwords to copy
+    jz      L_CopyBytes
+    pushl   %eax
+    pushl   %eax
+    movq    %mm0, (%esp)                # save mm0
+L2:
+    movq    (%esi), %mm0
+    movq    %mm0, (%edi)
+    addl    $8, %esi
+    addl    $8, %edi
+    loop    L2
+    movq    (%esp), %mm0                # restore mm0
+    popl    %ecx                        # stack cleanup
+    popl    %ecx                        # stack cleanup
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movl    %eax, %esi                  # esi <- Last byte in Source
+    leal    -1(%edi,%edx,), %edi        # edi <- Last byte in Destination
+    std
+L_CopyBytes:
+    movl    %edx, %ecx
+    rep
+    movsb
+    cld
+    movl    12(%esp), %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.asm
new file mode 100644
index 000000000000..a64df5d8ca18
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.asm
@@ -0,0 +1,77 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    esi edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     @F
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    mov     ecx, edx
+    and     edx, 7
+    shr     ecx, 3                      ; ecx <- # of Qwords to copy
+    jz      @CopyBytes
+    push    eax
+    push    eax
+    movq    [esp], mm0                  ; save mm0
+@@:
+    movq    mm0, [esi]
+    movq    [edi], mm0
+    add     esi, 8
+    add     edi, 8
+    loop    @B
+    movq    mm0, [esp]                  ; restore mm0
+    pop     ecx                         ; stack cleanup
+    pop     ecx                         ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.nasm
new file mode 100644
index 000000000000..21e4427c70c5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/CopyMem.nasm
@@ -0,0 +1,77 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     .0
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    mov     ecx, edx
+    and     edx, 7
+    shr     ecx, 3                      ; ecx <- # of Qwords to copy
+    jz      @CopyBytes
+    push    eax
+    push    eax
+    movq    [esp], mm0                  ; save mm0
+.1:
+    movq    mm0, [esi]
+    movq    [edi], mm0
+    add     esi, 8
+    add     edi, 8
+    loop    .1
+    movq    mm0, [esp]                  ; restore mm0
+    pop     ecx                         ; stack cleanup
+    pop     ecx                         ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..cfd41a62500b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    edi
+    mov     edi, [esp + 8]             ; edi <- Buffer
+    mov     ecx, [esp + 12]            ; ecx <- Length
+    mov     edx, ecx                   ; edx <- ecx
+    shr     ecx, 2                     ; ecx <- number of dwords
+    and     edx, 3                     ; edx <- number of trailing bytes
+    xor     eax, eax                   ; eax <- 0, also set ZF
+    repe    scasd
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     ecx, edx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     edi
+    mov     eax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     edi
+    xor     eax, eax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.S
new file mode 100644
index 000000000000..c485543e873e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem16.Asm
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem16):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasw
+    leal    -2(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.asm
new file mode 100644
index 000000000000..bca66e02c896
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.nasm
new file mode 100644
index 000000000000..78d9f3071e8c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem16.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.S
new file mode 100644
index 000000000000..a9b497579442
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem32.Asm
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem32):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasl
+    leal    -4(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.asm
new file mode 100644
index 000000000000..8c24bd010953
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.nasm
new file mode 100644
index 000000000000..bbacf38a7245
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.S
new file mode 100644
index 000000000000..e23cf5f5dc28
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.S
@@ -0,0 +1,61 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem64.Asm
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    cmpl    (%edi), %eax
+    leal    8(%edi), %edi
+    loopne  L0
+    jne     L1
+    cmpl    -4(%edi), %edx
+    jecxz   L1
+    jne     L0
+L1:
+    leal    -8(%edi), %eax
+    cmovne  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.asm
new file mode 100644
index 000000000000..c835effc0cea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  @B
+    jne     @F
+    cmp     edx, [edi - 4]
+    jecxz   @F
+    jne     @B
+@@:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.nasm
new file mode 100644
index 000000000000..e994d4ac437a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem64.nasm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  .0
+    jne     .1
+    cmp     edx, [edi - 4]
+    jecxz   .1
+    jne     .0
+.1:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.S
new file mode 100644
index 000000000000..afefaab917ea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem8.Asm
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem8):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movb    16(%esp), %al
+    repne   scasb
+    leal    -1(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.asm
new file mode 100644
index 000000000000..f199bb957a6c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.nasm
new file mode 100644
index 000000000000..d13c9c7bf400
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ScanMem8.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.S
new file mode 100644
index 000000000000..52b5da6d447e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.S
@@ -0,0 +1,66 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   SetMem.asm
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem):
+    push    %edi
+    movb    16(%esp), %al
+    movb    %al, %ah
+    shrdl   $16, %eax, %edx
+    shldl   $16, %edx, %eax
+    movl    12(%esp), %ecx              # ecx <- Count
+    movl    8(%esp), %edi               # edi <- Buffer
+    movl    %ecx, %edx
+    andl    $7, %edx
+    shrl    $3, %ecx                    # # of Qwords to set
+    jz      L1
+    addl    $-16, %esp
+    movq    %mm0, (%esp)                # save mm0
+    movq    %mm1, 8(%esp)               # save mm1
+    movd    %eax, %mm0
+    movd    %eax, %mm1
+    psllq   $32, %mm0
+    por     %mm1, %mm0                  # fill mm0 with 8 Value's
+L0:
+    movq    %mm0, (%edi)
+    addl    $8, %edi
+    loop    L0
+    movq    (%esp), %mm0                # restore mm0
+    movq    8(%esp), %mm1               # restore mm1
+    addl    $0x10, %esp                 # stack cleanup
+L1:
+    movl    %edx, %ecx
+    rep
+    stosb
+    movl    8(%esp), %eax               # eax <- Buffer as return value
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.asm
new file mode 100644
index 000000000000..e40204b19f7f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.asm
@@ -0,0 +1,70 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    edi
+    mov     al, [esp + 16]
+    mov     ah, al
+    shrd    edx, eax, 16
+    shld    eax, edx, 16
+    mov     ecx, [esp + 12]             ; ecx <- Count
+    mov     edi, [esp + 8]              ; edi <- Buffer
+    mov     edx, ecx
+    and     edx, 7
+    shr     ecx, 3                      ; # of Qwords to set
+    jz      @SetBytes
+    add     esp, -10h
+    movq    [esp], mm0                  ; save mm0
+    movq    [esp + 8], mm1              ; save mm1
+    movd    mm0, eax
+    movd    mm1, eax
+    psllq   mm0, 32
+    por     mm0, mm1                    ; fill mm0 with 8 Value's
+@@:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    @B
+    movq    mm0, [esp]                  ; restore mm0
+    movq    mm1, [esp + 8]              ; restore mm1
+    add     esp, 10h                    ; stack cleanup
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]              ; eax <- Buffer as return value
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.nasm
new file mode 100644
index 000000000000..ab715860bd3c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem.nasm
@@ -0,0 +1,68 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.nasm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    edi
+    mov     al, [esp + 16]
+    mov     ah, al
+    shrd    edx, eax, 16
+    shld    eax, edx, 16
+    mov     ecx, [esp + 12]             ; ecx <- Count
+    mov     edi, [esp + 8]              ; edi <- Buffer
+    mov     edx, ecx
+    and     edx, 7
+    shr     ecx, 3                      ; # of Qwords to set
+    jz      @SetBytes
+    add     esp, -0x10
+    movq    [esp], mm0                  ; save mm0
+    movq    [esp + 8], mm1              ; save mm1
+    movd    mm0, eax
+    movd    mm1, eax
+    psllq   mm0, 32
+    por     mm0, mm1                    ; fill mm0 with 8 Value's
+.0:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    .0
+    movq    mm0, [esp]                  ; restore mm0
+    movq    mm1, [esp + 8]              ; restore mm1
+    add     esp, 0x10                    ; stack cleanup
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]              ; eax <- Buffer as return value
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.S
new file mode 100644
index 000000000000..af1060502229
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.S
@@ -0,0 +1,59 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   SetMem16.asm
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem16):
+    push    %edi
+    movl    16(%esp), %eax
+    shrdl   $16, %eax, %edx
+    shldl   $16, %edx, %eax
+    movl    12(%esp), %edx
+    movl    8(%esp), %edi
+    movl    %edx, %ecx
+    andl    $3, %edx
+    shrl    $2, %ecx
+    jz      L1
+    movd    %eax, %mm0
+    movd    %eax, %mm1
+    psllq   $32, %mm0
+    por     %mm1, %mm0
+L0:
+    movq    %mm0, (%edi)
+    addl    $8, %edi
+    loop    L0
+L1:
+    movl    %edx, %ecx
+    rep
+    stosw
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.asm
new file mode 100644
index 000000000000..edaec4e6995a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.asm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    edi
+    mov     eax, [esp + 16]
+    shrd    edx, eax, 16
+    shld    eax, edx, 16
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    jz      @SetWords
+    movd    mm0, eax
+    movd    mm1, eax
+    psllq   mm0, 32
+    por     mm0, mm1
+@@:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    @B
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.nasm
new file mode 100644
index 000000000000..61d1ef061cbc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem16.nasm
@@ -0,0 +1,61 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.nasm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    edi
+    mov     eax, [esp + 16]
+    shrd    edx, eax, 16
+    shld    eax, edx, 16
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    jz      @SetWords
+    movd    mm0, eax
+    movd    mm1, eax
+    psllq   mm0, 32
+    por     mm0, mm1
+.0:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    .0
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.S
new file mode 100644
index 000000000000..acf273d57786
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   SetMem32.asm
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem32):
+    movl    4(%esp), %eax
+    movl    8(%esp), %ecx
+    movd    12(%esp), %mm0
+    shrl    %ecx
+    movl    %eax, %edx
+    jz      L1
+    movq    %mm0, %mm1
+    psllq   $32, %mm1
+    por     %mm1, %mm0
+L0:
+    movq    %mm0, (%edx)
+    lea     8(%edx), %edx
+    loop    L0
+L1:
+    jnc     L2
+    movd    %mm0, (%edx)
+L2:
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.asm
new file mode 100644
index 000000000000..6c58b474b9d9
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.asm
@@ -0,0 +1,59 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC
+    mov     eax, [esp + 4]              ; eax <- Buffer as return value
+    mov     ecx, [esp + 8]              ; ecx <- Count
+    movd    mm0, dword ptr [esp + 12]             ; mm0 <- Value
+    shr     ecx, 1                      ; ecx <- number of qwords to set
+    mov     edx, eax                    ; edx <- Buffer
+    jz      @SetDwords
+    movq    mm1, mm0
+    psllq   mm1, 32
+    por     mm0, mm1
+@@:
+    movq    qword ptr [edx], mm0
+    lea     edx, [edx + 8]              ; use "lea" to avoid change in flags
+    loop    @B
+@SetDwords:
+    jnc     @F
+    movd    dword ptr [edx], mm0
+@@:
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.nasm
new file mode 100644
index 000000000000..9289f33c4ba6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.nasm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    mov     eax, [esp + 4]              ; eax <- Buffer as return value
+    mov     ecx, [esp + 8]              ; ecx <- Count
+    movd    mm0, dword [esp + 12]             ; mm0 <- Value
+    shr     ecx, 1                      ; ecx <- number of qwords to set
+    mov     edx, eax                    ; edx <- Buffer
+    jz      @SetDwords
+    movq    mm1, mm0
+    psllq   mm1, 32
+    por     mm0, mm1
+.0:
+    movq    qword [edx], mm0
+    lea     edx, [edx + 8]              ; use "lea" to avoid change in flags
+    loop    .0
+@SetDwords:
+    jnc     .1
+    movd    dword [edx], mm0
+.1:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.S
new file mode 100644
index 000000000000..be4b42ba95ba
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   SetMem64.asm
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem64):
+    movl    4(%esp), %eax
+    movl    8(%esp), %ecx
+    movq    12(%esp), %mm0
+    movl    %eax, %edx
+L0:
+    movq    %mm0, (%edx)
+    lea     8(%edx), %edx
+    loop    L0
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.asm
new file mode 100644
index 000000000000..318f1185e747
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.asm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    movq    mm0, [esp + 12]
+    mov     edx, eax
+@@:
+    movq    [edx], mm0
+    add     edx, 8
+    loop    @B
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.nasm
new file mode 100644
index 000000000000..13fa52fe160c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/SetMem64.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.nasm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    mov     eax, [esp + 4]
+    mov     ecx, [esp + 8]
+    movq    mm0, [esp + 12]
+    mov     edx, eax
+.0:
+    movq    [edx], mm0
+    add     edx, 8
+    loop    .0
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.S b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.S
new file mode 100644
index 000000000000..ac92ec2cf250
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.S
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   ZeroMem.asm
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemZeroMem):
+    push    %edi
+    movl    8(%esp), %edi
+    movl    12(%esp), %ecx
+    movl    %ecx, %edx
+    shrl    $3, %ecx
+    jz      L_ZeroBytes
+    pxor    %mm0, %mm0
+L0:
+    movq    %mm0, (%edi)
+    addl    $8, %edi
+    loop    L0
+L_ZeroBytes:
+    andl    $7, %edx
+    xorl    %eax, %eax
+    movl    %edx, %ecx
+    rep
+    stosb
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.asm
new file mode 100644
index 000000000000..3820ddd84a9f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .mmx
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    edi
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 3
+    jz      @ZeroBytes
+    pxor    mm0, mm0
+@@:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    @B
+@ZeroBytes:
+    and     edx, 7
+    xor     eax, eax
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.nasm
new file mode 100644
index 000000000000..bcf7cf643da3
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/Ia32/ZeroMem.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.nasm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    edi
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 3
+    jz      @ZeroBytes
+    pxor    mm0, mm0
+.0:
+    movq    [edi], mm0
+    add     edi, 8
+    loop    .0
+@ZeroBytes:
+    and     edx, 7
+    xor     eax, eax
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLibMmx/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibMmx/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/MemLibInternals.h b/MdePkg/Library/BaseMemoryLibMmx/MemLibInternals.h
new file mode 100644
index 000000000000..ce1c17f6de76
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer The target of the copy request.
+  @param  SourceBuffer      The place to copy from.
+  @param  Length            The number of bytes to copy
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLibMmx/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..5a06f6b1ed07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       Thevalue to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..f296da2e7a48
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/SetMem32Wrapper.c
new file mode 100644
index 000000000000..7758e1f438db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibMmx/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLibMmx/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.S b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.S
new file mode 100644
index 000000000000..e03049281cdc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.S
@@ -0,0 +1,59 @@
+#
+# ConvertAsm.py: Automatically generated from CompareMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rcx, %rsi 
+    movq    %rdx, %rdi 
+    movq    %r8, %rcx 
+    repe    cmpsb
+    movzbq  -1(%rsi), %rax
+    movzbq  -1(%rdi), %rdx
+    subq    %rdx, %rax 
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.asm
new file mode 100644
index 000000000000..09f077b85df8
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    rsi rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte ptr [rsi - 1]
+    movzx   rdx, byte ptr [rdi - 1]
+    sub     rax, rdx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.nasm
new file mode 100644
index 000000000000..cb0d88658387
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CompareMem.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte [rsi - 1]
+    movzx   rdx, byte [rdi - 1]
+    sub     rax, rdx
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.S b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.S
new file mode 100644
index 000000000000..290dec091d46
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.S
@@ -0,0 +1,74 @@
+#
+# ConvertAsm.py: Automatically generated from CopyMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rdx, %rsi                  # rsi <- Source
+    movq    %rcx, %rdi                  # rdi <- Destination
+    leaq    -1(%rsi, %r8,), %r9         # r9 <- End of Source          
+    cmpq    %rdi, %rsi 
+    movq    %rdi, %rax                  # rax <- Destination as return value
+    jae     L0
+    cmpq    %rdi, %r9
+    jae     L_CopyBackward              # Copy backward if overlapped
+L0:
+    movq    %r8, %rcx 
+    andq    $7, %r8
+    shrq    $3, %rcx                    # rcx <- # of Qwords to copy
+    jz      L_CopyBytes
+    movd    %mm0, %r10                  # (Save mm0 in r10)
+L1:
+    movq    (%rsi), %mm0
+    movntq  %mm0, (%rdi)
+    addq    $8, %rsi 
+    addq    $8, %rdi
+    loop    L1
+    mfence
+    movd    %r10, %mm0                  # (Restore mm0)
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movq    %r9, %rsi                   # rsi <- End of Source
+    leaq    -1(%rdi, %r8,), %rdi        # rdi <- End of Destination
+    std                                 # set direction flag
+L_CopyBytes:
+    movq    %r8, %rcx 
+    rep     movsb                       # Copy bytes backward
+    cld
+    popq    %rdi
+    popq    %rsi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.asm
new file mode 100644
index 000000000000..120e3e8dd4fa
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.asm
@@ -0,0 +1,70 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemCopyMem (
+;   OUT     VOID                      *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    rsi rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     @F
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3                      ; rcx <- # of Qwords to copy
+    jz      @CopyBytes
+    DB      49h, 0fh, 7eh, 0c2h         ; movd r10, mm0 (Save mm0 in r10)
+@@:
+    DB      0fh, 6fh, 06h               ; movd mm0, [rsi]
+    DB      0fh, 0e7h, 07h              ; movntq [rdi], mm0
+    add     rsi, 8
+    add     rdi, 8
+    loop    @B
+    mfence
+    DB      49h, 0fh, 6eh, 0c2h         ; movd mm0, r10 (Restore mm0)
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.nasm
new file mode 100644
index 000000000000..b3b9634f181f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/CopyMem.nasm
@@ -0,0 +1,74 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemCopyMem (
+;   OUT     VOID                      *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     .0
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3                      ; rcx <- # of Qwords to copy
+    jz      @CopyBytes
+    DB      0x49, 0xf, 0x7e, 0xc2         ; movd r10, mm0 (Save mm0 in r10)
+.1:
+    DB      0xf, 0x6f, 0x6               ; movd mm0, [rsi]
+    DB      0xf, 0xe7, 0x7              ; movntq [rdi], mm0
+    add     rsi, 8
+    add     rdi, 8
+    loop    .1
+    mfence
+    DB      0x49, 0xf, 0x6e, 0xc2         ; movd mm0, r10 (Restore mm0)
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..3b855a7bf4a6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    rdi
+    mov     rdi, rcx                   ; rdi <- Buffer
+    mov     rcx, rdx                   ; rcx <- Length
+    shr     rcx, 3                     ; rcx <- number of qwords
+    and     rdx, 7                     ; rdx <- number of trailing bytes
+    xor     rax, rax                   ; rax <- 0, also set ZF
+    repe    scasq
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     rcx, rdx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     rdi
+    mov     rax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     rdi
+    xor     rax, rax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.S b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.S
new file mode 100644
index 000000000000..7ba23fdee679
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi 
+    movq    %r8, %rax 
+    movq    %rdx, %rcx 
+    repne   scasw
+    leaq    -2(%rdi), %rax
+    cmovnz  %rcx, %rax 
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.asm
new file mode 100644
index 000000000000..75200414d1c1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.nasm
new file mode 100644
index 000000000000..9f0de63ea655
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem16.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.S b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.S
new file mode 100644
index 000000000000..914cf5328775
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    pushq    %rdi
+    movq     %rcx, %rdi 
+    movq     %r8, %rax 
+    movq     %rdx, %rcx 
+    repne    scasl
+    leaq     -4(%rdi), %rax
+    cmovnz   %rcx, %rax 
+    popq     %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.asm
new file mode 100644
index 000000000000..ad47e5a53a13
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.nasm
new file mode 100644
index 000000000000..5c9ae5d08389
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.S b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.S
new file mode 100644
index 000000000000..c6b62d0d0392
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.S
@@ -0,0 +1,55 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    pushq    %rdi
+    movq     %rcx, %rdi 
+    movq     %r8, %rax 
+    movq     %rdx, %rcx 
+    repne    scasq
+    leaq     -8(%rdi), %rax
+    cmovnz   %rcx, %rax 
+    popq     %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.asm
new file mode 100644
index 000000000000..3eb5b719fa07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.nasm
new file mode 100644
index 000000000000..b98c6dece330
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem64.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.S b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.S
new file mode 100644
index 000000000000..9d453c1edf54
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem8.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    pushq    %rdi
+    movq     %rcx, %rdi 
+    movq     %rdx, %rcx  
+    movq     %r8,   %rax 
+    repne    scasb
+    leaq     -1(%rdi), %rax
+    cmovnz   %rcx, %rax                     # set rax to 0 if not found
+    popq     %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.asm
new file mode 100644
index 000000000000..8ece85e5b4a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.nasm
new file mode 100644
index 000000000000..8499795a1d7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ScanMem8.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.S b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.S
new file mode 100644
index 000000000000..f6aee4210308
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.S
@@ -0,0 +1,61 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    %rdi
+    movq    %r8, %rax
+    movb    %al, %ah
+    movd    %rax, %mm0
+    movq    %rcx, %r8
+    movq    %r8, %rdi                     # rdi <- Buffer
+    movq    %rdx, %rcx
+    andq    $7, %rdx 
+    shrq    $3, %rcx
+    jz      L_SetBytes
+    .byte   0x0f, 0x70, 0x0C0, 0x00
+L0:
+    movntq  %mm0, (%rdi) 
+    addq    $8, %rdi
+    loop    L0
+    mfence
+L_SetBytes:
+    movl    %edx, %ecx
+    rep       stosb
+    movq    %r8, %rax
+    pop     %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.asm
new file mode 100644
index 000000000000..932973badc28
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.asm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemSetMem (
+;   OUT     VOID                      *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    rdi
+    mov     rax, r8
+    mov     ah, al
+    DB      48h, 0fh, 6eh, 0c0h         ; movd mm0, rax
+    mov     r8, rcx
+    mov     rdi, r8                     ; rdi <- Buffer
+    mov     rcx, rdx
+    and     edx, 7
+    shr     rcx, 3
+    jz      @SetBytes
+    DB      0fh, 70h, 0C0h, 00h         ; pshufw mm0, mm0, 0h
+@@:
+    DB      0fh, 0e7h, 07h              ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    @B
+    mfence
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.nasm
new file mode 100644
index 000000000000..1b50e5ec3bfd
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem.nasm
@@ -0,0 +1,60 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.nasm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemSetMem (
+;   OUT     VOID                      *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    rdi
+    mov     rax, r8
+    mov     ah, al
+    DB      0x48, 0xf, 0x6e, 0xc0         ; movd mm0, rax
+    mov     r8, rcx
+    mov     rdi, r8                     ; rdi <- Buffer
+    mov     rcx, rdx
+    and     edx, 7
+    shr     rcx, 3
+    jz      @SetBytes
+    DB      0xf, 0x70, 0xC0, 0x0         ; pshufw mm0, mm0, 0h
+.0:
+    DB      0xf, 0xe7, 0x7              ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    .0
+    mfence
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.S b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.S
new file mode 100644
index 000000000000..06c7d6bb939f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.S
@@ -0,0 +1,60 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    pushq    %rdi
+    movq     %r8, %rax 
+    movd     %rax, %mm0 
+    movq     %rcx, %r8 
+    movq     %r8, %rdi 
+    movq     %rdx, %rcx 
+    andl     $3, %edx 
+    shrq     $2, %rcx
+    jz       L_SetWords
+    .byte    0x0f, 0x70, 0x0C0, 0x00
+L0:
+    movntq   %mm0, (%rdi) 
+    addq     $8, %rdi 
+    loop     L0
+    mfence
+L_SetWords:
+    movl    %edx, %ecx 
+    rep     stosw
+    movq    %r8, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.asm
new file mode 100644
index 000000000000..ca0022448970
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemSetMem16 (
+;   OUT     VOID                      *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    rdi
+    mov     rax, r8
+    DB      48h, 0fh, 6eh, 0c0h         ; movd mm0, rax
+    mov     r8, rcx
+    mov     rdi, r8
+    mov     rcx, rdx
+    and     edx, 3
+    shr     rcx, 2
+    jz      @SetWords
+    DB      0fh, 70h, 0C0h, 00h         ; pshufw mm0, mm0, 0h
+@@:
+    DB      0fh, 0e7h, 07h              ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    @B
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     rax, r8
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.nasm
new file mode 100644
index 000000000000..43435503366e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem16.nasm
@@ -0,0 +1,59 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.nasm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; VOID *
+; EFIAPI
+; InternalMemSetMem16 (
+;   OUT     VOID                      *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    rdi
+    mov     rax, r8
+    DB      0x48, 0xf, 0x6e, 0xc0         ; movd mm0, rax
+    mov     r8, rcx
+    mov     rdi, r8
+    mov     rcx, rdx
+    and     edx, 3
+    shr     rcx, 2
+    jz      @SetWords
+    DB      0xf, 0x70, 0xC0, 0x0         ; pshufw mm0, mm0, 0h
+.0:
+    DB      0xf, 0xe7, 0x7              ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    .0
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     rax, r8
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.S b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.S
new file mode 100644
index 000000000000..d2dc235a731e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.S
@@ -0,0 +1,55 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    movd    %r8, %mm0                   # mm0 <- Value
+    movq    %rcx, %rax                  # rax <- Buffer
+    xchgq   %rdx, %rcx                  # rcx <- Count  rdx <- Buffer
+    shrq    $1, % rcx                   # rcx <- # of qwords to set
+    jz      L_SetDwords
+   .byte    0x0f, 0x70, 0x0C0, 0x44
+L0:
+    movntq  %mm0, (%rdx) 
+    leaq    8(%rdx), %rdx               # use "lea" to avoid flag changes
+    loop    L0
+    mfence
+L_SetDwords:
+    jnc     L1
+    movd    %mm0, (%rdx) 
+L1:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.asm
new file mode 100644
index 000000000000..5eadd00fbf64
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC
+    DB      49h, 0fh, 6eh, 0c0h         ; movd mm0, r8 (Value)
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count  rdx <- Buffer
+    shr     rcx, 1                      ; rcx <- # of qwords to set
+    jz      @SetDwords
+    DB      0fh, 70h, 0C0h, 44h         ; pshufw mm0, mm0, 44h
+@@:
+    DB      0fh, 0e7h, 02h              ; movntq [rdx], mm0
+    lea     rdx, [rdx + 8]              ; use "lea" to avoid flag changes
+    loop    @B
+    mfence
+@SetDwords:
+    jnc     @F
+    DB      0fh, 7eh, 02h               ; movd [rdx], mm0
+@@:
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.nasm
new file mode 100644
index 000000000000..cf659b0f26f1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem32.nasm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.nasm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    DB      0x49, 0xf, 0x6e, 0xc0         ; movd mm0, r8 (Value)
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count  rdx <- Buffer
+    shr     rcx, 1                      ; rcx <- # of qwords to set
+    jz      @SetDwords
+    DB      0xf, 0x70, 0xC0, 0x44         ; pshufw mm0, mm0, 44h
+.0:
+    DB      0xf, 0xe7, 0x2              ; movntq [rdx], mm0
+    lea     rdx, [rdx + 8]              ; use "lea" to avoid flag changes
+    loop    .0
+    mfence
+@SetDwords:
+    jnc     .1
+    DB      0xf, 0x7e, 0x2               ; movd [rdx], mm0
+.1:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.S b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.S
new file mode 100644
index 000000000000..2f2dd6757a90
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    movd      %r8, %mm0                 #Value
+    movq      %rcx, %rax                #rax <- Buffer
+    xchg      %rdx, %rcx                #rcx <- Count
+L0:
+    movntq  %mm0, (%rdx) 
+    addq    $8, %rdx
+    loop    L0
+    mfence
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.asm
new file mode 100644
index 000000000000..1f551cb1a2af
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.asm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC
+    DB      49h, 0fh, 6eh, 0c0h         ; movd mm0, r8 (Value)
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count
+@@:
+    DB      0fh, 0e7h, 02h              ; movntq  [rdx], mm0
+    add     rdx, 8
+    loop    @B
+    mfence
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.nasm
new file mode 100644
index 000000000000..f4aa51c1fe76
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/SetMem64.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.nasm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    DB      0x49, 0xf, 0x6e, 0xc0         ; movd mm0, r8 (Value)
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count
+.0:
+    DB      0xf, 0xe7, 0x2              ; movntq  [rdx], mm0
+    add     rdx, 8
+    loop    .0
+    mfence
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.S b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.S
new file mode 100644
index 000000000000..1994f9c6b656
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.S
@@ -0,0 +1,57 @@
+#
+# ConvertAsm.py: Automatically generated from ZeroMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %rdi, %r8
+    andq    $7, %rdx
+    shrq    $3, %rcx
+    jz      L_ZeroBytes
+    pxor    %mm0, %mm0
+L0:
+    movntq  %mm0, (%rdi)
+    addq    $8, %rdi
+    loop    L0
+    mfence
+L_ZeroBytes:
+    xorl    %eax, %eax
+    movl    %edx, %ecx
+    rep     stosb
+    movq    %r8, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.asm
new file mode 100644
index 000000000000..ed8d385f8b4a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     r8, rdi
+    and     edx, 7
+    shr     rcx, 3
+    jz      @ZeroBytes
+    DB      0fh, 0efh, 0c0h             ; pxor mm0, mm0
+@@:
+    DB      0fh, 0e7h, 7                ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    @B
+    DB      0fh, 0aeh, 0f0h             ; mfence
+@ZeroBytes:
+    xor     eax, eax
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.nasm
new file mode 100644
index 000000000000..9eb4d263600b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/X64/ZeroMem.nasm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.nasm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     r8, rdi
+    and     edx, 7
+    shr     rcx, 3
+    jz      @ZeroBytes
+    DB      0xf, 0xef, 0xc0             ; pxor mm0, mm0
+.0:
+    DB      0xf, 0xe7, 7                ; movntq [rdi], mm0
+    add     rdi, 8
+    loop    .0
+    DB      0xf, 0xae, 0xf0             ; mfence
+@ZeroBytes:
+    xor     eax, eax
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibMmx/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLibMmx/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibMmx/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareGuid.S b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareGuid.S
new file mode 100644
index 000000000000..8544c018c4f5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareGuid.S
@@ -0,0 +1,40 @@
+//
+// Copyright (c) 2016, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+    .text
+    .align  5
+ASM_GLOBAL ASM_PFX(InternalMemCompareGuid)
+ASM_PFX(InternalMemCompareGuid):
+    mov     x2, xzr
+    ldp     x3, x4, [x0]
+    cbz     x1, 0f
+    ldp     x1, x2, [x1]
+0:  cmp     x1, x3
+    ccmp    x2, x4, #0, eq
+    cset    w0, eq
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareMem.S
new file mode 100644
index 000000000000..7e5bf8a6c334
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CompareMem.S
@@ -0,0 +1,142 @@
+//
+// Copyright (c) 2013, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// Assumptions:
+//
+// ARMv8-a, AArch64
+//
+
+
+// Parameters and result.
+#define src1      x0
+#define src2      x1
+#define limit     x2
+#define result    x0
+
+// Internal variables.
+#define data1     x3
+#define data1w    w3
+#define data2     x4
+#define data2w    w4
+#define diff      x6
+#define endloop   x7
+#define tmp1      x8
+#define tmp2      x9
+#define pos       x11
+#define limit_wd  x12
+#define mask      x13
+
+    .p2align 6
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    eor     tmp1, src1, src2
+    tst     tmp1, #7
+    b.ne    .Lmisaligned8
+    ands    tmp1, src1, #7
+    b.ne    .Lmutual_align
+    add     limit_wd, limit, #7
+    lsr     limit_wd, limit_wd, #3
+
+    // Start of performance-critical section  -- one 64B cache line.
+.Lloop_aligned:
+    ldr     data1, [src1], #8
+    ldr     data2, [src2], #8
+.Lstart_realigned:
+    subs    limit_wd, limit_wd, #1
+    eor     diff, data1, data2        // Non-zero if differences found.
+    csinv   endloop, diff, xzr, ne    // Last Dword or differences.
+    cbz     endloop, .Lloop_aligned
+    // End of performance-critical section  -- one 64B cache line.
+
+    // Not reached the limit, must have found a diff.
+    cbnz    limit_wd, .Lnot_limit
+
+    // Limit % 8 == 0 => all bytes significant.
+    ands    limit, limit, #7
+    b.eq    .Lnot_limit
+
+    lsl     limit, limit, #3              // Bits -> bytes.
+    mov     mask, #~0
+    lsl     mask, mask, limit
+    bic     data1, data1, mask
+    bic     data2, data2, mask
+
+    orr     diff, diff, mask
+
+.Lnot_limit:
+    rev     diff, diff
+    rev     data1, data1
+    rev     data2, data2
+
+    // The MS-non-zero bit of DIFF marks either the first bit
+    // that is different, or the end of the significant data.
+    // Shifting left now will bring the critical information into the
+    // top bits.
+    clz     pos, diff
+    lsl     data1, data1, pos
+    lsl     data2, data2, pos
+
+    // But we need to zero-extend (char is unsigned) the value and then
+    // perform a signed 32-bit subtraction.
+    lsr     data1, data1, #56
+    sub     result, data1, data2, lsr #56
+    ret
+
+.Lmutual_align:
+    // Sources are mutually aligned, but are not currently at an
+    // alignment boundary.  Round down the addresses and then mask off
+    // the bytes that precede the start point.
+    bic     src1, src1, #7
+    bic     src2, src2, #7
+    add     limit, limit, tmp1          // Adjust the limit for the extra.
+    lsl     tmp1, tmp1, #3              // Bytes beyond alignment -> bits.
+    ldr     data1, [src1], #8
+    neg     tmp1, tmp1                  // Bits to alignment -64.
+    ldr     data2, [src2], #8
+    mov     tmp2, #~0
+
+    // Little-endian.  Early bytes are at LSB.
+    lsr     tmp2, tmp2, tmp1            // Shift (tmp1 & 63).
+    add     limit_wd, limit, #7
+    orr     data1, data1, tmp2
+    orr     data2, data2, tmp2
+    lsr     limit_wd, limit_wd, #3
+    b       .Lstart_realigned
+
+    .p2align 6
+.Lmisaligned8:
+    sub     limit, limit, #1
+1:
+    // Perhaps we can do better than this.
+    ldrb    data1w, [src1], #1
+    ldrb    data2w, [src2], #1
+    subs    limit, limit, #1
+    ccmp    data1w, data2w, #0, cs      // NZCV = 0b0000.
+    b.eq    1b
+    sub     result, data1, data2
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CopyMem.S
new file mode 100644
index 000000000000..fdba763f8b47
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/CopyMem.S
@@ -0,0 +1,284 @@
+//
+// Copyright (c) 2012 - 2016, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+//
+// Copyright (c) 2015 ARM Ltd
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. The name of the company may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY ARM LTD ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL ARM LTD BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// Assumptions:
+//
+// ARMv8-a, AArch64, unaligned accesses.
+//
+//
+
+#define dstin     x0
+#define src       x1
+#define count     x2
+#define dst       x3
+#define srcend    x4
+#define dstend    x5
+#define A_l       x6
+#define A_lw      w6
+#define A_h       x7
+#define A_hw      w7
+#define B_l       x8
+#define B_lw      w8
+#define B_h       x9
+#define C_l       x10
+#define C_h       x11
+#define D_l       x12
+#define D_h       x13
+#define E_l       x14
+#define E_h       x15
+#define F_l       srcend
+#define F_h       dst
+#define tmp1      x9
+#define tmp2      x3
+
+#define L(l) .L ## l
+
+// Copies are split into 3 main cases: small copies of up to 16 bytes,
+// medium copies of 17..96 bytes which are fully unrolled. Large copies
+// of more than 96 bytes align the destination and use an unrolled loop
+// processing 64 bytes per iteration.
+// Small and medium copies read all data before writing, allowing any
+// kind of overlap, and memmove tailcalls memcpy for these cases as
+// well as non-overlapping copies.
+
+__memcpy:
+    prfm    PLDL1KEEP, [src]
+    add     srcend, src, count
+    add     dstend, dstin, count
+    cmp     count, 16
+    b.ls    L(copy16)
+    cmp     count, 96
+    b.hi    L(copy_long)
+
+    // Medium copies: 17..96 bytes.
+    sub     tmp1, count, 1
+    ldp     A_l, A_h, [src]
+    tbnz    tmp1, 6, L(copy96)
+    ldp     D_l, D_h, [srcend, -16]
+    tbz     tmp1, 5, 1f
+    ldp     B_l, B_h, [src, 16]
+    ldp     C_l, C_h, [srcend, -32]
+    stp     B_l, B_h, [dstin, 16]
+    stp     C_l, C_h, [dstend, -32]
+1:
+    stp     A_l, A_h, [dstin]
+    stp     D_l, D_h, [dstend, -16]
+    ret
+
+    .p2align 4
+    // Small copies: 0..16 bytes.
+L(copy16):
+    cmp     count, 8
+    b.lo    1f
+    ldr     A_l, [src]
+    ldr     A_h, [srcend, -8]
+    str     A_l, [dstin]
+    str     A_h, [dstend, -8]
+    ret
+    .p2align 4
+1:
+    tbz     count, 2, 1f
+    ldr     A_lw, [src]
+    ldr     A_hw, [srcend, -4]
+    str     A_lw, [dstin]
+    str     A_hw, [dstend, -4]
+    ret
+
+    // Copy 0..3 bytes.  Use a branchless sequence that copies the same
+    // byte 3 times if count==1, or the 2nd byte twice if count==2.
+1:
+    cbz     count, 2f
+    lsr     tmp1, count, 1
+    ldrb    A_lw, [src]
+    ldrb    A_hw, [srcend, -1]
+    ldrb    B_lw, [src, tmp1]
+    strb    A_lw, [dstin]
+    strb    B_lw, [dstin, tmp1]
+    strb    A_hw, [dstend, -1]
+2:  ret
+
+    .p2align 4
+    // Copy 64..96 bytes.  Copy 64 bytes from the start and
+    // 32 bytes from the end.
+L(copy96):
+    ldp     B_l, B_h, [src, 16]
+    ldp     C_l, C_h, [src, 32]
+    ldp     D_l, D_h, [src, 48]
+    ldp     E_l, E_h, [srcend, -32]
+    ldp     F_l, F_h, [srcend, -16]
+    stp     A_l, A_h, [dstin]
+    stp     B_l, B_h, [dstin, 16]
+    stp     C_l, C_h, [dstin, 32]
+    stp     D_l, D_h, [dstin, 48]
+    stp     E_l, E_h, [dstend, -32]
+    stp     F_l, F_h, [dstend, -16]
+    ret
+
+    // Align DST to 16 byte alignment so that we don't cross cache line
+    // boundaries on both loads and stores. There are at least 96 bytes
+    // to copy, so copy 16 bytes unaligned and then align.	The loop
+    // copies 64 bytes per iteration and prefetches one iteration ahead.
+
+    .p2align 4
+L(copy_long):
+    and     tmp1, dstin, 15
+    bic     dst, dstin, 15
+    ldp     D_l, D_h, [src]
+    sub     src, src, tmp1
+    add     count, count, tmp1      // Count is now 16 too large.
+    ldp     A_l, A_h, [src, 16]
+    stp     D_l, D_h, [dstin]
+    ldp     B_l, B_h, [src, 32]
+    ldp     C_l, C_h, [src, 48]
+    ldp     D_l, D_h, [src, 64]!
+    subs    count, count, 128 + 16  // Test and readjust count.
+    b.ls    2f
+1:
+    stp     A_l, A_h, [dst, 16]
+    ldp     A_l, A_h, [src, 16]
+    stp     B_l, B_h, [dst, 32]
+    ldp     B_l, B_h, [src, 32]
+    stp     C_l, C_h, [dst, 48]
+    ldp     C_l, C_h, [src, 48]
+    stp     D_l, D_h, [dst, 64]!
+    ldp     D_l, D_h, [src, 64]!
+    subs    count, count, 64
+    b.hi    1b
+
+    // Write the last full set of 64 bytes.	 The remainder is at most 64
+    // bytes, so it is safe to always copy 64 bytes from the end even if
+    // there is just 1 byte left.
+2:
+    ldp     E_l, E_h, [srcend, -64]
+    stp     A_l, A_h, [dst, 16]
+    ldp     A_l, A_h, [srcend, -48]
+    stp     B_l, B_h, [dst, 32]
+    ldp     B_l, B_h, [srcend, -32]
+    stp     C_l, C_h, [dst, 48]
+    ldp     C_l, C_h, [srcend, -16]
+    stp     D_l, D_h, [dst, 64]
+    stp     E_l, E_h, [dstend, -64]
+    stp     A_l, A_h, [dstend, -48]
+    stp     B_l, B_h, [dstend, -32]
+    stp     C_l, C_h, [dstend, -16]
+    ret
+
+
+//
+// All memmoves up to 96 bytes are done by memcpy as it supports overlaps.
+// Larger backwards copies are also handled by memcpy. The only remaining
+// case is forward large copies.  The destination is aligned, and an
+// unrolled loop processes 64 bytes per iteration.
+//
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    sub     tmp2, dstin, src
+    cmp     count, 96
+    ccmp    tmp2, count, 2, hi
+    b.hs    __memcpy
+
+    cbz     tmp2, 3f
+    add     dstend, dstin, count
+    add     srcend, src, count
+
+    // Align dstend to 16 byte alignment so that we don't cross cache line
+    // boundaries on both loads and stores. There are at least 96 bytes
+    // to copy, so copy 16 bytes unaligned and then align. The loop
+    // copies 64 bytes per iteration and prefetches one iteration ahead.
+
+    and     tmp2, dstend, 15
+    ldp     D_l, D_h, [srcend, -16]
+    sub     srcend, srcend, tmp2
+    sub     count, count, tmp2
+    ldp     A_l, A_h, [srcend, -16]
+    stp     D_l, D_h, [dstend, -16]
+    ldp     B_l, B_h, [srcend, -32]
+    ldp     C_l, C_h, [srcend, -48]
+    ldp     D_l, D_h, [srcend, -64]!
+    sub     dstend, dstend, tmp2
+    subs    count, count, 128
+    b.ls    2f
+    nop
+1:
+    stp     A_l, A_h, [dstend, -16]
+    ldp     A_l, A_h, [srcend, -16]
+    stp     B_l, B_h, [dstend, -32]
+    ldp     B_l, B_h, [srcend, -32]
+    stp     C_l, C_h, [dstend, -48]
+    ldp     C_l, C_h, [srcend, -48]
+    stp     D_l, D_h, [dstend, -64]!
+    ldp     D_l, D_h, [srcend, -64]!
+    subs    count, count, 64
+    b.hi    1b
+
+    // Write the last full set of 64 bytes. The remainder is at most 64
+    // bytes, so it is safe to always copy 64 bytes from the start even if
+    // there is just 1 byte left.
+2:
+    ldp     E_l, E_h, [src, 48]
+    stp     A_l, A_h, [dstend, -16]
+    ldp     A_l, A_h, [src, 32]
+    stp     B_l, B_h, [dstend, -32]
+    ldp     B_l, B_h, [src, 16]
+    stp     C_l, C_h, [dstend, -48]
+    ldp     C_l, C_h, [src]
+    stp     D_l, D_h, [dstend, -64]
+    stp     E_l, E_h, [dstin, 48]
+    stp     A_l, A_h, [dstin, 32]
+    stp     B_l, B_h, [dstin, 16]
+    stp     C_l, C_h, [dstin]
+3:  ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/ScanMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/ScanMem.S
new file mode 100644
index 000000000000..708ebb59c423
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/ScanMem.S
@@ -0,0 +1,161 @@
+//
+// Copyright (c) 2014, ARM Limited
+// All rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the company nor the names of its contributors
+//       may be used to endorse or promote products derived from this
+//       software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// Assumptions:
+//
+// ARMv8-a, AArch64
+// Neon Available.
+//
+
+// Arguments and results.
+#define srcin     x0
+#define cntin     x1
+#define chrin     w2
+
+#define result    x0
+
+#define src       x3
+#define	tmp       x4
+#define wtmp2     w5
+#define synd      x6
+#define soff      x9
+#define cntrem    x10
+
+#define vrepchr   v0
+#define vdata1    v1
+#define vdata2    v2
+#define vhas_chr1 v3
+#define vhas_chr2 v4
+#define vrepmask  v5
+#define vend      v6
+
+//
+// Core algorithm:
+//
+// For each 32-byte chunk we calculate a 64-bit syndrome value, with two bits
+// per byte. For each tuple, bit 0 is set if the relevant byte matched the
+// requested character and bit 1 is not used (faster than using a 32bit
+// syndrome). Since the bits in the syndrome reflect exactly the order in which
+// things occur in the original string, counting trailing zeros allows to
+// identify exactly which byte has matched.
+//
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    // Do not dereference srcin if no bytes to compare.
+    cbz	cntin, .Lzero_length
+    //
+    // Magic constant 0x40100401 allows us to identify which lane matches
+    // the requested byte.
+    //
+    mov     wtmp2, #0x0401
+    movk    wtmp2, #0x4010, lsl #16
+    dup     vrepchr.16b, chrin
+    // Work with aligned 32-byte chunks
+    bic     src, srcin, #31
+    dup     vrepmask.4s, wtmp2
+    ands    soff, srcin, #31
+    and     cntrem, cntin, #31
+    b.eq    .Lloop
+
+    //
+    // Input string is not 32-byte aligned. We calculate the syndrome
+    // value for the aligned 32 bytes block containing the first bytes
+    // and mask the irrelevant part.
+    //
+
+    ld1     {vdata1.16b, vdata2.16b}, [src], #32
+    sub     tmp, soff, #32
+    adds    cntin, cntin, tmp
+    cmeq    vhas_chr1.16b, vdata1.16b, vrepchr.16b
+    cmeq    vhas_chr2.16b, vdata2.16b, vrepchr.16b
+    and     vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b
+    and     vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b
+    addp    vend.16b, vhas_chr1.16b, vhas_chr2.16b        // 256->128
+    addp    vend.16b, vend.16b, vend.16b                  // 128->64
+    mov     synd, vend.d[0]
+    // Clear the soff*2 lower bits
+    lsl     tmp, soff, #1
+    lsr     synd, synd, tmp
+    lsl     synd, synd, tmp
+    // The first block can also be the last
+    b.ls    .Lmasklast
+    // Have we found something already?
+    cbnz    synd, .Ltail
+
+.Lloop:
+    ld1     {vdata1.16b, vdata2.16b}, [src], #32
+    subs    cntin, cntin, #32
+    cmeq    vhas_chr1.16b, vdata1.16b, vrepchr.16b
+    cmeq    vhas_chr2.16b, vdata2.16b, vrepchr.16b
+    // If we're out of data we finish regardless of the result
+    b.ls    .Lend
+    // Use a fast check for the termination condition
+    orr     vend.16b, vhas_chr1.16b, vhas_chr2.16b
+    addp    vend.2d, vend.2d, vend.2d
+    mov     synd, vend.d[0]
+    // We're not out of data, loop if we haven't found the character
+    cbz     synd, .Lloop
+
+.Lend:
+    // Termination condition found, let's calculate the syndrome value
+    and     vhas_chr1.16b, vhas_chr1.16b, vrepmask.16b
+    and     vhas_chr2.16b, vhas_chr2.16b, vrepmask.16b
+    addp    vend.16b, vhas_chr1.16b, vhas_chr2.16b      // 256->128
+    addp    vend.16b, vend.16b, vend.16b                // 128->64
+    mov     synd, vend.d[0]
+    // Only do the clear for the last possible block
+    b.hi    .Ltail
+
+.Lmasklast:
+    // Clear the (32 - ((cntrem + soff) % 32)) * 2 upper bits
+    add     tmp, cntrem, soff
+    and     tmp, tmp, #31
+    sub     tmp, tmp, #32
+    neg     tmp, tmp, lsl #1
+    lsl     synd, synd, tmp
+    lsr     synd, synd, tmp
+
+.Ltail:
+    // Count the trailing zeros using bit reversing
+    rbit    synd, synd
+    // Compensate the last post-increment
+    sub     src, src, #32
+    // Check that we have found a character
+    cmp     synd, #0
+    // And count the leading zeros
+    clz     synd, synd
+    // Compute the potential result
+    add     result, src, synd, lsr #1
+    // Select result or NULL
+    csel    result, xzr, result, eq
+    ret
+
+.Lzero_length:
+    mov   result, #0
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/SetMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/SetMem.S
new file mode 100644
index 000000000000..384fbdc6c04e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/AArch64/SetMem.S
@@ -0,0 +1,247 @@
+//
+// Copyright (c) 2012 - 2016, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+//
+// Copyright (c) 2015 ARM Ltd
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. The name of the company may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY ARM LTD ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL ARM LTD BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// Assumptions:
+//
+// ARMv8-a, AArch64, unaligned accesses
+//
+//
+
+#define dstin     x0
+#define count     x1
+#define val       x2
+#define valw      w2
+#define dst       x3
+#define dstend    x4
+#define tmp1      x5
+#define tmp1w     w5
+#define tmp2      x6
+#define tmp2w     w6
+#define zva_len   x7
+#define zva_lenw  w7
+
+#define L(l) .L ## l
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    dup     v0.8H, valw
+    lsl     count, count, #1
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    dup     v0.4S, valw
+    lsl     count, count, #2
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    dup     v0.2D, val
+    lsl     count, count, #3
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    movi    v0.16B, #0
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    dup     v0.16B, valw
+0:  add     dstend, dstin, count
+    mov     val, v0.D[0]
+
+    cmp     count, 96
+    b.hi    L(set_long)
+    cmp     count, 16
+    b.hs    L(set_medium)
+
+    // Set 0..15 bytes.
+    tbz     count, 3, 1f
+    str     val, [dstin]
+    str     val, [dstend, -8]
+    ret
+    nop
+1:  tbz     count, 2, 2f
+    str     valw, [dstin]
+    str     valw, [dstend, -4]
+    ret
+2:  cbz     count, 3f
+    strb    valw, [dstin]
+    tbz     count, 1, 3f
+    strh    valw, [dstend, -2]
+3:  ret
+
+    // Set 17..96 bytes.
+L(set_medium):
+    str     q0, [dstin]
+    tbnz    count, 6, L(set96)
+    str     q0, [dstend, -16]
+    tbz     count, 5, 1f
+    str     q0, [dstin, 16]
+    str     q0, [dstend, -32]
+1:  ret
+
+    .p2align 4
+    // Set 64..96 bytes.  Write 64 bytes from the start and
+    // 32 bytes from the end.
+L(set96):
+    str     q0, [dstin, 16]
+    stp     q0, q0, [dstin, 32]
+    stp     q0, q0, [dstend, -32]
+    ret
+
+    .p2align 3
+    nop
+L(set_long):
+    bic     dst, dstin, 15
+    str     q0, [dstin]
+    cmp     count, 256
+    ccmp    val, 0, 0, cs
+    b.eq    L(try_zva)
+L(no_zva):
+    sub     count, dstend, dst        // Count is 16 too large.
+    add     dst, dst, 16
+    sub     count, count, 64 + 16     // Adjust count and bias for loop.
+1:  stp     q0, q0, [dst], 64
+    stp     q0, q0, [dst, -32]
+L(tail64):
+    subs    count, count, 64
+    b.hi    1b
+2:  stp     q0, q0, [dstend, -64]
+    stp     q0, q0, [dstend, -32]
+    ret
+
+    .p2align 3
+L(try_zva):
+    mrs     tmp1, dczid_el0
+    tbnz    tmp1w, 4, L(no_zva)
+    and     tmp1w, tmp1w, 15
+    cmp     tmp1w, 4                  // ZVA size is 64 bytes.
+    b.ne    L(zva_128)
+
+    // Write the first and last 64 byte aligned block using stp rather
+    // than using DC ZVA.  This is faster on some cores.
+L(zva_64):
+    str     q0, [dst, 16]
+    stp     q0, q0, [dst, 32]
+    bic     dst, dst, 63
+    stp     q0, q0, [dst, 64]
+    stp     q0, q0, [dst, 96]
+    sub     count, dstend, dst         // Count is now 128 too large.
+    sub     count, count, 128+64+64    // Adjust count and bias for loop.
+    add     dst, dst, 128
+    nop
+1:  dc      zva, dst
+    add     dst, dst, 64
+    subs    count, count, 64
+    b.hi    1b
+    stp     q0, q0, [dst, 0]
+    stp     q0, q0, [dst, 32]
+    stp     q0, q0, [dstend, -64]
+    stp     q0, q0, [dstend, -32]
+    ret
+
+    .p2align 3
+L(zva_128):
+    cmp     tmp1w, 5                    // ZVA size is 128 bytes.
+    b.ne    L(zva_other)
+
+    str     q0, [dst, 16]
+    stp     q0, q0, [dst, 32]
+    stp     q0, q0, [dst, 64]
+    stp     q0, q0, [dst, 96]
+    bic     dst, dst, 127
+    sub     count, dstend, dst          // Count is now 128 too large.
+    sub     count, count, 128+128       // Adjust count and bias for loop.
+    add     dst, dst, 128
+1:  dc      zva, dst
+    add     dst, dst, 128
+    subs    count, count, 128
+    b.hi    1b
+    stp     q0, q0, [dstend, -128]
+    stp     q0, q0, [dstend, -96]
+    stp     q0, q0, [dstend, -64]
+    stp     q0, q0, [dstend, -32]
+    ret
+
+L(zva_other):
+    mov     tmp2w, 4
+    lsl     zva_lenw, tmp2w, tmp1w
+    add     tmp1, zva_len, 64           // Max alignment bytes written.
+    cmp     count, tmp1
+    blo     L(no_zva)
+
+    sub     tmp2, zva_len, 1
+    add     tmp1, dst, zva_len
+    add     dst, dst, 16
+    subs    count, tmp1, dst            // Actual alignment bytes to write.
+    bic     tmp1, tmp1, tmp2            // Aligned dc zva start address.
+    beq     2f
+1:  stp     q0, q0, [dst], 64
+    stp     q0, q0, [dst, -32]
+    subs    count, count, 64
+    b.hi    1b
+2:  mov     dst, tmp1
+    sub     count, dstend, tmp1         // Remaining bytes to write.
+    subs    count, count, zva_len
+    b.lo    4f
+3:  dc      zva, dst
+    add     dst, dst, zva_len
+    subs    count, count, zva_len
+    b.hs    3b
+4:  add     count, count, zva_len
+    b       L(tail64)
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.S b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.S
new file mode 100644
index 000000000000..abda83a1f18c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.S
@@ -0,0 +1,65 @@
+//
+// Copyright (c) 2016, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+    .text
+    .thumb
+    .syntax unified
+    .align  5
+ASM_GLOBAL ASM_PFX(InternalMemCompareGuid)
+ASM_PFX(InternalMemCompareGuid):
+    push    {r4, lr}
+    ldr     r2, [r0]
+    ldr     r3, [r0, #4]
+    ldr     r4, [r0, #8]
+    ldr     r0, [r0, #12]
+    cbz     r1, 1f
+    ldr     ip, [r1]
+    ldr     lr, [r1, #4]
+    cmp     r2, ip
+    it      eq
+    cmpeq.n r3, lr
+    beq     0f
+    movs    r0, #0
+    pop     {r4, pc}
+
+0:  ldr     r2, [r1, #8]
+    ldr     r3, [r1, #12]
+    cmp     r4, r2
+    it      eq
+    cmpeq.n r0, r3
+    bne     2f
+    movs    r0, #1
+    pop     {r4, pc}
+
+1:  orrs    r2, r2, r3
+    orrs    r4, r4, r0
+    movs    r0, #1
+    orrs    r2, r2, r4
+2:  it      ne
+    movne.n r0, #0
+    pop     {r4, pc}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.asm
new file mode 100644
index 000000000000..0373404ea9d5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareGuid.asm
@@ -0,0 +1,70 @@
+;
+; Copyright (c) 2016, Linaro Limited
+; All rights reserved.
+;
+; Redistribution and use in source and binary forms, with or without
+; modification, are permitted provided that the following conditions are met:
+;     * Redistributions of source code must retain the above copyright
+;       notice, this list of conditions and the following disclaimer.
+;     * Redistributions in binary form must reproduce the above copyright
+;       notice, this list of conditions and the following disclaimer in the
+;       documentation and/or other materials provided with the distribution.
+;     * Neither the name of the Linaro nor the
+;       names of its contributors may be used to endorse or promote products
+;       derived from this software without specific prior written permission.
+;
+; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+; HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;
+
+    EXPORT  InternalMemCompareGuid
+    THUMB
+    AREA    CompareGuid, CODE, READONLY, CODEALIGN, ALIGN=5
+
+InternalMemCompareGuid
+    push    {r4, lr}
+    ldr     r2, [r0]
+    ldr     r3, [r0, #4]
+    ldr     r4, [r0, #8]
+    ldr     r0, [r0, #12]
+    cbz     r1, L1
+    ldr     ip, [r1]
+    ldr     lr, [r1, #4]
+    cmp     r2, ip
+    it      eq
+    cmpeq   r3, lr
+    beq     L0
+    movs    r0, #0
+    pop     {r4, pc}
+
+L0
+    ldr     r2, [r1, #8]
+    ldr     r3, [r1, #12]
+    cmp     r4, r2
+    it      eq
+    cmpeq   r0, r3
+    bne     L2
+    movs    r0, #1
+    pop     {r4, pc}
+
+L1
+    orrs    r2, r2, r3
+    orrs    r4, r4, r0
+    movs    r0, #1
+    orrs    r2, r2, r4
+
+L2
+    it      ne
+    movne   r0, #0
+    pop     {r4, pc}
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.S
new file mode 100644
index 000000000000..763f54a8b802
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.S
@@ -0,0 +1,138 @@
+//
+// Copyright (c) 2013 - 2016, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Linaro nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+// Parameters and result.
+#define src1      r0
+#define src2      r1
+#define limit     r2
+#define result    r0
+
+// Internal variables.
+#define data1     r3
+#define data2     r4
+#define limit_wd  r5
+#define diff      r6
+#define tmp1      r7
+#define tmp2      r12
+#define pos       r8
+#define mask      r14
+
+    .text
+    .thumb
+    .syntax unified
+    .align  5
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    {r4-r8, lr}
+    eor     tmp1, src1, src2
+    tst     tmp1, #3
+    bne     .Lmisaligned4
+    ands    tmp1, src1, #3
+    bne     .Lmutual_align
+    add     limit_wd, limit, #3
+    nop.w
+    lsr     limit_wd, limit_wd, #2
+
+    // Start of performance-critical section  -- one 32B cache line.
+.Lloop_aligned:
+    ldr     data1, [src1], #4
+    ldr     data2, [src2], #4
+.Lstart_realigned:
+    subs    limit_wd, limit_wd, #1
+    eor     diff, data1, data2        // Non-zero if differences found.
+    cbnz    diff, 0f
+    bne     .Lloop_aligned
+    // End of performance-critical section  -- one 32B cache line.
+
+    // Not reached the limit, must have found a diff.
+0:  cbnz    limit_wd, .Lnot_limit
+
+    // Limit % 4 == 0 => all bytes significant.
+    ands    limit, limit, #3
+    beq     .Lnot_limit
+
+    lsl     limit, limit, #3              // Bits -> bytes.
+    mov     mask, #~0
+    lsl     mask, mask, limit
+    bic     data1, data1, mask
+    bic     data2, data2, mask
+
+    orr     diff, diff, mask
+
+.Lnot_limit:
+    rev     diff, diff
+    rev     data1, data1
+    rev     data2, data2
+
+    // The MS-non-zero bit of DIFF marks either the first bit
+    // that is different, or the end of the significant data.
+    // Shifting left now will bring the critical information into the
+    // top bits.
+    clz     pos, diff
+    lsl     data1, data1, pos
+    lsl     data2, data2, pos
+
+    // But we need to zero-extend (char is unsigned) the value and then
+    // perform a signed 32-bit subtraction.
+    lsr     data1, data1, #28
+    sub     result, data1, data2, lsr #28
+    pop     {r4-r8, pc}
+
+.Lmutual_align:
+    // Sources are mutually aligned, but are not currently at an
+    // alignment boundary.  Round down the addresses and then mask off
+    // the bytes that precede the start point.
+    bic     src1, src1, #3
+    bic     src2, src2, #3
+    add     limit, limit, tmp1          // Adjust the limit for the extra.
+    lsl     tmp1, tmp1, #3              // Bytes beyond alignment -> bits.
+    ldr     data1, [src1], #4
+    rsb     tmp1, tmp1, #32             // Bits to alignment -32.
+    ldr     data2, [src2], #4
+    mov     tmp2, #~0
+
+    // Little-endian.  Early bytes are at LSB.
+    lsr     tmp2, tmp2, tmp1            // Shift (tmp1 & 31).
+    add     limit_wd, limit, #3
+    orr     data1, data1, tmp2
+    orr     data2, data2, tmp2
+    lsr     limit_wd, limit_wd, #2
+    b       .Lstart_realigned
+
+.Lmisaligned4:
+    sub     limit, limit, #1
+1:
+    // Perhaps we can do better than this.
+    ldrb    data1, [src1], #1
+    ldrb    data2, [src2], #1
+    subs    limit, limit, #1
+    it      cs
+    cmpcs.n data1, data2
+    beq     1b
+    sub     result, data1, data2
+    pop     {r4-r8, pc}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.asm
new file mode 100644
index 000000000000..4c72dcf38597
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CompareMem.asm
@@ -0,0 +1,140 @@
+;
+; Copyright (c) 2013 - 2016, Linaro Limited
+; All rights reserved.
+;
+; Redistribution and use in source and binary forms, with or without
+; modification, are permitted provided that the following conditions are met:
+;     * Redistributions of source code must retain the above copyright
+;       notice, this list of conditions and the following disclaimer.
+;     * Redistributions in binary form must reproduce the above copyright
+;       notice, this list of conditions and the following disclaimer in the
+;       documentation and/or other materials provided with the distribution.
+;     * Neither the name of the Linaro nor the
+;       names of its contributors may be used to endorse or promote products
+;       derived from this software without specific prior written permission.
+;
+; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+; HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;
+
+; Parameters and result.
+#define src1      r0
+#define src2      r1
+#define limit     r2
+#define result    r0
+
+; Internal variables.
+#define data1     r3
+#define data2     r4
+#define limit_wd  r5
+#define diff      r6
+#define tmp1      r7
+#define tmp2      r12
+#define pos       r8
+#define mask      r14
+
+    EXPORT  InternalMemCompareMem
+    THUMB
+    AREA    CompareMem, CODE, READONLY
+
+InternalMemCompareMem
+    push    {r4-r8, lr}
+    eor     tmp1, src1, src2
+    tst     tmp1, #3
+    bne     Lmisaligned4
+    ands    tmp1, src1, #3
+    bne     Lmutual_align
+    add     limit_wd, limit, #3
+    nop.w
+    lsr     limit_wd, limit_wd, #2
+
+    ; Start of performance-critical section  -- one 32B cache line.
+Lloop_aligned
+    ldr     data1, [src1], #4
+    ldr     data2, [src2], #4
+Lstart_realigned
+    subs    limit_wd, limit_wd, #1
+    eor     diff, data1, data2        ; Non-zero if differences found.
+    cbnz    diff, L0
+    bne     Lloop_aligned
+    ; End of performance-critical section  -- one 32B cache line.
+
+    ; Not reached the limit, must have found a diff.
+L0
+    cbnz    limit_wd, Lnot_limit
+
+    // Limit % 4 == 0 => all bytes significant.
+    ands    limit, limit, #3
+    beq     Lnot_limit
+
+    lsl     limit, limit, #3              // Bits -> bytes.
+    mov     mask, #~0
+    lsl     mask, mask, limit
+    bic     data1, data1, mask
+    bic     data2, data2, mask
+
+    orr     diff, diff, mask
+
+Lnot_limit
+    rev     diff, diff
+    rev     data1, data1
+    rev     data2, data2
+
+    ; The MS-non-zero bit of DIFF marks either the first bit
+    ; that is different, or the end of the significant data.
+    ; Shifting left now will bring the critical information into the
+    ; top bits.
+    clz     pos, diff
+    lsl     data1, data1, pos
+    lsl     data2, data2, pos
+
+    ; But we need to zero-extend (char is unsigned) the value and then
+    ; perform a signed 32-bit subtraction.
+    lsr     data1, data1, #28
+    sub     result, data1, data2, lsr #28
+    pop     {r4-r8, pc}
+
+Lmutual_align
+    ; Sources are mutually aligned, but are not currently at an
+    ; alignment boundary.  Round down the addresses and then mask off
+    ; the bytes that precede the start point.
+    bic     src1, src1, #3
+    bic     src2, src2, #3
+    add     limit, limit, tmp1          ; Adjust the limit for the extra.
+    lsl     tmp1, tmp1, #2              ; Bytes beyond alignment -> bits.
+    ldr     data1, [src1], #4
+    neg     tmp1, tmp1                  ; Bits to alignment -32.
+    ldr     data2, [src2], #4
+    mov     tmp2, #~0
+
+    ; Little-endian.  Early bytes are at LSB.
+    lsr     tmp2, tmp2, tmp1            ; Shift (tmp1 & 31).
+    add     limit_wd, limit, #3
+    orr     data1, data1, tmp2
+    orr     data2, data2, tmp2
+    lsr     limit_wd, limit_wd, #2
+    b       Lstart_realigned
+
+Lmisaligned4
+    sub     limit, limit, #1
+L1
+    // Perhaps we can do better than this.
+    ldrb    data1, [src1], #1
+    ldrb    data2, [src2], #1
+    subs    limit, limit, #1
+    it      cs
+    cmpcs   data1, data2
+    beq     L1
+    sub     result, data1, data2
+    pop     {r4-r8, pc}
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.S
new file mode 100644
index 000000000000..32c104999d22
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.S
@@ -0,0 +1,175 @@
+#------------------------------------------------------------------------------
+#
+# CopyMem() worker for ARM
+#
+# This file started out as C code that did 64 bit moves if the buffer was
+# 32-bit aligned, else it does a byte copy. It also does a byte copy for
+# any trailing bytes. It was updated to do 32-byte copies using stm/ldm.
+#
+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
+# Copyright (c) 2016, Linaro Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+    .text
+    .thumb
+    .syntax unified
+
+/**
+  Copy Length bytes from Source to Destination. Overlap is OK.
+
+  This implementation
+
+  @param  Destination Target of copy
+  @param  Source      Place to copy from
+  @param  Length      Number of bytes to copy
+
+  @return Destination
+
+
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  )
+**/
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    {r4-r11, lr}
+    // Save the input parameters in extra registers (r11 = destination, r14 = source, r12 = length)
+    mov     r11, r0
+    mov     r10, r0
+    mov     r12, r2
+    mov     r14, r1
+
+    cmp     r11, r1
+    // If (dest < source)
+    bcc     memcopy_check_optim_default
+
+    // If (source + length < dest)
+    rsb     r3, r1, r11
+    cmp     r12, r3
+    bcc     memcopy_check_optim_default
+    b       memcopy_check_optim_overlap
+
+memcopy_check_optim_default:
+    // Check if we can use an optimized path ((length >= 32) && destination word-aligned && source word-aligned) for the memcopy (optimized path if r0 == 1)
+    tst     r0, #0xF
+    it      ne
+    movne.n r0, #0
+    bne     memcopy_default
+    tst     r1, #0xF
+    it      ne
+    movne.n r3, #0
+    it      eq
+    moveq.n r3, #1
+    cmp     r2, #31
+    it      ls
+    movls.n r0, #0
+    bls     memcopy_default
+    and     r0, r3, #1
+    b       memcopy_default
+
+memcopy_check_optim_overlap:
+    // r10 = dest_end, r14 = source_end
+    add     r10, r11, r12
+    add     r14, r12, r1
+
+    // Are we in the optimized case ((length >= 32) && dest_end word-aligned && source_end word-aligned)
+    cmp     r2, #31
+    it      ls
+    movls.n r0, #0
+    it      hi
+    movhi.n r0, #1
+    tst     r10, #0xF
+    it      ne
+    movne.n r0, #0
+    tst     r14, #0xF
+    it      ne
+    movne.n r0, #0
+    b       memcopy_overlapped
+
+memcopy_overlapped_non_optim:
+    // We read 1 byte from the end of the source buffer
+    sub     r3, r14, #1
+    sub     r12, r12, #1
+    ldrb    r3, [r3, #0]
+    sub     r2, r10, #1
+    cmp     r12, #0
+    // We write 1 byte at the end of the dest buffer
+    sub     r10, r10, #1
+    sub     r14, r14, #1
+    strb    r3, [r2, #0]
+    bne     memcopy_overlapped_non_optim
+    b       memcopy_end
+
+// r10 = dest_end, r14 = source_end
+memcopy_overlapped:
+    // Are we in the optimized case ?
+    cmp     r0, #0
+    beq     memcopy_overlapped_non_optim
+
+    // Optimized Overlapped - Read 32 bytes
+    sub     r14, r14, #32
+    sub     r12, r12, #32
+    cmp     r12, #31
+    ldmia   r14, {r2-r9}
+
+    // If length is less than 32 then disable optim
+    it      ls
+    movls.n r0, #0
+
+    cmp     r12, #0
+
+    // Optimized Overlapped - Write 32 bytes
+    sub     r10, r10, #32
+    stmia   r10, {r2-r9}
+
+    // while (length != 0)
+    bne     memcopy_overlapped
+    b       memcopy_end
+
+memcopy_default_non_optim:
+    // Byte copy
+    ldrb    r3, [r14], #1
+    sub     r12, r12, #1
+    strb    r3, [r10], #1
+
+memcopy_default:
+    cmp     r12, #0
+    beq     memcopy_end
+
+// r10 = dest, r14 = source
+memcopy_default_loop:
+    cmp     r0, #0
+    beq     memcopy_default_non_optim
+
+    // Optimized memcopy - Read 32 Bytes
+    sub     r12, r12, #32
+    cmp     r12, #31
+    ldmia   r14!, {r2-r9}
+
+    // If length is less than 32 then disable optim
+    it      ls
+    movls.n r0, #0
+
+    cmp     r12, #0
+
+    // Optimized memcopy - Write 32 Bytes
+    stmia   r10!, {r2-r9}
+
+    // while (length != 0)
+    bne     memcopy_default_loop
+
+memcopy_end:
+    mov     r0, r11
+    pop     {r4-r11, pc}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.asm
new file mode 100644
index 000000000000..f5447405fbf1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/CopyMem.asm
@@ -0,0 +1,147 @@
+;------------------------------------------------------------------------------
+;
+; CopyMem() worker for ARM
+;
+; This file started out as C code that did 64 bit moves if the buffer was
+; 32-bit aligned, else it does a byte copy. It also does a byte copy for
+; any trailing bytes. It was updated to do 32-byte copies using stm/ldm.
+;
+; Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
+; Copyright (c) 2016, Linaro Ltd. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT  InternalMemCopyMem
+    AREA    SetMem, CODE, READONLY
+    THUMB
+
+InternalMemCopyMem
+  stmfd  sp!, {r4-r11, lr}
+  // Save the input parameters in extra registers (r11 = destination, r14 = source, r12 = length)
+  mov  r11, r0
+  mov  r10, r0
+  mov  r12, r2
+  mov  r14, r1
+
+memcopy_check_overlapped
+  cmp  r11, r1
+  // If (dest < source)
+  bcc  memcopy_check_optim_default
+
+  // If (source + length < dest)
+  rsb  r3, r1, r11
+  cmp  r12, r3
+  bcc  memcopy_check_optim_default
+  b     memcopy_check_optim_overlap
+
+memcopy_check_optim_default
+  // Check if we can use an optimized path ((length >= 32) && destination word-aligned && source word-aligned) for the memcopy (optimized path if r0 == 1)
+  tst  r0, #0xF
+  movne  r0, #0
+  bne   memcopy_default
+  tst  r1, #0xF
+  movne  r3, #0
+  moveq  r3, #1
+  cmp  r2, #31
+  movls  r0, #0
+  andhi  r0, r3, #1
+  b     memcopy_default
+
+memcopy_check_optim_overlap
+  // r10 = dest_end, r14 = source_end
+  add  r10, r11, r12
+  add  r14, r12, r1
+
+  // Are we in the optimized case ((length >= 32) && dest_end word-aligned && source_end word-aligned)
+  cmp  r2, #31
+  movls  r0, #0
+  movhi  r0, #1
+  tst  r10, #0xF
+  movne  r0, #0
+  tst  r14, #0xF
+  movne  r0, #0
+  b  memcopy_overlapped
+
+memcopy_overlapped_non_optim
+  // We read 1 byte from the end of the source buffer
+  sub  r3, r14, #1
+  sub  r12, r12, #1
+  ldrb  r3, [r3, #0]
+  sub  r2, r10, #1
+  cmp  r12, #0
+  // We write 1 byte at the end of the dest buffer
+  sub  r10, r10, #1
+  sub  r14, r14, #1
+  strb  r3, [r2, #0]
+  bne  memcopy_overlapped_non_optim
+  b   memcopy_end
+
+// r10 = dest_end, r14 = source_end
+memcopy_overlapped
+  // Are we in the optimized case ?
+  cmp  r0, #0
+  beq  memcopy_overlapped_non_optim
+
+  // Optimized Overlapped - Read 32 bytes
+  sub  r14, r14, #32
+  sub  r12, r12, #32
+  cmp  r12, #31
+  ldmia  r14, {r2-r9}
+
+  // If length is less than 32 then disable optim
+  movls  r0, #0
+
+  cmp  r12, #0
+
+  // Optimized Overlapped - Write 32 bytes
+  sub  r10, r10, #32
+  stmia  r10, {r2-r9}
+
+  // while (length != 0)
+  bne  memcopy_overlapped
+  b   memcopy_end
+
+memcopy_default_non_optim
+  // Byte copy
+  ldrb  r3, [r14], #1
+  sub  r12, r12, #1
+  strb  r3, [r10], #1
+
+memcopy_default
+  cmp  r12, #0
+  beq  memcopy_end
+
+// r10 = dest, r14 = source
+memcopy_default_loop
+  cmp  r0, #0
+  beq  memcopy_default_non_optim
+
+  // Optimized memcopy - Read 32 Bytes
+  sub  r12, r12, #32
+  cmp  r12, #31
+  ldmia  r14!, {r2-r9}
+
+  // If length is less than 32 then disable optim
+  movls  r0, #0
+
+  cmp  r12, #0
+
+  // Optimized memcopy - Write 32 Bytes
+  stmia  r10!, {r2-r9}
+
+  // while (length != 0)
+  bne  memcopy_default_loop
+
+memcopy_end
+  mov  r0, r11
+  ldmfd  sp!, {r4-r11, pc}
+
+  END
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/MemLibGuid.c
new file mode 100644
index 000000000000..b2942f31c3f5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/MemLibGuid.c
@@ -0,0 +1,165 @@
+/** @file
+  Implementation of GUID functions for ARM and AARCH64
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2016, Linaro Ltd. 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 "MemLibInternals.h"
+
+/**
+  Internal function to compare two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemCompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  );
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  ASSERT (DestinationGuid != NULL);
+  ASSERT (SourceGuid != NULL);
+
+  return InternalMemCopyMem (DestinationGuid, SourceGuid, sizeof (GUID));
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  ASSERT (Guid1 != NULL);
+  ASSERT (Guid2 != NULL);
+
+  return InternalMemCompareGuid (Guid1, Guid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (InternalMemCompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return InternalMemCompareGuid (Guid, NULL);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.S
new file mode 100644
index 000000000000..5502f286537e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.S
@@ -0,0 +1,148 @@
+// Copyright (c) 2010-2011, Linaro Limited
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    * Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+//    * Neither the name of Linaro Limited nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+//
+// Written by Dave Gilbert <david.gilbert@linaro.org>
+//
+// This memchr routine is optimised on a Cortex-A9 and should work on
+// all ARMv7 processors.   It has a fast past for short sizes, and has
+// an optimised path for large data sets; the worst case is finding the
+// match early in a large data set.
+//
+
+
+// 2011-02-07 david.gilbert@linaro.org
+//    Extracted from local git a5b438d861
+// 2011-07-14 david.gilbert@linaro.org
+//    Import endianness fix from local git ea786f1b
+// 2011-12-07 david.gilbert@linaro.org
+//    Removed unneeded cbz from align loop
+
+// this lets us check a flag in a 00/ff byte easily in either endianness
+#define CHARTSTMASK(c) 1<<(c*8)
+
+    .text
+    .thumb
+    .syntax unified
+
+    .type ASM_PFX(InternalMemScanMem8), %function
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    // r0 = start of memory to scan
+    // r1 = length
+    // r2 = character to look for
+    // returns r0 = pointer to character or NULL if not found
+    uxtb    r2, r2        // Don't think we can trust the caller to actually pass a char
+
+    cmp     r1, #16       // If it's short don't bother with anything clever
+    blt     20f
+
+    tst     r0, #7        // If it's already aligned skip the next bit
+    beq     10f
+
+    // Work up to an aligned point
+5:
+    ldrb    r3, [r0],#1
+    subs    r1, r1, #1
+    cmp     r3, r2
+    beq     50f           // If it matches exit found
+    tst     r0, #7
+    bne     5b            // If not aligned yet then do next byte
+
+10:
+    // At this point, we are aligned, we know we have at least 8 bytes to work with
+    push    {r4-r7}
+    orr     r2, r2, r2, lsl #8  // expand the match word across to all bytes
+    orr     r2, r2, r2, lsl #16
+    bic     r4, r1, #7    // Number of double words to work with
+    mvns    r7, #0        // all F's
+    movs    r3, #0
+
+15:
+    ldmia   r0!, {r5,r6}
+    subs    r4, r4, #8
+    eor     r5, r5, r2    // Get it so that r5,r6 have 00's where the bytes match the target
+    eor     r6, r6, r2
+    uadd8   r5, r5, r7    // Parallel add 0xff - sets the GE bits for anything that wasn't 0
+    sel     r5, r3, r7    // bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION
+    uadd8   r6, r6, r7    // Parallel add 0xff - sets the GE bits for anything that wasn't 0
+    sel     r6, r5, r7    // chained....bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION
+    cbnz    r6, 60f
+    bne     15b           // (Flags from the subs above) If not run out of bytes then go around again
+
+    pop     {r4-r7}
+    and     r2, r2, #0xff // Get r2 back to a single character from the expansion above
+    and     r1, r1, #7    // Leave the count remaining as the number after the double words have been done
+
+20:
+    cbz     r1, 40f       // 0 length or hit the end already then not found
+
+21: // Post aligned section, or just a short call
+    ldrb    r3, [r0], #1
+    subs    r1, r1, #1
+    eor     r3, r3, r2    // r3 = 0 if match - doesn't break flags from sub
+    cbz     r3, 50f
+    bne     21b           // on r1 flags
+
+40:
+    movs    r0, #0        // not found
+    bx      lr
+
+50:
+    subs    r0, r0, #1    // found
+    bx      lr
+
+60: // We're here because the fast path found a hit - now we have to track down exactly which word it was
+    // r0 points to the start of the double word after the one that was tested
+    // r5 has the 00/ff pattern for the first word, r6 has the chained value
+    subs    r0, r0, #3
+    cmp     r5, #0
+    it      eq
+    moveq.n r5, r6        // the end is in the 2nd word
+    it      ne
+    subne.n r0, r0, #4    // or 2nd byte of 1st word
+
+    // r0 currently points to the 3rd byte of the word containing the hit
+    tst     r5, #CHARTSTMASK(0)     // 1st character
+    bne     61f
+    adds    r0, r0, #1
+    tst     r5, #CHARTSTMASK(1)     // 2nd character
+    bne     61f
+    adds    r0, r0 ,#1
+    tst     r5, #(3 << 15)          // 2nd & 3rd character
+    // If not the 3rd must be the last one
+    it      eq
+    addeq.n r0, r0, #1
+
+61:
+    pop     {r4-r7}
+    subs    r0, r0, #1
+    bx      lr
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.asm
new file mode 100644
index 000000000000..bb489f14cf7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMem.asm
@@ -0,0 +1,147 @@
+; Copyright (c) 2010-2011, Linaro Limited
+; All rights reserved.
+;
+; Redistribution and use in source and binary forms, with or without
+; modification, are permitted provided that the following conditions
+; are met:
+;
+;    * Redistributions of source code must retain the above copyright
+;    notice, this list of conditions and the following disclaimer.
+;
+;    * Redistributions in binary form must reproduce the above copyright
+;    notice, this list of conditions and the following disclaimer in the
+;    documentation and/or other materials provided with the distribution.
+;
+;    * Neither the name of Linaro Limited nor the names of its
+;    contributors may be used to endorse or promote products derived
+;    from this software without specific prior written permission.
+;
+; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+; HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;
+
+;
+; Written by Dave Gilbert <david.gilbert@linaro.org>
+;
+; This memchr routine is optimised on a Cortex-A9 and should work on
+; all ARMv7 processors.   It has a fast past for short sizes, and has
+; an optimised path for large data sets; the worst case is finding the
+; match early in a large data set.
+;
+
+
+; 2011-02-07 david.gilbert@linaro.org
+;    Extracted from local git a5b438d861
+; 2011-07-14 david.gilbert@linaro.org
+;    Import endianness fix from local git ea786f1b
+; 2011-12-07 david.gilbert@linaro.org
+;    Removed unneeded cbz from align loop
+
+; this lets us check a flag in a 00/ff byte easily in either endianness
+#define CHARTSTMASK(c) 1<<(c*8)
+
+    EXPORT  InternalMemScanMem8
+    AREA    ScanMem, CODE, READONLY
+    THUMB
+
+InternalMemScanMem8
+    ; r0 = start of memory to scan
+    ; r1 = length
+    ; r2 = character to look for
+    ; returns r0 = pointer to character or NULL if not found
+    uxtb    r2, r2        ; Don't think we can trust the caller to actually pass a char
+
+    cmp     r1, #16       ; If it's short don't bother with anything clever
+    blt     L20
+
+    tst     r0, #7        ; If it's already aligned skip the next bit
+    beq     L10
+
+    ; Work up to an aligned point
+L5
+    ldrb    r3, [r0],#1
+    subs    r1, r1, #1
+    cmp     r3, r2
+    beq     L50           ; If it matches exit found
+    tst     r0, #7
+    bne     L5            ; If not aligned yet then do next byte
+
+L10
+    ; At this point, we are aligned, we know we have at least 8 bytes to work with
+    push    {r4-r7}
+    orr     r2, r2, r2, lsl #8  ; expand the match word across to all bytes
+    orr     r2, r2, r2, lsl #16
+    bic     r4, r1, #7    ; Number of double words to work with
+    mvns    r7, #0        ; all F's
+    movs    r3, #0
+
+L15
+    ldmia   r0!, {r5,r6}
+    subs    r4, r4, #8
+    eor     r5, r5, r2    ; Get it so that r5,r6 have 00's where the bytes match the target
+    eor     r6, r6, r2
+    uadd8   r5, r5, r7    ; Parallel add 0xff - sets the GE bits for anything that wasn't 0
+    sel     r5, r3, r7    ; bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION
+    uadd8   r6, r6, r7    ; Parallel add 0xff - sets the GE bits for anything that wasn't 0
+    sel     r6, r5, r7    ; chained....bytes are 00 for none-00 bytes, or ff for 00 bytes - NOTE INVERSION
+    cbnz    r6, L60
+    bne     L15           ; (Flags from the subs above) If not run out of bytes then go around again
+
+    pop     {r4-r7}
+    and     r2, r2, #0xff ; Get r2 back to a single character from the expansion above
+    and     r1, r1, #7    ; Leave the count remaining as the number after the double words have been done
+
+L20
+    cbz     r1, L40       ; 0 length or hit the end already then not found
+
+L21 ; Post aligned section, or just a short call
+    ldrb    r3, [r0], #1
+    subs    r1, r1, #1
+    eor     r3, r3, r2    ; r3 = 0 if match - doesn't break flags from sub
+    cbz     r3, L50
+    bne     L21           ; on r1 flags
+
+L40
+    movs    r0, #0        ; not found
+    bx      lr
+
+L50
+    subs    r0, r0, #1    ; found
+    bx      lr
+
+L60 ; We're here because the fast path found a hit - now we have to track down exactly which word it was
+    ; r0 points to the start of the double word after the one that was tested
+    ; r5 has the 00/ff pattern for the first word, r6 has the chained value
+    cmp     r5, #0
+    itte    eq
+    moveq   r5, r6        ; the end is in the 2nd word
+    subeq   r0, r0, #3    ; Points to 2nd byte of 2nd word
+    subne   r0, r0, #7    ; or 2nd byte of 1st word
+
+    ; r0 currently points to the 3rd byte of the word containing the hit
+    tst     r5, #CHARTSTMASK(0)     ; 1st character
+    bne     L61
+    adds    r0, r0, #1
+    tst     r5, #CHARTSTMASK(1)     ; 2nd character
+    ittt    eq
+    addeq   r0, r0 ,#1
+    tsteq   r5, #(3 << 15)          ; 2nd & 3rd character
+    ; If not the 3rd must be the last one
+    addeq   r0, r0, #1
+
+L61
+    pop     {r4-r7}
+    subs    r0, r0, #1
+    bx      lr
+
+    END
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMemGeneric.c b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMemGeneric.c
new file mode 100644
index 000000000000..e48db7278aa0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/ScanMemGeneric.c
@@ -0,0 +1,142 @@
+/** @file
+  Architecture Independent Base Memory Library Implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "../MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  CONST UINT16                      *Pointer;
+
+  Pointer = (CONST UINT16*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  CONST UINT32                      *Pointer;
+
+  Pointer = (CONST UINT32*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  CONST UINT64                      *Pointer;
+
+  Pointer = (CONST UINT64*)Buffer;
+  do {
+    if (*Pointer == Value) {
+      return Pointer;
+    }
+    ++Pointer;
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  CONST UINT8 *BufferData;
+  UINTN       Index;
+
+  BufferData = Buffer;
+  for (Index = 0; Index < Length; Index++) {
+    if (BufferData[Index] != 0) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.S
new file mode 100644
index 000000000000..41cf81a8e20f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.S
@@ -0,0 +1,89 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2016, Linaro Ltd. 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.
+#
+#------------------------------------------------------------------------------
+
+    .text
+    .thumb
+    .syntax unified
+    .align  5
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    uxth    r2, r2
+    lsl     r1, r1, #1
+    orr     r2, r2, r2, lsl #16
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    lsl     r1, r1, #2
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    lsl     r1, r1, #3
+    b       1f
+
+    .align  5
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    uxtb    r2, r2
+    orr     r2, r2, r2, lsl #8
+    orr     r2, r2, r2, lsl #16
+    b       0f
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    movs    r2, #0
+0:  mov     r3, r2
+
+1:  push    {r4, lr}
+    cmp     r1, #16                 // fewer than 16 bytes of input?
+    add     r1, r1, r0              // r1 := dst + length
+    add     lr, r0, #16
+    blt     2f
+    bic     lr, lr, #15             // align output pointer
+
+    str     r2, [r0]                // potentially unaligned store of 4 bytes
+    str     r3, [r0, #4]            // potentially unaligned store of 4 bytes
+    str     r2, [r0, #8]            // potentially unaligned store of 4 bytes
+    str     r3, [r0, #12]           // potentially unaligned store of 4 bytes
+    beq     1f
+
+0:  add     lr, lr, #16             // advance the output pointer by 16 bytes
+    subs    r4, r1, lr              // past the output?
+    blt     3f                      // break out of the loop
+    strd    r2, r3, [lr, #-16]      // aligned store of 16 bytes
+    strd    r2, r3, [lr, #-8]
+    bne     0b                      // goto beginning of loop
+1:  pop     {r4, pc}
+
+2:  subs    r4, r1, lr
+3:  adds    r4, r4, #16
+    subs    r1, r1, #8
+    cmp     r4, #4                  // between 4 and 15 bytes?
+    blt     4f
+    cmp     r4, #8                  // between 8 and 15 bytes?
+    sub     r4, lr, #16
+    str     r2, [r4]                // overlapping store of 4 + (4 + 4) + 4 bytes
+    it      gt
+    strgt.n r3, [r4, #4]
+    it      gt
+    strgt.n r2, [r1]
+    str     r3, [r1, #4]
+    pop     {r4, pc}
+
+4:  cmp     r4, #2                  // 2 or 3 bytes?
+    strb    r2, [lr, #-16]          // store 1 byte
+    it      ge
+    strhge.n r2, [r1, #6]           // store 2 bytes
+    pop     {r4, pc}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.asm
new file mode 100644
index 000000000000..000c2a22fad6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Arm/SetMem.asm
@@ -0,0 +1,96 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, Linaro Ltd. 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.
+;
+;------------------------------------------------------------------------------
+
+    EXPORT  InternalMemZeroMem
+    EXPORT  InternalMemSetMem
+    EXPORT  InternalMemSetMem16
+    EXPORT  InternalMemSetMem32
+    EXPORT  InternalMemSetMem64
+
+    AREA    SetMem, CODE, READONLY, CODEALIGN, ALIGN=5
+    THUMB
+
+InternalMemSetMem16
+    uxth    r2, r2
+    lsl     r1, r1, #1
+    orr     r2, r2, r2, lsl #16
+    b       B0
+
+InternalMemSetMem32
+    lsl     r1, r1, #2
+    b       B0
+
+InternalMemSetMem64
+    lsl     r1, r1, #3
+    b       B1
+
+    ALIGN   32
+InternalMemSetMem
+    uxtb    r2, r2
+    orr     r2, r2, r2, lsl #8
+    orr     r2, r2, r2, lsl #16
+    b       B0
+
+InternalMemZeroMem
+    movs    r2, #0
+B0
+    mov     r3, r2
+
+B1
+    push    {r4, lr}
+    cmp     r1, #16                 ; fewer than 16 bytes of input?
+    add     r1, r1, r0              ; r1 := dst + length
+    add     lr, r0, #16
+    blt     L2
+    bic     lr, lr, #15             ; align output pointer
+
+    str     r2, [r0]                ; potentially unaligned store of 4 bytes
+    str     r3, [r0, #4]            ; potentially unaligned store of 4 bytes
+    str     r2, [r0, #8]            ; potentially unaligned store of 4 bytes
+    str     r3, [r0, #12]           ; potentially unaligned store of 4 bytes
+    beq     L1
+
+L0
+    add     lr, lr, #16             ; advance the output pointer by 16 bytes
+    subs    r4, r1, lr              ; past the output?
+    blt     L3                      ; break out of the loop
+    strd    r2, r3, [lr, #-16]      ; aligned store of 16 bytes
+    strd    r2, r3, [lr, #-8]
+    bne     L0                      ; goto beginning of loop
+L1
+    pop     {r4, pc}
+
+L2
+    subs    r4, r1, lr
+L3
+    adds    r4, r4, #16
+    subs    r1, r1, #8
+    cmp     r4, #4                  ; between 4 and 15 bytes?
+    blt     L4
+    cmp     r4, #8                  ; between 8 and 15 bytes?
+    str     r2, [lr, #-16]          ; overlapping store of 4 + (4 + 4) + 4 bytes
+    itt     gt
+    strgt   r3, [lr, #-12]
+    strgt   r2, [r1]
+    str     r3, [r1, #4]
+    pop     {r4, pc}
+
+L4
+    cmp     r4, #2                  ; 2 or 3 bytes?
+    strb    r2, [lr, #-16]          ; store 1 byte
+    it      ge
+    strhge  r2, [r1, #6]            ; store 2 bytes
+    pop     {r4, pc}
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.inf b/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.inf
new file mode 100644
index 000000000000..d28aa84a33b9
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.inf
@@ -0,0 +1,174 @@
+## @file
+#  Instance of Base Memory Library optimized for use in DXE phase.
+#
+#  Base Memory Library that is optimized for use in DXE phase.  
+#  Uses REP, MMX, XMM registers as required for best performance.
+#
+#  Copyright (c) 2007 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLibOptDxe
+  MODULE_UNI_FILE                = BaseMemoryLibOptDxe.uni
+  FILE_GUID                      = 02BD55C2-AB1D-4b75-B0FD-9A63AE09B31D
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 ARM AARCH64
+#
+
+[Sources]
+  MemLibInternals.h
+
+[Sources.Ia32]
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.S
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.S
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.S
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.S
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.S
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.S
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.S
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.S
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.S
+  Ia32/SetMem.nasm
+  Ia32/SetMem.S
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.S
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.asm
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.asm
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.asm
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.asm
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.asm
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.asm
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.asm
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.asm
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.asm
+  Ia32/SetMem.nasm
+  Ia32/SetMem.asm
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.asm
+  Ia32/IsZeroBuffer.nasm
+  MemLibGuid.c
+
+[Sources.X64]
+  X64/ScanMem64.nasm
+  X64/ScanMem64.asm
+  X64/ScanMem64.S
+  X64/ScanMem32.nasm
+  X64/ScanMem32.asm
+  X64/ScanMem32.S
+  X64/ScanMem16.nasm
+  X64/ScanMem16.asm
+  X64/ScanMem16.S
+  X64/ScanMem8.nasm
+  X64/ScanMem8.asm
+  X64/ScanMem8.S
+  X64/CompareMem.nasm
+  X64/CompareMem.asm
+  X64/CompareMem.S
+  X64/ZeroMem.nasm
+  X64/ZeroMem.asm
+  X64/ZeroMem.S
+  X64/SetMem64.nasm
+  X64/SetMem64.asm
+  X64/SetMem64.S
+  X64/SetMem32.nasm
+  X64/SetMem32.asm
+  X64/SetMem32.S
+  X64/SetMem16.nasm
+  X64/SetMem16.asm
+  X64/SetMem16.S
+  X64/SetMem.nasm
+  X64/SetMem.asm
+  X64/SetMem.S
+  X64/CopyMem.nasm
+  X64/CopyMem.asm
+  X64/CopyMem.S
+  X64/IsZeroBuffer.nasm
+  MemLibGuid.c
+
+[Defines.ARM, Defines.AARCH64]
+  #
+  # The ARM implementations of this library may perform unaligned accesses, and
+  # may use DC ZVA instructions that are only allowed when the MMU and D-cache
+  # are on. Since SEC, PEI_CORE and PEIM modules may execute with the MMU off,
+  # omit them from the supported module types list for this library.
+  #
+  LIBRARY_CLASS = BaseMemoryLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER UEFI_DRIVER UEFI_APPLICATION
+
+[Sources.ARM]
+  Arm/ScanMem.S       |GCC
+  Arm/SetMem.S        |GCC
+  Arm/CopyMem.S       |GCC
+  Arm/CompareMem.S    |GCC
+  Arm/CompareGuid.S   |GCC
+
+  Arm/ScanMem.asm     |RVCT
+  Arm/SetMem.asm      |RVCT
+  Arm/CopyMem.asm     |RVCT
+  Arm/CompareMem.asm  |RVCT
+  Arm/CompareGuid.asm |RVCT
+
+[Sources.AARCH64]
+  AArch64/ScanMem.S
+  AArch64/SetMem.S
+  AArch64/CopyMem.S
+  AArch64/CompareMem.S
+  AArch64/CompareGuid.S
+
+[Sources.ARM, Sources.AARCH64]
+  Arm/ScanMemGeneric.c
+  Arm/MemLibGuid.c
+
+[Sources]
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.uni b/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.uni
new file mode 100644
index 000000000000..bb0cd565a25c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library optimized for use in DXE phase.
+//
+// Base Memory Library that is optimized for use in DXE phase.
+// Uses REP, MMX, XMM registers as required for best performance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Base Memory Library for DXE"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library that is optimized for use in DXE phase. Uses REP, MMX, XMM registers as required for best performance."
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/CompareMemWrapper.c
new file mode 100644
index 000000000000..aa7c2aab812c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.S
new file mode 100644
index 000000000000..a430453938e7
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.S
@@ -0,0 +1,55 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCompareMem):
+    push    %esi
+    push    %edi
+    movl    12(%esp), %esi
+    movl    16(%esp), %edi
+    movl    20(%esp), %ecx
+    repe    cmpsb
+    movzbl  -1(%esi), %eax
+    movzbl  -1(%edi), %edx
+    subl    %edx, %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.asm
new file mode 100644
index 000000000000..ba31a1875712
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    esi edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte ptr [esi - 1]
+    movzx   edx, byte ptr [edi - 1]
+    sub     eax, edx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.nasm
new file mode 100644
index 000000000000..e8d1abdc17fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CompareMem.nasm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte [esi - 1]
+    movzx   edx, byte [edi - 1]
+    sub     eax, edx
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.S
new file mode 100644
index 000000000000..dbd052ba71c0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.S
@@ -0,0 +1,85 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCopyMem):
+    push    %esi
+    push    %edi
+    movl    16(%esp), %esi              # esi <- Source
+    movl    12(%esp), %edi              # edi <- Destination
+    movl    20(%esp), %edx              # edx <- Count
+    leal    -1(%esi,%edx,), %eax        # eax <- End of Source
+    cmpl    %edi, %esi
+    jae     L0
+    cmpl    %edi, %eax                  # Overlapped?
+    jae     L_CopyBackward               # Copy backward if overlapped
+L0:
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    andl    $15, %ecx                   # ecx + edi aligns on 16-byte boundary
+    jz      L1
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx                  # edx <- remaining bytes to copy
+    rep
+    movsb
+L1:
+    movl    %edx, %ecx
+    andl    $15, %edx
+    shrl    $4, %ecx                    # ecx <- # of DQwords to copy
+    jz      L_CopyBytes
+    addl    $-16, %esp
+    movdqu  %xmm0, (%esp)
+L2:
+    movdqu  (%esi), %xmm0
+    movntdq %xmm0, (%edi)
+    addl    $16, %esi
+    addl    $16, %edi
+    loop    L2
+    mfence
+    movdqu  (%esp),%xmm0
+    addl    $16, %esp                   # stack cleanup
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movl    %eax, %esi                  # esi <- Last byte in Source
+    leal    -1(%edi,%edx,), %edi        # edi <- Last byte in Destination
+    std
+L_CopyBytes:
+    movl    %edx, %ecx
+    rep
+    movsb
+    cld
+    movl    12(%esp), %eax              # eax <- Destination as return value
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.asm
new file mode 100644
index 000000000000..84fad9190d2f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.asm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    esi edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     @F
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      @F
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx                    ; edx <- remaining bytes to copy
+    rep     movsb
+@@:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to copy
+    jz      @CopyBytes
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+@@:
+    movdqu  xmm0, [esi]                 ; esi may not be 16-bytes aligned
+    movntdq [edi], xmm0                 ; edi should be 16-bytes aligned
+    add     esi, 16
+    add     edi, 16
+    loop    @B
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.nasm
new file mode 100644
index 000000000000..6913874d3055
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/CopyMem.nasm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     .0
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      .1
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx                    ; edx <- remaining bytes to copy
+    rep     movsb
+.1:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to copy
+    jz      @CopyBytes
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+.2:
+    movdqu  xmm0, [esi]                 ; esi may not be 16-bytes aligned
+    movntdq [edi], xmm0                 ; edi should be 16-bytes aligned
+    add     esi, 16
+    add     edi, 16
+    loop    .2
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..cfd41a62500b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    edi
+    mov     edi, [esp + 8]             ; edi <- Buffer
+    mov     ecx, [esp + 12]            ; ecx <- Length
+    mov     edx, ecx                   ; edx <- ecx
+    shr     ecx, 2                     ; ecx <- number of dwords
+    and     edx, 3                     ; edx <- number of trailing bytes
+    xor     eax, eax                   ; eax <- 0, also set ZF
+    repe    scasd
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     ecx, edx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     edi
+    mov     eax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     edi
+    xor     eax, eax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.S
new file mode 100644
index 000000000000..c485543e873e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem16.Asm
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem16):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasw
+    leal    -2(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.asm
new file mode 100644
index 000000000000..bca66e02c896
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.nasm
new file mode 100644
index 000000000000..78d9f3071e8c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem16.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.S
new file mode 100644
index 000000000000..016ebd252265
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem32):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasl
+    leal    -4(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.asm
new file mode 100644
index 000000000000..8c24bd010953
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.nasm
new file mode 100644
index 000000000000..bbacf38a7245
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.S
new file mode 100644
index 000000000000..6e4285645711
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.S
@@ -0,0 +1,61 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    cmpl    (%edi), %eax
+    leal    8(%edi), %edi
+    loopne  L0
+    jne     L1
+    cmpl    -4(%edi), %edx
+    jecxz   L1
+    jne     L0
+L1:
+    leal    -8(%edi), %eax
+    cmovne  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.asm
new file mode 100644
index 000000000000..c835effc0cea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  @B
+    jne     @F
+    cmp     edx, [edi - 4]
+    jecxz   @F
+    jne     @B
+@@:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.nasm
new file mode 100644
index 000000000000..e994d4ac437a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem64.nasm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  .0
+    jne     .1
+    cmp     edx, [edi - 4]
+    jecxz   .1
+    jne     .0
+.1:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.S
new file mode 100644
index 000000000000..02bb27f36ac6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem8):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movb    16(%esp), %al
+    repne   scasb
+    leal    -1(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.asm
new file mode 100644
index 000000000000..f199bb957a6c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.nasm
new file mode 100644
index 000000000000..d13c9c7bf400
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ScanMem8.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.S
new file mode 100644
index 000000000000..ee0b659afd97
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.S
@@ -0,0 +1,50 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem):
+    push    %edi
+    movl    12(%esp),%ecx
+    movb    16(%esp),%al
+    movb    %al, %ah
+    shrd    $16, %eax, %edx
+    shld    $16, %edx, %eax
+    movl    %ecx, %edx
+    movl    8(%esp),%edi
+    shr    $2, %ecx
+    rep stosl
+    movl    %edx, %ecx
+    andl    $3, %ecx
+    rep stosb
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.asm
new file mode 100644
index 000000000000..6de9c2ff8077
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    edi
+    mov         ecx, [esp + 12]
+    mov         al,  [esp + 16]
+    mov         ah,  al
+    shrd        edx, eax, 16
+    shld        eax, edx, 16
+    mov         edx, ecx
+    mov         edi, [esp + 8]
+    shr         ecx, 2
+    rep stosd
+    mov         ecx, edx
+    and         ecx, 3
+    rep stosb
+    mov         eax, [esp + 8]
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.nasm
new file mode 100644
index 000000000000..3a75363e3ad3
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem.nasm
@@ -0,0 +1,52 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    edi
+    mov         ecx, [esp + 12]
+    mov         al,  [esp + 16]
+    mov         ah,  al
+    shrd        edx, eax, 16
+    shld        eax, edx, 16
+    mov         edx, ecx
+    mov         edi, [esp + 8]
+    shr         ecx, 2
+    rep stosd
+    mov         ecx, edx
+    and         ecx, 3
+    rep stosb
+    mov         eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.S
new file mode 100644
index 000000000000..8989bdd02f40
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem16):
+    push    %edi
+    movl    16(%esp), %eax
+    movl    8(%esp), %edi
+    movl    12(%esp), %ecx
+    rep
+    stosw
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.asm
new file mode 100644
index 000000000000..3d8c9a6299fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.nasm
new file mode 100644
index 000000000000..cfa4906e729c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem16.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.S
new file mode 100644
index 000000000000..b2c9a854a988
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem32):
+    push    %edi
+    movl    16(%esp),%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    rep
+    stosl
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.asm
new file mode 100644
index 000000000000..f1e1991b8d67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.nasm
new file mode 100644
index 000000000000..78e09b39e2a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem32.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.S
new file mode 100644
index 000000000000..f25dfe180432
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    mov     %eax, -8(%edi, %ecx, 8)
+    mov     %edx, -4(%edi, %ecx, 8)
+    loop    L0
+    movl    %edi, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.asm
new file mode 100644
index 000000000000..31d718adae72
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.asm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    @B
+    mov     eax, edi
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.nasm
new file mode 100644
index 000000000000..d0afacb52493
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/SetMem64.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    .0
+    mov     eax, edi
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.S
new file mode 100644
index 000000000000..70cede6cce93
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.S
@@ -0,0 +1,49 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemZeroMem):
+    push    %edi
+    xorl    %eax,%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    movl    %ecx,%edx
+    shrl    $2,%ecx
+    andl    $3,%edx
+    pushl   %edi
+    rep
+    stosl
+    movl    %edx,%ecx
+    rep
+    stosb
+    popl    %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.asm
new file mode 100644
index 000000000000..01ea1af932ee
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.asm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.nasm
new file mode 100644
index 000000000000..31efb6ad8668
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/Ia32/ZeroMem.nasm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibOptDxe/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/MemLibInternals.h b/MdePkg/Library/BaseMemoryLibOptDxe/MemLibInternals.h
new file mode 100644
index 000000000000..be7952e75c86
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer The target of the copy request.
+  @param  SourceBuffer      The place to copy from.
+  @param  Length            The number of bytes to copy.
+
+  @return Destination.
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set.
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..a3243a67089c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..229703ebcccf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/ScanMem8Wrapper.c
@@ -0,0 +1,100 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       
+The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem32Wrapper.c
new file mode 100644
index 000000000000..7758e1f438db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/SetMemWrapper.c
new file mode 100644
index 000000000000..6e3c3f80f3b2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.S
new file mode 100644
index 000000000000..90a04bb709ba
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.S
@@ -0,0 +1,59 @@
+#
+# ConvertAsm.py: Automatically generated from CompareMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------ 
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rcx, %rsi
+    movq    %rdx, %rdi
+    movq    %r8, %rcx
+    repe    cmpsb
+    movzbq  -1(%rsi) , %rax
+    movzbq  -1(%rdi) , %rdx
+    sub     %dl, %al
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.asm
new file mode 100644
index 000000000000..09f077b85df8
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    rsi rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte ptr [rsi - 1]
+    movzx   rdx, byte ptr [rdi - 1]
+    sub     rax, rdx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.nasm
new file mode 100644
index 000000000000..cb0d88658387
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CompareMem.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte [rsi - 1]
+    movzx   rdx, byte [rdi - 1]
+    sub     rax, rdx
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.S
new file mode 100644
index 000000000000..39e36bd7f147
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.S
@@ -0,0 +1,82 @@
+#
+# ConvertAsm.py: Automatically generated from CopyMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rdx, %rsi                  # rsi <- Source
+    movq    %rcx, %rdi                  # rdi <- Destination
+    leaq    -1(%rsi,%r8,), %r9          # r9 <- Last byte of Source      
+    cmpq    %rdi, %rsi
+    movq    %rdi, %rax                  # rax <- Destination as return value
+    jae     L0                          # Copy forward if Source > Destination
+    cmpq    %rdi, %r9                   # Overlapped?
+    jae     L_CopyBackward              # Copy backward if overlapped
+L0:
+    xorq    %rcx, %rcx
+    subq    %rdi, %rcx                  # rcx <- -rdi
+    andq    $15, %rcx                   # rcx + rsi should be 16 bytes aligned
+    jz      L1                          # skip if rcx == 0
+    cmpq    %r8, %rcx
+    cmova   %r8, %rcx
+    subq    %rcx, %r8
+    rep     movsb
+L1:
+    movq    %r8,  %rcx
+    andq    $15, %r8
+    shrq    $4, %rcx                    # rcx <- # of DQwords to copy
+    jz      L_CopyBytes
+    movdqu  %xmm0, 0x18(%rsp)           # save xmm0 on stack
+L2:
+    movdqu  (%rsi), %xmm0               # rsi may not be 16-byte aligned
+    movntdq %xmm0, (%rdi)               # rdi should be 16-byte aligned
+    addq    $16, %rsi
+    addq    $16, %rdi
+    loop    L2
+    mfence
+    movdqa  0x18(%rsp), %xmm0            # restore xmm0
+    jmp     L_CopyBytes                  # copy remaining bytes
+L_CopyBackward:
+    movq    %r9, %rsi                   # rsi <- Last byte of Source
+    leaq     -1(%rdi, %r8,), %rdi       # rdi <- Last byte of Destination
+    std
+L_CopyBytes:
+    movq    %r8, %rcx
+    rep     movsb
+    cld
+    popq    %rdi
+    popq    %rsi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.asm
new file mode 100644
index 000000000000..9218003428f6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.asm
@@ -0,0 +1,79 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    rsi rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- Last byte of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     @F                          ; Copy forward if Source > Destination
+    cmp     r9, rdi                     ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    xor     rcx, rcx
+    sub     rcx, rdi                    ; rcx <- -rdi
+    and     rcx, 15                     ; rcx + rsi should be 16 bytes aligned
+    jz      @F                          ; skip if rcx == 0
+    cmp     rcx, r8
+    cmova   rcx, r8
+    sub     r8, rcx
+    rep     movsb
+@@:
+    mov     rcx, r8
+    and     r8, 15
+    shr     rcx, 4                      ; rcx <- # of DQwords to copy
+    jz      @CopyBytes
+    movdqa  [rsp + 18h], xmm0           ; save xmm0 on stack
+@@:
+    movdqu  xmm0, [rsi]                 ; rsi may not be 16-byte aligned
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rsi, 16
+    add     rdi, 16
+    loop    @B
+    mfence
+    movdqa  xmm0, [rsp + 18h]           ; restore xmm0
+    jmp     @CopyBytes                  ; copy remaining bytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- Last byte of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- Last byte of Destination
+    std
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb
+    cld
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.nasm
new file mode 100644
index 000000000000..9fe45d4e8c2f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/CopyMem.nasm
@@ -0,0 +1,83 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- Last byte of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     .0                          ; Copy forward if Source > Destination
+    cmp     r9, rdi                     ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    xor     rcx, rcx
+    sub     rcx, rdi                    ; rcx <- -rdi
+    and     rcx, 15                     ; rcx + rsi should be 16 bytes aligned
+    jz      .1                          ; skip if rcx == 0
+    cmp     rcx, r8
+    cmova   rcx, r8
+    sub     r8, rcx
+    rep     movsb
+.1:
+    mov     rcx, r8
+    and     r8, 15
+    shr     rcx, 4                      ; rcx <- # of DQwords to copy
+    jz      @CopyBytes
+    movdqa  [rsp + 0x18], xmm0           ; save xmm0 on stack
+.2:
+    movdqu  xmm0, [rsi]                 ; rsi may not be 16-byte aligned
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rsi, 16
+    add     rdi, 16
+    loop    .2
+    mfence
+    movdqa  xmm0, [rsp + 0x18]           ; restore xmm0
+    jmp     @CopyBytes                  ; copy remaining bytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- Last byte of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- Last byte of Destination
+    std
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb
+    cld
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..3b855a7bf4a6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    rdi
+    mov     rdi, rcx                   ; rdi <- Buffer
+    mov     rcx, rdx                   ; rcx <- Length
+    shr     rcx, 3                     ; rcx <- number of qwords
+    and     rdx, 7                     ; rdx <- number of trailing bytes
+    xor     rax, rax                   ; rax <- 0, also set ZF
+    repe    scasq
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     rcx, rdx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     rdi
+    mov     rax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     rdi
+    xor     rax, rax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.S
new file mode 100644
index 000000000000..ea82f5558829
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID          *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    pushq  %rdi
+    movq   %rcx, %rdi
+    movq   %r8, %rax
+    movq   %rdx, %rcx
+    repne   scasw
+    leaq    -2(%rdi), %rax
+    cmovnz  %rcx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.asm
new file mode 100644
index 000000000000..75200414d1c1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.nasm
new file mode 100644
index 000000000000..9f0de63ea655
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem16.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.S
new file mode 100644
index 000000000000..7ff1c08e111c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    movq    %rdx, %rcx
+    repne   scasl
+    leaq    -4(%rdi), %rax
+    cmovnz  %rcx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.asm
new file mode 100644
index 000000000000..ad47e5a53a13
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.nasm
new file mode 100644
index 000000000000..5c9ae5d08389
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.S
new file mode 100644
index 000000000000..1948c16e302c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.S
@@ -0,0 +1,55 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID          *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    movq    %rdx, %rcx
+    repne   scasq
+    leaq    -8(%rdi), %rax
+    cmovnz  %rcx, %rax
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.asm
new file mode 100644
index 000000000000..3eb5b719fa07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.nasm
new file mode 100644
index 000000000000..b98c6dece330
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem64.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.S
new file mode 100644
index 000000000000..688884f448a4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem8.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID          *Buffer,
+#   IN      UINTN               Length,
+#   IN      UINT8               Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasb
+    leaq    -1(%rdi), %rax
+    cmovnz  %rcx, %rax                  # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.asm
new file mode 100644
index 000000000000..8ece85e5b4a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.nasm
new file mode 100644
index 000000000000..8499795a1d7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ScanMem8.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.S
new file mode 100644
index 000000000000..41558f610563
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.S
@@ -0,0 +1,57 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    pushq   %rdi
+    pushq   %rbx
+    pushq   %rcx        # push Buffer
+    movq    %r8, %rax   # rax = Value
+    andq    $0xff, %rax # rax = lower 8 bits of r8, upper 56 bits are 0
+    movb    %al, %ah    # ah  = al
+    movw    %ax, %bx    # bx  = ax
+    shlq    $0x10, %rax # rax = ax << 16
+    movw    %bx,  %ax   # ax  = bx
+    movq    %rax, %rbx  # ebx = eax
+    shlq    $0x20, %rax # rax = rax << 32
+    orq     %rbx, %rax  # eax = ebx
+    movq    %rcx, %rdi  # rdi = Buffer
+    movq    %rdx, %rcx  # rcx = Count
+    shrq    $3, %rcx    # rcx = rcx / 8
+    cld
+    rep     stosq 
+    movq    %rdx, %rcx  # rcx = rdx
+    andq    $7, %rcx    # rcx = rcx & 7
+    rep     stosb 
+    popq    %rax        # rax = Buffer
+    popq    %rbx
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.asm
new file mode 100644
index 000000000000..ffe242da6657
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.asm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    rdi rbx
+    push    rcx       ; push Buffer
+    mov     rax, r8   ; rax = Value
+    and     rax, 0ffh ; rax = lower 8 bits of r8, upper 56 bits are 0
+    mov     ah,  al   ; ah  = al
+    mov     bx,  ax   ; bx  = ax
+    shl     rax, 10h  ; rax = ax << 16
+    mov     ax,  bx   ; ax  = bx
+    mov     rbx, rax  ; ebx = eax
+    shl     rax, 20h  ; rax = rax << 32
+    or      rax, rbx  ; eax = ebx
+    mov     rdi, rcx  ; rdi = Buffer
+    mov     rcx, rdx  ; rcx = Count
+    shr     rcx, 3    ; rcx = rcx / 8
+    cld
+    rep     stosq 
+    mov     rcx, rdx  ; rcx = rdx
+    and     rcx, 7    ; rcx = rcx & 7
+    rep     stosb 
+    pop     rax       ; rax = Buffer
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.nasm
new file mode 100644
index 000000000000..48d69ab9ab52
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem.nasm
@@ -0,0 +1,62 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    rdi
+    push    rbx
+    push    rcx       ; push Buffer
+    mov     rax, r8   ; rax = Value
+    and     rax, 0xff ; rax = lower 8 bits of r8, upper 56 bits are 0
+    mov     ah,  al   ; ah  = al
+    mov     bx,  ax   ; bx  = ax
+    shl     rax, 0x10  ; rax = ax << 16
+    mov     ax,  bx   ; ax  = bx
+    mov     rbx, rax  ; ebx = eax
+    shl     rax, 0x20  ; rax = rax << 32
+    or      rax, rbx  ; eax = ebx
+    mov     rdi, rcx  ; rdi = Buffer
+    mov     rcx, rdx  ; rcx = Count
+    shr     rcx, 3    ; rcx = rcx / 8
+    cld
+    rep     stosq
+    mov     rcx, rdx  ; rcx = rdx
+    and     rcx, 7    ; rcx = rcx & 7
+    rep     stosb
+    pop     rax       ; rax = Buffer
+    pop     rbx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.S
new file mode 100644
index 000000000000..d6f570f29207
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchg    %rdx, %rcx
+    rep     stosw
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.asm
new file mode 100644
index 000000000000..c09619f6da3d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    pop     rax
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.nasm
new file mode 100644
index 000000000000..d9a3d358cd0d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem16.nasm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    pop     rax
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.S
new file mode 100644
index 000000000000..7dba067a5065
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosl
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.asm
new file mode 100644
index 000000000000..99b6087b0ed1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    pop     rax
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.nasm
new file mode 100644
index 000000000000..6f9770438b35
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem32.nasm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    pop     rax
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.S
new file mode 100644
index 000000000000..a94f0388d00f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.S
@@ -0,0 +1,46 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchg    %rdx, %rcx
+    rep     stosq
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.asm
new file mode 100644
index 000000000000..1e33f053305b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    pop     rax
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.nasm
new file mode 100644
index 000000000000..9b0b8acaef45
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/SetMem64.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    rdi
+    push    rcx
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    pop     rax
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.S b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.S
new file mode 100644
index 000000000000..38b867897507
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.S
@@ -0,0 +1,51 @@
+#
+# ConvertAsm.py: Automatically generated from ZeroMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    pushq   %rdi
+    pushq   %rcx
+    xorq    %rax, %rax
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    shrq    $3, %rcx
+    andq    $7, %rdx
+    cld
+    rep     stosq
+    movq    %rdx, %rcx
+    rep     stosb
+    popq    %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.asm
new file mode 100644
index 000000000000..80ddd1d53e28
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.asm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    rdi
+    push    rcx       ; push Buffer
+    xor     rax, rax  ; rax = 0
+    mov     rdi, rcx  ; rdi = Buffer
+    mov     rcx, rdx  ; rcx = Count
+    shr     rcx, 3    ; rcx = rcx / 8
+    and     rdx, 7    ; rdx = rdx & 7
+    cld
+    rep     stosq
+    mov     rcx, rdx  ; rcx = rdx
+    rep     stosb
+    pop     rax       ; rax = Buffer
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.nasm
new file mode 100644
index 000000000000..12c1da99868e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/X64/ZeroMem.nasm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    rdi
+    push    rcx       ; push Buffer
+    xor     rax, rax  ; rax = 0
+    mov     rdi, rcx  ; rdi = Buffer
+    mov     rcx, rdx  ; rcx = Count
+    shr     rcx, 3    ; rcx = rcx / 8
+    and     rdx, 7    ; rdx = rdx & 7
+    cld
+    rep     stosq
+    mov     rcx, rdx  ; rcx = rdx
+    rep     stosb
+    pop     rax       ; rax = Buffer
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptDxe/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptDxe/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptDxe/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.inf b/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.inf
new file mode 100644
index 000000000000..205c665fd2db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.inf
@@ -0,0 +1,152 @@
+## @file
+#  Instance of Base Memory Library optimized for use in PEI phase.
+#
+#  Base Memory Library that is optimized for use in PEI phase.  
+#  Uses REP, MMX, XMM registers as required for best performance.
+#
+#  Copyright (c) 2007 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLibOptPei
+  MODULE_UNI_FILE                = BaseMemoryLibOptPei.uni
+  FILE_GUID                      = D6F43B1B-0F21-462b-B8B7-A033C3EB4261
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  MemLibInternals.h
+
+[Sources.Ia32]
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.S
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.S
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.S
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.S
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.S
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.S
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.S
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.S
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.S
+  Ia32/SetMem.nasm
+  Ia32/SetMem.S
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.S
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.asm
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.asm
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.asm
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.asm
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.asm
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.asm
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.asm
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.asm
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.asm
+  Ia32/SetMem.nasm
+  Ia32/SetMem.asm
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.asm
+  Ia32/IsZeroBuffer.nasm
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGuid.c
+
+[Sources.X64]
+  X64/ScanMem64.nasm
+  X64/ScanMem64.asm
+  X64/ScanMem64.S
+  X64/ScanMem32.nasm
+  X64/ScanMem32.asm
+  X64/ScanMem32.S
+  X64/ScanMem16.nasm
+  X64/ScanMem16.asm
+  X64/ScanMem16.S
+  X64/ScanMem8.nasm
+  X64/ScanMem8.asm
+  X64/ScanMem8.S
+  X64/CompareMem.nasm
+  X64/CompareMem.asm
+  X64/CompareMem.S
+  X64/ZeroMem.nasm
+  X64/ZeroMem.asm
+  X64/ZeroMem.S
+  X64/SetMem64.nasm
+  X64/SetMem64.asm
+  X64/SetMem64.S
+  X64/SetMem32.nasm
+  X64/SetMem32.asm
+  X64/SetMem32.S
+  X64/SetMem16.nasm
+  X64/SetMem16.asm
+  X64/SetMem16.S
+  X64/SetMem.nasm
+  X64/SetMem.asm
+  X64/SetMem.S
+  X64/CopyMem.nasm
+  X64/CopyMem.asm
+  X64/CopyMem.S
+  X64/IsZeroBuffer.nasm
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGuid.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.uni b/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.uni
new file mode 100644
index 000000000000..dda230ed3351
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library optimized for use in PEI phase.
+//
+// Base Memory Library that is optimized for use in PEI phase.
+// Uses REP, MMX, XMM registers as required for best performance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library optimized for use in the PEI phase"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This is the Base Memory Library that is optimized for use in the PEI phase. It uses REP, MMX, XMM registers, as required for best performance."
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/CompareMemWrapper.c
new file mode 100644
index 000000000000..aa7c2aab812c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.S
new file mode 100644
index 000000000000..a430453938e7
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.S
@@ -0,0 +1,55 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCompareMem):
+    push    %esi
+    push    %edi
+    movl    12(%esp), %esi
+    movl    16(%esp), %edi
+    movl    20(%esp), %ecx
+    repe    cmpsb
+    movzbl  -1(%esi), %eax
+    movzbl  -1(%edi), %edx
+    subl    %edx, %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.asm
new file mode 100644
index 000000000000..ba31a1875712
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    esi edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte ptr [esi - 1]
+    movzx   edx, byte ptr [edi - 1]
+    sub     eax, edx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.nasm
new file mode 100644
index 000000000000..e8d1abdc17fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CompareMem.nasm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte [esi - 1]
+    movzx   edx, byte [edi - 1]
+    sub     eax, edx
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.S
new file mode 100644
index 000000000000..12006753d89f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.S
@@ -0,0 +1,62 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCopyMem):
+    push    %esi
+    push    %edi
+    movl    16(%esp), %esi              # esi <- Source
+    movl    12(%esp), %edi              # edi <- Destination
+    movl    20(%esp), %edx              # edx <- Count
+    cmpl    %esi, %edi
+    je      L_CopyDone
+    cmpl    $0, %edx
+    je      L_CopyDone
+    leal    -1(%esi, %edx), %eax        # eax <- End of Source
+    cmpl    %edi, %esi
+    jae     L_CopyBytes
+    cmpl    %edi, %eax
+    jb      L_CopyBytes                 # Copy backward if overlapped
+    movl    %eax, %esi                  # esi <- End of Source
+    leal    -1(%edi, %edx), %edi        # edi <- End of Destination
+    std
+L_CopyBytes:
+    movl    %edx, %ecx
+    rep
+    movsb                               # Copy bytes backward
+    cld
+L_CopyDone:
+    movl    12(%esp), %eax              # eax <- Destination as return value
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.asm
new file mode 100644
index 000000000000..f3258331ef6a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.asm
@@ -0,0 +1,61 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    esi edi
+    mov     esi, [esp+16]                ; esi <- Source
+    mov     edi, [esp+12]                ; edi <- Destination
+    mov     edx, [esp+20]                ; edx <- Count
+    cmp     esi, edi
+    je      @CopyDone
+    cmp     edx, 0
+    je      @CopyDone
+    lea     eax, [esi + edx - 1]         ; eax <- End of Source
+    cmp     esi, edi
+    jae     @CopyBytes
+    cmp     eax, edi
+    jb      @CopyBytes                   ; Copy backward if overlapped
+    mov     esi, eax                     ; esi <- End of Source
+    lea     edi, [edi + edx - 1]         ; edi <- End of Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb                        ; Copy bytes backward
+    cld
+@CopyDone:
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.nasm
new file mode 100644
index 000000000000..d7e62aae6ebf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/CopyMem.nasm
@@ -0,0 +1,62 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    esi
+    push    edi
+    mov     esi, [esp+16]                ; esi <- Source
+    mov     edi, [esp+12]                ; edi <- Destination
+    mov     edx, [esp+20]                ; edx <- Count
+    cmp     esi, edi
+    je      @CopyDone
+    cmp     edx, 0
+    je      @CopyDone
+    lea     eax, [esi + edx - 1]         ; eax <- End of Source
+    cmp     esi, edi
+    jae     @CopyBytes
+    cmp     eax, edi
+    jb      @CopyBytes                   ; Copy backward if overlapped
+    mov     esi, eax                     ; esi <- End of Source
+    lea     edi, [edi + edx - 1]         ; edi <- End of Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb                        ; Copy bytes backward
+    cld
+@CopyDone:
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..cfd41a62500b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    edi
+    mov     edi, [esp + 8]             ; edi <- Buffer
+    mov     ecx, [esp + 12]            ; ecx <- Length
+    mov     edx, ecx                   ; edx <- ecx
+    shr     ecx, 2                     ; ecx <- number of dwords
+    and     edx, 3                     ; edx <- number of trailing bytes
+    xor     eax, eax                   ; eax <- 0, also set ZF
+    repe    scasd
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     ecx, edx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     edi
+    mov     eax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     edi
+    xor     eax, eax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.S
new file mode 100644
index 000000000000..9e383c293f2e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem16):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasw
+    leal    -2(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.asm
new file mode 100644
index 000000000000..bca66e02c896
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.nasm
new file mode 100644
index 000000000000..78d9f3071e8c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem16.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.S
new file mode 100644
index 000000000000..a9b497579442
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem32.Asm
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem32):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasl
+    leal    -4(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.asm
new file mode 100644
index 000000000000..8c24bd010953
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.nasm
new file mode 100644
index 000000000000..bbacf38a7245
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.S
new file mode 100644
index 000000000000..6e4285645711
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.S
@@ -0,0 +1,61 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    cmpl    (%edi), %eax
+    leal    8(%edi), %edi
+    loopne  L0
+    jne     L1
+    cmpl    -4(%edi), %edx
+    jecxz   L1
+    jne     L0
+L1:
+    leal    -8(%edi), %eax
+    cmovne  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.asm
new file mode 100644
index 000000000000..c835effc0cea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  @B
+    jne     @F
+    cmp     edx, [edi - 4]
+    jecxz   @F
+    jne     @B
+@@:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.nasm
new file mode 100644
index 000000000000..e994d4ac437a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem64.nasm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  .0
+    jne     .1
+    cmp     edx, [edi - 4]
+    jecxz   .1
+    jne     .0
+.1:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.S
new file mode 100644
index 000000000000..02bb27f36ac6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem8):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movb    16(%esp), %al
+    repne   scasb
+    leal    -1(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.asm
new file mode 100644
index 000000000000..f199bb957a6c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.nasm
new file mode 100644
index 000000000000..d13c9c7bf400
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ScanMem8.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.S
new file mode 100644
index 000000000000..ee0b659afd97
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.S
@@ -0,0 +1,50 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem):
+    push    %edi
+    movl    12(%esp),%ecx
+    movb    16(%esp),%al
+    movb    %al, %ah
+    shrd    $16, %eax, %edx
+    shld    $16, %edx, %eax
+    movl    %ecx, %edx
+    movl    8(%esp),%edi
+    shr    $2, %ecx
+    rep stosl
+    movl    %edx, %ecx
+    andl    $3, %ecx
+    rep stosb
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.asm
new file mode 100644
index 000000000000..6de9c2ff8077
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    edi
+    mov         ecx, [esp + 12]
+    mov         al,  [esp + 16]
+    mov         ah,  al
+    shrd        edx, eax, 16
+    shld        eax, edx, 16
+    mov         edx, ecx
+    mov         edi, [esp + 8]
+    shr         ecx, 2
+    rep stosd
+    mov         ecx, edx
+    and         ecx, 3
+    rep stosb
+    mov         eax, [esp + 8]
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.nasm
new file mode 100644
index 000000000000..3a75363e3ad3
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem.nasm
@@ -0,0 +1,52 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    edi
+    mov         ecx, [esp + 12]
+    mov         al,  [esp + 16]
+    mov         ah,  al
+    shrd        edx, eax, 16
+    shld        eax, edx, 16
+    mov         edx, ecx
+    mov         edi, [esp + 8]
+    shr         ecx, 2
+    rep stosd
+    mov         ecx, edx
+    and         ecx, 3
+    rep stosb
+    mov         eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.S
new file mode 100644
index 000000000000..8989bdd02f40
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem16):
+    push    %edi
+    movl    16(%esp), %eax
+    movl    8(%esp), %edi
+    movl    12(%esp), %ecx
+    rep
+    stosw
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.asm
new file mode 100644
index 000000000000..3d8c9a6299fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.nasm
new file mode 100644
index 000000000000..cfa4906e729c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem16.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.S
new file mode 100644
index 000000000000..b2c9a854a988
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem32):
+    push    %edi
+    movl    16(%esp),%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    rep
+    stosl
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.asm
new file mode 100644
index 000000000000..f1e1991b8d67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.nasm
new file mode 100644
index 000000000000..78e09b39e2a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem32.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.S
new file mode 100644
index 000000000000..f25dfe180432
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    mov     %eax, -8(%edi, %ecx, 8)
+    mov     %edx, -4(%edi, %ecx, 8)
+    loop    L0
+    movl    %edi, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.asm
new file mode 100644
index 000000000000..31d718adae72
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.asm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    @B
+    mov     eax, edi
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.nasm
new file mode 100644
index 000000000000..d0afacb52493
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/SetMem64.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    .0
+    mov     eax, edi
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.S b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.S
new file mode 100644
index 000000000000..70cede6cce93
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.S
@@ -0,0 +1,49 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemZeroMem):
+    push    %edi
+    xorl    %eax,%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    movl    %ecx,%edx
+    shrl    $2,%ecx
+    andl    $3,%edx
+    pushl   %edi
+    rep
+    stosl
+    movl    %edx,%ecx
+    rep
+    stosb
+    popl    %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.asm
new file mode 100644
index 000000000000..01ea1af932ee
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.asm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.nasm
new file mode 100644
index 000000000000..31efb6ad8668
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/Ia32/ZeroMem.nasm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibOptPei/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/MemLibInternals.h b/MdePkg/Library/BaseMemoryLibOptPei/MemLibInternals.h
new file mode 100644
index 000000000000..0c5bbe05e614
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer The target of the copy request.
+  @param  SourceBuffer      The place to copy from.
+  @param  Length            The number of bytes to copy.
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set.
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..a3243a67089c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..f296da2e7a48
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/SetMem32Wrapper.c
new file mode 100644
index 000000000000..c51b846acf8a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.S
new file mode 100644
index 000000000000..503127c23e0d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.S
@@ -0,0 +1,59 @@
+#
+# ConvertAsm.py: Automatically generated from CompareMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rcx, %rsi
+    movq    %rdx, %rdi
+    movq    %r8, %rcx
+    repe    cmpsb
+    movzbq  -1(%rsi) , %rax
+    movzbq  -1(%rdi) , %rdx
+    subq    %rdx, %rax
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.asm
new file mode 100644
index 000000000000..09f077b85df8
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    rsi rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte ptr [rsi - 1]
+    movzx   rdx, byte ptr [rdi - 1]
+    sub     rax, rdx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.nasm
new file mode 100644
index 000000000000..cb0d88658387
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CompareMem.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte [rsi - 1]
+    movzx   rdx, byte [rdi - 1]
+    sub     rax, rdx
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.S
new file mode 100644
index 000000000000..e3a7aef3aa86
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.S
@@ -0,0 +1,66 @@
+#
+# ConvertAsm.py: Automatically generated from CopyMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rdx, %rsi                  # rsi <- Source
+    movq    %rcx, %rdi                  # rdi <- Destination
+    leaq    -1(%rsi, %r8,), %r9         # r9 <- End of Source
+    cmpq    %rdi, %rsi
+    movq    %rdi, %rax                  # rax <- Destination as return value
+    jae     _InternalMemCopyMem_al_0000
+    cmpq    %rdi, %r9
+    jae     _atSym_CopyBackward         # Copy backward if overlapped
+_InternalMemCopyMem_al_0000:
+    movq    %r8, %rcx
+    andq    $7, %r8
+    shrq    $3, %rcx
+    rep     movsq                       # Copy as many Qwords as possible
+    jmp     _atSym_CopyBytes
+_atSym_CopyBackward:
+    movq    %r9, %rsi                   # rsi <- End of Source
+    leaq    -1(%rdi, %r8), %rdi         # rdi <- End of Destination
+    std                                 # set direction flag
+_atSym_CopyBytes:
+    movq    %r8, %rcx
+    rep     movsb                       # Copy bytes backward
+    cld
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.asm
new file mode 100644
index 000000000000..8f5b0e34ee2a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.asm
@@ -0,0 +1,61 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    rsi rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     @F
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3
+    rep     movsq                       ; Copy as many Qwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; esi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.nasm
new file mode 100644
index 000000000000..b30412399cf9
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/CopyMem.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     .0
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3
+    rep     movsq                       ; Copy as many Qwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; esi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..3b855a7bf4a6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    rdi
+    mov     rdi, rcx                   ; rdi <- Buffer
+    mov     rcx, rdx                   ; rcx <- Length
+    shr     rcx, 3                     ; rcx <- number of qwords
+    and     rdx, 7                     ; rdx <- number of trailing bytes
+    xor     rax, rax                   ; rax <- 0, also set ZF
+    repe    scasq
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     rcx, rdx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     rdi
+    mov     rax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     rdi
+    xor     rax, rax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.S
new file mode 100644
index 000000000000..5bdf2473a640
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasw
+    leaq    -2(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.asm
new file mode 100644
index 000000000000..75200414d1c1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.nasm
new file mode 100644
index 000000000000..9f0de63ea655
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem16.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.S
new file mode 100644
index 000000000000..2aac851ae9e0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasl
+    leaq    -4(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.asm
new file mode 100644
index 000000000000..ad47e5a53a13
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.nasm
new file mode 100644
index 000000000000..5c9ae5d08389
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.S
new file mode 100644
index 000000000000..21f0590455cf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasq
+    leaq    -8(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.asm
new file mode 100644
index 000000000000..3eb5b719fa07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.nasm
new file mode 100644
index 000000000000..b98c6dece330
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem64.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.S
new file mode 100644
index 000000000000..5209983eb87c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem8.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasb
+    leaq    -1(%rdi), %rax
+    cmovnz  %rcx, %rax                  # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.asm
new file mode 100644
index 000000000000..8ece85e5b4a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.nasm
new file mode 100644
index 000000000000..8499795a1d7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ScanMem8.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.S
new file mode 100644
index 000000000000..b3804e5bba44
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    pushq   %rdi
+    movq    %r8, %rax    # rax = Value
+    movq    %rcx, %rdi   # rdi = Buffer
+    xchgq   %rdx, %rcx   # rcx = Count, rdx = Buffer
+    rep     stosb
+    movq    %rdx, %rax   # rax = Buffer
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.asm
new file mode 100644
index 000000000000..61b7529228fa
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    rdi
+    push    rcx         ; push Buffer
+    mov     rax, r8     ; rax = Value
+    mov     rdi, rcx    ; rdi = Buffer
+    mov     rcx, rdx    ; rcx = Count
+    rep     stosb
+    pop     rax         ; rax = Buffer
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.nasm
new file mode 100644
index 000000000000..ae055172aae0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem.nasm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    rdi
+    push    rcx         ; push Buffer
+    mov     rax, r8     ; rax = Value
+    mov     rdi, rcx    ; rdi = Buffer
+    mov     rcx, rdx    ; rcx = Count
+    rep     stosb
+    pop     rax         ; rax = Buffer
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.S
new file mode 100644
index 000000000000..3434e8656702
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosw
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.asm
new file mode 100644
index 000000000000..7688e6e02c0c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    mov     rax, rdx
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.nasm
new file mode 100644
index 000000000000..d9c0e5403413
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem16.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.S
new file mode 100644
index 000000000000..7dba067a5065
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosl
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.asm
new file mode 100644
index 000000000000..1d739b24b354
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    mov     rax, rdx
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.nasm
new file mode 100644
index 000000000000..4da3d33a17d1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem32.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.S
new file mode 100644
index 000000000000..ad28243ea725
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.S
@@ -0,0 +1,46 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosq
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.asm
new file mode 100644
index 000000000000..e249aa38ac30
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    mov     rax, rdx
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.nasm
new file mode 100644
index 000000000000..6f364d3a0c37
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/SetMem64.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.S b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.S
new file mode 100644
index 000000000000..e5cb07469e3a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.S
@@ -0,0 +1,50 @@
+#
+# ConvertAsm.py: Automatically generated from ZeroMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    pushq   %rdi
+    pushq   %rcx
+    xorq    %rax, %rax
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    shrq    $3, %rcx
+    andq    $7, %rdx
+    rep     stosq
+    movl    %edx, %ecx
+    rep     stosb
+    popq    %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.asm
new file mode 100644
index 000000000000..52942446805e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    rdi
+    push    rcx
+    xor     rax, rax
+    mov     rdi, rcx
+    mov     rcx, rdx
+    shr     rcx, 3
+    and     rdx, 7
+    rep     stosq
+    mov     ecx, edx
+    rep     stosb
+    pop     rax
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.nasm
new file mode 100644
index 000000000000..8e0a5e4ff240
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/X64/ZeroMem.nasm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    rdi
+    push    rcx
+    xor     rax, rax
+    mov     rdi, rcx
+    mov     rcx, rdx
+    shr     rcx, 3
+    and     rdx, 7
+    rep     stosq
+    mov     ecx, edx
+    rep     stosb
+    pop     rax
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibOptPei/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLibOptPei/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibOptPei/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.inf b/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.inf
new file mode 100644
index 000000000000..447bc2fd4e4d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.inf
@@ -0,0 +1,149 @@
+## @file
+#  Instance of Base Memory Library using REP string instructions.
+#
+#  Base Memory Library that uses REP string instructions for
+#  high performance and small size. Optimized for use in PEI.
+#
+#  Copyright (c) 2007 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLibRepStr
+  MODULE_UNI_FILE                = BaseMemoryLibRepStr.uni
+  FILE_GUID                      = e7884bf4-51a1-485b-982a-ff89129983bc
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.1
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  MemLibInternals.h
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGuid.c
+
+[Sources.Ia32]
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.S
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.S
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.S
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.S
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.S
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.S
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.S
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.S
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.S
+  Ia32/SetMem.nasm
+  Ia32/SetMem.S
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.S
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.asm
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.asm
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.asm
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.asm
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.asm
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.asm
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.asm
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.asm
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.asm
+  Ia32/SetMem.nasm
+  Ia32/SetMem.asm
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.asm
+  Ia32/IsZeroBuffer.nasm
+
+[Sources.X64]
+  X64/ScanMem64.nasm
+  X64/ScanMem64.S
+  X64/ScanMem32.nasm
+  X64/ScanMem32.S
+  X64/ScanMem16.nasm
+  X64/ScanMem16.S
+  X64/ScanMem8.nasm
+  X64/ScanMem8.S
+  X64/CompareMem.nasm
+  X64/CompareMem.S
+  X64/ZeroMem.nasm
+  X64/ZeroMem.S
+  X64/SetMem64.nasm
+  X64/SetMem64.S
+  X64/SetMem32.nasm
+  X64/SetMem32.S
+  X64/SetMem16.nasm
+  X64/SetMem16.S
+  X64/SetMem.nasm
+  X64/SetMem.S
+  X64/CopyMem.nasm
+  X64/CopyMem.S
+  X64/ScanMem64.nasm
+  X64/ScanMem64.asm
+  X64/ScanMem32.nasm
+  X64/ScanMem32.asm
+  X64/ScanMem16.nasm
+  X64/ScanMem16.asm
+  X64/ScanMem8.nasm
+  X64/ScanMem8.asm
+  X64/CompareMem.nasm
+  X64/CompareMem.asm
+  X64/ZeroMem.nasm
+  X64/ZeroMem.asm
+  X64/SetMem64.nasm
+  X64/SetMem64.asm
+  X64/SetMem32.nasm
+  X64/SetMem32.asm
+  X64/SetMem16.nasm
+  X64/SetMem16.asm
+  X64/SetMem.nasm
+  X64/SetMem.asm
+  X64/CopyMem.nasm
+  X64/CopyMem.asm
+  X64/IsZeroBuffer.nasm
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.uni b/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.uni
new file mode 100644
index 000000000000..b6e1b5a79ba3
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library using REP string instructions.
+//
+// Base Memory Library that uses REP string instructions for
+// high performance and small size. Optimized for use in PEI.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library using REP string instructions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library that uses REP string instructions for high performance and small size. Optimized for use in PEI."
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/CompareMemWrapper.c
new file mode 100644
index 000000000000..aa7c2aab812c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.S
new file mode 100644
index 000000000000..1c9239eb3d09
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.S
@@ -0,0 +1,55 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CompareMem.Asm
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCompareMem):
+    push    %esi
+    push    %edi
+    movl    12(%esp), %esi
+    movl    16(%esp), %edi
+    movl    20(%esp), %ecx
+    repe    cmpsb
+    movzbl  -1(%esi), %eax
+    movzbl  -1(%edi), %edx
+    subl    %edx, %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.asm
new file mode 100644
index 000000000000..ba31a1875712
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    esi edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte ptr [esi - 1]
+    movzx   edx, byte ptr [edi - 1]
+    sub     eax, edx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.nasm
new file mode 100644
index 000000000000..e8d1abdc17fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CompareMem.nasm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte [esi - 1]
+    movzx   edx, byte [edi - 1]
+    sub     eax, edx
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.S
new file mode 100644
index 000000000000..9276699e57c6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.S
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CopyMem.Asm
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCopyMem):
+    push    %esi
+    push    %edi
+    movl    16(%esp), %esi              # esi <- Source
+    movl    12(%esp), %edi              # edi <- Destination
+    movl    20(%esp), %edx              # edx <- Count
+    leal    -1(%esi, %edx), %eax        # eax <- End of Source
+    cmpl    %edi, %esi
+    jae     L0
+    cmpl    %edi, %eax
+    jae     L_CopyBackward              # Copy backward if overlapped
+L0:
+    movl    %edx, %ecx
+    andl    $3, %edx
+    shrl    $2, %ecx
+    rep
+    movsl                               # Copy as many Dwords as possible
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movl    %eax, %esi                  # esi <- End of Source
+    leal    -1(%edi, %edx), %edi        # edi <- End of Destination
+    std
+L_CopyBytes:
+    movl    %edx, %ecx
+    rep
+    movsb                               # Copy bytes backward
+    cld
+    movl    12(%esp), %eax              # eax <- Destination as return value
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.asm
new file mode 100644
index 000000000000..3ddc82848f0a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.asm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    esi edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     @F
+    cmp     eax, edi
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    rep     movsd                       ; Copy as many Dwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- End of Source
+    lea     edi, [edi + edx - 1]        ; edi <- End of Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb                       ; Copy bytes backward
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.nasm
new file mode 100644
index 000000000000..ff9931d00e52
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/CopyMem.nasm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     .0
+    cmp     eax, edi
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    rep     movsd                       ; Copy as many Dwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- End of Source
+    lea     edi, [edi + edx - 1]        ; edi <- End of Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb                       ; Copy bytes backward
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..cfd41a62500b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    edi
+    mov     edi, [esp + 8]             ; edi <- Buffer
+    mov     ecx, [esp + 12]            ; ecx <- Length
+    mov     edx, ecx                   ; edx <- ecx
+    shr     ecx, 2                     ; ecx <- number of dwords
+    and     edx, 3                     ; edx <- number of trailing bytes
+    xor     eax, eax                   ; eax <- 0, also set ZF
+    repe    scasd
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     ecx, edx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     edi
+    mov     eax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     edi
+    xor     eax, eax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.S
new file mode 100644
index 000000000000..1a482f227264
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.S
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   ScanMem16.Asm
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem16):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasw
+    leal    -2(%edi), %eax
+    jz      L0
+    movl    %ecx, %eax
+L0:    
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.asm
new file mode 100644
index 000000000000..4084a952d21b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    jz      @F
+    mov     eax, ecx
+@@:    
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.nasm
new file mode 100644
index 000000000000..71171ee92147
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem16.nasm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    jz      .0
+    mov     eax, ecx
+.0:
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.S
new file mode 100644
index 000000000000..edf7827ffdf2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.S
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   ScanMem32.Asm
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem32):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasl
+    leal    -4(%edi), %eax
+    jz      L0
+    movl    %ecx, %eax
+L0:    
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.asm
new file mode 100644
index 000000000000..c2e968c214f7
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    jz      @F
+    mov     eax, ecx
+@@:    
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.nasm
new file mode 100644
index 000000000000..9d1b02859d09
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem32.nasm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    jz      .0
+    mov     eax, ecx
+.0:
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.S
new file mode 100644
index 000000000000..48aa5813b6be
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.S
@@ -0,0 +1,63 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   ScanMem64.Asm
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    cmpl    (%edi), %eax
+    leal    8(%edi), %edi
+    loopne  L0
+    jne     L1
+    cmpl    -4(%edi), %edx
+    jecxz   L1
+    jne     L0
+L1:
+    leal    -8(%edi), %eax
+    jz      L2
+    movl    %ecx, %eax
+L2:    
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.asm
new file mode 100644
index 000000000000..f3b90edea11e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.asm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  @B
+    jne     @F
+    cmp     edx, [edi - 4]
+    jecxz   @F
+    jne     @B
+@@:
+    lea     eax, [edi - 8]
+    jz      @F
+    mov     eax, ecx
+@@:    
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.nasm
new file mode 100644
index 000000000000..108263d19ed4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem64.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  .0
+    jne     .1
+    cmp     edx, [edi - 4]
+    jecxz   .1
+    jne     .0
+.1:
+    lea     eax, [edi - 8]
+    jz      .2
+    mov     eax, ecx
+.2:
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.S
new file mode 100644
index 000000000000..9fd9fa1fbe75
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.S
@@ -0,0 +1,54 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+# Module Name:
+#
+#   ScanMem8.Asm
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem8):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movb    16(%esp), %al
+    repne   scasb
+    leal    -1(%edi), %eax
+    jz      L0
+    movl    %ecx, %eax
+L0:    
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.asm
new file mode 100644
index 000000000000..870928ee82cb
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.asm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    jz      @F
+    mov     eax, ecx
+@@:    
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.nasm
new file mode 100644
index 000000000000..c6ecdfd8dd3b
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ScanMem8.nasm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2015, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    jz      .0
+    mov     eax, ecx
+.0:
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.S
new file mode 100644
index 000000000000..63065eacf3ff
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem.Asm
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+    .code:
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem):
+    push    %edi
+    movl    16(%esp),%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    rep
+    stosb
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.asm
new file mode 100644
index 000000000000..59971eea5284
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosb
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.nasm
new file mode 100644
index 000000000000..c27207d9c6f5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosb
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.S
new file mode 100644
index 000000000000..d32ce4a229a4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem16.Asm
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem16):
+    push    %edi
+    movl    16(%esp), %eax
+    movl    8(%esp), %edi
+    movl    12(%esp), %ecx
+    rep
+    stosw
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.asm
new file mode 100644
index 000000000000..3d8c9a6299fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.nasm
new file mode 100644
index 000000000000..cfa4906e729c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem16.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosw
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.S
new file mode 100644
index 000000000000..7fbe11ddaf4e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.S
@@ -0,0 +1,43 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem32.Asm
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem32):
+    push    %edi
+    movl    16(%esp),%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    rep
+    stosl
+    movl    8(%esp),%eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.asm
new file mode 100644
index 000000000000..f1e1991b8d67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.nasm
new file mode 100644
index 000000000000..78e09b39e2a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem32.nasm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    edi
+    mov     eax, [esp + 16]
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    rep     stosd
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.S
new file mode 100644
index 000000000000..9a0bb071a829
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.S
@@ -0,0 +1,46 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem64.Asm
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    mov     %eax, -8(%edi, %ecx, 8)
+    mov     %edx, -4(%edi, %ecx, 8)
+    loop    L0
+    movl    %edi, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.asm
new file mode 100644
index 000000000000..31d718adae72
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.asm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    @B
+    mov     eax, edi
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.nasm
new file mode 100644
index 000000000000..d0afacb52493
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/SetMem64.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    mov     [edi + ecx*8 - 8], eax
+    mov     [edi + ecx*8 - 4], edx
+    loop    .0
+    mov     eax, edi
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.S b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.S
new file mode 100644
index 000000000000..33b31ad38587
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.S
@@ -0,0 +1,49 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ZeroMem.Asm
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemZeroMem):
+    push    %edi
+    xorl    %eax,%eax
+    movl    8(%esp),%edi
+    movl    12(%esp),%ecx
+    movl    %ecx,%edx
+    shrl    $2,%ecx
+    andl    $3,%edx
+    pushl   %edi
+    rep
+    stosl
+    movl    %edx,%ecx
+    rep
+    stosb
+    popl    %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.asm
new file mode 100644
index 000000000000..01ea1af932ee
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.asm
@@ -0,0 +1,50 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.nasm
new file mode 100644
index 000000000000..31efb6ad8668
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/Ia32/ZeroMem.nasm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    edi
+    xor     eax, eax
+    mov     edi, [esp + 8]
+    mov     ecx, [esp + 12]
+    mov     edx, ecx
+    shr     ecx, 2
+    and     edx, 3
+    push    edi
+    rep     stosd
+    mov     ecx, edx
+    rep     stosb
+    pop     eax
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibRepStr/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/MemLibInternals.h b/MdePkg/Library/BaseMemoryLibRepStr/MemLibInternals.h
new file mode 100644
index 000000000000..83b0f067e224
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer Target of copy
+  @param  SourceBuffer      Place to copy from
+  @param  Length            The number of bytes to copy
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..a3243a67089c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..f296da2e7a48
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/SetMem32Wrapper.c
new file mode 100644
index 000000000000..7758e1f438db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.S
new file mode 100644
index 000000000000..435f29a2d3d7
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.S
@@ -0,0 +1,59 @@
+#
+# ConvertAsm.py: Automatically generated from CompareMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID          *DestinationBuffer,
+#   IN      CONST VOID          *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rcx, %rsi
+    movq    %rdx, %rdi
+    movq    %r8, %rcx
+    repe    cmpsb
+    movzbq  -1(%rsi) , %rax
+    movzbq  -1(%rdi) , %rdx
+    subq    %rdx, %rax
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.asm
new file mode 100644
index 000000000000..09f077b85df8
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    rsi rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte ptr [rsi - 1]
+    movzx   rdx, byte ptr [rdi - 1]
+    sub     rax, rdx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.nasm
new file mode 100644
index 000000000000..cb0d88658387
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CompareMem.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte [rsi - 1]
+    movzx   rdx, byte [rdi - 1]
+    sub     rax, rdx
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.S
new file mode 100644
index 000000000000..73f5964739f0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.S
@@ -0,0 +1,66 @@
+#
+# ConvertAsm.py: Automatically generated from CopyMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rdx, %rsi                  # rsi <- Source
+    movq    %rcx, %rdi                  # rdi <- Destination
+    leaq    -1(%rsi, %r8,), %r9         # r9 <- End of Source
+    cmpq    %rdi, %rsi
+    movq    %rdi, %rax                  # rax <- Destination as return value
+    jae     L0
+    cmpq    %rdi, %r9
+    jae     L_CopyBackward               # Copy backward if overlapped
+L0:
+    movq    %r8, %rcx
+    andq    $7, %r8
+    shrq    $3, %rcx
+    rep     movsq                       # Copy as many Qwords as possible
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movq    %r9, %rsi                   # rsi <- End of Source
+    leaq    -1(%rdi, %r8),  %rdi        # esi <- End of Destination
+    std                                 # set direction flag
+L_CopyBytes:
+    movq    %r8, %rcx
+    rep     movsb                       # Copy bytes backward
+    cld
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.asm
new file mode 100644
index 000000000000..8f5b0e34ee2a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.asm
@@ -0,0 +1,61 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    rsi rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     @F
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3
+    rep     movsq                       ; Copy as many Qwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; esi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.nasm
new file mode 100644
index 000000000000..b30412399cf9
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/CopyMem.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.Asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- End of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     .0
+    cmp     r9, rdi
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    mov     rcx, r8
+    and     r8, 7
+    shr     rcx, 3
+    rep     movsq                       ; Copy as many Qwords as possible
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- End of Source
+    lea     rdi, [rdi + r8 - 1]         ; esi <- End of Destination
+    std                                 ; set direction flag
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb                       ; Copy bytes backward
+    cld
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..3b855a7bf4a6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/IsZeroBuffer.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push    rdi
+    mov     rdi, rcx                   ; rdi <- Buffer
+    mov     rcx, rdx                   ; rcx <- Length
+    shr     rcx, 3                     ; rcx <- number of qwords
+    and     rdx, 7                     ; rdx <- number of trailing bytes
+    xor     rax, rax                   ; rax <- 0, also set ZF
+    repe    scasq
+    jnz     @ReturnFalse               ; ZF=0 means non-zero element found
+    mov     rcx, rdx
+    repe    scasb
+    jnz     @ReturnFalse
+    pop     rdi
+    mov     rax, 1                     ; return TRUE
+    ret
+@ReturnFalse:
+    pop     rdi
+    xor     rax, rax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.S
new file mode 100644
index 000000000000..5bdf2473a640
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasw
+    leaq    -2(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.asm
new file mode 100644
index 000000000000..75200414d1c1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.nasm
new file mode 100644
index 000000000000..9f0de63ea655
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem16.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.S
new file mode 100644
index 000000000000..2aac851ae9e0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasl
+    leaq    -4(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.asm
new file mode 100644
index 000000000000..ad47e5a53a13
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.nasm
new file mode 100644
index 000000000000..5c9ae5d08389
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.S
new file mode 100644
index 000000000000..21f0590455cf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasq
+    leaq    -8(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.asm
new file mode 100644
index 000000000000..3eb5b719fa07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.nasm
new file mode 100644
index 000000000000..b98c6dece330
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem64.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.S
new file mode 100644
index 000000000000..5209983eb87c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem8.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasb
+    leaq    -1(%rdi), %rax
+    cmovnz  %rcx, %rax                  # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.asm
new file mode 100644
index 000000000000..8ece85e5b4a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.nasm
new file mode 100644
index 000000000000..8499795a1d7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ScanMem8.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.S
new file mode 100644
index 000000000000..059bb665d6d0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    pushq   %rdi
+    movq    %r8, %rax      # rax = Value
+    movq    %rcx, %rdi     # rdi = Buffer
+    xchgq   %rdx, %rcx     # rcx = Count, rdx = Buffer
+    rep     stosb
+    movq    %rdx, %rax     # rax = Buffer
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.asm
new file mode 100644
index 000000000000..b95f3234c9a4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    rdi
+    mov     rax, r8    ; rax = Value
+    mov     rdi, rcx   ; rdi = Buffer
+    xchg    rcx, rdx   ; rcx = Count, rdx = Buffer
+    rep     stosb
+    mov     rax, rdx   ; rax = Buffer
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.nasm
new file mode 100644
index 000000000000..e80f671adbd4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.Asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    rdi
+    mov     rax, r8    ; rax = Value
+    mov     rdi, rcx   ; rdi = Buffer
+    xchg    rcx, rdx   ; rcx = Count, rdx = Buffer
+    rep     stosb
+    mov     rax, rdx   ; rax = Buffer
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.S
new file mode 100644
index 000000000000..3434e8656702
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosw
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.asm
new file mode 100644
index 000000000000..7688e6e02c0c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    mov     rax, rdx
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.nasm
new file mode 100644
index 000000000000..d9c0e5403413
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem16.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.Asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosw
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.S
new file mode 100644
index 000000000000..7dba067a5065
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.S
@@ -0,0 +1,47 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosl
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.asm
new file mode 100644
index 000000000000..1d739b24b354
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.asm
@@ -0,0 +1,44 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    mov     rax, rdx
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.nasm
new file mode 100644
index 000000000000..4da3d33a17d1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem32.nasm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.Asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosd
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.S
new file mode 100644
index 000000000000..ad28243ea725
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.S
@@ -0,0 +1,46 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %r8, %rax
+    xchgq   %rdx, %rcx
+    rep     stosq
+    movq    %rdx, %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.asm
new file mode 100644
index 000000000000..e249aa38ac30
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.asm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    mov     rax, rdx
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.nasm
new file mode 100644
index 000000000000..6f364d3a0c37
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/SetMem64.nasm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.Asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    xchg    rcx, rdx
+    rep     stosq
+    mov     rax, rdx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.S b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.S
new file mode 100644
index 000000000000..e5cb07469e3a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.S
@@ -0,0 +1,50 @@
+#
+# ConvertAsm.py: Automatically generated from ZeroMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    pushq   %rdi
+    pushq   %rcx
+    xorq    %rax, %rax
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    shrq    $3, %rcx
+    andq    $7, %rdx
+    rep     stosq
+    movl    %edx, %ecx
+    rep     stosb
+    popq    %rax
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.asm
new file mode 100644
index 000000000000..52942446805e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    rdi
+    push    rcx
+    xor     rax, rax
+    mov     rdi, rcx
+    mov     rcx, rdx
+    shr     rcx, 3
+    and     rdx, 7
+    rep     stosq
+    mov     ecx, edx
+    rep     stosb
+    pop     rax
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.nasm
new file mode 100644
index 000000000000..8e0a5e4ff240
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/X64/ZeroMem.nasm
@@ -0,0 +1,49 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.Asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    rdi
+    push    rcx
+    xor     rax, rax
+    mov     rdi, rcx
+    mov     rcx, rdx
+    shr     rcx, 3
+    and     rdx, 7
+    rep     stosq
+    mov     ecx, edx
+    rep     stosb
+    pop     rax
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibRepStr/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLibRepStr/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibRepStr/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.inf b/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.inf
new file mode 100644
index 000000000000..726d398637bc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.inf
@@ -0,0 +1,148 @@
+## @file
+#  Instance of Base Memory Library using SSE2 registers.
+#
+#  Base Memory Library that uses SSE2 registers for high performance.
+#
+#  Copyright (c) 2007 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseMemoryLibSse2
+  MODULE_UNI_FILE                = BaseMemoryLibSse2.uni
+  FILE_GUID                      = 65a18235-5096-4032-8c63-214f0249ce8d
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  MemLibInternals.h
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGuid.c
+
+[Sources.Ia32]
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.S
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.S
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.S
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.S
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.S
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.S
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.S
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.S
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.S
+  Ia32/SetMem.nasm
+  Ia32/SetMem.S
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.S
+  Ia32/ScanMem64.nasm
+  Ia32/ScanMem64.asm
+  Ia32/ScanMem32.nasm
+  Ia32/ScanMem32.asm
+  Ia32/ScanMem16.nasm
+  Ia32/ScanMem16.asm
+  Ia32/ScanMem8.nasm
+  Ia32/ScanMem8.asm
+  Ia32/CompareMem.nasm
+  Ia32/CompareMem.asm
+  Ia32/ZeroMem.nasm
+  Ia32/ZeroMem.asm
+  Ia32/SetMem64.nasm
+  Ia32/SetMem64.asm
+  Ia32/SetMem32.nasm
+  Ia32/SetMem32.asm
+  Ia32/SetMem16.nasm
+  Ia32/SetMem16.asm
+  Ia32/SetMem.nasm
+  Ia32/SetMem.asm
+  Ia32/CopyMem.nasm
+  Ia32/CopyMem.asm
+  Ia32/IsZeroBuffer.nasm
+
+[Sources.X64]
+  X64/ScanMem64.nasm
+  X64/ScanMem64.asm
+  X64/ScanMem32.nasm
+  X64/ScanMem32.asm
+  X64/ScanMem16.nasm
+  X64/ScanMem16.asm
+  X64/ScanMem8.nasm
+  X64/ScanMem8.asm
+  X64/CompareMem.nasm
+  X64/CompareMem.asm
+  X64/ZeroMem.nasm
+  X64/ZeroMem.asm
+  X64/SetMem64.nasm
+  X64/SetMem64.asm
+  X64/SetMem32.nasm
+  X64/SetMem32.asm
+  X64/SetMem16.nasm
+  X64/SetMem16.asm
+  X64/SetMem.nasm
+  X64/SetMem.asm
+  X64/CopyMem.nasm
+  X64/CopyMem.asm
+  X64/ScanMem64.nasm
+  X64/ScanMem64.S
+  X64/ScanMem32.nasm
+  X64/ScanMem32.S
+  X64/ScanMem16.nasm
+  X64/ScanMem16.S
+  X64/ScanMem8.nasm
+  X64/ScanMem8.S
+  X64/CompareMem.nasm
+  X64/CompareMem.S
+  X64/ZeroMem.nasm
+  X64/ZeroMem.S
+  X64/SetMem64.nasm
+  X64/SetMem64.S
+  X64/SetMem32.nasm
+  X64/SetMem32.S
+  X64/SetMem16.nasm
+  X64/SetMem16.S
+  X64/SetMem.nasm
+  X64/SetMem.S
+  X64/CopyMem.nasm
+  X64/CopyMem.S
+  X64/IsZeroBuffer.nasm
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.uni b/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.uni
new file mode 100644
index 000000000000..70155dc138b0
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Base Memory Library using SSE2 registers.
+//
+// Base Memory Library that uses SSE2 registers for high performance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library using SSE2 registers"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library that uses SSE2 registers for high performance."
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/CompareMemWrapper.c b/MdePkg/Library/BaseMemoryLibSse2/CompareMemWrapper.c
new file mode 100644
index 000000000000..aa7c2aab812c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/CopyMemWrapper.c b/MdePkg/Library/BaseMemoryLibSse2/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.S
new file mode 100644
index 000000000000..1c9239eb3d09
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.S
@@ -0,0 +1,55 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CompareMem.Asm
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCompareMem):
+    push    %esi
+    push    %edi
+    movl    12(%esp), %esi
+    movl    16(%esp), %edi
+    movl    20(%esp), %ecx
+    repe    cmpsb
+    movzbl  -1(%esi), %eax
+    movzbl  -1(%edi), %edx
+    subl    %edx, %eax
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.asm
new file mode 100644
index 000000000000..ba31a1875712
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.asm
@@ -0,0 +1,56 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    esi edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte ptr [esi - 1]
+    movzx   edx, byte ptr [edi - 1]
+    sub     eax, edx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.nasm
new file mode 100644
index 000000000000..e8d1abdc17fc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CompareMem.nasm
@@ -0,0 +1,57 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 12]
+    mov     edi, [esp + 16]
+    mov     ecx, [esp + 20]
+    repe    cmpsb
+    movzx   eax, byte [esi - 1]
+    movzx   edx, byte [edi - 1]
+    sub     eax, edx
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.S
new file mode 100644
index 000000000000..0716182143ee
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.S
@@ -0,0 +1,85 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   CopyMem.asm
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemCopyMem):
+    push    %esi
+    push    %edi
+    movl    16(%esp), %esi              # esi <- Source
+    movl    12(%esp), %edi              # edi <- Destination
+    movl    20(%esp), %edx              # edx <- Count
+    leal    -1(%esi,%edx,), %eax        # eax <- End of Source
+    cmpl    %edi, %esi
+    jae     L0
+    cmpl    %edi, %eax                  # Overlapped?
+    jae     L_CopyBackward               # Copy backward if overlapped
+L0:
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    andl    $15, %ecx                   # ecx + edi aligns on 16-byte boundary
+    jz      L1
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx                  # edx <- remaining bytes to copy
+    rep
+    movsb
+L1:
+    movl    %edx, %ecx
+    andl    $15, %edx
+    shrl    $4, %ecx                    # ecx <- # of DQwords to copy
+    jz      L_CopyBytes
+    addl    $-16, %esp
+    movdqu  %xmm0, (%esp)
+L2:
+    movdqu  (%esi), %xmm0
+    movntdq %xmm0, (%edi)
+    addl    $16, %esi
+    addl    $16, %edi
+    loop    L2
+    mfence
+    movdqu  (%esp),%xmm0
+    addl    $16, %esp                   # stack cleanup
+    jmp     L_CopyBytes
+L_CopyBackward:
+    movl    %eax, %esi                  # esi <- Last byte in Source
+    leal    -1(%edi,%edx,), %edi        # edi <- Last byte in Destination
+    std
+L_CopyBytes:
+    movl    %edx, %ecx
+    rep
+    movsb
+    cld
+    movl    12(%esp), %eax              # eax <- Destination as return value
+    pop     %edi
+    pop     %esi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.asm
new file mode 100644
index 000000000000..84fad9190d2f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.asm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    esi edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     @F
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      @F
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx                    ; edx <- remaining bytes to copy
+    rep     movsb
+@@:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to copy
+    jz      @CopyBytes
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+@@:
+    movdqu  xmm0, [esi]                 ; esi may not be 16-bytes aligned
+    movntdq [edi], xmm0                 ; edi should be 16-bytes aligned
+    add     esi, 16
+    add     edi, 16
+    loop    @B
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.nasm
new file mode 100644
index 000000000000..6913874d3055
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/CopyMem.nasm
@@ -0,0 +1,84 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    esi
+    push    edi
+    mov     esi, [esp + 16]             ; esi <- Source
+    mov     edi, [esp + 12]             ; edi <- Destination
+    mov     edx, [esp + 20]             ; edx <- Count
+    lea     eax, [esi + edx - 1]        ; eax <- End of Source
+    cmp     esi, edi
+    jae     .0
+    cmp     eax, edi                    ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      .1
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx                    ; edx <- remaining bytes to copy
+    rep     movsb
+.1:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to copy
+    jz      @CopyBytes
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+.2:
+    movdqu  xmm0, [esi]                 ; esi may not be 16-bytes aligned
+    movntdq [edi], xmm0                 ; edi should be 16-bytes aligned
+    add     esi, 16
+    add     edi, 16
+    loop    .2
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+    jmp     @CopyBytes
+@CopyBackward:
+    mov     esi, eax                    ; esi <- Last byte in Source
+    lea     edi, [edi + edx - 1]        ; edi <- Last byte in Destination
+    std
+@CopyBytes:
+    mov     ecx, edx
+    rep     movsb
+    cld
+    mov     eax, [esp + 12]             ; eax <- Destination as return value
+    pop     edi
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..e09ef850f818
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/IsZeroBuffer.nasm
@@ -0,0 +1,74 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push         edi
+    mov          edi, [esp + 8]        ; edi <- Buffer
+    mov          edx, [esp + 12]       ; edx <- Length
+    xor          ecx, ecx              ; ecx <- 0
+    sub          ecx, edi
+    and          ecx, 15               ; ecx + edi aligns on 16-byte boundary
+    jz           @Is16BytesZero
+    cmp          ecx, edx
+    cmova        ecx, edx              ; bytes before the 16-byte boundary
+    sub          edx, ecx
+    xor          eax, eax              ; eax <- 0, also set ZF
+    repe         scasb
+    jnz          @ReturnFalse          ; ZF=0 means non-zero element found
+@Is16BytesZero:
+    mov          ecx, edx
+    and          edx, 15
+    shr          ecx, 4
+    jz           @IsBytesZero
+.0:
+    pxor         xmm0, xmm0            ; xmm0 <- 0
+    pcmpeqb      xmm0, [edi]           ; check zero for 16 bytes
+    pmovmskb     eax, xmm0             ; eax <- compare results
+    cmp          eax, 0xffff
+    jnz          @ReturnFalse
+    add          edi, 16
+    loop         .0
+@IsBytesZero:
+    mov          ecx, edx
+    xor          eax, eax              ; eax <- 0, also set ZF
+    repe         scasb
+    jnz          @ReturnFalse          ; ZF=0 means non-zero element found
+    pop          edi
+    mov          eax, 1                ; return TRUE
+    ret
+@ReturnFalse:
+    pop          edi
+    xor          eax, eax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.S
new file mode 100644
index 000000000000..c485543e873e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem16.Asm
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem16):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasw
+    leal    -2(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.asm
new file mode 100644
index 000000000000..bca66e02c896
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.nasm
new file mode 100644
index 000000000000..78d9f3071e8c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem16.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasw
+    lea     eax, [edi - 2]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.S
new file mode 100644
index 000000000000..a9b497579442
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem32.Asm
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem32):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movl    16(%esp), %eax
+    repne   scasl
+    leal    -4(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.asm
new file mode 100644
index 000000000000..8c24bd010953
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.nasm
new file mode 100644
index 000000000000..bbacf38a7245
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem32.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     eax, [esp + 16]
+    repne   scasd
+    lea     eax, [edi - 4]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.S
new file mode 100644
index 000000000000..e23cf5f5dc28
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.S
@@ -0,0 +1,61 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem64.Asm
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem64):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    16(%esp), %eax
+    movl    20(%esp), %edx
+    movl    8(%esp), %edi
+L0:
+    cmpl    (%edi), %eax
+    leal    8(%edi), %edi
+    loopne  L0
+    jne     L1
+    cmpl    -4(%edi), %edx
+    jecxz   L1
+    jne     L0
+L1:
+    leal    -8(%edi), %eax
+    cmovne  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.asm
new file mode 100644
index 000000000000..c835effc0cea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+@@:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  @B
+    jne     @F
+    cmp     edx, [edi - 4]
+    jecxz   @F
+    jne     @B
+@@:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.nasm
new file mode 100644
index 000000000000..e994d4ac437a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem64.nasm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     edi, [esp + 8]
+.0:
+    cmp     eax, [edi]
+    lea     edi, [edi + 8]
+    loopne  .0
+    jne     .1
+    cmp     edx, [edi - 4]
+    jecxz   .1
+    jne     .0
+.1:
+    lea     eax, [edi - 8]
+    cmovne  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.S
new file mode 100644
index 000000000000..afefaab917ea
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.S
@@ -0,0 +1,52 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ScanMem8.Asm
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemScanMem8):
+    push    %edi
+    movl    12(%esp), %ecx
+    movl    8(%esp), %edi
+    movb    16(%esp), %al
+    repne   scasb
+    leal    -1(%edi), %eax
+    cmovnz  %ecx, %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.asm
new file mode 100644
index 000000000000..f199bb957a6c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.asm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.nasm
new file mode 100644
index 000000000000..d13c9c7bf400
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ScanMem8.nasm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    edi
+    mov     ecx, [esp + 12]
+    mov     edi, [esp + 8]
+    mov     al, [esp + 16]
+    repne   scasb
+    lea     eax, [edi - 1]
+    cmovnz  eax, ecx
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.S
new file mode 100644
index 000000000000..bcbe0cdf8000
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.S
@@ -0,0 +1,76 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem.asm
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+    #.MODEL flat,C
+    .xmm:
+    .code:
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  _mem_SetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    %edi
+    movl    12(%esp), %edx              # edx <- Count
+    movl    8(%esp), %edi               # edi <- Buffer
+    movb    16(%esp), %al               # al <- Value
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    andl    $15, %ecx                   # ecx + edi aligns on 16-byte boundary
+    jz      L0
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx
+    rep
+    stosb
+L0:
+    movl    %edx, %ecx
+    andl    $15, %edx
+    shrl    $4, %ecx                    # ecx <- # of DQwords to set
+    jz      L_SetBytes
+    movb    %al, %ah                    # ax <- Value | (Value << 8)
+    addl    $-16, %esp
+    movdqu  %xmm0, (%esp)
+    movd    %eax, %xmm0
+    pshuflw $0, %xmm0, %xmm0
+    movlhps %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%edi)
+    addl    $16, %edi
+    loop   L1
+    mfence
+    movdqu  (%esp), %xmm0
+    addl    $16, %esp                   # stack cleanup
+L_SetBytes:
+    movl    %edx, %ecx
+    rep
+    stosb
+    movl    8(%esp), %eax               # eax <- Buffer as return value
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.asm
new file mode 100644
index 000000000000..424f69ef4af7
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.asm
@@ -0,0 +1,75 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    edi
+    mov     edx, [esp + 12]             ; edx <- Count
+    mov     edi, [esp + 8]              ; edi <- Buffer
+    mov     al, [esp + 16]              ; al <- Value
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      @F
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosb
+@@:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to set
+    jz      @SetBytes
+    mov     ah, al                      ; ax <- Value | (Value << 8)
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0               ; xmm0[0..63] <- Value repeats 8 times
+    movlhps xmm0, xmm0                  ; xmm0 <- Value repeats 16 times
+@@:
+    movntdq [edi], xmm0                 ; edi should be 16-byte aligned
+    add     edi, 16
+    loop    @B
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]              ; eax <- Buffer as return value
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.nasm
new file mode 100644
index 000000000000..2852ee5e6adf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem.nasm
@@ -0,0 +1,73 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.nasm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    edi
+    mov     edx, [esp + 12]             ; edx <- Count
+    mov     edi, [esp + 8]              ; edi <- Buffer
+    mov     al, [esp + 16]              ; al <- Value
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    jz      .0
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosb
+.0:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4                      ; ecx <- # of DQwords to set
+    jz      @SetBytes
+    mov     ah, al                      ; ax <- Value | (Value << 8)
+    add     esp, -16
+    movdqu  [esp], xmm0                 ; save xmm0
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0               ; xmm0[0..63] <- Value repeats 8 times
+    movlhps xmm0, xmm0                  ; xmm0 <- Value repeats 16 times
+.1:
+    movntdq [edi], xmm0                 ; edi should be 16-byte aligned
+    add     edi, 16
+    loop    .1
+    mfence
+    movdqu  xmm0, [esp]                 ; restore xmm0
+    add     esp, 16                     ; stack cleanup
+@SetBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]              ; eax <- Buffer as return value
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.S
new file mode 100644
index 000000000000..4269833599ef
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.S
@@ -0,0 +1,69 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem16.asm
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem16):
+    push    %edi
+    movl    12(%esp), %edx
+    movl    8(%esp), %edi
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    andl    $15, %ecx                   # ecx + edi aligns on 16-byte boundary
+    movl    16(%esp), %eax
+    jz      L0
+    shrl    %ecx
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx
+    rep
+    stosw
+L0:
+    movl    %edx, %ecx
+    andl    $7, %edx
+    shrl    $3, %ecx
+    jz      L_SetWords
+    movd    %eax, %xmm0
+    pshuflw $0, %xmm0, %xmm0
+    movlhps %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%edi)
+    addl    $16, %edi
+    loop    L1
+    mfence
+L_SetWords:
+    movl    %edx, %ecx
+    rep
+    stosw
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.asm
new file mode 100644
index 000000000000..6086415f7f94
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.asm
@@ -0,0 +1,71 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    edi
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    mov     eax, [esp + 16]
+    jz      @F
+    shr     ecx, 1
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosw
+@@:
+    mov     ecx, edx
+    and     edx, 7
+    shr     ecx, 3
+    jz      @SetWords
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0
+    movlhps xmm0, xmm0
+@@:
+    movntdq [edi], xmm0                 ; edi should be 16-byte aligned
+    add     edi, 16
+    loop    @B
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.nasm
new file mode 100644
index 000000000000..3a79e7908ccf
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem16.nasm
@@ -0,0 +1,69 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.nasm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    edi
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    mov     eax, [esp + 16]
+    jz      .0
+    shr     ecx, 1
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosw
+.0:
+    mov     ecx, edx
+    and     edx, 7
+    shr     ecx, 3
+    jz      @SetWords
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0
+    movlhps xmm0, xmm0
+.1:
+    movntdq [edi], xmm0                 ; edi should be 16-byte aligned
+    add     edi, 16
+    loop    .1
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.S
new file mode 100644
index 000000000000..9e9c7e268321
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.S
@@ -0,0 +1,68 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   SetMem32.asm
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem32):
+    push    %edi
+    movl    12(%esp), %edx
+    movl    8(%esp), %edi
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    andl    $15, %ecx                   # ecx + edi aligns on 16-byte boundary
+    movl    16(%esp), %eax
+    jz      L0
+    shrl    $2, %ecx
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx
+    rep
+    stosl
+L0:
+    movl    %edx, %ecx
+    andl    $3, %edx
+    shrl    $2, %ecx
+    jz      L_SetDwords
+    movd    %eax, %xmm0
+    pshufd  $0, %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%edi)
+    addl    $16, %edi
+    loop    L1
+    mfence
+L_SetDwords:
+    movl    %edx, %ecx
+    rep
+    stosl
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.asm
new file mode 100644
index 000000000000..21b01b9ac097
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.asm
@@ -0,0 +1,70 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    edi
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    mov     eax, [esp + 16]
+    jz      @F
+    shr     ecx, 2
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosd
+@@:
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    jz      @SetDwords
+    movd    xmm0, eax
+    pshufd  xmm0, xmm0, 0
+@@:
+    movntdq [edi], xmm0
+    add     edi, 16
+    loop    @B
+    mfence
+@SetDwords:
+    mov     ecx, edx
+    rep     stosd
+    mov     eax, [esp + 8]
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.nasm
new file mode 100644
index 000000000000..7d2d9fb84a88
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem32.nasm
@@ -0,0 +1,68 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.nasm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT32 Value
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    edi
+    mov     edx, [esp + 12]
+    mov     edi, [esp + 8]
+    xor     ecx, ecx
+    sub     ecx, edi
+    and     ecx, 15                     ; ecx + edi aligns on 16-byte boundary
+    mov     eax, [esp + 16]
+    jz      .0
+    shr     ecx, 2
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosd
+.0:
+    mov     ecx, edx
+    and     edx, 3
+    shr     ecx, 2
+    jz      @SetDwords
+    movd    xmm0, eax
+    pshufd  xmm0, xmm0, 0
+.1:
+    movntdq [edi], xmm0
+    add     edi, 16
+    loop    .1
+    mfence
+@SetDwords:
+    mov     ecx, edx
+    rep     stosd
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.S
new file mode 100644
index 000000000000..d5983e768c23
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.S
@@ -0,0 +1,58 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemSetMem64):
+    movl    4(%esp), %eax
+    movl    8(%esp), %ecx
+    testb   $8, %al
+    movl    %eax, %edx
+    movq    0xc(%esp), %xmm0
+    jz      L1
+    movq    %xmm0, (%edx)
+    addl    $8, %edx
+    decl    %ecx
+L1:
+    shrl    %ecx
+    jz      L_SetQwords
+    movlhps %xmm0, %xmm0
+L2:
+    movntdq %xmm0, (%edx)
+    leal    16(%edx), %edx
+    loop    L2
+    mfence
+L_SetQwords:
+    jnc     L3
+    movq    %xmm0, (%edx)
+L3:
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.asm
new file mode 100644
index 000000000000..801e4c33da51
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.asm
@@ -0,0 +1,64 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC
+    mov     eax, [esp + 4]              ; eax <- Buffer
+    mov     ecx, [esp + 8]              ; ecx <- Count
+    test    al, 8
+    mov     edx, eax
+    movq    xmm0, qword ptr [esp + 12]
+    jz      @F
+    movq    qword ptr [edx], xmm0
+    add     edx, 8
+    dec     ecx
+@@:
+    shr     ecx, 1
+    jz      @SetQwords
+    movlhps xmm0, xmm0
+@@:
+    movntdq [edx], xmm0
+    lea     edx, [edx + 16]
+    loop    @B
+    mfence
+@SetQwords:
+    jnc     @F
+    movq    qword ptr [edx], xmm0
+@@:
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.nasm
new file mode 100644
index 000000000000..ace62749426f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/SetMem64.nasm
@@ -0,0 +1,60 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.nasm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    mov     eax, [esp + 4]              ; eax <- Buffer
+    mov     ecx, [esp + 8]              ; ecx <- Count
+    test    al, 8
+    mov     edx, eax
+    movq    xmm0, qword [esp + 12]
+    jz      .0
+    movq    qword [edx], xmm0
+    add     edx, 8
+    dec     ecx
+.0:
+    shr     ecx, 1
+    jz      @SetQwords
+    movlhps xmm0, xmm0
+.1:
+    movntdq [edx], xmm0
+    lea     edx, [edx + 16]
+    loop    .1
+    mfence
+@SetQwords:
+    jnc     .2
+    movq    qword [edx], xmm0
+.2:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.S b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.S
new file mode 100644
index 000000000000..2a8c8b751d2a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.S
@@ -0,0 +1,65 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, 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.
+#
+# Module Name:
+#
+#   ZeroMem.asm
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_PFX(InternalMemZeroMem):
+    push    %edi
+    movl    8(%esp), %edi
+    movl    12(%esp), %edx
+    xorl    %ecx, %ecx
+    subl    %edi, %ecx
+    xorl    %eax, %eax
+    andl    $15, %ecx
+    jz      L0
+    cmpl    %edx, %ecx
+    cmova   %edx, %ecx
+    subl    %ecx, %edx
+    rep
+    stosb
+L0:
+    movl    %edx, %ecx
+    andl    $15, %edx
+    shrl    $4, %ecx
+    jz      L_ZeroBytes
+    pxor    %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%edi)
+    addl    $16, %edi
+    loop    L1
+    mfence
+L_ZeroBytes:
+    movl    %edx, %ecx
+    rep
+    stosb
+    movl    8(%esp), %eax
+    pop     %edi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.asm
new file mode 100644
index 000000000000..847d96bf7ea5
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.asm
@@ -0,0 +1,67 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .686
+    .model  flat,C
+    .xmm
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    edi
+    mov     edi, [esp + 8]
+    mov     edx, [esp + 12]
+    xor     ecx, ecx
+    sub     ecx, edi
+    xor     eax, eax
+    and     ecx, 15
+    jz      @F
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosb
+@@:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4
+    jz      @ZeroBytes
+    pxor    xmm0, xmm0
+@@:
+    movntdq [edi], xmm0
+    add     edi, 16
+    loop    @B
+    mfence
+@ZeroBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.nasm
new file mode 100644
index 000000000000..cee361871f70
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/Ia32/ZeroMem.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.nasm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    edi
+    mov     edi, [esp + 8]
+    mov     edx, [esp + 12]
+    xor     ecx, ecx
+    sub     ecx, edi
+    xor     eax, eax
+    and     ecx, 15
+    jz      .0
+    cmp     ecx, edx
+    cmova   ecx, edx
+    sub     edx, ecx
+    rep     stosb
+.0:
+    mov     ecx, edx
+    and     edx, 15
+    shr     ecx, 4
+    jz      @ZeroBytes
+    pxor    xmm0, xmm0
+.1:
+    movntdq [edi], xmm0
+    add     edi, 16
+    loop    .1
+    mfence
+@ZeroBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     eax, [esp + 8]
+    pop     edi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/IsZeroBufferWrapper.c b/MdePkg/Library/BaseMemoryLibSse2/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/MemLibGuid.c b/MdePkg/Library/BaseMemoryLibSse2/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/MemLibInternals.h b/MdePkg/Library/BaseMemoryLibSse2/MemLibInternals.h
new file mode 100644
index 000000000000..e7afa2337464
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/MemLibInternals.h
@@ -0,0 +1,251 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Copy Length bytes from Source to Destination.
+
+  @param  DestinationBuffer The target of the copy request.
+  @param  SourceBuffer      The place to copy from.
+  @param  Length            The number of bytes to copy.
+
+  @return Destination
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Set Buffer to Value for Size bytes.
+
+  @param  Buffer   The memory to set.
+  @param  Length   The number of bytes to set.
+  @param  Value    The value of the set operation.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer Memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer.
+  @param  SourceBuffer      The second memory buffer.
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return A pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseMemoryLibSse2/ScanMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..c407469843c4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/ScanMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..a3243a67089c
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/ScanMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..10ed74d50256
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/ScanMem8Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..f296da2e7a48
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/SetMem16Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/SetMem16Wrapper.c
new file mode 100644
index 000000000000..8e6daa3928cc
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/SetMem32Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/SetMem32Wrapper.c
new file mode 100644
index 000000000000..7758e1f438db
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/SetMem64Wrapper.c b/MdePkg/Library/BaseMemoryLibSse2/SetMem64Wrapper.c
new file mode 100644
index 000000000000..5273a864f187
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/SetMemWrapper.c b/MdePkg/Library/BaseMemoryLibSse2/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.S b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.S
new file mode 100644
index 000000000000..503127c23e0d
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.S
@@ -0,0 +1,59 @@
+#
+# ConvertAsm.py: Automatically generated from CompareMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CompareMem.S
+#
+# Abstract:
+#
+#   CompareMem function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# INTN
+# EFIAPI
+# InternalMemCompareMem (
+#   IN      CONST VOID                *DestinationBuffer,
+#   IN      CONST VOID                *SourceBuffer,
+#   IN      UINTN                     Length
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rcx, %rsi
+    movq    %rdx, %rdi
+    movq    %r8, %rcx
+    repe    cmpsb
+    movzbq  -1(%rsi) , %rax
+    movzbq  -1(%rdi) , %rdx
+    subq    %rdx, %rax
+    popq    %rdi
+    popq    %rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.asm
new file mode 100644
index 000000000000..09f077b85df8
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.asm
@@ -0,0 +1,54 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+InternalMemCompareMem   PROC    USES    rsi rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte ptr [rsi - 1]
+    movzx   rdx, byte ptr [rdi - 1]
+    sub     rax, rdx
+    ret
+InternalMemCompareMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.nasm
new file mode 100644
index 000000000000..cb0d88658387
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CompareMem.nasm
@@ -0,0 +1,58 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   CompareMem.Asm
+;
+; Abstract:
+;
+;   CompareMem function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; INTN
+; EFIAPI
+; InternalMemCompareMem (
+;   IN      CONST VOID                *DestinationBuffer,
+;   IN      CONST VOID                *SourceBuffer,
+;   IN      UINTN                     Length
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCompareMem)
+ASM_PFX(InternalMemCompareMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rcx
+    mov     rdi, rdx
+    mov     rcx, r8
+    repe    cmpsb
+    movzx   rax, byte [rsi - 1]
+    movzx   rdx, byte [rdi - 1]
+    sub     rax, rdx
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.S b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.S
new file mode 100644
index 000000000000..bf26cd384455
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.S
@@ -0,0 +1,83 @@
+#
+# ConvertAsm.py: Automatically generated from CopyMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   CopyMem.S
+#
+# Abstract:
+#
+#   CopyMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemCopyMem (
+#    IN VOID   *Destination,
+#    IN VOID   *Source,
+#    IN UINTN  Count
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    pushq   %rsi
+    pushq   %rdi
+    movq    %rdx, %rsi                  # rsi <- Source
+    movq    %rcx, %rdi                  # rdi <- Destination
+    leaq    -1(%rsi, %r8,), %r9         # r9 <- Last byte of Source
+    cmpq    %rdi, %rsi
+    movq    %rdi, %rax                  # rax <- Destination as return value
+    jae     L0                          # Copy forward if Source > Destination
+    cmpq    %rdi, %r9                   # Overlapped?
+    jae     L_CopyBackward              # Copy backward if overlapped
+L0:            
+    xorq    %rcx, %rcx                    
+    subq    %rdi, %rcx                  # rcx <- -rdi
+    andq    $15, %rcx                   # rcx + rsi should be 16 bytes aligned
+    jz      L1                          # skip if rcx == 0
+    cmpq    %r8, %rcx
+    cmova   %r8, %rcx
+    subq    %rcx, %r8
+    rep     movsb
+L1:
+    movq    %r8, %rcx
+    andq    $15, %r8
+    shrq    $4, %rcx                    # rcx <- # of DQwords to copy
+    jz      L_CopyBytes
+    movdqa  %xmm0, 0x18(%rsp)           # save xmm0 on stack
+L2:
+    movdqu  (%rsi), %xmm0               # rsi may not be 16-byte aligned
+    movntdq  %xmm0, (%rdi)              # rdi should be 16-byte aligned
+    addq    $16, %rsi
+    addq    $16, %rdi
+    loop    L2
+    mfence
+    movdqa  0x18(%rsp), %xmm0           # restore xmm0
+    jmp     L_CopyBytes                 # copy remaining bytes
+L_CopyBackward:
+    movq    %r9, %rsi                   # rsi <- Last byte of Source
+    leaq    -1(%rdi, %r8,), %rdi        # rdi <- Last byte of Destination
+    std
+L_CopyBytes:
+    movq    %r8, %rcx
+    rep     movsb
+    cld
+    popq    %rdi
+    popq    %rsi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.asm
new file mode 100644
index 000000000000..9218003428f6
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.asm
@@ -0,0 +1,79 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.asm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+InternalMemCopyMem  PROC    USES    rsi rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- Last byte of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     @F                          ; Copy forward if Source > Destination
+    cmp     r9, rdi                     ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+@@:
+    xor     rcx, rcx
+    sub     rcx, rdi                    ; rcx <- -rdi
+    and     rcx, 15                     ; rcx + rsi should be 16 bytes aligned
+    jz      @F                          ; skip if rcx == 0
+    cmp     rcx, r8
+    cmova   rcx, r8
+    sub     r8, rcx
+    rep     movsb
+@@:
+    mov     rcx, r8
+    and     r8, 15
+    shr     rcx, 4                      ; rcx <- # of DQwords to copy
+    jz      @CopyBytes
+    movdqa  [rsp + 18h], xmm0           ; save xmm0 on stack
+@@:
+    movdqu  xmm0, [rsi]                 ; rsi may not be 16-byte aligned
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rsi, 16
+    add     rdi, 16
+    loop    @B
+    mfence
+    movdqa  xmm0, [rsp + 18h]           ; restore xmm0
+    jmp     @CopyBytes                  ; copy remaining bytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- Last byte of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- Last byte of Destination
+    std
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb
+    cld
+    ret
+InternalMemCopyMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.nasm
new file mode 100644
index 000000000000..9fe45d4e8c2f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/CopyMem.nasm
@@ -0,0 +1,83 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   CopyMem.nasm
+;
+; Abstract:
+;
+;   CopyMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  EFIAPI
+;  InternalMemCopyMem (
+;    IN VOID   *Destination,
+;    IN VOID   *Source,
+;    IN UINTN  Count
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemCopyMem)
+ASM_PFX(InternalMemCopyMem):
+    push    rsi
+    push    rdi
+    mov     rsi, rdx                    ; rsi <- Source
+    mov     rdi, rcx                    ; rdi <- Destination
+    lea     r9, [rsi + r8 - 1]          ; r9 <- Last byte of Source
+    cmp     rsi, rdi
+    mov     rax, rdi                    ; rax <- Destination as return value
+    jae     .0                          ; Copy forward if Source > Destination
+    cmp     r9, rdi                     ; Overlapped?
+    jae     @CopyBackward               ; Copy backward if overlapped
+.0:
+    xor     rcx, rcx
+    sub     rcx, rdi                    ; rcx <- -rdi
+    and     rcx, 15                     ; rcx + rsi should be 16 bytes aligned
+    jz      .1                          ; skip if rcx == 0
+    cmp     rcx, r8
+    cmova   rcx, r8
+    sub     r8, rcx
+    rep     movsb
+.1:
+    mov     rcx, r8
+    and     r8, 15
+    shr     rcx, 4                      ; rcx <- # of DQwords to copy
+    jz      @CopyBytes
+    movdqa  [rsp + 0x18], xmm0           ; save xmm0 on stack
+.2:
+    movdqu  xmm0, [rsi]                 ; rsi may not be 16-byte aligned
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rsi, 16
+    add     rdi, 16
+    loop    .2
+    mfence
+    movdqa  xmm0, [rsp + 0x18]           ; restore xmm0
+    jmp     @CopyBytes                  ; copy remaining bytes
+@CopyBackward:
+    mov     rsi, r9                     ; rsi <- Last byte of Source
+    lea     rdi, [rdi + r8 - 1]         ; rdi <- Last byte of Destination
+    std
+@CopyBytes:
+    mov     rcx, r8
+    rep     movsb
+    cld
+    pop     rdi
+    pop     rsi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/IsZeroBuffer.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/IsZeroBuffer.nasm
new file mode 100644
index 000000000000..3d5b6a128104
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/IsZeroBuffer.nasm
@@ -0,0 +1,76 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2016, 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.
+;
+; Module Name:
+;
+;   IsZeroBuffer.nasm
+;
+; Abstract:
+;
+;   IsZeroBuffer function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  BOOLEAN
+;  EFIAPI
+;  InternalMemIsZeroBuffer (
+;    IN CONST VOID  *Buffer,
+;    IN UINTN       Length
+;    );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemIsZeroBuffer)
+ASM_PFX(InternalMemIsZeroBuffer):
+    push         rdi
+    mov          rdi, rcx              ; rdi <- Buffer
+    xor          rcx, rcx              ; rcx <- 0
+    sub          rcx, rdi
+    and          rcx, 15               ; rcx + rdi aligns on 16-byte boundary
+    jz           @Is16BytesZero
+    cmp          rcx, rdx              ; Length already in rdx
+    cmova        rcx, rdx              ; bytes before the 16-byte boundary
+    sub          rdx, rcx
+    xor          rax, rax              ; rax <- 0, also set ZF
+    repe         scasb
+    jnz          @ReturnFalse          ; ZF=0 means non-zero element found
+@Is16BytesZero:
+    mov          rcx, rdx
+    and          rdx, 15
+    shr          rcx, 4
+    jz           @IsBytesZero
+.0:
+    pxor         xmm0, xmm0            ; xmm0 <- 0
+    pcmpeqb      xmm0, [rdi]           ; check zero for 16 bytes
+    pmovmskb     eax, xmm0             ; eax <- compare results
+                                       ; nasm doesn't support 64-bit destination
+                                       ; for pmovmskb
+    cmp          eax, 0xffff
+    jnz          @ReturnFalse
+    add          rdi, 16
+    loop         .0
+@IsBytesZero:
+    mov          rcx, rdx
+    xor          rax, rax              ; rax <- 0, also set ZF
+    repe         scasb
+    jnz          @ReturnFalse          ; ZF=0 means non-zero element found
+    pop          rdi
+    mov          rax, 1                ; return TRUE
+    ret
+@ReturnFalse:
+    pop          rdi
+    xor          rax, rax
+    ret                                ; return FALSE
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.S b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.S
new file mode 100644
index 000000000000..5bdf2473a640
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem16.S
+#
+# Abstract:
+#
+#   ScanMem16 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem16 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT16                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasw
+    leaq    -2(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.asm
new file mode 100644
index 000000000000..75200414d1c1
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem16    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem16    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.nasm
new file mode 100644
index 000000000000..9f0de63ea655
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem16.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem16.Asm
+;
+; Abstract:
+;
+;   ScanMem16 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem16 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT16                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem16)
+ASM_PFX(InternalMemScanMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasw
+    lea     rax, [rdi - 2]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.S b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.S
new file mode 100644
index 000000000000..9979e972cfaa
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem32.S
+#
+# Abstract:
+#
+#   ScanMem32 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem32 (
+#   IN      CONST VOID          *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT32                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasl
+    leaq    -4(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.asm
new file mode 100644
index 000000000000..ad47e5a53a13
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem32    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem32    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.nasm
new file mode 100644
index 000000000000..5c9ae5d08389
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem32.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem32.Asm
+;
+; Abstract:
+;
+;   ScanMem32 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem32 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT32                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem32)
+ASM_PFX(InternalMemScanMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasd
+    lea     rax, [rdi - 4]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.S b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.S
new file mode 100644
index 000000000000..4c994b9d5a1a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem64.S
+#
+# Abstract:
+#
+#   ScanMem64 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem64 (
+#   IN      CONST VOID          *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT64                    Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasq
+    leaq    -8(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.asm
new file mode 100644
index 000000000000..3eb5b719fa07
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem64    PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    ret
+InternalMemScanMem64    ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.nasm
new file mode 100644
index 000000000000..b98c6dece330
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem64.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem64.Asm
+;
+; Abstract:
+;
+;   ScanMem64 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem64 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT64                    Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem64)
+ASM_PFX(InternalMemScanMem64):
+    push    rdi
+    mov     rdi, rcx
+    mov     rax, r8
+    mov     rcx, rdx
+    repne   scasq
+    lea     rax, [rdi - 8]
+    cmovnz  rax, rcx
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.S b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.S
new file mode 100644
index 000000000000..1bb04aa41464
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.S
@@ -0,0 +1,56 @@
+#
+# ConvertAsm.py: Automatically generated from ScanMem8.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ScanMem8.S
+#
+# Abstract:
+#
+#   ScanMem8 function
+#
+# Notes:
+#
+#   The following BaseMemoryLib instances contain the same copy of this file:
+#
+#       BaseMemoryLibRepStr
+#       BaseMemoryLibMmx
+#       BaseMemoryLibSse2
+#       BaseMemoryLibOptDxe
+#       BaseMemoryLibOptPei
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# CONST VOID *
+# EFIAPI
+# InternalMemScanMem8 (
+#   IN      CONST VOID                *Buffer,
+#   IN      UINTN                     Length,
+#   IN      UINT8                     Value
+#   );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdx, %rcx
+    movq    %r8, %rax
+    repne   scasb
+    leaq    -1(%rdi), %rax
+    cmovnz  %rcx, %rax                    # set rax to 0 if not found
+    popq    %rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.asm
new file mode 100644
index 000000000000..8ece85e5b4a2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.asm
@@ -0,0 +1,53 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+InternalMemScanMem8 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    ret
+InternalMemScanMem8 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.nasm
new file mode 100644
index 000000000000..8499795a1d7e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ScanMem8.nasm
@@ -0,0 +1,55 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2008, 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.
+;
+; Module Name:
+;
+;   ScanMem8.Asm
+;
+; Abstract:
+;
+;   ScanMem8 function
+;
+; Notes:
+;
+;   The following BaseMemoryLib instances contain the same copy of this file:
+;
+;       BaseMemoryLibRepStr
+;       BaseMemoryLibMmx
+;       BaseMemoryLibSse2
+;       BaseMemoryLibOptDxe
+;       BaseMemoryLibOptPei
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; CONST VOID *
+; EFIAPI
+; InternalMemScanMem8 (
+;   IN      CONST VOID                *Buffer,
+;   IN      UINTN                     Length,
+;   IN      UINT8                     Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemScanMem8)
+ASM_PFX(InternalMemScanMem8):
+    push    rdi
+    mov     rdi, rcx
+    mov     rcx, rdx
+    mov     rax, r8
+    repne   scasb
+    lea     rax, [rdi - 1]
+    cmovnz  rax, rcx                    ; set rax to 0 if not found
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.S b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.S
new file mode 100644
index 000000000000..25012d402b0e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.S
@@ -0,0 +1,72 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem.S
+#
+# Abstract:
+#
+#   SetMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT8  Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    pushq   %rdi
+    movq    %rcx, %rdi                  # rdi <- Buffer
+    movb    %r8b, %al                   # al <- Value
+    movq    %rdi, %r9                   # r9 <- Buffer as return value
+    xorq    %rcx, %rcx
+    subq    %rdi, %rcx
+    andq    $15, %rcx                   # rcx + rdi aligns on 16-byte boundary
+    jz      L0
+    cmpq    %rdx, %rcx
+    cmova   %rdx, %rcx
+    subq    %rcx, %rdx
+    rep     stosb
+L0:
+    movq    %rdx, %rcx
+    andq    $15, %rdx
+    shrq    $4, %rcx
+    jz      L_SetBytes
+    movb    %al, %ah                    # ax <- Value repeats twice
+    movdqa  %xmm0, 0x10(%rsp)           # save xmm0
+    movd    %eax, %xmm0                 # xmm0[0..16] <- Value repeats twice
+    pshuflw $0, %xmm0, %xmm0            # xmm0[0..63] <- Value repeats 8 times
+    movlhps %xmm0, %xmm0                # xmm0 <- Value repeats 16 times
+L1:
+    movntdq %xmm0, (%rdi)               # rdi should be 16-byte aligned
+    add     $16, %rdi
+    loop    L1
+    mfence
+    movdqa  0x10(%rsp), %xmm0           # restore xmm0
+L_SetBytes:
+    movl    %edx, %ecx                  # high 32 bits of rcx are always zero
+    rep     stosb
+    movq    %r9, %rax                   # rax <- Return value
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.asm
new file mode 100644
index 000000000000..5b5623ff186f
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.asm
@@ -0,0 +1,69 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.asm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem   PROC    USES    rdi
+    mov     rdi, rcx                    ; rdi <- Buffer
+    mov     al, r8b                     ; al <- Value
+    mov     r9, rdi                     ; r9 <- Buffer as return value
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15                     ; rcx + rdi aligns on 16-byte boundary
+    jz      @F
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosb
+@@:
+    mov     rcx, rdx
+    and     rdx, 15
+    shr     rcx, 4
+    jz      @SetBytes
+    mov     ah, al                      ; ax <- Value repeats twice
+    movdqa  [rsp + 10h], xmm0           ; save xmm0
+    movd    xmm0, eax                   ; xmm0[0..16] <- Value repeats twice
+    pshuflw xmm0, xmm0, 0               ; xmm0[0..63] <- Value repeats 8 times
+    movlhps xmm0, xmm0                  ; xmm0 <- Value repeats 16 times
+@@:
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rdi, 16
+    loop    @B
+    mfence
+    movdqa  xmm0, [rsp + 10h]           ; restore xmm0
+@SetBytes:
+    mov     ecx, edx                    ; high 32 bits of rcx are always zero
+    rep     stosb
+    mov     rax, r9                     ; rax <- Return value
+    ret
+InternalMemSetMem   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.nasm
new file mode 100644
index 000000000000..fddf4c9e9e99
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem.nasm
@@ -0,0 +1,71 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem.nasm
+;
+; Abstract:
+;
+;   SetMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem)
+ASM_PFX(InternalMemSetMem):
+    push    rdi
+    mov     rdi, rcx                    ; rdi <- Buffer
+    mov     al, r8b                     ; al <- Value
+    mov     r9, rdi                     ; r9 <- Buffer as return value
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15                     ; rcx + rdi aligns on 16-byte boundary
+    jz      .0
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosb
+.0:
+    mov     rcx, rdx
+    and     rdx, 15
+    shr     rcx, 4
+    jz      @SetBytes
+    mov     ah, al                      ; ax <- Value repeats twice
+    movdqa  [rsp + 0x10], xmm0           ; save xmm0
+    movd    xmm0, eax                   ; xmm0[0..16] <- Value repeats twice
+    pshuflw xmm0, xmm0, 0               ; xmm0[0..63] <- Value repeats 8 times
+    movlhps xmm0, xmm0                  ; xmm0 <- Value repeats 16 times
+.1:
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rdi, 16
+    loop    .1
+    mfence
+    movdqa  xmm0, [rsp + 0x10]           ; restore xmm0
+@SetBytes:
+    mov     ecx, edx                    ; high 32 bits of rcx are always zero
+    rep     stosb
+    mov     rax, r9                     ; rax <- Return value
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.S b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.S
new file mode 100644
index 000000000000..e6bdc14eabeb
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.S
@@ -0,0 +1,70 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem16.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem16.S
+#
+# Abstract:
+#
+#   SetMem16 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem16 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT16 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdi, %r9
+    xorq    %rcx, %rcx
+    subq    %rdi, %rcx
+    andq    $15, %rcx
+    movq    %r8, %rax
+    jz      L0
+    shrq    $1, %rcx
+    cmpq    %rdx, %rcx
+    cmova   %rdx, %rcx
+    subq    %rcx, %rdx
+    rep     stosw
+L0:
+    movq    %rdx, %rcx
+    andl    $7, %edx
+    shrq    $3, %rcx
+    jz      L_SetWords
+    movd    %eax, %xmm0
+    pshuflw $0, %xmm0, %xmm0
+    movlhps %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%rdi)
+    addq    $16, %rdi
+    loop    L1
+    mfence
+L_SetWords:
+    movl    %edx, %ecx
+    rep     stosw
+    movq    %r9, %rax
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.asm
new file mode 100644
index 000000000000..785cf9ae7d43
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.asm
@@ -0,0 +1,67 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.asm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem16 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     r9, rdi
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     rax, r8
+    jz      @F
+    shr     rcx, 1
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosw
+@@:
+    mov     rcx, rdx
+    and     edx, 7
+    shr     rcx, 3
+    jz      @SetWords
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0
+    movlhps xmm0, xmm0
+@@:
+    movntdq [rdi], xmm0
+    add     rdi, 16
+    loop    @B
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     rax, r9
+    ret
+InternalMemSetMem16 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.nasm
new file mode 100644
index 000000000000..f2e61e891dd2
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem16.nasm
@@ -0,0 +1,69 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem16.nasm
+;
+; Abstract:
+;
+;   SetMem16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem16 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT16 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem16)
+ASM_PFX(InternalMemSetMem16):
+    push    rdi
+    mov     rdi, rcx
+    mov     r9, rdi
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     rax, r8
+    jz      .0
+    shr     rcx, 1
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosw
+.0:
+    mov     rcx, rdx
+    and     edx, 7
+    shr     rcx, 3
+    jz      @SetWords
+    movd    xmm0, eax
+    pshuflw xmm0, xmm0, 0
+    movlhps xmm0, xmm0
+.1:
+    movntdq [rdi], xmm0
+    add     rdi, 16
+    loop    .1
+    mfence
+@SetWords:
+    mov     ecx, edx
+    rep     stosw
+    mov     rax, r9
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.S b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.S
new file mode 100644
index 000000000000..e0abd7195729
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.S
@@ -0,0 +1,69 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem32.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem32.S
+#
+# Abstract:
+#
+#   SetMem32 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  EFIAPI
+#  InternalMemSetMem32 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT32 Value
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    movq    %rdi, %r9
+    xorq    %rcx, %rcx
+    subq    %rdi, %rcx
+    andq    $15, %rcx
+    movq    %r8, %rax
+    jz      L0
+    shrq    $2, %rcx
+    cmpq    %rdx, %rcx
+    cmova   %rdx, %rcx
+    subq    %rcx, %rdx
+    rep     stosl
+L0:
+    movq    %rdx, %rcx
+    andl    $3, %edx
+    shrq    $2, %rcx
+    jz      L_SetDwords
+    movd    %eax, %xmm0
+    pshufd  $0, %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%rdi)
+    addq    $16, %rdi
+    loop    L1
+    mfence
+L_SetDwords:
+    movl    %edx, %ecx
+    rep     stosl
+    movq    %r9, %rax
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.asm
new file mode 100644
index 000000000000..4c93f89b7aff
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.asm
@@ -0,0 +1,66 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.asm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem32 PROC    USES    rdi
+    mov     rdi, rcx
+    mov     r9, rdi
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     rax, r8
+    jz      @F
+    shr     rcx, 2
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosd
+@@:
+    mov     rcx, rdx
+    and     edx, 3
+    shr     rcx, 2
+    jz      @SetDwords
+    movd    xmm0, eax
+    pshufd  xmm0, xmm0, 0
+@@:
+    movntdq [rdi], xmm0
+    add     rdi, 16
+    loop    @B
+    mfence
+@SetDwords:
+    mov     ecx, edx
+    rep     stosd
+    mov     rax, r9
+    ret
+InternalMemSetMem32 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.nasm
new file mode 100644
index 000000000000..d4ecf170a48a
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem32.nasm
@@ -0,0 +1,68 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem32.nasm
+;
+; Abstract:
+;
+;   SetMem32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem32 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT8  Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem32)
+ASM_PFX(InternalMemSetMem32):
+    push    rdi
+    mov     rdi, rcx
+    mov     r9, rdi
+    xor     rcx, rcx
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     rax, r8
+    jz      .0
+    shr     rcx, 2
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosd
+.0:
+    mov     rcx, rdx
+    and     edx, 3
+    shr     rcx, 2
+    jz      @SetDwords
+    movd    xmm0, eax
+    pshufd  xmm0, xmm0, 0
+.1:
+    movntdq [rdi], xmm0
+    add     rdi, 16
+    loop    .1
+    mfence
+@SetDwords:
+    mov     ecx, edx
+    rep     stosd
+    mov     rax, r9
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.S b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.S
new file mode 100644
index 000000000000..de48ff23db75
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.S
@@ -0,0 +1,60 @@
+#
+# ConvertAsm.py: Automatically generated from SetMem64.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   SetMem64.S
+#
+# Abstract:
+#
+#   SetMem64 function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemSetMem64 (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count,
+#    IN UINT64 Value
+#    )
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    movq    %rcx, %rax                    # rax <- Buffer
+    xchgq   %rdx, %rcx                    # rcx <- Count & rdx <- Buffer
+    testb   $8, %dl
+    movd    %r8, %xmm0
+    jz      L0
+    movq    %r8, (%rdx)
+    addq    $8, %rdx
+    decq    %rcx
+L0:
+    shrq    $1, %rcx
+    jz      L_SetQwords
+    movlhps %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%rdx)
+    leaq    16(%rdx), %rdx
+    loop    L1
+    mfence
+L_SetQwords:
+    jnc     L2
+    movq    %r8, (%rdx)
+L2:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.asm
new file mode 100644
index 000000000000..c2c413cd793e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.asm
@@ -0,0 +1,59 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.asm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+InternalMemSetMem64 PROC
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count & rdx <- Buffer
+    test    dl, 8
+    movd    xmm0, r8
+    jz      @F
+    mov     [rdx], r8
+    add     rdx, 8
+    dec     rcx
+@@:
+    shr     rcx, 1
+    jz      @SetQwords
+    movlhps xmm0, xmm0
+@@:
+    movntdq [rdx], xmm0
+    lea     rdx, [rdx + 16]
+    loop    @B
+    mfence
+@SetQwords:
+    jnc     @F
+    mov     [rdx], r8
+@@:
+    ret
+InternalMemSetMem64 ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.nasm
new file mode 100644
index 000000000000..f543693d109e
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/SetMem64.nasm
@@ -0,0 +1,59 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   SetMem64.nasm
+;
+; Abstract:
+;
+;   SetMem64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemSetMem64 (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count,
+;    IN UINT64 Value
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemSetMem64)
+ASM_PFX(InternalMemSetMem64):
+    mov     rax, rcx                    ; rax <- Buffer
+    xchg    rcx, rdx                    ; rcx <- Count & rdx <- Buffer
+    test    dl, 8
+    movq    xmm0, r8
+    jz      .0
+    mov     [rdx], r8
+    add     rdx, 8
+    dec     rcx
+.0:
+    shr     rcx, 1
+    jz      @SetQwords
+    movlhps xmm0, xmm0
+.1:
+    movntdq [rdx], xmm0
+    lea     rdx, [rdx + 16]
+    loop    .1
+    mfence
+@SetQwords:
+    jnc     .2
+    mov     [rdx], r8
+.2:
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.S b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.S
new file mode 100644
index 000000000000..7cf7a267d174
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.S
@@ -0,0 +1,65 @@
+#
+# ConvertAsm.py: Automatically generated from ZeroMem.asm
+#
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2009, 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.
+#
+# Module Name:
+#
+#   ZeroMem.S
+#
+# Abstract:
+#
+#   ZeroMem function
+#
+# Notes:
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+#  VOID *
+#  InternalMemZeroMem (
+#    IN VOID   *Buffer,
+#    IN UINTN  Count
+#    );
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    pushq   %rdi
+    movq    %rcx, %rdi
+    xorq    %rcx, %rcx
+    xorl    %eax, %eax
+    subq    %rdi, %rcx
+    andq    $15, %rcx
+    movq    %rdi, %r8
+    jz      L0
+    cmpq    %rdx, %rcx
+    cmova   %rdx, %rcx
+    subq    %rcx, %rdx
+    rep     stosb
+L0:
+    movq    %rdx, %rcx
+    andl    $15, %edx
+    shrq    $4, %rcx
+    jz      L_ZeroBytes
+    pxor    %xmm0, %xmm0
+L1:
+    movntdq %xmm0, (%rdi)                 # rdi should be 16-byte aligned
+    addq    $16, %rdi
+    loop    L1
+    mfence
+L_ZeroBytes:
+    movl    %edx, %ecx
+    rep     stosb
+    movq    %r8, %rax
+    popq    %rdi
+    ret
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.asm b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.asm
new file mode 100644
index 000000000000..4a486c9ca5a4
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.asm
@@ -0,0 +1,63 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.asm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+InternalMemZeroMem  PROC    USES    rdi
+    mov     rdi, rcx
+    xor     rcx, rcx
+    xor     eax, eax
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     r8, rdi
+    jz      @F
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosb
+@@:
+    mov     rcx, rdx
+    and     edx, 15
+    shr     rcx, 4
+    jz      @ZeroBytes
+    pxor    xmm0, xmm0
+@@:
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rdi, 16
+    loop    @B
+    mfence
+@ZeroBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    ret
+InternalMemZeroMem  ENDP
+
+    END
diff --git a/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.nasm b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.nasm
new file mode 100644
index 000000000000..1dd0a1477040
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/X64/ZeroMem.nasm
@@ -0,0 +1,65 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006, 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.
+;
+; Module Name:
+;
+;   ZeroMem.nasm
+;
+; Abstract:
+;
+;   ZeroMem function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+;  VOID *
+;  InternalMemZeroMem (
+;    IN VOID   *Buffer,
+;    IN UINTN  Count
+;    )
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalMemZeroMem)
+ASM_PFX(InternalMemZeroMem):
+    push    rdi
+    mov     rdi, rcx
+    xor     rcx, rcx
+    xor     eax, eax
+    sub     rcx, rdi
+    and     rcx, 15
+    mov     r8, rdi
+    jz      .0
+    cmp     rcx, rdx
+    cmova   rcx, rdx
+    sub     rdx, rcx
+    rep     stosb
+.0:
+    mov     rcx, rdx
+    and     edx, 15
+    shr     rcx, 4
+    jz      @ZeroBytes
+    pxor    xmm0, xmm0
+.1:
+    movntdq [rdi], xmm0                 ; rdi should be 16-byte aligned
+    add     rdi, 16
+    loop    .1
+    mfence
+@ZeroBytes:
+    mov     ecx, edx
+    rep     stosb
+    mov     rax, r8
+    pop     rdi
+    ret
+
diff --git a/MdePkg/Library/BaseMemoryLibSse2/ZeroMemWrapper.c b/MdePkg/Library/BaseMemoryLibSse2/ZeroMemWrapper.c
new file mode 100644
index 000000000000..067c7af84819
--- /dev/null
+++ b/MdePkg/Library/BaseMemoryLibSse2/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.c b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.c
new file mode 100644
index 000000000000..3089c1df8784
--- /dev/null
+++ b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.c
@@ -0,0 +1,1454 @@
+/** @file
+  An OrderedCollectionLib instance that provides a red-black tree
+  implementation, and allocates and releases tree nodes with
+  MemoryAllocationLib.
+
+  This library instance is useful when a fast associative container is needed.
+  Worst case time complexity is O(log n) for Find(), Next(), Prev(), Min(),
+  Max(), Insert(), and Delete(), where "n" is the number of elements in the
+  tree. Complete ordered traversal takes O(n) time.
+
+  The implementation is also useful as a fast priority queue.
+
+  Copyright (C) 2014, Red Hat, Inc.
+  Copyright (c) 2014, 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.
+**/
+
+#include <Library/OrderedCollectionLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+
+typedef enum {
+  RedBlackTreeRed,
+  RedBlackTreeBlack
+} RED_BLACK_TREE_COLOR;
+
+//
+// Incomplete types and convenience typedefs are present in the library class
+// header. Beside completing the types, we introduce typedefs here that reflect
+// the implementation closely.
+//
+typedef ORDERED_COLLECTION              RED_BLACK_TREE;
+typedef ORDERED_COLLECTION_ENTRY        RED_BLACK_TREE_NODE;
+typedef ORDERED_COLLECTION_USER_COMPARE RED_BLACK_TREE_USER_COMPARE;
+typedef ORDERED_COLLECTION_KEY_COMPARE  RED_BLACK_TREE_KEY_COMPARE;
+
+struct ORDERED_COLLECTION {
+  RED_BLACK_TREE_NODE         *Root;
+  RED_BLACK_TREE_USER_COMPARE UserStructCompare;
+  RED_BLACK_TREE_KEY_COMPARE  KeyCompare;
+};
+
+struct ORDERED_COLLECTION_ENTRY {
+  VOID                 *UserStruct;
+  RED_BLACK_TREE_NODE  *Parent;
+  RED_BLACK_TREE_NODE  *Left;
+  RED_BLACK_TREE_NODE  *Right;
+  RED_BLACK_TREE_COLOR Color;
+};
+
+
+/**
+  Retrieve the user structure linked by the specified tree node.
+
+  Read-only operation.
+
+  @param[in] Node  Pointer to the tree node whose associated user structure we
+                   want to retrieve. The caller is responsible for passing a
+                   non-NULL argument.
+
+  @return  Pointer to user structure linked by Node.
+**/
+VOID *
+EFIAPI
+OrderedCollectionUserStruct (
+  IN CONST RED_BLACK_TREE_NODE *Node
+  )
+{
+  return Node->UserStruct;
+}
+
+/**
+  A slow function that asserts that the tree is a valid red-black tree, and
+  that it orders user structures correctly.
+
+  Read-only operation.
+
+  This function uses the stack for recursion and is not recommended for
+  "production use".
+
+  @param[in] Tree  The tree to validate.
+**/
+VOID
+RedBlackTreeValidate (
+  IN CONST RED_BLACK_TREE *Tree
+  );
+
+
+/**
+  Allocate and initialize the RED_BLACK_TREE structure.
+
+  Allocation occurs via MemoryAllocationLib's AllocatePool() function.
+
+  @param[in]  UserStructCompare  This caller-provided function will be used to
+                                 order two user structures linked into the
+                                 tree, during the insertion procedure.
+
+  @param[in]  KeyCompare         This caller-provided function will be used to
+                                 order the standalone search key against user
+                                 structures linked into the tree, during the
+                                 lookup procedure.
+
+  @retval NULL  If allocation failed.
+
+  @return       Pointer to the allocated, initialized RED_BLACK_TREE structure,
+                otherwise.
+**/
+RED_BLACK_TREE *
+EFIAPI
+OrderedCollectionInit (
+  IN RED_BLACK_TREE_USER_COMPARE UserStructCompare,
+  IN RED_BLACK_TREE_KEY_COMPARE  KeyCompare
+  )
+{
+  RED_BLACK_TREE *Tree;
+
+  Tree = AllocatePool (sizeof *Tree);
+  if (Tree == NULL) {
+    return NULL;
+  }
+
+  Tree->Root              = NULL;
+  Tree->UserStructCompare = UserStructCompare;
+  Tree->KeyCompare        = KeyCompare;
+
+  if (FeaturePcdGet (PcdValidateOrderedCollection)) {
+    RedBlackTreeValidate (Tree);
+  }
+  return Tree;
+}
+
+
+/**
+  Check whether the tree is empty (has no nodes).
+
+  Read-only operation.
+
+  @param[in] Tree  The tree to check for emptiness.
+
+  @retval TRUE   The tree is empty.
+
+  @retval FALSE  The tree is not empty.
+**/
+BOOLEAN
+EFIAPI
+OrderedCollectionIsEmpty (
+  IN CONST RED_BLACK_TREE *Tree
+  )
+{
+  return (BOOLEAN)(Tree->Root == NULL);
+}
+
+
+/**
+  Uninitialize and release an empty RED_BLACK_TREE structure.
+
+  Read-write operation.
+
+  Release occurs via MemoryAllocationLib's FreePool() function.
+
+  It is the caller's responsibility to delete all nodes from the tree before
+  calling this function.
+
+  @param[in] Tree  The empty tree to uninitialize and release.
+**/
+VOID
+EFIAPI
+OrderedCollectionUninit (
+  IN RED_BLACK_TREE *Tree
+  )
+{
+  ASSERT (OrderedCollectionIsEmpty (Tree));
+  FreePool (Tree);
+}
+
+
+/**
+  Look up the tree node that links the user structure that matches the
+  specified standalone key.
+
+  Read-only operation.
+
+  @param[in] Tree           The tree to search for StandaloneKey.
+
+  @param[in] StandaloneKey  The key to locate among the user structures linked
+                            into Tree. StandaloneKey will be passed to
+                            Tree->KeyCompare().
+
+  @retval NULL  StandaloneKey could not be found.
+
+  @return       The tree node that links to the user structure matching
+                StandaloneKey, otherwise.
+**/
+RED_BLACK_TREE_NODE *
+EFIAPI
+OrderedCollectionFind (
+  IN CONST RED_BLACK_TREE *Tree,
+  IN CONST VOID           *StandaloneKey
+  )
+{
+  RED_BLACK_TREE_NODE *Node;
+
+  Node = Tree->Root;
+  while (Node != NULL) {
+    INTN Result;
+
+    Result = Tree->KeyCompare (StandaloneKey, Node->UserStruct);
+    if (Result == 0) {
+      break;
+    }
+    Node = (Result < 0) ? Node->Left : Node->Right;
+  }
+  return Node;
+}
+
+
+/**
+  Find the tree node of the minimum user structure stored in the tree.
+
+  Read-only operation.
+
+  @param[in] Tree  The tree to return the minimum node of. The user structure
+                   linked by the minimum node compares less than all other user
+                   structures in the tree.
+
+  @retval NULL  If Tree is empty.
+
+  @return       The tree node that links the minimum user structure, otherwise.
+**/
+RED_BLACK_TREE_NODE *
+EFIAPI
+OrderedCollectionMin (
+  IN CONST RED_BLACK_TREE *Tree
+  )
+{
+  RED_BLACK_TREE_NODE *Node;
+
+  Node = Tree->Root;
+  if (Node == NULL) {
+    return NULL;
+  }
+  while (Node->Left != NULL) {
+    Node = Node->Left;
+  }
+  return Node;
+}
+
+
+/**
+  Find the tree node of the maximum user structure stored in the tree.
+
+  Read-only operation.
+
+  @param[in] Tree  The tree to return the maximum node of. The user structure
+                   linked by the maximum node compares greater than all other
+                   user structures in the tree.
+
+  @retval NULL  If Tree is empty.
+
+  @return       The tree node that links the maximum user structure, otherwise.
+**/
+RED_BLACK_TREE_NODE *
+EFIAPI
+OrderedCollectionMax (
+  IN CONST RED_BLACK_TREE *Tree
+  )
+{
+  RED_BLACK_TREE_NODE *Node;
+
+  Node = Tree->Root;
+  if (Node == NULL) {
+    return NULL;
+  }
+  while (Node->Right != NULL) {
+    Node = Node->Right;
+  }
+  return Node;
+}
+
+
+/**
+  Get the tree node of the least user structure that is greater than the one
+  linked by Node.
+
+  Read-only operation.
+
+  @param[in] Node  The node to get the successor node of.
+
+  @retval NULL  If Node is NULL, or Node is the maximum node of its containing
+                tree (ie. Node has no successor node).
+
+  @return       The tree node linking the least user structure that is greater
+                than the one linked by Node, otherwise.
+**/
+RED_BLACK_TREE_NODE *
+EFIAPI
+OrderedCollectionNext (
+  IN CONST RED_BLACK_TREE_NODE *Node
+  )
+{
+  RED_BLACK_TREE_NODE       *Walk;
+  CONST RED_BLACK_TREE_NODE *Child;
+
+  if (Node == NULL) {
+    return NULL;
+  }
+
+  //
+  // If Node has a right subtree, then the successor is the minimum node of
+  // that subtree.
+  //
+  Walk = Node->Right;
+  if (Walk != NULL) {
+    while (Walk->Left != NULL) {
+      Walk = Walk->Left;
+    }
+    return Walk;
+  }
+
+  //
+  // Otherwise we have to ascend as long as we're our parent's right child (ie.
+  // ascending to the left).
+  //
+  Child = Node;
+  Walk = Child->Parent;
+  while (Walk != NULL && Child == Walk->Right) {
+    Child = Walk;
+    Walk = Child->Parent;
+  }
+  return Walk;
+}
+
+
+/**
+  Get the tree node of the greatest user structure that is less than the one
+  linked by Node.
+
+  Read-only operation.
+
+  @param[in] Node  The node to get the predecessor node of.
+
+  @retval NULL  If Node is NULL, or Node is the minimum node of its containing
+                tree (ie. Node has no predecessor node).
+
+  @return       The tree node linking the greatest user structure that is less
+                than the one linked by Node, otherwise.
+**/
+RED_BLACK_TREE_NODE *
+EFIAPI
+OrderedCollectionPrev (
+  IN CONST RED_BLACK_TREE_NODE *Node
+  )
+{
+  RED_BLACK_TREE_NODE       *Walk;
+  CONST RED_BLACK_TREE_NODE *Child;
+
+  if (Node == NULL) {
+    return NULL;
+  }
+
+  //
+  // If Node has a left subtree, then the predecessor is the maximum node of
+  // that subtree.
+  //
+  Walk = Node->Left;
+  if (Walk != NULL) {
+    while (Walk->Right != NULL) {
+      Walk = Walk->Right;
+    }
+    return Walk;
+  }
+
+  //
+  // Otherwise we have to ascend as long as we're our parent's left child (ie.
+  // ascending to the right).
+  //
+  Child = Node;
+  Walk = Child->Parent;
+  while (Walk != NULL && Child == Walk->Left) {
+    Child = Walk;
+    Walk = Child->Parent;
+  }
+  return Walk;
+}
+
+
+/**
+  Rotate tree nodes around Pivot to the right.
+
+                Parent                       Parent
+                  |                            |
+                Pivot                      LeftChild
+               /     .                    .         \_
+      LeftChild       Node1   --->   Node2           Pivot
+         . \                                          / .
+    Node2   LeftRightChild              LeftRightChild   Node1
+
+  The ordering Node2 < LeftChild < LeftRightChild < Pivot < Node1 is kept
+  intact. Parent (if any) is either at the left extreme or the right extreme of
+  this ordering, and that relation is also kept intact.
+
+  Edges marked with a dot (".") don't change during rotation.
+
+  Internal read-write operation.
+
+  @param[in,out] Pivot    The tree node to rotate other nodes right around. It
+                          is the caller's responsibility to ensure that
+                          Pivot->Left is not NULL.
+
+  @param[out]    NewRoot  If Pivot has a parent node on input, then the
+                          function updates Pivot's original parent on output
+                          according to the rotation, and NewRoot is not
+                          accessed.
+
+                          If Pivot has no parent node on input (ie. Pivot is
+                          the root of the tree), then the function stores the
+                          new root node of the tree in NewRoot.
+**/
+VOID
+RedBlackTreeRotateRight (
+  IN OUT RED_BLACK_TREE_NODE *Pivot,
+  OUT    RED_BLACK_TREE_NODE **NewRoot
+  )
+{
+  RED_BLACK_TREE_NODE *Parent;
+  RED_BLACK_TREE_NODE *LeftChild;
+  RED_BLACK_TREE_NODE *LeftRightChild;
+
+  Parent         = Pivot->Parent;
+  LeftChild      = Pivot->Left;
+  LeftRightChild = LeftChild->Right;
+
+  Pivot->Left = LeftRightChild;
+  if (LeftRightChild != NULL) {
+    LeftRightChild->Parent = Pivot;
+  }
+  LeftChild->Parent = Parent;
+  if (Parent == NULL) {
+    *NewRoot = LeftChild;
+  } else {
+    if (Pivot == Parent->Left) {
+      Parent->Left = LeftChild;
+    } else {
+      Parent->Right = LeftChild;
+    }
+  }
+  LeftChild->Right = Pivot;
+  Pivot->Parent = LeftChild;
+}
+
+
+/**
+  Rotate tree nodes around Pivot to the left.
+
+          Parent                                 Parent
+            |                                      |
+          Pivot                                RightChild
+         .     \                              /          .
+    Node1       RightChild    --->       Pivot            Node2
+                    /.                    . \_
+      RightLeftChild  Node2          Node1   RightLeftChild
+
+  The ordering Node1 < Pivot < RightLeftChild < RightChild < Node2 is kept
+  intact. Parent (if any) is either at the left extreme or the right extreme of
+  this ordering, and that relation is also kept intact.
+
+  Edges marked with a dot (".") don't change during rotation.
+
+  Internal read-write operation.
+
+  @param[in,out] Pivot    The tree node to rotate other nodes left around. It
+                          is the caller's responsibility to ensure that
+                          Pivot->Right is not NULL.
+
+  @param[out]    NewRoot  If Pivot has a parent node on input, then the
+                          function updates Pivot's original parent on output
+                          according to the rotation, and NewRoot is not
+                          accessed.
+
+                          If Pivot has no parent node on input (ie. Pivot is
+                          the root of the tree), then the function stores the
+                          new root node of the tree in NewRoot.
+**/
+VOID
+RedBlackTreeRotateLeft (
+  IN OUT RED_BLACK_TREE_NODE *Pivot,
+  OUT    RED_BLACK_TREE_NODE **NewRoot
+  )
+{
+  RED_BLACK_TREE_NODE *Parent;
+  RED_BLACK_TREE_NODE *RightChild;
+  RED_BLACK_TREE_NODE *RightLeftChild;
+
+  Parent         = Pivot->Parent;
+  RightChild     = Pivot->Right;
+  RightLeftChild = RightChild->Left;
+
+  Pivot->Right = RightLeftChild;
+  if (RightLeftChild != NULL) {
+    RightLeftChild->Parent = Pivot;
+  }
+  RightChild->Parent = Parent;
+  if (Parent == NULL) {
+    *NewRoot = RightChild;
+  } else {
+    if (Pivot == Parent->Left) {
+      Parent->Left = RightChild;
+    } else {
+      Parent->Right = RightChild;
+    }
+  }
+  RightChild->Left = Pivot;
+  Pivot->Parent = RightChild;
+}
+
+
+/**
+  Insert (link) a user structure into the tree.
+
+  Read-write operation.
+
+  This function allocates the new tree node with MemoryAllocationLib's
+  AllocatePool() function.
+
+  @param[in,out] Tree        The tree to insert UserStruct into.
+
+  @param[out]    Node        The meaning of this optional, output-only
+                             parameter depends on the return value of the
+                             function.
+
+                             When insertion is successful (RETURN_SUCCESS),
+                             Node is set on output to the new tree node that
+                             now links UserStruct.
+
+                             When insertion fails due to lack of memory
+                             (RETURN_OUT_OF_RESOURCES), Node is not changed.
+
+                             When insertion fails due to key collision (ie.
+                             another user structure is already in the tree that
+                             compares equal to UserStruct), with return value
+                             RETURN_ALREADY_STARTED, then Node is set on output
+                             to the node that links the colliding user
+                             structure. This enables "find-or-insert" in one
+                             function call, or helps with later removal of the
+                             colliding element.
+
+  @param[in]     UserStruct  The user structure to link into the tree.
+                             UserStruct is ordered against in-tree user
+                             structures with the Tree->UserStructCompare()
+                             function.
+
+  @retval RETURN_SUCCESS           Insertion successful. A new tree node has
+                                   been allocated, linking UserStruct. The new
+                                   tree node is reported back in Node (if the
+                                   caller requested it).
+
+                                   Existing RED_BLACK_TREE_NODE pointers into
+                                   Tree remain valid. For example, on-going
+                                   iterations in the caller can continue with
+                                   OrderedCollectionNext() /
+                                   OrderedCollectionPrev(), and they will
+                                   return the new node at some point if user
+                                   structure order dictates it.
+
+  @retval RETURN_OUT_OF_RESOURCES  AllocatePool() failed to allocate memory for
+                                   the new tree node. The tree has not been
+                                   changed. Existing RED_BLACK_TREE_NODE
+                                   pointers into Tree remain valid.
+
+  @retval RETURN_ALREADY_STARTED   A user structure has been found in the tree
+                                   that compares equal to UserStruct. The node
+                                   linking the colliding user structure is
+                                   reported back in Node (if the caller
+                                   requested it). The tree has not been
+                                   changed. Existing RED_BLACK_TREE_NODE
+                                   pointers into Tree remain valid.
+**/
+RETURN_STATUS
+EFIAPI
+OrderedCollectionInsert (
+  IN OUT RED_BLACK_TREE      *Tree,
+  OUT    RED_BLACK_TREE_NODE **Node      OPTIONAL,
+  IN     VOID                *UserStruct
+  )
+{
+  RED_BLACK_TREE_NODE *Tmp;
+  RED_BLACK_TREE_NODE *Parent;
+  INTN                Result;
+  RETURN_STATUS       Status;
+  RED_BLACK_TREE_NODE *NewRoot;
+
+  Tmp = Tree->Root;
+  Parent = NULL;
+  Result = 0;
+
+  //
+  // First look for a collision, saving the last examined node for the case
+  // when there's no collision.
+  //
+  while (Tmp != NULL) {
+    Result = Tree->UserStructCompare (UserStruct, Tmp->UserStruct);
+    if (Result == 0) {
+      break;
+    }
+    Parent = Tmp;
+    Tmp = (Result < 0) ? Tmp->Left : Tmp->Right;
+  }
+
+  if (Tmp != NULL) {
+    if (Node != NULL) {
+      *Node = Tmp;
+    }
+    Status = RETURN_ALREADY_STARTED;
+    goto Done;
+  }
+
+  //
+  // no collision, allocate a new node
+  //
+  Tmp = AllocatePool (sizeof *Tmp);
+  if (Tmp == NULL) {
+    Status = RETURN_OUT_OF_RESOURCES;
+    goto Done;
+  }
+  if (Node != NULL) {
+    *Node = Tmp;
+  }
+
+  //
+  // reference the user structure from the node
+  //
+  Tmp->UserStruct = UserStruct;
+
+  //
+  // Link the node as a child to the correct side of the parent.
+  // If there's no parent, the new node is the root node in the tree.
+  //
+  Tmp->Parent = Parent;
+  Tmp->Left = NULL;
+  Tmp->Right = NULL;
+  if (Parent == NULL) {
+    Tree->Root = Tmp;
+    Tmp->Color = RedBlackTreeBlack;
+    Status = RETURN_SUCCESS;
+    goto Done;
+  }
+  if (Result < 0) {
+    Parent->Left = Tmp;
+  } else {
+    Parent->Right = Tmp;
+  }
+  Tmp->Color = RedBlackTreeRed;
+
+  //
+  // Red-black tree properties:
+  //
+  // #1 Each node is either red or black (RED_BLACK_TREE_NODE.Color).
+  //
+  // #2 Each leaf (ie. a pseudo-node pointed-to by a NULL valued
+  //    RED_BLACK_TREE_NODE.Left or RED_BLACK_TREE_NODE.Right field) is black.
+  //
+  // #3 Each red node has two black children.
+  //
+  // #4 For any node N, and for any leaves L1 and L2 reachable from N, the
+  //    paths N..L1 and N..L2 contain the same number of black nodes.
+  //
+  // #5 The root node is black.
+  //
+  // By replacing a leaf with a red node above, only property #3 may have been
+  // broken. (Note that this is the only edge across which property #3 might
+  // not hold in the entire tree.) Restore property #3.
+  //
+
+  NewRoot = Tree->Root;
+  while (Tmp != NewRoot && Parent->Color == RedBlackTreeRed) {
+    RED_BLACK_TREE_NODE *GrandParent;
+    RED_BLACK_TREE_NODE *Uncle;
+
+    //
+    // Tmp is not the root node. Tmp is red. Tmp's parent is red. (Breaking
+    // property #3.)
+    //
+    // Due to property #5, Tmp's parent cannot be the root node, hence Tmp's
+    // grandparent exists.
+    //
+    // Tmp's grandparent is black, because property #3 is only broken between
+    // Tmp and Tmp's parent.
+    //
+    GrandParent = Parent->Parent;
+
+    if (Parent == GrandParent->Left) {
+      Uncle = GrandParent->Right;
+      if (Uncle != NULL && Uncle->Color == RedBlackTreeRed) {
+        //
+        //             GrandParent (black)
+        //            /                   \_
+        // Parent (red)                    Uncle (red)
+        //      |
+        //  Tmp (red)
+        //
+
+        Parent->Color = RedBlackTreeBlack;
+        Uncle->Color = RedBlackTreeBlack;
+        GrandParent->Color = RedBlackTreeRed;
+
+        //
+        //                GrandParent (red)
+        //               /                 \_
+        // Parent (black)                   Uncle (black)
+        //       |
+        //   Tmp (red)
+        //
+        // We restored property #3 between Tmp and Tmp's parent, without
+        // breaking property #4. However, we may have broken property #3
+        // between Tmp's grandparent and Tmp's great-grandparent (if any), so
+        // repeat the loop for Tmp's grandparent.
+        //
+        // If Tmp's grandparent has no parent, then the loop will terminate,
+        // and we will have broken property #5, by coloring the root red. We'll
+        // restore property #5 after the loop, without breaking any others.
+        //
+        Tmp = GrandParent;
+        Parent = Tmp->Parent;
+      } else {
+        //
+        // Tmp's uncle is black (satisfied by the case too when Tmp's uncle is
+        // NULL, see property #2).
+        //
+
+        if (Tmp == Parent->Right) {
+          //
+          //                 GrandParent (black): D
+          //                /                      \_
+          // Parent (red): A                        Uncle (black): E
+          //      \_
+          //       Tmp (red): B
+          //            \_
+          //             black: C
+          //
+          // Rotate left, pivoting on node A. This keeps the breakage of
+          // property #3 in the same spot, and keeps other properties intact
+          // (because both Tmp and its parent are red).
+          //
+          Tmp = Parent;
+          RedBlackTreeRotateLeft (Tmp, &NewRoot);
+          Parent = Tmp->Parent;
+
+          //
+          // With the rotation we reached the same configuration as if Tmp had
+          // been a left child to begin with.
+          //
+          //                       GrandParent (black): D
+          //                      /                      \_
+          //       Parent (red): B                        Uncle (black): E
+          //             / \_
+          // Tmp (red): A   black: C
+          //
+          ASSERT (GrandParent == Parent->Parent);
+        }
+
+        Parent->Color = RedBlackTreeBlack;
+        GrandParent->Color = RedBlackTreeRed;
+
+        //
+        // Property #3 is now restored, but we've broken property #4. Namely,
+        // paths going through node E now see a decrease in black count, while
+        // paths going through node B don't.
+        //
+        //                        GrandParent (red): D
+        //                       /                    \_
+        //      Parent (black): B                      Uncle (black): E
+        //             / \_
+        // Tmp (red): A   black: C
+        //
+
+        RedBlackTreeRotateRight (GrandParent, &NewRoot);
+
+        //
+        // Property #4 has been restored for node E, and preserved for others.
+        //
+        //              Parent (black): B
+        //             /                 \_
+        // Tmp (red): A                   [GrandParent] (red): D
+        //                                         / \_
+        //                                 black: C   [Uncle] (black): E
+        //
+        // This configuration terminates the loop because Tmp's parent is now
+        // black.
+        //
+      }
+    } else {
+      //
+      // Symmetrical to the other branch.
+      //
+      Uncle = GrandParent->Left;
+      if (Uncle != NULL && Uncle->Color == RedBlackTreeRed) {
+        Parent->Color = RedBlackTreeBlack;
+        Uncle->Color = RedBlackTreeBlack;
+        GrandParent->Color = RedBlackTreeRed;
+        Tmp = GrandParent;
+        Parent = Tmp->Parent;
+      } else {
+        if (Tmp == Parent->Left) {
+          Tmp = Parent;
+          RedBlackTreeRotateRight (Tmp, &NewRoot);
+          Parent = Tmp->Parent;
+          ASSERT (GrandParent == Parent->Parent);
+        }
+        Parent->Color = RedBlackTreeBlack;
+        GrandParent->Color = RedBlackTreeRed;
+        RedBlackTreeRotateLeft (GrandParent, &NewRoot);
+      }
+    }
+  }
+
+  NewRoot->Color = RedBlackTreeBlack;
+  Tree->Root = NewRoot;
+  Status = RETURN_SUCCESS;
+
+Done:
+  if (FeaturePcdGet (PcdValidateOrderedCollection)) {
+    RedBlackTreeValidate (Tree);
+  }
+  return Status;
+}
+
+
+/**
+  Check if a node is black, allowing for leaf nodes (see property #2).
+
+  This is a convenience shorthand.
+
+  param[in] Node  The node to check. Node may be NULL, corresponding to a leaf.
+
+  @return  If Node is NULL or colored black.
+**/
+BOOLEAN
+NodeIsNullOrBlack (
+  IN CONST RED_BLACK_TREE_NODE *Node
+  )
+{
+  return (BOOLEAN)(Node == NULL || Node->Color == RedBlackTreeBlack);
+}
+
+
+/**
+  Delete a node from the tree, unlinking the associated user structure.
+
+  Read-write operation.
+
+  @param[in,out] Tree        The tree to delete Node from.
+
+  @param[in]     Node        The tree node to delete from Tree. The caller is
+                             responsible for ensuring that Node belongs to
+                             Tree, and that Node is non-NULL and valid. Node is
+                             typically an earlier return value, or output
+                             parameter, of:
+
+                             - OrderedCollectionFind(), for deleting a node by
+                               user structure key,
+
+                             - OrderedCollectionMin() / OrderedCollectionMax(),
+                               for deleting the minimum / maximum node,
+
+                             - OrderedCollectionNext() /
+                               OrderedCollectionPrev(), for deleting a node
+                               found during an iteration,
+
+                             - OrderedCollectionInsert() with return value
+                               RETURN_ALREADY_STARTED, for deleting a node
+                               whose linked user structure caused collision
+                               during insertion.
+
+                             Given a non-empty Tree, Tree->Root is also a valid
+                             Node argument (typically used for simplicity in
+                             loops that empty the tree completely).
+
+                             Node is released with MemoryAllocationLib's
+                             FreePool() function.
+
+                             Existing RED_BLACK_TREE_NODE pointers (ie.
+                             iterators) *different* from Node remain valid. For
+                             example:
+
+                             - OrderedCollectionNext() /
+                               OrderedCollectionPrev() iterations in the caller
+                               can be continued from Node, if
+                               OrderedCollectionNext() or
+                               OrderedCollectionPrev() is called on Node
+                               *before* OrderedCollectionDelete() is. That is,
+                               fetch the successor / predecessor node first,
+                               then delete Node.
+
+                             - On-going iterations in the caller that would
+                               have otherwise returned Node at some point, as
+                               dictated by user structure order, will correctly
+                               reflect the absence of Node after
+                               OrderedCollectionDelete() is called
+                               mid-iteration.
+
+  @param[out]    UserStruct  If the caller provides this optional output-only
+                             parameter, then on output it is set to the user
+                             structure originally linked by Node (which is now
+                             freed).
+
+                             This is a convenience that may save the caller a
+                             OrderedCollectionUserStruct() invocation before
+                             calling OrderedCollectionDelete(), in order to
+                             retrieve the user structure being unlinked.
+**/
+VOID
+EFIAPI
+OrderedCollectionDelete (
+  IN OUT RED_BLACK_TREE      *Tree,
+  IN     RED_BLACK_TREE_NODE *Node,
+  OUT    VOID                **UserStruct OPTIONAL
+  )
+{
+  RED_BLACK_TREE_NODE  *NewRoot;
+  RED_BLACK_TREE_NODE  *OrigLeftChild;
+  RED_BLACK_TREE_NODE  *OrigRightChild;
+  RED_BLACK_TREE_NODE  *OrigParent;
+  RED_BLACK_TREE_NODE  *Child;
+  RED_BLACK_TREE_NODE  *Parent;
+  RED_BLACK_TREE_COLOR ColorOfUnlinked;
+
+  NewRoot        = Tree->Root;
+  OrigLeftChild  = Node->Left,
+  OrigRightChild = Node->Right,
+  OrigParent     = Node->Parent;
+
+  if (UserStruct != NULL) {
+    *UserStruct = Node->UserStruct;
+  }
+
+  //
+  // After this block, no matter which branch we take:
+  // - Child will point to the unique (or NULL) original child of the node that
+  //   we will have unlinked,
+  // - Parent will point to the *position* of the original parent of the node
+  //   that we will have unlinked.
+  //
+  if (OrigLeftChild == NULL || OrigRightChild == NULL) {
+    //
+    // Node has at most one child. We can connect that child (if any) with
+    // Node's parent (if any), unlinking Node. This will preserve ordering
+    // because the subtree rooted in Node's child (if any) remains on the same
+    // side of Node's parent (if any) that Node was before.
+    //
+    Parent = OrigParent;
+    Child = (OrigLeftChild != NULL) ? OrigLeftChild : OrigRightChild;
+    ColorOfUnlinked = Node->Color;
+
+    if (Child != NULL) {
+      Child->Parent = Parent;
+    }
+    if (OrigParent == NULL) {
+      NewRoot = Child;
+    } else {
+      if (Node == OrigParent->Left) {
+        OrigParent->Left = Child;
+      } else {
+        OrigParent->Right = Child;
+      }
+    }
+  } else {
+    //
+    // Node has two children. We unlink Node's successor, and then link it into
+    // Node's place, keeping Node's original color. This preserves ordering
+    // because:
+    // - Node's left subtree is less than Node, hence less than Node's
+    //   successor.
+    // - Node's right subtree is greater than Node. Node's successor is the
+    //   minimum of that subtree, hence Node's successor is less than Node's
+    //   right subtree with its minimum removed.
+    // - Node's successor is in Node's subtree, hence it falls on the same side
+    //   of Node's parent as Node itself. The relinking doesn't change this
+    //   relation.
+    //
+    RED_BLACK_TREE_NODE *ToRelink;
+
+    ToRelink = OrigRightChild;
+    if (ToRelink->Left == NULL) {
+      //
+      // OrigRightChild itself is Node's successor, it has no left child:
+      //
+      //                OrigParent
+      //                    |
+      //                  Node: B
+      //                 /       \_
+      // OrigLeftChild: A         OrigRightChild: E <--- Parent, ToRelink
+      //                                           \_
+      //                                            F <--- Child
+      //
+      Parent = OrigRightChild;
+      Child = OrigRightChild->Right;
+    } else {
+      do {
+        ToRelink = ToRelink->Left;
+      } while (ToRelink->Left != NULL);
+
+      //
+      // Node's successor is the minimum of OrigRightChild's proper subtree:
+      //
+      //                OrigParent
+      //                    |
+      //                  Node: B
+      //                 /       \_
+      // OrigLeftChild: A         OrigRightChild: E <--- Parent
+      //                                  /
+      //                                 C <--- ToRelink
+      //                                  \_
+      //                                   D <--- Child
+      Parent = ToRelink->Parent;
+      Child = ToRelink->Right;
+
+      //
+      // Unlink Node's successor (ie. ToRelink):
+      //
+      //                OrigParent
+      //                    |
+      //                  Node: B
+      //                 /       \_
+      // OrigLeftChild: A         OrigRightChild: E <--- Parent
+      //                                  /
+      //                                 D <--- Child
+      //
+      //                                 C <--- ToRelink
+      //
+      Parent->Left = Child;
+      if (Child != NULL) {
+        Child->Parent = Parent;
+      }
+
+      //
+      // We start to link Node's unlinked successor into Node's place:
+      //
+      //                OrigParent
+      //                    |
+      //                  Node: B     C <--- ToRelink
+      //                 /             \_
+      // OrigLeftChild: A               OrigRightChild: E <--- Parent
+      //                                        /
+      //                                       D <--- Child
+      //
+      //
+      //
+      ToRelink->Right = OrigRightChild;
+      OrigRightChild->Parent = ToRelink;
+    }
+
+    //
+    // The rest handles both cases, attaching ToRelink (Node's original
+    // successor) to OrigLeftChild and OrigParent.
+    //
+    //                           Parent,
+    //              OrigParent   ToRelink             OrigParent
+    //                  |        |                        |
+    //                Node: B    |                      Node: B          Parent
+    //                           v                                          |
+    //           OrigRightChild: E                        C <--- ToRelink   |
+    //                 / \                               / \                v
+    // OrigLeftChild: A   F              OrigLeftChild: A   OrigRightChild: E
+    //                    ^                                         /
+    //                    |                                        D <--- Child
+    //                  Child
+    //
+    ToRelink->Left = OrigLeftChild;
+    OrigLeftChild->Parent = ToRelink;
+
+    //
+    // Node's color must be preserved in Node's original place.
+    //
+    ColorOfUnlinked = ToRelink->Color;
+    ToRelink->Color = Node->Color;
+
+    //
+    // Finish linking Node's unlinked successor into Node's place.
+    //
+    //                           Parent,
+    //                Node: B    ToRelink               Node: B
+    //                           |
+    //              OrigParent   |                    OrigParent         Parent
+    //                  |        v                        |                 |
+    //           OrigRightChild: E                        C <--- ToRelink   |
+    //                 / \                               / \                v
+    // OrigLeftChild: A   F              OrigLeftChild: A   OrigRightChild: E
+    //                    ^                                         /
+    //                    |                                        D <--- Child
+    //                  Child
+    //
+    ToRelink->Parent = OrigParent;
+    if (OrigParent == NULL) {
+      NewRoot = ToRelink;
+    } else {
+      if (Node == OrigParent->Left) {
+        OrigParent->Left = ToRelink;
+      } else {
+        OrigParent->Right = ToRelink;
+      }
+    }
+  }
+
+  FreePool (Node);
+
+  //
+  // If the node that we unlinked from its original spot (ie. Node itself, or
+  // Node's successor), was red, then we broke neither property #3 nor property
+  // #4: we didn't create any red-red edge between Child and Parent, and we
+  // didn't change the black count on any path.
+  //
+  if (ColorOfUnlinked == RedBlackTreeBlack) {
+    //
+    // However, if the unlinked node was black, then we have to transfer its
+    // "black-increment" to its unique child (pointed-to by Child), lest we
+    // break property #4 for its ancestors.
+    //
+    // If Child is red, we can simply color it black. If Child is black
+    // already, we can't technically transfer a black-increment to it, due to
+    // property #1.
+    //
+    // In the following loop we ascend searching for a red node to color black,
+    // or until we reach the root (in which case we can drop the
+    // black-increment). Inside the loop body, Child has a black value of 2,
+    // transitorily breaking property #1 locally, but maintaining property #4
+    // globally.
+    //
+    // Rotations in the loop preserve property #4.
+    //
+    while (Child != NewRoot && NodeIsNullOrBlack (Child)) {
+      RED_BLACK_TREE_NODE *Sibling;
+      RED_BLACK_TREE_NODE *LeftNephew;
+      RED_BLACK_TREE_NODE *RightNephew;
+
+      if (Child == Parent->Left) {
+        Sibling = Parent->Right;
+        //
+        // Sibling can never be NULL (ie. a leaf).
+        //
+        // If Sibling was NULL, then the black count on the path from Parent to
+        // Sibling would equal Parent's black value, plus 1 (due to property
+        // #2). Whereas the black count on the path from Parent to any leaf via
+        // Child would be at least Parent's black value, plus 2 (due to Child's
+        // black value of 2). This would clash with property #4.
+        //
+        // (Sibling can be black of course, but it has to be an internal node.
+        // Internality allows Sibling to have children, bumping the black
+        // counts of paths that go through it.)
+        //
+        ASSERT (Sibling != NULL);
+        if (Sibling->Color == RedBlackTreeRed) {
+          //
+          // Sibling's red color implies its children (if any), node C and node
+          // E, are black (property #3). It also implies that Parent is black.
+          //
+          //           grandparent                                 grandparent
+          //                |                                           |
+          //            Parent,b:B                                     b:D
+          //           /          \                                   /   \_
+          // Child,2b:A            Sibling,r:D  --->        Parent,r:B     b:E
+          //                           /\                       /\_
+          //                        b:C  b:E          Child,2b:A  Sibling,b:C
+          //
+          Sibling->Color = RedBlackTreeBlack;
+          Parent->Color = RedBlackTreeRed;
+          RedBlackTreeRotateLeft (Parent, &NewRoot);
+          Sibling = Parent->Right;
+          //
+          // Same reasoning as above.
+          //
+          ASSERT (Sibling != NULL);
+        }
+
+        //
+        // Sibling is black, and not NULL. (Ie. Sibling is a black internal
+        // node.)
+        //
+        ASSERT (Sibling->Color == RedBlackTreeBlack);
+        LeftNephew = Sibling->Left;
+        RightNephew = Sibling->Right;
+        if (NodeIsNullOrBlack (LeftNephew) &&
+            NodeIsNullOrBlack (RightNephew)) {
+          //
+          // In this case we can "steal" one black value from Child and Sibling
+          // each, and pass it to Parent. "Stealing" means that Sibling (black
+          // value 1) becomes red, Child (black value 2) becomes singly-black,
+          // and Parent will have to be examined if it can eat the
+          // black-increment.
+          //
+          // Sibling is allowed to become red because both of its children are
+          // black (property #3).
+          //
+          //           grandparent                             Parent
+          //                |                                     |
+          //            Parent,x:B                            Child,x:B
+          //           /          \                          /         \_
+          // Child,2b:A            Sibling,b:D    --->    b:A           r:D
+          //                           /\                                /\_
+          //             LeftNephew,b:C  RightNephew,b:E              b:C  b:E
+          //
+          Sibling->Color = RedBlackTreeRed;
+          Child = Parent;
+          Parent = Parent->Parent;
+          //
+          // Continue ascending.
+          //
+        } else {
+          //
+          // At least one nephew is red.
+          //
+          if (NodeIsNullOrBlack (RightNephew)) {
+            //
+            // Since the right nephew is black, the left nephew is red. Due to
+            // property #3, LeftNephew has two black children, hence node E is
+            // black.
+            //
+            // Together with the rotation, this enables us to color node F red
+            // (because property #3 will be satisfied). We flip node D to black
+            // to maintain property #4.
+            //
+            //      grandparent                         grandparent
+            //           |                                   |
+            //       Parent,x:B                          Parent,x:B
+            //           /\                                  /\_
+            // Child,2b:A  Sibling,b:F     --->    Child,2b:A  Sibling,b:D
+            //                  /\                            /   \_
+            //    LeftNephew,r:D  RightNephew,b:G          b:C  RightNephew,r:F
+            //               /\                                       /\_
+            //            b:C  b:E                                 b:E  b:G
+            //
+            LeftNephew->Color = RedBlackTreeBlack;
+            Sibling->Color = RedBlackTreeRed;
+            RedBlackTreeRotateRight (Sibling, &NewRoot);
+            Sibling = Parent->Right;
+            RightNephew = Sibling->Right;
+            //
+            // These operations ensure that...
+            //
+          }
+          //
+          // ... RightNephew is definitely red here, plus Sibling is (still)
+          // black and non-NULL.
+          //
+          ASSERT (RightNephew != NULL);
+          ASSERT (RightNephew->Color == RedBlackTreeRed);
+          ASSERT (Sibling != NULL);
+          ASSERT (Sibling->Color == RedBlackTreeBlack);
+          //
+          // In this case we can flush the extra black-increment immediately,
+          // restoring property #1 for Child (node A): we color RightNephew
+          // (node E) from red to black.
+          //
+          // In order to maintain property #4, we exchange colors between
+          // Parent and Sibling (nodes B and D), and rotate left around Parent
+          // (node B). The transformation doesn't change the black count
+          // increase incurred by each partial path, eg.
+          // - ascending from node A: 2 + x     == 1 + 1 + x
+          // - ascending from node C: y + 1 + x == y + 1 + x
+          // - ascending from node E: 0 + 1 + x == 1 + x
+          //
+          // The color exchange is valid, because even if x stands for red,
+          // both children of node D are black after the transformation
+          // (preserving property #3).
+          //
+          //           grandparent                                  grandparent
+          //                |                                            |
+          //            Parent,x:B                                      x:D
+          //           /          \                                    /   \_
+          // Child,2b:A            Sibling,b:D              --->    b:B     b:E
+          //                         /     \                       /   \_
+          //                      y:C       RightNephew,r:E     b:A     y:C
+          //
+          //
+          Sibling->Color = Parent->Color;
+          Parent->Color = RedBlackTreeBlack;
+          RightNephew->Color = RedBlackTreeBlack;
+          RedBlackTreeRotateLeft (Parent, &NewRoot);
+          Child = NewRoot;
+          //
+          // This terminates the loop.
+          //
+        }
+      } else {
+        //
+        // Mirrors the other branch.
+        //
+        Sibling = Parent->Left;
+        ASSERT (Sibling != NULL);
+        if (Sibling->Color == RedBlackTreeRed) {
+          Sibling->Color = RedBlackTreeBlack;
+          Parent->Color = RedBlackTreeRed;
+          RedBlackTreeRotateRight (Parent, &NewRoot);
+          Sibling = Parent->Left;
+          ASSERT (Sibling != NULL);
+        }
+
+        ASSERT (Sibling->Color == RedBlackTreeBlack);
+        RightNephew = Sibling->Right;
+        LeftNephew = Sibling->Left;
+        if (NodeIsNullOrBlack (RightNephew) &&
+            NodeIsNullOrBlack (LeftNephew)) {
+          Sibling->Color = RedBlackTreeRed;
+          Child = Parent;
+          Parent = Parent->Parent;
+        } else {
+          if (NodeIsNullOrBlack (LeftNephew)) {
+            RightNephew->Color = RedBlackTreeBlack;
+            Sibling->Color = RedBlackTreeRed;
+            RedBlackTreeRotateLeft (Sibling, &NewRoot);
+            Sibling = Parent->Left;
+            LeftNephew = Sibling->Left;
+          }
+          ASSERT (LeftNephew != NULL);
+          ASSERT (LeftNephew->Color == RedBlackTreeRed);
+          ASSERT (Sibling != NULL);
+          ASSERT (Sibling->Color == RedBlackTreeBlack);
+          Sibling->Color = Parent->Color;
+          Parent->Color = RedBlackTreeBlack;
+          LeftNephew->Color = RedBlackTreeBlack;
+          RedBlackTreeRotateRight (Parent, &NewRoot);
+          Child = NewRoot;
+        }
+      }
+    }
+
+    if (Child != NULL) {
+      Child->Color = RedBlackTreeBlack;
+    }
+  }
+
+  Tree->Root = NewRoot;
+
+  if (FeaturePcdGet (PcdValidateOrderedCollection)) {
+    RedBlackTreeValidate (Tree);
+  }
+}
+
+
+/**
+  Recursively check the red-black tree properties #1 to #4 on a node.
+
+  @param[in] Node  The root of the subtree to validate.
+
+  @retval  The black-height of Node's parent.
+**/
+UINT32
+RedBlackTreeRecursiveCheck (
+  IN CONST RED_BLACK_TREE_NODE *Node
+  )
+{
+  UINT32 LeftHeight;
+  UINT32 RightHeight;
+
+  //
+  // property #2
+  //
+  if (Node == NULL) {
+    return 1;
+  }
+
+  //
+  // property #1
+  //
+  ASSERT (Node->Color == RedBlackTreeRed || Node->Color == RedBlackTreeBlack);
+
+  //
+  // property #3
+  //
+  if (Node->Color == RedBlackTreeRed) {
+    ASSERT (NodeIsNullOrBlack (Node->Left));
+    ASSERT (NodeIsNullOrBlack (Node->Right));
+  }
+
+  //
+  // property #4
+  //
+  LeftHeight = RedBlackTreeRecursiveCheck (Node->Left);
+  RightHeight = RedBlackTreeRecursiveCheck (Node->Right);
+  ASSERT (LeftHeight == RightHeight);
+
+  return (Node->Color == RedBlackTreeBlack) + LeftHeight;
+}
+
+
+/**
+  A slow function that asserts that the tree is a valid red-black tree, and
+  that it orders user structures correctly.
+
+  Read-only operation.
+
+  This function uses the stack for recursion and is not recommended for
+  "production use".
+
+  @param[in] Tree  The tree to validate.
+**/
+VOID
+RedBlackTreeValidate (
+  IN CONST RED_BLACK_TREE *Tree
+  )
+{
+  UINT32                    BlackHeight;
+  UINT32                    ForwardCount;
+  UINT32                    BackwardCount;
+  CONST RED_BLACK_TREE_NODE *Last;
+  CONST RED_BLACK_TREE_NODE *Node;
+
+  DEBUG ((DEBUG_VERBOSE, "%a: Tree=%p\n", __FUNCTION__, Tree));
+
+  //
+  // property #5
+  //
+  ASSERT (NodeIsNullOrBlack (Tree->Root));
+
+  //
+  // check the other properties
+  //
+  BlackHeight = RedBlackTreeRecursiveCheck (Tree->Root) - 1;
+
+  //
+  // forward ordering
+  //
+  Last = OrderedCollectionMin (Tree);
+  ForwardCount = (Last != NULL);
+  for (Node = OrderedCollectionNext (Last); Node != NULL;
+       Node = OrderedCollectionNext (Last)) {
+    ASSERT (Tree->UserStructCompare (Last->UserStruct, Node->UserStruct) < 0);
+    Last = Node;
+    ++ForwardCount;
+  }
+
+  //
+  // backward ordering
+  //
+  Last = OrderedCollectionMax (Tree);
+  BackwardCount = (Last != NULL);
+  for (Node = OrderedCollectionPrev (Last); Node != NULL;
+       Node = OrderedCollectionPrev (Last)) {
+    ASSERT (Tree->UserStructCompare (Last->UserStruct, Node->UserStruct) > 0);
+    Last = Node;
+    ++BackwardCount;
+  }
+
+  ASSERT (ForwardCount == BackwardCount);
+
+  DEBUG ((DEBUG_VERBOSE, "%a: Tree=%p BlackHeight=%Ld Count=%Ld\n",
+    __FUNCTION__, Tree, (INT64)BlackHeight, (INT64)ForwardCount));
+}
diff --git a/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.inf b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.inf
new file mode 100644
index 000000000000..7a3c29191cbb
--- /dev/null
+++ b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.inf
@@ -0,0 +1,50 @@
+## @file
+#  An OrderedCollectionLib instance that provides a red-black tree
+#  implementation, and allocates and releases tree nodes with
+#  MemoryAllocationLib.
+#
+#  This library instance is useful when a fast associative container is needed.
+#  Worst case time complexity is O(log n) for Find(), Next(), Prev(), Min(),
+#  Max(), Insert(), and Delete(), where "n" is the number of elements in the
+#  tree. Complete ordered traversal takes O(n) time.
+#
+#  The implementation is also useful as a fast priority queue.
+#
+#  Copyright (C) 2014, Red Hat, Inc.
+#
+#  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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseOrderedCollectionRedBlackTreeLib
+  MODULE_UNI_FILE                = BaseOrderedCollectionRedBlackTreeLib.uni
+  FILE_GUID                      = 699F73C3-0058-484C-A9E5-61189276A985
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = OrderedCollectionLib
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseOrderedCollectionRedBlackTreeLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  MemoryAllocationLib
+
+[FeaturePcd]
+  gEfiMdePkgTokenSpaceGuid.PcdValidateOrderedCollection ## CONSUMES
diff --git a/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.uni b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.uni
new file mode 100644
index 000000000000..1cce72784305
--- /dev/null
+++ b/MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.uni
@@ -0,0 +1,31 @@
+// /** @file
+// An OrderedCollectionLib instance that provides a red-black tree
+//
+// implementation, and allocates and releases tree nodes with
+// MemoryAllocationLib.
+// 
+// This library instance is useful when a fast associative container is needed.
+// Worst case time complexity is O(log n) for Find(), Next(), Prev(), Min(),
+// Max(), Insert(), and Delete(), where "n" is the number of elements in the
+// tree. Complete ordered traversal takes O(n) time.
+// 
+// The implementation is also useful as a fast priority queue.
+//
+// Copyright (C) 2014, Red Hat, Inc.
+//
+// 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "An OrderedCollectionLib instance that provides a red-black tree implementation."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "An OrderedCollectionLib instance that provides a red-black tree implementation."
+
diff --git a/MdePkg/Library/BasePalLibNull/BasePalLibNull.inf b/MdePkg/Library/BasePalLibNull/BasePalLibNull.inf
new file mode 100644
index 000000000000..57d2937d8dec
--- /dev/null
+++ b/MdePkg/Library/BasePalLibNull/BasePalLibNull.inf
@@ -0,0 +1,40 @@
+## @file
+#  Null instance of PAL Library with empty functions.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePalLibNull
+  MODULE_UNI_FILE                = BasePalLibNull.uni
+  FILE_GUID                      = 632D5625-B73D-43b8-AF30-8D225D96168E
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PalLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  PalCall.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/BasePalLibNull/BasePalLibNull.uni b/MdePkg/Library/BasePalLibNull/BasePalLibNull.uni
new file mode 100644
index 000000000000..9a0a2e208f6d
--- /dev/null
+++ b/MdePkg/Library/BasePalLibNull/BasePalLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Null instance of PAL Library with empty functions.
+//
+// Null instance of PAL Library with empty functions.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Null instance of PAL Library with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Null instance of PAL Library with empty functions."
+
diff --git a/MdePkg/Library/BasePalLibNull/PalCall.c b/MdePkg/Library/BasePalLibNull/PalCall.c
new file mode 100644
index 000000000000..c9ab3d28fb52
--- /dev/null
+++ b/MdePkg/Library/BasePalLibNull/PalCall.c
@@ -0,0 +1,59 @@
+/** @file
+  
+  Template and Sample instance of PalCallLib.
+  
+  Copyright (c) 2006 - 2010, 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 <Base.h>
+#include <Library/PalLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param Index  The PAL procedure Index number.
+  @param Arg2   The 2nd parameter for PAL procedure calls.
+  @param Arg3   The 3rd parameter for PAL procedure calls.
+  @param Arg4   The 4th parameter for PAL procedure calls.
+
+  @return The structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  )
+{
+  PAL_CALL_RETURN Ret;
+
+  Ret.Status = (UINT64) -1;
+  ASSERT (!RETURN_ERROR (RETURN_UNSUPPORTED));
+  return Ret;
+}
diff --git a/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf b/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
new file mode 100644
index 000000000000..b9717b1d3be5
--- /dev/null
+++ b/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
@@ -0,0 +1,42 @@
+## @file
+#  Instance of PCD Library without support of dynamic PCD entries.
+#
+#  PCD Library that only provides access to Feature Flag, Fixed At Build,
+#  and Binary Patch typed PCD entries. Access to Dynamic PCD entries is ignored.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePcdLibNull
+  MODULE_UNI_FILE                = BasePcdLibNull.uni
+  FILE_GUID                      = 40096a3a-5c2a-4fbc-aef7-5475dd7ab334
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PcdLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PcdLib.c
+
+[LibraryClasses]
+  DebugLib
+  BaseMemoryLib
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.uni b/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.uni
new file mode 100644
index 000000000000..a51c8bd72c68
--- /dev/null
+++ b/MdePkg/Library/BasePcdLibNull/BasePcdLibNull.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PCD Library without support of dynamic PCD entries.
+//
+// PCD Library that only provides access to Feature Flag, Fixed At Build,
+// and Binary Patch typed PCD entries. Access to Dynamic PCD entries is ignored.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCD Library without support of dynamic PCD entries"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCD Library that only provides access to Feature Flag, Fixed At Build, and Binary Patch typed PCD entries. Access to Dynamic PCD entries is ignored."
+
diff --git a/MdePkg/Library/BasePcdLibNull/PcdLib.c b/MdePkg/Library/BasePcdLibNull/PcdLib.c
new file mode 100644
index 000000000000..44180d70887b
--- /dev/null
+++ b/MdePkg/Library/BasePcdLibNull/PcdLib.c
@@ -0,0 +1,1480 @@
+/** @file
+  A emptry template implementation of PCD Library.
+
+  Copyright (c) 2006 - 2016, 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 <Base.h>
+
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseMemoryLib.h>
+
+
+/**
+  This function provides a means by which SKU support can be established in the PCD infrastructure.
+
+  Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
+
+  @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and 
+                    set values associated with a PCD token.
+
+  @return Return the SKU ID that just be set.
+
+**/
+UINTN
+EFIAPI
+LibPcdSetSku (
+  IN UINTN   SkuId
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 8-bit value for the token specified by TokenNumber. 
+
+**/
+UINT8
+EFIAPI
+LibPcdGet8 (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 16-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 16-bit value for the token specified by TokenNumber. 
+
+**/
+UINT16
+EFIAPI
+LibPcdGet16 (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 32-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 32-bit value for the token specified by TokenNumber.
+
+**/
+UINT32
+EFIAPI
+LibPcdGet32 (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 64-bit value for the token specified by TokenNumber.
+
+**/
+UINT64
+EFIAPI
+LibPcdGet64 (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the pointer to the token specified by TokenNumber.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetPtr (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the Boolean value of the token specified by TokenNumber. 
+
+**/
+BOOLEAN 
+EFIAPI
+LibPcdGetBool (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the size of the token specified by TokenNumber. 
+
+**/
+UINTN
+EFIAPI
+LibPcdGetSize (
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid The pointer to a 128-bit unique value that designates 
+              which namespace to retrieve a value from.
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Return the UINT8.
+
+**/
+UINT8
+EFIAPI
+LibPcdGetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+
+  Returns the 16-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid The pointer to a 128-bit unique value that designates 
+              which namespace to retrieve a value from.
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Return the UINT16.
+
+**/
+UINT16
+EFIAPI
+LibPcdGetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  Returns the 32-bit value for the token specified by TokenNumber and Guid.
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid The pointer to a 128-bit unique value that designates 
+              which namespace to retrieve a value from.
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Return the UINT32.
+
+**/
+UINT32
+EFIAPI
+LibPcdGetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the UINT64.
+
+**/
+UINT64
+EFIAPI
+LibPcdGetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the VOID* pointer.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetExPtr (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the BOOLEAN.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdGetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+  
+  Returns the size of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the size.
+
+**/
+UINTN
+EFIAPI
+LibPcdGetExSize (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSet8 (
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSet16 (
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSet32 (
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSet64 (
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value 
+  specified by Buffer and SizeOfBuffer.  Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size support by TokenNumber, 
+  then set SizeOfBuffer to the maximum size supported by TokenNumber and 
+  return NULL to indicate that the set operation was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 
+  maximum size supported by TokenName and NULL must be returned.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return Return the pointer for the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetPtr (
+  IN        UINTN             TokenNumber,
+  IN OUT    UINTN             *SizeOfBuffer,
+  IN CONST  VOID              *Buffer
+  )
+{
+  ASSERT (FALSE);
+
+  return NULL;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetBool (
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  ASSERT (FALSE);
+
+  return FALSE;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value specified by 
+  Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size 
+  supported by TokenNumber and return NULL to indicate that the set operation 
+  was not actually performed.
+  
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]  Guid              The pointer to a 128-bit unique value that 
+                                designates which namespace to set a value from.
+  @param[in]  TokenNumber       The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]  Buffer            A pointer to the buffer to set.
+
+  @return Return the pinter to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetExPtr (
+  IN      CONST GUID        *Guid,
+  IN      UINTN             TokenNumber,
+  IN OUT  UINTN             *SizeOfBuffer,
+  IN      VOID              *Buffer
+  )
+{
+  ASSERT (FALSE);
+
+  return NULL;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The Boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  ASSERT (FALSE);
+
+  return FALSE;
+}
+#endif
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet8S (
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet16S (
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet32S (
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet64S (
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
+  maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned.
+
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetPtrS (
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetBoolS (
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx8S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx16S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx32S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx64S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified by
+  Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      Guid          Pointer to a 128-bit unique value that
+                                designates which namespace to set a value from.
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExPtrS (
+  IN CONST GUID     *Guid,
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN       VOID     *Buffer
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExBoolS (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  ASSERT (FALSE);
+
+  return RETURN_INVALID_PARAMETER;
+}
+
+/**
+  Set up a notification function that is called when a specified token is set.
+  
+  When the token specified by TokenNumber and Guid is set, 
+  then notification function specified by NotificationFunction is called.  
+  If Guid is NULL, then the default token space is used. 
+  
+  If NotificationFunction is NULL, then ASSERT().
+
+  @param[in]  Guid      The pointer to a 128-bit unique value that designates which 
+                        namespace to set a value from.  If NULL, then the default 
+                        token space is used.
+  @param[in]  TokenNumber   The PCD token number to monitor.
+  @param[in]  NotificationFunction  The function to call when the token 
+                                    specified by Guid and TokenNumber is set.
+
+**/
+VOID
+EFIAPI
+LibPcdCallbackOnSet (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  ASSERT (FALSE);
+}
+
+
+
+/**
+  Disable a notification function that was established with LibPcdCallbackonSet().
+  
+  Disable a notification function that was previously established with LibPcdCallbackOnSet(). 
+  
+  If NotificationFunction is NULL, then ASSERT().
+  If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber, 
+  and NotificationFunction, then ASSERT().
+  
+  @param[in]  Guid          Specify the GUID token space.
+  @param[in]  TokenNumber   Specify the token number.
+  @param[in]  NotificationFunction The callback function to be unregistered.
+
+**/
+VOID
+EFIAPI
+LibPcdCancelCallback (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  ASSERT (FALSE);
+}
+
+
+
+/**
+  Retrieves the next token in a token space.
+  
+  Retrieves the next PCD token number from the token space specified by Guid.  
+  If Guid is NULL, then the default token space is used.  If TokenNumber is 0, 
+  then the first token number is returned.  Otherwise, the token number that 
+  follows TokenNumber in the token space is returned.  If TokenNumber is the last 
+  token number in the token space, then 0 is returned.  
+  
+  If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]  Guid        The pointer to a 128-bit unique value that designates which namespace 
+                          to set a value from.  If NULL, then the default token space is used.
+  @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD 
+                          token number.
+
+  @return The next valid token number.
+
+**/
+UINTN           
+EFIAPI
+LibPcdGetNextToken (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
+
+
+/**
+  Used to retrieve the list of available PCD token space GUIDs.
+  
+  Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
+  in the platform.
+  If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
+  If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
+  
+  @param  TokenSpaceGuid  The pointer to a PCD token space GUID.
+
+  @return The next valid token namespace.
+
+**/
+GUID *           
+EFIAPI
+LibPcdGetNextTokenSpace (
+  IN CONST GUID  *TokenSpaceGuid
+  )
+{
+  ASSERT (FALSE);
+
+  return NULL;
+}
+
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer that was set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtr (
+  OUT       VOID        *PatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrS (
+  OUT      VOID     *PatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtrAndSize (
+  OUT       VOID        *PatchVariable,
+  OUT       UINTN       *SizeOfPatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrAndSizeS (
+  OUT      VOID     *PatchVariable,
+  OUT      UINTN    *SizeOfPatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the default token space specified, then ASSERT().
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfo (
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfoEx (
+  IN CONST  GUID            *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+UINTN
+EFIAPI
+LibPcdGetSku (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+
+  return 0;
+}
+
diff --git a/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf b/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf
new file mode 100644
index 000000000000..51015b49c28b
--- /dev/null
+++ b/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf
@@ -0,0 +1,42 @@
+## @file
+#  Instance of PCI CF8 Library using I/O ports 0xCF8 and 0xCFC.
+#
+#  PCI CF8 Library that uses I/O ports 0xCF8 and 0xCFC to perform PCI Configuration cycles.
+#  Layers on top of an I/O Library instance.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePciCf8Lib
+  MODULE_UNI_FILE                = BasePciCf8Lib.uni
+  FILE_GUID                      = 472ab06d-9810-4c00-bb7f-dad1828fc1ab
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciCf8Lib 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciCf8Lib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+  IoLib
+
diff --git a/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.uni b/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.uni
new file mode 100644
index 000000000000..6e44ffd97821
--- /dev/null
+++ b/MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PCI CF8 Library using I/O ports 0xCF8 and 0xCFC.
+//
+// PCI CF8 Library that uses I/O ports 0xCF8 and 0xCFC to perform PCI Configuration cycles.
+// Layers on top of an I/O Library instance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCI CF8 Library using I/O ports 0xCF8 and 0xCFC"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCI CF8 Library that uses I/O ports 0xCF8 and 0xCFC to perform PCI Configuration cycles. Layers on top of an I/O Library instance."
+
diff --git a/MdePkg/Library/BasePciCf8Lib/PciCf8Lib.c b/MdePkg/Library/BasePciCf8Lib/PciCf8Lib.c
new file mode 100644
index 000000000000..1ed37697234e
--- /dev/null
+++ b/MdePkg/Library/BasePciCf8Lib/PciCf8Lib.c
@@ -0,0 +1,1784 @@
+/** @file
+  PCI CF8 Library functions that use I/O ports 0xCF8 and 0xCFC to perform PCI Configuration cycles.
+  Layers on top of an I/O Library instance.
+
+  Copyright (c) 2006 - 2012, 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 <Base.h>
+
+#include <Library/BaseLib.h>
+#include <Library/PciCf8Lib.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+
+//
+// Declare I/O Ports used to perform PCI Confguration Cycles
+//
+#define PCI_CONFIGURATION_ADDRESS_PORT  0xCF8
+#define PCI_CONFIGURATION_DATA_PORT     0xCFC
+
+/**
+  Convert a PCI Library address to PCI CF8 formatted address.
+
+  Declare macro to convert PCI Library address to PCI CF8 formatted address.
+  Bit fields of PCI Library and CF8 formatted address is as follows:
+  PCI Library formatted address    CF8 Formatted Address
+ =============================    ======================
+    Bits 00..11  Register           Bits 00..07  Register
+    Bits 12..14  Function           Bits 08..10  Function
+    Bits 15..19  Device             Bits 11..15  Device
+    Bits 20..27  Bus                Bits 16..23  Bus
+    Bits 28..31  Reserved(MBZ)      Bits 24..30  Reserved(MBZ)
+                                    Bits 31..31  Must be 1
+
+  @param  A The address to convert.
+
+  @retval The coverted address.
+
+**/
+#define PCI_TO_CF8_ADDRESS(A) \
+  ((UINT32) ((((A) >> 4) & 0x00ffff00) | ((A) & 0xfc) | 0x80000000))
+
+/**
+  Assert the validity of a PCI CF8 address. A valid PCI CF8 address should contain 1's
+  only in the low 28 bits, excluding bits 08..11.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A,M) \
+  ASSERT (((A) & (~0xffff0ff | (M))) == 0)
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciCf8RegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  return RETURN_SUCCESS;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Read8 (
+  IN      UINTN                     Address
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoRead8 (PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3));
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Write8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoWrite8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8Or8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoOr8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8And8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAnd8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8AndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAndThenOr8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             AndData,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldRead8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             StartBit,
+             EndBit
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldWrite8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             StartBit,
+             EndBit,
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldOr8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             StartBit,
+             EndBit,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAnd8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             StartBit,
+             EndBit,
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciCf8BitFieldAndThenOr8(
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT8    Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAndThenOr8 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 3),
+             StartBit,
+             EndBit,
+             AndData,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Read16 (
+  IN      UINTN                     Address
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoRead16 (PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2));
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Write16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoWrite16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8Or16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoOr16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8And16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAnd16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8AndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAndThenOr16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             AndData,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldRead16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             StartBit,
+             EndBit
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldWrite16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             StartBit,
+             EndBit,
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldOr16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             StartBit,
+             EndBit,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAnd16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             StartBit,
+             EndBit,
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciCf8BitFieldAndThenOr16(
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT16   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAndThenOr16 (
+             PCI_CONFIGURATION_DATA_PORT + (UINT16)(Address & 2),
+             StartBit,
+             EndBit,
+             AndData,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Read32 (
+  IN      UINTN                     Address
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoRead32 (PCI_CONFIGURATION_DATA_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Write32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoWrite32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8Or32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoOr32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8And32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAnd32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8AndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoAndThenOr32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             AndData,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldRead32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             StartBit,
+             EndBit
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldWrite32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             StartBit,
+             EndBit,
+             Value
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldOr32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             StartBit,
+             EndBit,
+             OrData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAnd32 (
+             PCI_CONFIGURATION_DATA_PORT,
+             StartBit,
+             EndBit,
+             AndData
+             );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If the register specified by Address >= 0x100, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciCf8BitFieldAndThenOr32(
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  BOOLEAN  InterruptState;
+  UINT32   AddressPort;
+  UINT32   Result;
+  
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+  InterruptState = SaveAndDisableInterrupts ();
+  AddressPort = IoRead32 (PCI_CONFIGURATION_ADDRESS_PORT);
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, PCI_TO_CF8_ADDRESS (Address));
+  Result = IoBitFieldAndThenOr32 (
+               PCI_CONFIGURATION_DATA_PORT,
+               StartBit,
+               EndBit,
+               AndData,
+               OrData
+               );
+  IoWrite32 (PCI_CONFIGURATION_ADDRESS_PORT, AddressPort);
+  SetInterruptState (InterruptState);
+  return Result;
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If the register specified by StartAddress >= 0x100, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x100, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size read from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciCf8ReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN   ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x100);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciCf8Read8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 ((UINT16 *)Buffer, (UINT16) PciCf8Read16 (StartAddress));
+
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 ((UINT32 *)Buffer, (UINT32) PciCf8Read32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 ((UINT16 *)Buffer, (UINT16) PciCf8Read16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciCf8Read8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If the register specified by StartAddress >= 0x100, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x100, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciCf8WriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN   ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x100);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciCf8Write8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciCf8Write16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciCf8Write32 (StartAddress, ReadUnaligned32 ((UINT32*)Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciCf8Write16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciCf8Write8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.inf b/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.inf
new file mode 100644
index 000000000000..ae5b7245784f
--- /dev/null
+++ b/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.inf
@@ -0,0 +1,46 @@
+## @file
+#  Instance of PCI Express Library using the 256 MB PCI Express MMIO window.
+#
+#  PCI Express Library that uses the 256 MB PCI Express MMIO window to perform
+#  PCI Configuration cycles. Layers on top of an I/O Library instance.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePciExpressLib
+  MODULE_UNI_FILE                = BasePciExpressLib.uni
+  FILE_GUID                      = 287e50f4-a188-4699-b907-3e4080ca5688
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciExpressLib 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciExpressLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  PcdLib
+  DebugLib
+  IoLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress  ## CONSUMES
+
diff --git a/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.uni b/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.uni
new file mode 100644
index 000000000000..b04bd0e17194
--- /dev/null
+++ b/MdePkg/Library/BasePciExpressLib/BasePciExpressLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PCI Express Library using the 256 MB PCI Express MMIO window.
+//
+// PCI Express Library that uses the 256 MB PCI Express MMIO window to perform
+// PCI Configuration cycles. Layers on top of an I/O Library instance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCI Express Library using the 256 MB PCI Express MMIO window"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCI Express Library that uses the 256 MB PCI Express MMIO window to perform PCI Configuration cycles. Layers on top of an I/O Library instance."
+
diff --git a/MdePkg/Library/BasePciExpressLib/PciExpressLib.c b/MdePkg/Library/BasePciExpressLib/PciExpressLib.c
new file mode 100644
index 000000000000..33ef5aa78905
--- /dev/null
+++ b/MdePkg/Library/BasePciExpressLib/PciExpressLib.c
@@ -0,0 +1,1419 @@
+/** @file
+  Functions in this library instance make use of MMIO functions in IoLib to
+  access memory mapped PCI configuration space.
+
+  All assertions for I/O operations are handled in MMIO functions in the IoLib
+  Library.
+
+  Copyright (c) 2006 - 2012, 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 <Base.h>
+
+#include <Library/BaseLib.h>
+#include <Library/PciExpressLib.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+
+/**
+  Assert the validity of a PCI address. A valid PCI address should contain 1's
+  only in the low 28 bits.
+
+  @param  A The address to validate.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A) \
+  ASSERT (((A) & ~0xfffffff) == 0)
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration 
+  registers associated with that PCI device may be accessed after SetVirtualAddressMap() 
+  is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciExpressRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Gets the base address of PCI Express.
+  
+  This internal functions retrieves PCI Express Base Address via a PCD entry
+  PcdPciExpressBaseAddress.
+  
+  @return The base address of PCI Express.
+
+**/
+VOID*
+GetPciExpressBaseAddress (
+  VOID
+  )
+{
+  return (VOID*)(UINTN) PcdGet64 (PcdPciExpressBaseAddress);
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressRead8 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioRead8 ((UINTN) GetPciExpressBaseAddress () + Address);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioWrite8 ((UINTN) GetPciExpressBaseAddress () + Address, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioOr8 ((UINTN) GetPciExpressBaseAddress () + Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAnd8 ((UINTN) GetPciExpressBaseAddress () + Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAndThenOr8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldRead8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldWrite8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldOr8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAnd8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAndThenOr8 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressRead16 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioRead16 ((UINTN) GetPciExpressBaseAddress () + Address);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioWrite16 ((UINTN) GetPciExpressBaseAddress () + Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioOr16 ((UINTN) GetPciExpressBaseAddress () + Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAnd16 ((UINTN) GetPciExpressBaseAddress () + Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAndThenOr16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldRead16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldWrite16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldOr16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAnd16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAndThenOr16 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressRead32 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioRead32 ((UINTN) GetPciExpressBaseAddress () + Address);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioWrite32 ((UINTN) GetPciExpressBaseAddress () + Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioOr32 ((UINTN) GetPciExpressBaseAddress () + Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAnd32 ((UINTN) GetPciExpressBaseAddress () + Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioAndThenOr32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldRead32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldWrite32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldOr32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAnd32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address);
+  return MmioBitFieldAndThenOr32 (
+           (UINTN) GetPciExpressBaseAddress () + Address,
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size read data from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN   ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 ((UINT32 *) Buffer, (UINT32) PciExpressRead32 (StartAddress));
+
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciExpressWrite32 (StartAddress, ReadUnaligned32 ((UINT32*)Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf b/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf
new file mode 100644
index 000000000000..517f97364220
--- /dev/null
+++ b/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf
@@ -0,0 +1,40 @@
+## @file
+#  Instance of PCI Library based on PCI CF8 Library.
+#
+#  PCI Library that uses I/O ports 0xCF8 and 0xCFC to perform
+#  PCI Configuration cycles. Layers on top of one PCI CF8 Library instance.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePciLibCf8
+  MODULE_UNI_FILE                = BasePciLibCf8.uni
+  FILE_GUID                      = 28bde99c-e8a7-4e3e-9a8a-e66cd64f31c6
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PciCf8Lib
+
diff --git a/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.uni b/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.uni
new file mode 100644
index 000000000000..1f1e5fd65c34
--- /dev/null
+++ b/MdePkg/Library/BasePciLibCf8/BasePciLibCf8.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PCI Library based on PCI CF8 Library.
+//
+// PCI Library that uses I/O ports 0xCF8 and 0xCFC to perform
+// PCI Configuration cycles. Layers on top of one PCI CF8 Library instance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCI Library based on PCI CF8 Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCI Library that uses I/O ports 0xCF8 and 0xCFC to perform PCI Configuration cycles. Layers on top of one PCI CF8 Library instance."
+
diff --git a/MdePkg/Library/BasePciLibCf8/PciLib.c b/MdePkg/Library/BasePciLibCf8/PciLib.c
new file mode 100644
index 000000000000..077b7653ba49
--- /dev/null
+++ b/MdePkg/Library/BasePciLibCf8/PciLib.c
@@ -0,0 +1,1138 @@
+/** @file
+  PCI Library functions that use I/O ports 0xCF8 and 0xCFC to perform
+  PCI Configuration cycles. Layers on top of one PCI CF8 Library instance.
+
+  Copyright (c) 2006 - 2012, 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 <Base.h>
+
+#include <Library/PciLib.h>
+#include <Library/PciCf8Lib.h>
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  return PciCf8RegisterForRuntimeAccess (Address);
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return PciCf8Read8 (Address);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return PciCf8Write8 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciCf8Or8 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciCf8And8 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciCf8AndThenOr8 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciCf8BitFieldRead8 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciCf8BitFieldWrite8 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciCf8BitFieldOr8 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciCf8BitFieldAnd8 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciCf8BitFieldAndThenOr8 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  return PciCf8Read16 (Address);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  return PciCf8Write16 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciCf8Or16 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciCf8And16 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciCf8AndThenOr16 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciCf8BitFieldRead16 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciCf8BitFieldWrite16 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciCf8BitFieldOr16 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciCf8BitFieldAnd16 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciCf8BitFieldAndThenOr16 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  return PciCf8Read32 (Address);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  return PciCf8Write32 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciCf8Or32 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciCf8And32 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciCf8AndThenOr32 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciCf8BitFieldRead32 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciCf8BitFieldWrite32 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciCf8BitFieldOr32 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciCf8BitFieldAnd32 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciCf8BitFieldAndThenOr32 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  return PciCf8ReadBuffer (StartAddress, Size, Buffer);
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  return PciCf8WriteBuffer (StartAddress, Size, Buffer);
+}
diff --git a/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.inf b/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.inf
new file mode 100644
index 000000000000..1c8c9d91cff3
--- /dev/null
+++ b/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.inf
@@ -0,0 +1,41 @@
+## @file
+#  Instance of PCI Library based on PCI Express Library.
+#
+#  PCI Library that uses the 256 MB PCI Express MMIO window to perform PCI
+#  Configuration cycles. Layers on one PCI Express Library instance.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePciLibPciExpress
+  MODULE_UNI_FILE                = BasePciLibPciExpress.uni
+  FILE_GUID                      = 8987081e-daeb-44a9-8bef-a195b22d9417
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources]
+  PciLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PciExpressLib
+
diff --git a/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.uni b/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.uni
new file mode 100644
index 000000000000..a8116046dfca
--- /dev/null
+++ b/MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PCI Library based on PCI Express Library.
+//
+// PCI Library that uses the 256 MB PCI Express MMIO window to perform PCI
+// Configuration cycles. Layers on one PCI Express Library instance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCI Library based on PCI Express Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCI Library that uses the 256 MB PCI Express MMIO window to perform PCI Configuration cycles. Layers on an PCI Express Library instance."
+
diff --git a/MdePkg/Library/BasePciLibPciExpress/PciLib.c b/MdePkg/Library/BasePciLibPciExpress/PciLib.c
new file mode 100644
index 000000000000..a5eec2ba8a60
--- /dev/null
+++ b/MdePkg/Library/BasePciLibPciExpress/PciLib.c
@@ -0,0 +1,1138 @@
+/** @file
+  PCI Library functions that use the 256 MB PCI Express MMIO window to perform PCI
+  Configuration cycles. Layers on PCI Express Library.
+
+  Copyright (c) 2006 - 2012, 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 <Base.h>
+
+#include <Library/PciLib.h>
+#include <Library/PciExpressLib.h>
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  return PciExpressRegisterForRuntimeAccess (Address);
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return PciExpressRead8 (Address);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return PciExpressWrite8 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciExpressOr8 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciExpressAnd8 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciExpressAndThenOr8 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciExpressBitFieldRead8 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciExpressBitFieldWrite8 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciExpressBitFieldOr8 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciExpressBitFieldAnd8 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciExpressBitFieldAndThenOr8 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  return PciExpressRead16 (Address);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  return PciExpressWrite16 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciExpressOr16 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciExpressAnd16 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciExpressAndThenOr16 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciExpressBitFieldRead16 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciExpressBitFieldWrite16 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciExpressBitFieldOr16 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciExpressBitFieldAnd16 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciExpressBitFieldAndThenOr16 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  return PciExpressRead32 (Address);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  return PciExpressWrite32 (Address, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciExpressOr32 (Address, OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciExpressAnd32 (Address, AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciExpressAndThenOr32 (Address, AndData, OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return PciExpressBitFieldRead32 (Address, StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciExpressBitFieldWrite32 (Address, StartBit, EndBit, Value);
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciExpressBitFieldOr32 (Address, StartBit, EndBit, OrData);
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciExpressBitFieldAnd32 (Address, StartBit, EndBit, AndData);
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciExpressBitFieldAndThenOr32 (Address, StartBit, EndBit, AndData, OrData);
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  return PciExpressReadBuffer (StartAddress, Size, Buffer);
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  return PciExpressWriteBuffer (StartAddress, Size, Buffer);
+}
diff --git a/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.inf b/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.inf
new file mode 100644
index 000000000000..3374272c245f
--- /dev/null
+++ b/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.inf
@@ -0,0 +1,43 @@
+## @file
+# Instance of PCI Segment Library based on PCI Library.
+#
+# PCI Segment Library that layers on top of the PCI Library which only
+#  supports segment 0 PCI configuration access.
+#
+# Copyright (c) 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePciSegmentLibPci
+  MODULE_UNI_FILE                = BasePciSegmentLibPci.uni
+  FILE_GUID                      = AABF95D6-F40C-405F-8360-6A59794B8040
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciSegmentLib
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciSegmentLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  PciLib
+  DebugLib
diff --git a/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.uni b/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.uni
new file mode 100644
index 000000000000..b6d4ef69b269
--- /dev/null
+++ b/MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of PCI Segment Library based on PCI Library.
+//
+// PCI Segment Library that layers on top of the PCI Library which only
+//  supports segment 0 PCI configuration access.
+//
+// Copyright (c) 2016, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PCI Segment Library based on PCI Library."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PCI Segment Library that layers on top of the PCI Library which only supports segment 0 PCI configuration access."
diff --git a/MdePkg/Library/BasePciSegmentLibPci/PciSegmentLib.c b/MdePkg/Library/BasePciSegmentLibPci/PciSegmentLib.c
new file mode 100644
index 000000000000..69cfef136c3d
--- /dev/null
+++ b/MdePkg/Library/BasePciSegmentLibPci/PciSegmentLib.c
@@ -0,0 +1,1286 @@
+/** @file
+  PCI Segment Library that layers on top of the PCI Library which only
+   supports segment 0 PCI configuration access.
+
+  Copyright (c) 2016, 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 <Base.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PciLib.h>
+#include <Library/PciSegmentLib.h>
+
+/**
+  Assert the validity of a PCI Segment address.
+  A valid PCI Segment address should not contain 1's in bits 28..31 and 48..63
+  and the segment should be 0.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_SEGMENT_ADDRESS(A,M) \
+  ASSERT (((A) & (0xfffffffff0000000ULL | (M))) == 0)
+
+/**
+  Convert the PCI Segment library address to PCI library address.
+
+  @param A The address to convert.
+**/
+#define PCI_SEGMENT_TO_PCI_ADDRESS(A) ((UINTN) (UINT32) A)
+
+/**
+  Register a PCI device so PCI configuration registers may be accessed after
+  SetVirtualAddressMap().
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciSegmentRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+  return PciRegisterForRuntimeAccess (PCI_SEGMENT_TO_PCI_ADDRESS (Address));
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 8-bit PCI configuration register specified by Address.
+
+**/
+UINT8
+EFIAPI
+PciSegmentRead8 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return PciRead8 (PCI_SEGMENT_TO_PCI_ADDRESS (Address));
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentWrite8 (
+  IN UINT64                    Address,
+  IN UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return PciWrite8 (PCI_SEGMENT_TO_PCI_ADDRESS (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     OrData
+  )
+{
+  return PciWrite8 (PCI_SEGMENT_TO_PCI_ADDRESS (Address), (UINT8) (PciSegmentRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAnd8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value,
+  followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) ((PciSegmentRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldRead8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciSegmentRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldWrite8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     Value
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldWrite8 (PciSegmentRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldOr8 (PciSegmentRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAnd8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAnd8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 16-bit PCI configuration register specified by Address.
+
+**/
+UINT16
+EFIAPI
+PciSegmentRead16 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return PciRead16 (PCI_SEGMENT_TO_PCI_ADDRESS (Address));
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+PciSegmentWrite16 (
+  IN UINT64                    Address,
+  IN UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return PciWrite16 (PCI_SEGMENT_TO_PCI_ADDRESS (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAnd16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value,
+  followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) ((PciSegmentRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldRead16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciSegmentRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldWrite16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    Value
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldWrite16 (PciSegmentRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldOr16 (PciSegmentRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR,
+  and writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    The ordinal of the least significant bit in a byte is bit 0.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    The ordinal of the most significant bit in a byte is bit 7.
+  @param  AndData   The value to AND with the read value from the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAnd16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAnd16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 32-bit PCI configuration register specified by Address.
+
+**/
+UINT32
+EFIAPI
+PciSegmentRead32 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return PciRead32 (PCI_SEGMENT_TO_PCI_ADDRESS (Address));
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT32
+EFIAPI
+PciSegmentWrite32 (
+  IN UINT64                    Address,
+  IN UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return PciWrite32 (PCI_SEGMENT_TO_PCI_ADDRESS (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAnd32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value,
+  followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, (PciSegmentRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldRead32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciSegmentRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldWrite32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    Value
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldWrite32 (PciSegmentRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldOr32 (PciSegmentRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a bitwise
+  AND between the read result and the value specified by AndData, and writes the result
+  to the 32-bit PCI configuration register specified by Address. The value written to
+  the PCI configuration register is returned.  This function must guarantee that all PCI
+  read and write operations are serialized.  Extra left bits in AndData are stripped.
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAnd32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAnd32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentReadBuffer (
+  IN  UINT64                   StartAddress,
+  IN  UINTN                    Size,
+  OUT VOID                     *Buffer
+  )
+{
+  UINTN                                ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciSegmentRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return The parameter of Size.
+
+**/
+UINTN
+EFIAPI
+PciSegmentWriteBuffer (
+  IN UINT64                    StartAddress,
+  IN UINTN                     Size,
+  IN VOID                      *Buffer
+  )
+{
+  UINTN                                ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*) Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*) Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*) Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciSegmentWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*) Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*) Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*) Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf b/MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
new file mode 100644
index 000000000000..6a4cb3b46bb5
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
@@ -0,0 +1,38 @@
+## @file
+#  Null PE/Coff Extra Action library instances with empty functions.
+#
+#  Copyright (c) 2009 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeCoffExtraActionLibNull
+  MODULE_UNI_FILE                = PeCoffExtraActionLibNull.uni
+  FILE_GUID                      = 0EB84DA1-267A-40b4-8347-1F48694C8B47
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeCoffExtraActionLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PeCoffExtraActionLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLib.c b/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLib.c
new file mode 100644
index 000000000000..db778bbd644d
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLib.c
@@ -0,0 +1,54 @@
+/** @file
+  Null PE/Coff Extra Action library instances with empty functions.
+
+  Copyright (c) 2009, 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 <Base.h>
+#include <Library/PeCoffExtraActionLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Performs additional actions after a PE/COFF image has been loaded and relocated.
+
+  If ImageContext is NULL, then ASSERT().
+
+  @param  ImageContext  The pointer to the image context structure that describes the
+                        PE/COFF image that has already been loaded and relocated.
+
+**/
+VOID
+EFIAPI
+PeCoffLoaderRelocateImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  ASSERT (ImageContext != NULL);
+}  
+
+/**
+  Performs additional actions just before a PE/COFF image is unloaded.  Any resources
+  that were allocated by PeCoffLoaderRelocateImageExtraAction() must be freed.
+  
+  If ImageContext is NULL, then ASSERT().
+  
+  @param  ImageContext  The pointer to the image context structure that describes the
+                        PE/COFF image that is being unloaded.
+
+**/
+VOID
+EFIAPI
+PeCoffLoaderUnloadImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  ASSERT (ImageContext != NULL);
+}
diff --git a/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLibNull.uni b/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLibNull.uni
new file mode 100644
index 000000000000..27af386f71aa
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffExtraActionLibNull/PeCoffExtraActionLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Null PE/Coff Extra Action library instances with empty functions.
+//
+// Null PE/Coff Extra Action library instances with empty functions.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Null PE/Coff Extra Action library instances with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Null PE/Coff Extra Action library instances with empty functions."
+
diff --git a/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf b/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
new file mode 100644
index 000000000000..42037b86fbc3
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
@@ -0,0 +1,40 @@
+## @file
+#  PE/COFF Entry Point Library implementation.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePeCoffGetEntryPointLib
+  MODULE_UNI_FILE                = BasePeCoffGetEntryPointLib.uni
+  FILE_GUID                      = be490364-73d2-420d-950e-f6450ca75dfb
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeCoffGetEntryPointLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PeCoffGetEntryPoint.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.uni b/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.uni
new file mode 100644
index 000000000000..a94dac83fa1e
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// PE/COFF Entry Point Library implementation.
+//
+// PE/COFF Entry Point Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PE/COFF Entry Point Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PE/COFF Entry Point Library implementation."
+
diff --git a/MdePkg/Library/BasePeCoffGetEntryPointLib/PeCoffGetEntryPoint.c b/MdePkg/Library/BasePeCoffGetEntryPointLib/PeCoffGetEntryPoint.c
new file mode 100644
index 000000000000..8ebcf0d7d3f3
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffGetEntryPointLib/PeCoffGetEntryPoint.c
@@ -0,0 +1,318 @@
+/** @file
+  Provides the services to get the entry point to a PE/COFF image that has either been 
+  loaded into memory or is executing at it's linked address.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 <Base.h>
+
+#include <Library/PeCoffGetEntryPointLib.h>
+#include <Library/DebugLib.h>
+
+#include <IndustryStandard/PeImage.h>
+
+/**
+  Retrieves and returns a pointer to the entry point to a PE/COFF image that has been loaded
+  into system memory with the PE/COFF Loader Library functions.
+
+  Retrieves the entry point to the PE/COFF image specified by Pe32Data and returns this entry
+  point in EntryPoint.  If the entry point could not be retrieved from the PE/COFF image, then
+  return RETURN_INVALID_PARAMETER.  Otherwise return RETURN_SUCCESS.
+  If Pe32Data is NULL, then ASSERT().
+  If EntryPoint is NULL, then ASSERT().
+
+  @param  Pe32Data                  The pointer to the PE/COFF image that is loaded in system memory.
+  @param  EntryPoint                The pointer to entry point to the PE/COFF image to return.
+
+  @retval RETURN_SUCCESS            EntryPoint was returned.
+  @retval RETURN_INVALID_PARAMETER  The entry point could not be found in the PE/COFF image.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderGetEntryPoint (
+  IN  VOID  *Pe32Data,
+  OUT VOID  **EntryPoint
+  )
+{
+  EFI_IMAGE_DOS_HEADER                  *DosHdr;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+
+  ASSERT (Pe32Data   != NULL);
+  ASSERT (EntryPoint != NULL);
+
+  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // DOS image header is present, so read the PE header after the DOS image header.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
+  } else {
+    //
+    // DOS image header is not present, so PE header is at the image base.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
+  }
+
+  //
+  // Calculate the entry point relative to the start of the image.
+  // AddressOfEntryPoint is common for PE32 & PE32+
+  //
+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
+    *EntryPoint = (VOID *)((UINTN)Pe32Data + (UINTN)(Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof(EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize);
+    return RETURN_SUCCESS;
+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
+    *EntryPoint = (VOID *)((UINTN)Pe32Data + (UINTN)(Hdr.Pe32->OptionalHeader.AddressOfEntryPoint & 0x0ffffffff));
+    return RETURN_SUCCESS;
+  }
+
+  return RETURN_UNSUPPORTED;
+}
+
+
+/**
+  Returns the machine type of a PE/COFF image.
+
+  Returns the machine type from the PE/COFF image specified by Pe32Data.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return Machine type or zero if not a valid image.
+
+**/
+UINT16
+EFIAPI
+PeCoffLoaderGetMachineType (
+  IN VOID  *Pe32Data
+  )
+{
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;
+  EFI_IMAGE_DOS_HEADER                 *DosHdr;
+
+  ASSERT (Pe32Data != NULL);
+
+  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // DOS image header is present, so read the PE header after the DOS image header.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
+  } else {
+    //
+    // DOS image header is not present, so PE header is at the image base.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
+  }
+
+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
+    return Hdr.Te->Machine;
+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE)  {
+    return Hdr.Pe32->FileHeader.Machine;
+  }
+
+  return 0x0000;
+}
+
+/**
+  Returns a pointer to the PDB file name for a PE/COFF image that has been
+  loaded into system memory with the PE/COFF Loader Library functions. 
+
+  Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If
+  the PE/COFF image specified by Pe32Data is not a valid, then NULL is
+  returned.  If the PE/COFF image specified by Pe32Data does not contain a
+  debug directory entry, then NULL is returned.  If the debug directory entry
+  in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
+  then NULL is returned.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL
+          if it cannot be retrieved.
+
+**/
+VOID *
+EFIAPI
+PeCoffLoaderGetPdbPointer (
+  IN VOID  *Pe32Data
+  )
+{
+  EFI_IMAGE_DOS_HEADER                  *DosHdr;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;
+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;
+  UINTN                                 DirCount;
+  VOID                                  *CodeViewEntryPointer;
+  INTN                                  TEImageAdjust;
+  UINT32                                NumberOfRvaAndSizes;
+  UINT16                                Magic;
+
+  ASSERT (Pe32Data   != NULL);
+
+  TEImageAdjust       = 0;
+  DirectoryEntry      = NULL;
+  DebugEntry          = NULL;
+  NumberOfRvaAndSizes = 0;
+
+  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // DOS image header is present, so read the PE header after the DOS image header.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
+  } else {
+    //
+    // DOS image header is not present, so PE header is at the image base.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
+  }
+
+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
+    if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {
+      DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];
+      TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;
+      DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +
+                    Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +
+                    TEImageAdjust);
+    }
+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
+    //
+    // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.
+    //       It is due to backward-compatibility, for some system might
+    //       generate PE32+ image with PE32 Magic.
+    //
+    switch (Hdr.Pe32->FileHeader.Machine) {
+    case IMAGE_FILE_MACHINE_I386:
+      //
+      // Assume PE32 image with IA32 Machine field.
+      //
+      Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
+      break;
+    case IMAGE_FILE_MACHINE_X64:
+    case IMAGE_FILE_MACHINE_IA64:
+      //
+      // Assume PE32+ image with x64 or IA64 Machine field
+      //
+      Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+      break;
+    default:
+      //
+      // For unknow Machine field, use Magic in optional Header
+      //
+      Magic = Hdr.Pe32->OptionalHeader.Magic;
+    }
+
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset get Debug Directory Entry
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
+      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
+    } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
+      //
+      // Use PE32+ offset get Debug Directory Entry
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
+      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
+    }
+
+    if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
+      DirectoryEntry = NULL;
+      DebugEntry = NULL;
+    }
+  } else {
+    return NULL;
+  }
+
+  if (DebugEntry == NULL || DirectoryEntry == NULL) {
+    return NULL;
+  }
+
+  //
+  // Scan the directory to find the debug entry.
+  // 
+  for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {
+    if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
+      if (DebugEntry->SizeOfData > 0) {
+        CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);
+        switch (* (UINT32 *) CodeViewEntryPointer) {
+        case CODEVIEW_SIGNATURE_NB10:
+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));
+        case CODEVIEW_SIGNATURE_RSDS:
+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));
+        case CODEVIEW_SIGNATURE_MTOC:
+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));
+        default:
+          break;
+        }
+      }
+    }
+  }
+
+  return NULL;
+}
+
+/**
+  Returns the size of the PE/COFF headers
+
+  Returns the size of the PE/COFF header specified by Pe32Data.
+  If Pe32Data is NULL, then ASSERT().
+
+  @param  Pe32Data   The pointer to the PE/COFF image that is loaded in system
+                     memory.
+
+  @return Size of PE/COFF header in bytes or zero if not a valid image.
+
+**/
+UINT32
+EFIAPI
+PeCoffGetSizeOfHeaders (
+  IN VOID     *Pe32Data
+  )
+{
+  EFI_IMAGE_DOS_HEADER                  *DosHdr;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+  UINTN                                 SizeOfHeaders;
+
+  ASSERT (Pe32Data   != NULL);
+ 
+  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // DOS image header is present, so read the PE header after the DOS image header.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
+  } else {
+    //
+    // DOS image header is not present, so PE header is at the image base.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
+  }
+
+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
+    SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;
+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
+    SizeOfHeaders = Hdr.Pe32->OptionalHeader.SizeOfHeaders;
+  } else {
+    SizeOfHeaders = 0;
+  }
+
+  return (UINT32) SizeOfHeaders;
+}
+
diff --git a/MdePkg/Library/BasePeCoffLib/Arm/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/Arm/PeCoffLoaderEx.c
new file mode 100644
index 000000000000..75e89fc10572
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/Arm/PeCoffLoaderEx.c
@@ -0,0 +1,250 @@
+/** @file
+  Specific relocation fixups for ARM architecture.
+
+  Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2010, Apple Inc. 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 "BasePeCoffLibInternals.h"
+#include <Library/BaseLib.h>
+
+
+/**
+  Pass in a pointer to an ARM MOVT or MOVW immediate instruciton and 
+  return the immediate data encoded in the instruction.
+
+  @param  Instruction   Pointer to ARM MOVT or MOVW immediate instruction
+
+  @return Immediate address encoded in the instruction
+
+**/
+UINT16
+ThumbMovtImmediateAddress (
+  IN UINT16 *Instruction
+  )
+{
+  UINT32  Movt;
+  UINT16  Address;
+  
+  // Thumb2 is two 16-bit instructions working together. Not a single 32-bit instruction
+  // Example MOVT R0, #0 is 0x0000f2c0 or 0xf2c0 0x0000
+  Movt = (*Instruction << 16) | (*(Instruction + 1)); 
+
+  // imm16 = imm4:i:imm3:imm8
+  //         imm4 -> Bit19:Bit16
+  //         i    -> Bit26
+  //         imm3 -> Bit14:Bit12
+  //         imm8 -> Bit7:Bit0
+  Address  = (UINT16)(Movt & 0x000000ff);         // imm8
+  Address |= (UINT16)((Movt >> 4) &  0x0000f700); // imm4 imm3
+  Address |= (((Movt & BIT26) != 0) ? BIT11 : 0); // i
+  return Address;
+}
+
+
+/**
+  Update an ARM MOVT or MOVW immediate instruction immediate data.
+
+  @param  Instruction   Pointer to ARM MOVT or MOVW immediate instruction
+  @param  Address       New addres to patch into the instruction
+**/
+VOID
+ThumbMovtImmediatePatch (
+  IN OUT UINT16 *Instruction,
+  IN     UINT16 Address
+  )
+{
+  UINT16  Patch;
+
+  // First 16-bit chunk of instruciton
+  Patch  = ((Address >> 12) & 0x000f);            // imm4 
+  Patch |= (((Address & BIT11) != 0) ? BIT10 : 0); // i
+  // Mask out instruction bits and or in address
+  *(Instruction) = (*Instruction & ~0x040f) | Patch;
+
+  // Second 16-bit chunk of instruction
+  Patch  =  Address & 0x000000ff;          // imm8
+  Patch |=  ((Address << 4) & 0x00007000); // imm3
+  // Mask out instruction bits and or in address
+  Instruction++;
+  *Instruction = (*Instruction & ~0x70ff) | Patch;
+}
+
+
+
+/**
+  Pass in a pointer to an ARM MOVW/MOVT instruciton pair and 
+  return the immediate data encoded in the two` instruction.
+
+  @param  Instructions  Pointer to ARM MOVW/MOVT insturction pair
+
+  @return Immediate address encoded in the instructions
+
+**/
+UINT32
+ThumbMovwMovtImmediateAddress (
+  IN UINT16 *Instructions
+  )
+{
+  UINT16  *Word;
+  UINT16  *Top;
+  
+  Word = Instructions;  // MOVW
+  Top  = Word + 2;      // MOVT
+  
+  return (ThumbMovtImmediateAddress (Top) << 16) + ThumbMovtImmediateAddress (Word);
+}
+
+
+/**
+  Update an ARM MOVW/MOVT immediate instruction instruction pair.
+
+  @param  Instructions  Pointer to ARM MOVW/MOVT instruction pair
+  @param  Address       New addres to patch into the instructions
+**/
+VOID
+ThumbMovwMovtImmediatePatch (
+  IN OUT UINT16 *Instructions,
+  IN     UINT32 Address
+  )
+{
+  UINT16  *Word;
+  UINT16  *Top;
+  
+  Word = Instructions;  // MOVW
+  Top  = Word + 2;      // MOVT
+
+  ThumbMovtImmediatePatch (Word, (UINT16)(Address & 0xffff));
+  ThumbMovtImmediatePatch (Top, (UINT16)(Address >> 16));
+}
+  
+  
+
+/**
+  Performs an ARM-based specific relocation fixup and is a no-op on other
+  instruction sets.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeCoffLoaderRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  UINT16      *Fixup16;
+  UINT32      FixupVal;
+
+  Fixup16   = (UINT16 *) Fixup;
+
+  switch ((*Reloc) >> 12) {
+  
+  case EFI_IMAGE_REL_BASED_ARM_MOV32T:
+    FixupVal = ThumbMovwMovtImmediateAddress (Fixup16) + (UINT32)Adjust;
+    ThumbMovwMovtImmediatePatch (Fixup16, FixupVal);
+
+    if (*FixupData != NULL) {
+      *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));
+      // Fixup16 is not aligned so we must copy it. Thumb instructions are streams of 16 bytes. 
+      CopyMem (*FixupData, Fixup16, sizeof (UINT64));
+      *FixupData = *FixupData + sizeof(UINT64);
+    }
+    break;
+  
+  case EFI_IMAGE_REL_BASED_ARM_MOV32A:
+     ASSERT (FALSE);
+     // break omitted - ARM instruction encoding not implemented
+  default:
+    return RETURN_UNSUPPORTED;
+  }
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Returns TRUE if the machine type of PE/COFF image is supported. Supported
+  does not mean the image can be executed it means the PE/COFF loader supports
+  loading and relocating of the image type. It's up to the caller to support
+  the entry point.
+  
+  @param  Machine   Machine type from the PE Header.
+
+  @return TRUE if this PE/COFF loader can load the image
+
+**/
+BOOLEAN
+PeCoffLoaderImageFormatSupported (
+  IN  UINT16  Machine
+  )
+{
+  if ((Machine == IMAGE_FILE_MACHINE_ARMTHUMB_MIXED) || (Machine ==  IMAGE_FILE_MACHINE_EBC)) {
+    return TRUE; 
+  }
+
+  return FALSE;
+}
+
+/**
+  Performs an ARM-based specific re-relocation fixup and is a no-op on other
+  instruction sets. This is used to re-relocated the image into the EFI virtual
+  space for runtime calls.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeHotRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  UINT16  *Fixup16;
+  UINT32  FixupVal;
+
+  Fixup16 = (UINT16 *)Fixup;
+
+  switch ((*Reloc) >> 12) {
+
+  case EFI_IMAGE_REL_BASED_ARM_MOV32T:
+    *FixupData  = ALIGN_POINTER (*FixupData, sizeof (UINT64));
+    if (*(UINT64 *) (*FixupData) == ReadUnaligned64 ((UINT64 *)Fixup16)) {
+      FixupVal = ThumbMovwMovtImmediateAddress (Fixup16) + (UINT32)Adjust;
+      ThumbMovwMovtImmediatePatch (Fixup16, FixupVal);
+    }
+    *FixupData = *FixupData + sizeof(UINT64);
+    break;
+  
+  case EFI_IMAGE_REL_BASED_ARM_MOV32A:
+    ASSERT (FALSE);
+    // break omitted - ARM instruction encoding not implemented
+  default:
+    DEBUG ((EFI_D_ERROR, "PeHotRelocateEx:unknown fixed type\n"));
+    return RETURN_UNSUPPORTED;
+  }
+  
+  return RETURN_SUCCESS;
+}
+
diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoff.c b/MdePkg/Library/BasePeCoffLib/BasePeCoff.c
new file mode 100644
index 000000000000..82e78737a958
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoff.c
@@ -0,0 +1,1957 @@
+/** @file
+  Base PE/COFF loader supports loading any PE32/PE32+ or TE image, but
+  only supports relocating IA32, x64, IPF, and EBC images.
+
+  Caution: This file requires additional review when modified.
+  This library will have external input - PE/COFF image.
+  This external input must be validated carefully to avoid security issue like
+  buffer overflow, integer overflow.
+
+  The basic guideline is that caller need provide ImageContext->ImageRead () with the
+  necessary data range check, to make sure when this library reads PE/COFF image, the
+  PE image buffer is always in valid range.
+  This library will also do some additional check for PE header fields.
+
+  PeCoffLoaderGetPeHeader() routine will do basic check for PE/COFF header.
+  PeCoffLoaderGetImageInfo() routine will do basic check for whole PE/COFF image.
+
+  Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BasePeCoffLibInternals.h"
+
+/**
+  Adjust some fields in section header for TE image.
+
+  @param  SectionHeader             Pointer to the section header.
+  @param  TeStrippedOffset          Size adjust for the TE image.
+
+**/
+VOID
+PeCoffLoaderAdjustOffsetForTeImage (
+  EFI_IMAGE_SECTION_HEADER              *SectionHeader,
+  UINT32                                TeStrippedOffset
+  )
+{
+  SectionHeader->VirtualAddress   -= TeStrippedOffset;
+  SectionHeader->PointerToRawData -= TeStrippedOffset;
+}
+
+/**
+  Retrieves the magic value from the PE/COFF header.
+
+  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.
+
+  @return EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC - Image is PE32
+  @return EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC - Image is PE32+
+
+**/
+UINT16
+PeCoffLoaderGetPeHeaderMagicValue (
+  IN  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr
+  )
+{
+  //
+  // NOTE: Some versions of Linux ELILO for Itanium have an incorrect magic value 
+  //       in the PE/COFF Header.  If the MachineType is Itanium(IA64) and the 
+  //       Magic value in the OptionalHeader is  EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC
+  //       then override the returned value to EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC
+  //
+  if (Hdr.Pe32->FileHeader.Machine == IMAGE_FILE_MACHINE_IA64 && Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+    return EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+  }
+  //
+  // Return the magic value from the PC/COFF Optional Header
+  //
+  return Hdr.Pe32->OptionalHeader.Magic;
+}
+
+
+/**
+  Retrieves the PE or TE Header from a PE/COFF or TE image. 
+
+  Caution: This function may receive untrusted input.
+  PE/COFF image is external input, so this routine will 
+  also done many checks in PE image to make sure PE image DosHeader, PeOptionHeader, 
+  SizeOfHeader, Section Data Region and Security Data Region be in PE image range. 
+
+  @param  ImageContext    The context of the image being loaded.
+  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.
+
+  @retval RETURN_SUCCESS  The PE or TE Header is read.
+  @retval Other           The error status from reading the PE/COFF or TE image using the ImageRead function.
+
+**/
+RETURN_STATUS
+PeCoffLoaderGetPeHeader (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext,
+  OUT    EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr
+  )
+{
+  RETURN_STATUS         Status;
+  EFI_IMAGE_DOS_HEADER  DosHdr;
+  UINTN                 Size;
+  UINTN                 ReadSize;
+  UINT16                Magic;
+  UINT32                SectionHeaderOffset;
+  UINT32                Index;
+  UINT32                HeaderWithoutDataDir;
+  CHAR8                 BufferData;
+  UINTN                 NumberOfSections;
+  EFI_IMAGE_SECTION_HEADER  SectionHeader;
+
+  //
+  // Read the DOS image header to check for its existence
+  //
+  Size = sizeof (EFI_IMAGE_DOS_HEADER);
+  ReadSize = Size;
+  Status = ImageContext->ImageRead (
+                           ImageContext->Handle,
+                           0,
+                           &Size,
+                           &DosHdr
+                           );
+  if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+    if (Size != ReadSize) {
+      Status = RETURN_UNSUPPORTED;
+    }
+    return Status;
+  }
+
+  ImageContext->PeCoffHeaderOffset = 0;
+  if (DosHdr.e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // DOS image header is present, so read the PE header after the DOS image
+    // header
+    //
+    ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew;
+  }
+
+  //
+  // Read the PE/COFF Header. For PE32 (32-bit) this will read in too much
+  // data, but that should not hurt anything. Hdr.Pe32->OptionalHeader.Magic
+  // determines if this is a PE32 or PE32+ image. The magic is in the same
+  // location in both images.
+  //
+  Size = sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION);
+  ReadSize = Size;
+  Status = ImageContext->ImageRead (
+                           ImageContext->Handle,
+                           ImageContext->PeCoffHeaderOffset,
+                           &Size,
+                           Hdr.Pe32
+                           );
+  if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+    if (Size != ReadSize) {
+      Status = RETURN_UNSUPPORTED;
+    }
+    return Status;
+  }
+
+  //
+  // Use Signature to figure out if we understand the image format
+  //
+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
+    ImageContext->IsTeImage         = TRUE;
+    ImageContext->Machine           = Hdr.Te->Machine;
+    ImageContext->ImageType         = (UINT16)(Hdr.Te->Subsystem);
+    //
+    // For TeImage, SectionAlignment is undefined to be set to Zero
+    // ImageSize can be calculated.
+    //
+    ImageContext->ImageSize         = 0;
+    ImageContext->SectionAlignment  = 0;
+    ImageContext->SizeOfHeaders     = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;
+
+    //
+    // Check the StrippedSize.
+    //
+    if (sizeof (EFI_TE_IMAGE_HEADER) >= (UINT32)Hdr.Te->StrippedSize) {
+      ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+      return RETURN_UNSUPPORTED;
+    }
+
+    //
+    // Check the SizeOfHeaders field.
+    //
+    if (Hdr.Te->BaseOfCode <= Hdr.Te->StrippedSize) {
+      ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+      return RETURN_UNSUPPORTED;
+    }
+
+    //
+    // Read last byte of Hdr.Te->SizeOfHeaders from the file.
+    //
+    Size = 1;
+    ReadSize = Size;
+    Status = ImageContext->ImageRead (
+                             ImageContext->Handle,
+                             ImageContext->SizeOfHeaders - 1,
+                             &Size,
+                             &BufferData
+                             );
+    if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+      ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+      if (Size != ReadSize) {
+        Status = RETURN_UNSUPPORTED;
+      }
+      return Status;
+    }
+
+    //
+    // TE Image Data Directory Entry size is non-zero, but the Data Directory Virtual Address is zero.
+    // This case is not a valid TE image. 
+    //
+    if ((Hdr.Te->DataDirectory[0].Size != 0 && Hdr.Te->DataDirectory[0].VirtualAddress == 0) ||
+        (Hdr.Te->DataDirectory[1].Size != 0 && Hdr.Te->DataDirectory[1].VirtualAddress == 0)) {
+      ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+      return RETURN_UNSUPPORTED;
+    }
+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE)  {
+    ImageContext->IsTeImage = FALSE;
+    ImageContext->Machine = Hdr.Pe32->FileHeader.Machine;
+
+    Magic = PeCoffLoaderGetPeHeaderMagicValue (Hdr);
+
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // 1. Check OptionalHeader.NumberOfRvaAndSizes filed.
+      //
+      if (EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES < Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // 2. Check the FileHeader.SizeOfOptionalHeader field.
+      // OptionalHeader.NumberOfRvaAndSizes is not bigger than 16, so 
+      // OptionalHeader.NumberOfRvaAndSizes * sizeof (EFI_IMAGE_DATA_DIRECTORY) will not overflow.
+      //
+      HeaderWithoutDataDir = sizeof (EFI_IMAGE_OPTIONAL_HEADER32) - sizeof (EFI_IMAGE_DATA_DIRECTORY) * EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
+      if (((UINT32)Hdr.Pe32->FileHeader.SizeOfOptionalHeader - HeaderWithoutDataDir) !=
+          Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes * sizeof (EFI_IMAGE_DATA_DIRECTORY)) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      SectionHeaderOffset = ImageContext->PeCoffHeaderOffset + sizeof (UINT32) + sizeof (EFI_IMAGE_FILE_HEADER) + Hdr.Pe32->FileHeader.SizeOfOptionalHeader;
+      //
+      // 3. Check the FileHeader.NumberOfSections field.
+      //
+      if (Hdr.Pe32->OptionalHeader.SizeOfImage <= SectionHeaderOffset) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if ((Hdr.Pe32->OptionalHeader.SizeOfImage - SectionHeaderOffset) / EFI_IMAGE_SIZEOF_SECTION_HEADER <= Hdr.Pe32->FileHeader.NumberOfSections) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // 4. Check the OptionalHeader.SizeOfHeaders field.
+      //
+      if (Hdr.Pe32->OptionalHeader.SizeOfHeaders <= SectionHeaderOffset) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if (Hdr.Pe32->OptionalHeader.SizeOfHeaders >= Hdr.Pe32->OptionalHeader.SizeOfImage) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if ((Hdr.Pe32->OptionalHeader.SizeOfHeaders - SectionHeaderOffset) / EFI_IMAGE_SIZEOF_SECTION_HEADER < (UINT32)Hdr.Pe32->FileHeader.NumberOfSections) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // 4.2 Read last byte of Hdr.Pe32.OptionalHeader.SizeOfHeaders from the file.
+      //
+      Size = 1;
+      ReadSize = Size;
+      Status = ImageContext->ImageRead (
+                               ImageContext->Handle,
+                               Hdr.Pe32->OptionalHeader.SizeOfHeaders - 1,
+                               &Size,
+                               &BufferData
+                               );
+      if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+        if (Size != ReadSize) {
+          Status = RETURN_UNSUPPORTED;
+        }
+        return Status;
+      }
+
+      //
+      // Check the EFI_IMAGE_DIRECTORY_ENTRY_SECURITY data.
+      // Read the last byte to make sure the data is in the image region.
+      // The DataDirectory array begin with 1, not 0, so here use < to compare not <=.
+      //
+      if (EFI_IMAGE_DIRECTORY_ENTRY_SECURITY < Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes) {
+        if (Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size != 0) {
+          //
+          // Check the member data to avoid overflow.
+          //
+          if ((UINT32) (~0) - Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress <
+              Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size) {
+            ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+            return RETURN_UNSUPPORTED;
+          }
+
+          //
+          // Read last byte of section header from file
+          //
+          Size = 1;
+          ReadSize = Size;
+          Status = ImageContext->ImageRead (
+                                   ImageContext->Handle,
+                                   Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress +
+                                    Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size - 1,
+                                   &Size,
+                                   &BufferData
+                                   );
+          if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+            if (Size != ReadSize) {
+              Status = RETURN_UNSUPPORTED;
+            }
+            return Status;
+          }
+        }
+      }
+
+      //
+      // Use PE32 offset
+      //
+      ImageContext->ImageType         = Hdr.Pe32->OptionalHeader.Subsystem;
+      ImageContext->ImageSize         = (UINT64)Hdr.Pe32->OptionalHeader.SizeOfImage;
+      ImageContext->SectionAlignment  = Hdr.Pe32->OptionalHeader.SectionAlignment;
+      ImageContext->SizeOfHeaders     = Hdr.Pe32->OptionalHeader.SizeOfHeaders;
+
+    } else if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
+      //
+      // 1. Check FileHeader.NumberOfRvaAndSizes filed.
+      //
+      if (EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES < Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      //
+      // 2. Check the FileHeader.SizeOfOptionalHeader field.
+      // OptionalHeader.NumberOfRvaAndSizes is not bigger than 16, so 
+      // OptionalHeader.NumberOfRvaAndSizes * sizeof (EFI_IMAGE_DATA_DIRECTORY) will not overflow.
+      //
+      HeaderWithoutDataDir = sizeof (EFI_IMAGE_OPTIONAL_HEADER64) - sizeof (EFI_IMAGE_DATA_DIRECTORY) * EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
+      if (((UINT32)Hdr.Pe32Plus->FileHeader.SizeOfOptionalHeader - HeaderWithoutDataDir) !=
+          Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes * sizeof (EFI_IMAGE_DATA_DIRECTORY)) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      SectionHeaderOffset = ImageContext->PeCoffHeaderOffset + sizeof (UINT32) + sizeof (EFI_IMAGE_FILE_HEADER) + Hdr.Pe32Plus->FileHeader.SizeOfOptionalHeader;
+      //
+      // 3. Check the FileHeader.NumberOfSections field.
+      //
+      if (Hdr.Pe32Plus->OptionalHeader.SizeOfImage <= SectionHeaderOffset) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if ((Hdr.Pe32Plus->OptionalHeader.SizeOfImage - SectionHeaderOffset) / EFI_IMAGE_SIZEOF_SECTION_HEADER <= Hdr.Pe32Plus->FileHeader.NumberOfSections) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // 4. Check the OptionalHeader.SizeOfHeaders field.
+      //
+      if (Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders <= SectionHeaderOffset) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if (Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders >= Hdr.Pe32Plus->OptionalHeader.SizeOfImage) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+      if ((Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders - SectionHeaderOffset) / EFI_IMAGE_SIZEOF_SECTION_HEADER < (UINT32)Hdr.Pe32Plus->FileHeader.NumberOfSections) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // 4.2 Read last byte of Hdr.Pe32Plus.OptionalHeader.SizeOfHeaders from the file.
+      //
+      Size = 1;
+      ReadSize = Size;
+      Status = ImageContext->ImageRead (
+                               ImageContext->Handle,
+                               Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders - 1,
+                               &Size,
+                               &BufferData
+                               );
+      if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+        if (Size != ReadSize) {
+          Status = RETURN_UNSUPPORTED;
+        }
+        return Status;
+      }
+
+      //
+      // Check the EFI_IMAGE_DIRECTORY_ENTRY_SECURITY data.
+      // Read the last byte to make sure the data is in the image region.
+      // The DataDirectory array begin with 1, not 0, so here use < to compare not <=.
+      //
+      if (EFI_IMAGE_DIRECTORY_ENTRY_SECURITY < Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes) {
+        if (Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size != 0) {
+          //
+          // Check the member data to avoid overflow.
+          //
+          if ((UINT32) (~0) - Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress <
+              Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size) {
+            ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+            return RETURN_UNSUPPORTED;
+          }
+
+          //
+          // Read last byte of section header from file
+          //
+          Size = 1;
+          ReadSize = Size;
+          Status = ImageContext->ImageRead (
+                                   ImageContext->Handle,
+                                   Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress +
+                                    Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size - 1,
+                                   &Size,
+                                   &BufferData
+                                   );
+          if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+            if (Size != ReadSize) {
+              Status = RETURN_UNSUPPORTED;
+            }
+            return Status;
+          }
+        }
+      }
+
+      //
+      // Use PE32+ offset
+      //
+      ImageContext->ImageType         = Hdr.Pe32Plus->OptionalHeader.Subsystem;
+      ImageContext->ImageSize         = (UINT64) Hdr.Pe32Plus->OptionalHeader.SizeOfImage;
+      ImageContext->SectionAlignment  = Hdr.Pe32Plus->OptionalHeader.SectionAlignment;
+      ImageContext->SizeOfHeaders     = Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders;
+    } else {
+      ImageContext->ImageError = IMAGE_ERROR_INVALID_MACHINE_TYPE;
+      return RETURN_UNSUPPORTED;
+    }
+  } else {
+    ImageContext->ImageError = IMAGE_ERROR_INVALID_MACHINE_TYPE;
+    return RETURN_UNSUPPORTED;
+  }
+
+  if (!PeCoffLoaderImageFormatSupported (ImageContext->Machine)) {
+    //
+    // If the PE/COFF loader does not support the image type return
+    // unsupported. This library can support lots of types of images
+    // this does not mean the user of this library can call the entry
+    // point of the image.
+    //
+    return RETURN_UNSUPPORTED;
+  }
+
+  //
+  // Check each section field.
+  //
+  if (ImageContext->IsTeImage) {
+    SectionHeaderOffset = sizeof(EFI_TE_IMAGE_HEADER);
+    NumberOfSections    = (UINTN) (Hdr.Te->NumberOfSections);
+  } else {
+    SectionHeaderOffset = ImageContext->PeCoffHeaderOffset + sizeof (UINT32) + sizeof (EFI_IMAGE_FILE_HEADER) + Hdr.Pe32->FileHeader.SizeOfOptionalHeader;
+    NumberOfSections    = (UINTN) (Hdr.Pe32->FileHeader.NumberOfSections);
+  }
+
+  for (Index = 0; Index < NumberOfSections; Index++) {
+    //
+    // Read section header from file
+    //
+    Size = sizeof (EFI_IMAGE_SECTION_HEADER);
+    ReadSize = Size;
+    Status = ImageContext->ImageRead (
+                             ImageContext->Handle,
+                             SectionHeaderOffset,
+                             &Size,
+                             &SectionHeader
+                             );
+    if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+      ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+      if (Size != ReadSize) {
+        Status = RETURN_UNSUPPORTED;
+      }
+      return Status;
+    }
+
+    //
+    // Adjust some field in Section Header for TE image.
+    //
+    if (ImageContext->IsTeImage) {
+      PeCoffLoaderAdjustOffsetForTeImage (&SectionHeader, (UINT32)Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER));
+    }
+
+    if (SectionHeader.SizeOfRawData > 0) {
+      //
+      // Section data should bigger than the Pe header.
+      //
+      if (SectionHeader.VirtualAddress < ImageContext->SizeOfHeaders || 
+          SectionHeader.PointerToRawData < ImageContext->SizeOfHeaders) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // Check the member data to avoid overflow.
+      //
+      if ((UINT32) (~0) - SectionHeader.PointerToRawData < SectionHeader.SizeOfRawData) {
+        ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+        return RETURN_UNSUPPORTED;
+      }
+
+      //
+      // Base on the ImageRead function to check the section data field.
+      // Read the last byte to make sure the data is in the image region.
+      //
+      Size = 1;
+      ReadSize = Size;
+      Status = ImageContext->ImageRead (
+                               ImageContext->Handle,
+                               SectionHeader.PointerToRawData + SectionHeader.SizeOfRawData - 1,
+                               &Size,
+                               &BufferData
+                               );
+      if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+        if (Size != ReadSize) {
+          Status = RETURN_UNSUPPORTED;
+        }
+        return Status;
+      }
+    }
+
+    //
+    // Check next section.
+    //
+    SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
+  }
+
+  return RETURN_SUCCESS;
+}
+
+
+/**
+  Retrieves information about a PE/COFF image.
+
+  Computes the PeCoffHeaderOffset, IsTeImage, ImageType, ImageAddress, ImageSize, 
+  DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, and 
+  DebugDirectoryEntryRva fields of the ImageContext structure.  
+  If ImageContext is NULL, then return RETURN_INVALID_PARAMETER.  
+  If the PE/COFF image accessed through the ImageRead service in the ImageContext 
+  structure is not a supported PE/COFF image type, then return RETURN_UNSUPPORTED.  
+  If any errors occur while computing the fields of ImageContext, 
+  then the error status is returned in the ImageError field of ImageContext.  
+  If the image is a TE image, then SectionAlignment is set to 0.
+  The ImageRead and Handle fields of ImageContext structure must be valid prior 
+  to invoking this service.
+
+  Caution: This function may receive untrusted input.
+  PE/COFF image is external input, so this routine will 
+  also done many checks in PE image to make sure PE image DosHeader, PeOptionHeader, 
+  SizeOfHeader, Section Data Region and Security Data Region be in PE image range. 
+
+  @param  ImageContext              The pointer to the image context structure that describes the PE/COFF
+                                    image that needs to be examined by this function.
+
+  @retval RETURN_SUCCESS            The information on the PE/COFF image was collected.
+  @retval RETURN_INVALID_PARAMETER  ImageContext is NULL.
+  @retval RETURN_UNSUPPORTED        The PE/COFF image is not supported.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderGetImageInfo (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  RETURN_STATUS                         Status;
+  EFI_IMAGE_OPTIONAL_HEADER_UNION       HdrData;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+  EFI_IMAGE_DATA_DIRECTORY              *DebugDirectoryEntry;
+  UINTN                                 Size;
+  UINTN                                 ReadSize;
+  UINTN                                 Index;
+  UINTN                                 DebugDirectoryEntryRva;
+  UINTN                                 DebugDirectoryEntryFileOffset;
+  UINTN                                 SectionHeaderOffset;
+  EFI_IMAGE_SECTION_HEADER              SectionHeader;
+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       DebugEntry;
+  UINT32                                NumberOfRvaAndSizes;
+  UINT16                                Magic;
+  UINT32                                TeStrippedOffset;
+
+  if (ImageContext == NULL) {
+    return RETURN_INVALID_PARAMETER;
+  }
+  //
+  // Assume success
+  //
+  ImageContext->ImageError  = IMAGE_ERROR_SUCCESS;
+
+  Hdr.Union = &HdrData;
+  Status = PeCoffLoaderGetPeHeader (ImageContext, Hdr);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  Magic = PeCoffLoaderGetPeHeaderMagicValue (Hdr);
+
+  //
+  // Retrieve the base address of the image
+  //
+  if (!(ImageContext->IsTeImage)) {
+    TeStrippedOffset = 0;
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      ImageContext->ImageAddress = Hdr.Pe32->OptionalHeader.ImageBase;
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      ImageContext->ImageAddress = Hdr.Pe32Plus->OptionalHeader.ImageBase;
+    }
+  } else {
+    TeStrippedOffset = (UINT32)Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER);
+    ImageContext->ImageAddress = (PHYSICAL_ADDRESS)(Hdr.Te->ImageBase + TeStrippedOffset);
+  }
+
+  //
+  // Initialize the alternate destination address to 0 indicating that it
+  // should not be used.
+  //
+  ImageContext->DestinationAddress = 0;
+
+  //
+  // Initialize the debug codeview pointer.
+  //
+  ImageContext->DebugDirectoryEntryRva = 0;
+  ImageContext->CodeView               = NULL;
+  ImageContext->PdbPointer             = NULL;
+
+  //
+  // Three cases with regards to relocations:
+  // - Image has base relocs, RELOCS_STRIPPED==0    => image is relocatable
+  // - Image has no base relocs, RELOCS_STRIPPED==1 => Image is not relocatable
+  // - Image has no base relocs, RELOCS_STRIPPED==0 => Image is relocatable but
+  //   has no base relocs to apply
+  // Obviously having base relocations with RELOCS_STRIPPED==1 is invalid.
+  //
+  // Look at the file header to determine if relocations have been stripped, and
+  // save this information in the image context for later use.
+  //
+  if ((!(ImageContext->IsTeImage)) && ((Hdr.Pe32->FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) != 0)) {
+    ImageContext->RelocationsStripped = TRUE;
+  } else if ((ImageContext->IsTeImage) && (Hdr.Te->DataDirectory[0].Size == 0) && (Hdr.Te->DataDirectory[0].VirtualAddress == 0)) {
+    ImageContext->RelocationsStripped = TRUE;
+  } else {
+    ImageContext->RelocationsStripped = FALSE;
+  }
+
+  if (!(ImageContext->IsTeImage)) {
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+      DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+      DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
+    }
+
+    if (NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
+
+      DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress;
+
+      //
+      // Determine the file offset of the debug directory...  This means we walk
+      // the sections to find which section contains the RVA of the debug
+      // directory
+      //
+      DebugDirectoryEntryFileOffset = 0;
+
+      SectionHeaderOffset = ImageContext->PeCoffHeaderOffset +
+                            sizeof (UINT32) +
+                            sizeof (EFI_IMAGE_FILE_HEADER) +
+                            Hdr.Pe32->FileHeader.SizeOfOptionalHeader;
+
+      for (Index = 0; Index < Hdr.Pe32->FileHeader.NumberOfSections; Index++) {
+        //
+        // Read section header from file
+        //
+        Size = sizeof (EFI_IMAGE_SECTION_HEADER);
+        ReadSize = Size;
+        Status = ImageContext->ImageRead (
+                                 ImageContext->Handle,
+                                 SectionHeaderOffset,
+                                 &Size,
+                                 &SectionHeader
+                                 );
+        if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+          if (Size != ReadSize) {
+            Status = RETURN_UNSUPPORTED;
+          }
+          return Status;
+        }
+
+        if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&
+            DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {
+
+          DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData;
+          break;
+        }
+
+        SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
+      }
+
+      if (DebugDirectoryEntryFileOffset != 0) {
+        for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) {
+          //
+          // Read next debug directory entry
+          //
+          Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+          ReadSize = Size;
+          Status = ImageContext->ImageRead (
+                                   ImageContext->Handle,
+                                   DebugDirectoryEntryFileOffset + Index,
+                                   &Size,
+                                   &DebugEntry
+                                   );
+          if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+            if (Size != ReadSize) {
+              Status = RETURN_UNSUPPORTED;
+            }
+            return Status;
+          }
+
+          //
+          // From PeCoff spec, when DebugEntry.RVA == 0 means this debug info will not load into memory.
+          // Here we will always load EFI_IMAGE_DEBUG_TYPE_CODEVIEW type debug info. so need adjust the
+          // ImageContext->ImageSize when DebugEntry.RVA == 0.
+          //
+          if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
+            ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index);
+            if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) {
+              ImageContext->ImageSize += DebugEntry.SizeOfData;
+            }
+
+            return RETURN_SUCCESS;
+          }
+        }
+      }
+    }
+  } else {
+
+    DebugDirectoryEntry             = &Hdr.Te->DataDirectory[1];
+    DebugDirectoryEntryRva          = DebugDirectoryEntry->VirtualAddress;
+    SectionHeaderOffset             = (UINTN)(sizeof (EFI_TE_IMAGE_HEADER));
+
+    DebugDirectoryEntryFileOffset   = 0;
+
+    for (Index = 0; Index < Hdr.Te->NumberOfSections;) {
+      //
+      // Read section header from file
+      //
+      Size   = sizeof (EFI_IMAGE_SECTION_HEADER);
+      ReadSize = Size;
+      Status = ImageContext->ImageRead (
+                               ImageContext->Handle,
+                               SectionHeaderOffset,
+                               &Size,
+                               &SectionHeader
+                               );
+      if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+        if (Size != ReadSize) {
+          Status = RETURN_UNSUPPORTED;
+        }
+        return Status;
+      }
+
+      if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&
+          DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {
+        DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva -
+                                        SectionHeader.VirtualAddress +
+                                        SectionHeader.PointerToRawData -
+                                        TeStrippedOffset;
+
+        //
+        // File offset of the debug directory was found, if this is not the last
+        // section, then skip to the last section for calculating the image size.
+        //
+        if (Index < (UINTN) Hdr.Te->NumberOfSections - 1) {
+          SectionHeaderOffset += (Hdr.Te->NumberOfSections - 1 - Index) * sizeof (EFI_IMAGE_SECTION_HEADER);
+          Index = Hdr.Te->NumberOfSections - 1;
+          continue;
+        }
+      }
+
+      //
+      // In Te image header there is not a field to describe the ImageSize.
+      // Actually, the ImageSize equals the RVA plus the VirtualSize of
+      // the last section mapped into memory (Must be rounded up to
+      // a multiple of Section Alignment). Per the PE/COFF specification, the
+      // section headers in the Section Table must appear in order of the RVA
+      // values for the corresponding sections. So the ImageSize can be determined
+      // by the RVA and the VirtualSize of the last section header in the
+      // Section Table.  
+      //
+      if ((++Index) == (UINTN)Hdr.Te->NumberOfSections) {
+        ImageContext->ImageSize = (SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) - TeStrippedOffset;
+      }
+
+      SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
+    }
+
+    if (DebugDirectoryEntryFileOffset != 0) {
+      for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) {
+        //
+        // Read next debug directory entry
+        //
+        Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+        ReadSize = Size;
+        Status = ImageContext->ImageRead (
+                                 ImageContext->Handle,
+                                 DebugDirectoryEntryFileOffset + Index,
+                                 &Size,
+                                 &DebugEntry
+                                 );
+        if (RETURN_ERROR (Status) || (Size != ReadSize)) {
+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+          if (Size != ReadSize) {
+            Status = RETURN_UNSUPPORTED;
+          }
+          return Status;
+        }
+
+        if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
+          ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index);
+          return RETURN_SUCCESS;
+        }
+      }
+    }
+  }
+
+  return RETURN_SUCCESS;
+}
+
+
+/**
+  Converts an image address to the loaded address.
+
+  @param  ImageContext      The context of the image being loaded.
+  @param  Address           The address to be converted to the loaded address.
+  @param  TeStrippedOffset  Stripped offset for TE image.
+
+  @return The converted address or NULL if the address can not be converted.
+
+**/
+VOID *
+PeCoffLoaderImageAddress (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,
+  IN     UINTN                                 Address, 
+  IN     UINTN                                 TeStrippedOffset
+  )
+{
+  //
+  // Make sure that Address and ImageSize is correct for the loaded image.
+  //
+  if (Address >= ImageContext->ImageSize + TeStrippedOffset) {
+    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;
+    return NULL;
+  }
+
+  return (CHAR8 *)((UINTN) ImageContext->ImageAddress + Address - TeStrippedOffset);
+}
+
+/**
+  Applies relocation fixups to a PE/COFF image that was loaded with PeCoffLoaderLoadImage().
+
+  If the DestinationAddress field of ImageContext is 0, then use the ImageAddress field of
+  ImageContext as the relocation base address.  Otherwise, use the DestinationAddress field
+  of ImageContext as the relocation base address.  The caller must allocate the relocation
+  fixup log buffer and fill in the FixupData field of ImageContext prior to calling this function.
+  
+  The ImageRead, Handle, PeCoffHeaderOffset,  IsTeImage, Machine, ImageType, ImageAddress, 
+  ImageSize, DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, 
+  DebugDirectoryEntryRva, EntryPoint, FixupDataSize, CodeView, PdbPointer, and FixupData of 
+  the ImageContext structure must be valid prior to invoking this service.
+    
+  If ImageContext is NULL, then ASSERT().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageContext        The pointer to the image context structure that describes the PE/COFF
+                              image that is being relocated.
+
+  @retval RETURN_SUCCESS      The PE/COFF image was relocated.
+                              Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_LOAD_ERROR   The image in not a valid PE/COFF image.
+                              Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_UNSUPPORTED  A relocation record type is not supported.
+                              Extended status information is in the ImageError field of ImageContext.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderRelocateImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  RETURN_STATUS                         Status;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+  EFI_IMAGE_DATA_DIRECTORY              *RelocDir;
+  UINT64                                Adjust;
+  EFI_IMAGE_BASE_RELOCATION             *RelocBaseOrg;
+  EFI_IMAGE_BASE_RELOCATION             *RelocBase;
+  EFI_IMAGE_BASE_RELOCATION             *RelocBaseEnd;
+  UINT16                                *Reloc;
+  UINT16                                *RelocEnd;
+  CHAR8                                 *Fixup;
+  CHAR8                                 *FixupBase;
+  UINT16                                *Fixup16;
+  UINT32                                *Fixup32;
+  UINT64                                *Fixup64;
+  CHAR8                                 *FixupData;
+  PHYSICAL_ADDRESS                      BaseAddress;
+  UINT32                                NumberOfRvaAndSizes;
+  UINT16                                Magic;
+  UINT32                                TeStrippedOffset;
+
+  ASSERT (ImageContext != NULL);
+
+  //
+  // Assume success
+  //
+  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;
+
+  //
+  // If there are no relocation entries, then we are done
+  //
+  if (ImageContext->RelocationsStripped) {
+    // Applies additional environment specific actions to relocate fixups 
+    // to a PE/COFF image if needed
+    PeCoffLoaderRelocateImageExtraAction (ImageContext);  
+    return RETURN_SUCCESS;
+  }
+
+  //
+  // If the destination address is not 0, use that rather than the
+  // image address as the relocation target.
+  //
+  if (ImageContext->DestinationAddress != 0) {
+    BaseAddress = ImageContext->DestinationAddress;
+  } else {
+    BaseAddress = ImageContext->ImageAddress;
+  }
+
+  if (!(ImageContext->IsTeImage)) {
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset);
+    TeStrippedOffset = 0;
+    Magic = PeCoffLoaderGetPeHeaderMagicValue (Hdr);
+
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      Adjust = (UINT64)BaseAddress - Hdr.Pe32->OptionalHeader.ImageBase;
+      if (Adjust != 0) {
+        Hdr.Pe32->OptionalHeader.ImageBase = (UINT32)BaseAddress;
+      }
+
+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+      RelocDir  = &Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      Adjust = (UINT64) BaseAddress - Hdr.Pe32Plus->OptionalHeader.ImageBase;
+      if (Adjust != 0) {
+        Hdr.Pe32Plus->OptionalHeader.ImageBase = (UINT64)BaseAddress;
+      }
+
+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+      RelocDir  = &Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+    }
+
+    //
+    // Find the relocation block
+    // Per the PE/COFF spec, you can't assume that a given data directory
+    // is present in the image. You have to check the NumberOfRvaAndSizes in
+    // the optional header to verify a desired directory entry is there.
+    //
+    if ((NumberOfRvaAndSizes < EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC)) {
+      RelocDir = NULL;
+    }
+  } else {
+    Hdr.Te             = (EFI_TE_IMAGE_HEADER *)(UINTN)(ImageContext->ImageAddress);
+    TeStrippedOffset   = (UINT32)Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER);
+    Adjust             = (UINT64) (BaseAddress - (Hdr.Te->ImageBase + TeStrippedOffset));
+    if (Adjust != 0) {
+      Hdr.Te->ImageBase  = (UINT64) (BaseAddress - TeStrippedOffset);
+    }
+
+    //
+    // Find the relocation block
+    //
+    RelocDir = &Hdr.Te->DataDirectory[0];
+  }
+
+  if ((RelocDir != NULL) && (RelocDir->Size > 0)) {
+    RelocBase = (EFI_IMAGE_BASE_RELOCATION *) PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress, TeStrippedOffset);
+    RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *) PeCoffLoaderImageAddress (ImageContext,
+                                                                            RelocDir->VirtualAddress + RelocDir->Size - 1,
+                                                                            TeStrippedOffset
+                                                                            );
+    if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) {
+      ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+      return RETURN_LOAD_ERROR;
+    }
+  } else {
+    //
+    // Set base and end to bypass processing below.
+    //
+    RelocBase = RelocBaseEnd = NULL;    
+  }
+  RelocBaseOrg = RelocBase;
+
+  //
+  // If Adjust is not zero, then apply fix ups to the image
+  //
+  if (Adjust != 0) {
+    //
+    // Run the relocation information and apply the fixups
+    //
+    FixupData = ImageContext->FixupData;
+    while (RelocBase < RelocBaseEnd) {
+
+      Reloc     = (UINT16 *) ((CHAR8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION));
+      //
+      // Add check for RelocBase->SizeOfBlock field.
+      //
+      if (RelocBase->SizeOfBlock == 0) {
+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+        return RETURN_LOAD_ERROR;
+      }
+      if ((UINTN)RelocBase > MAX_ADDRESS - RelocBase->SizeOfBlock) {
+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+        return RETURN_LOAD_ERROR;
+      }
+
+      RelocEnd  = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock);
+      if ((UINTN)RelocEnd > (UINTN)RelocBaseOrg + RelocDir->Size) {
+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+        return RETURN_LOAD_ERROR;
+      }
+      FixupBase = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress, TeStrippedOffset);
+      if (FixupBase == NULL) {
+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+        return RETURN_LOAD_ERROR;
+      }  
+
+      //
+      // Run this relocation record
+      //
+      while (Reloc < RelocEnd) {
+        Fixup = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress + (*Reloc & 0xFFF), TeStrippedOffset);
+        if (Fixup == NULL) {
+          ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+          return RETURN_LOAD_ERROR;
+        }
+        switch ((*Reloc) >> 12) {
+        case EFI_IMAGE_REL_BASED_ABSOLUTE:
+          break;
+
+        case EFI_IMAGE_REL_BASED_HIGH:
+          Fixup16   = (UINT16 *) Fixup;
+          *Fixup16 = (UINT16) (*Fixup16 + ((UINT16) ((UINT32) Adjust >> 16)));
+          if (FixupData != NULL) {
+            *(UINT16 *) FixupData = *Fixup16;
+            FixupData             = FixupData + sizeof (UINT16);
+          }
+          break;
+
+        case EFI_IMAGE_REL_BASED_LOW:
+          Fixup16   = (UINT16 *) Fixup;
+          *Fixup16  = (UINT16) (*Fixup16 + (UINT16) Adjust);
+          if (FixupData != NULL) {
+            *(UINT16 *) FixupData = *Fixup16;
+            FixupData             = FixupData + sizeof (UINT16);
+          }
+          break;
+
+        case EFI_IMAGE_REL_BASED_HIGHLOW:
+          Fixup32   = (UINT32 *) Fixup;
+          *Fixup32  = *Fixup32 + (UINT32) Adjust;
+          if (FixupData != NULL) {
+            FixupData             = ALIGN_POINTER (FixupData, sizeof (UINT32));
+            *(UINT32 *)FixupData  = *Fixup32;
+            FixupData             = FixupData + sizeof (UINT32);
+          }
+          break;
+
+        case EFI_IMAGE_REL_BASED_DIR64:
+          Fixup64 = (UINT64 *) Fixup;
+          *Fixup64 = *Fixup64 + (UINT64) Adjust;
+          if (FixupData != NULL) {
+            FixupData = ALIGN_POINTER (FixupData, sizeof(UINT64));
+            *(UINT64 *)(FixupData) = *Fixup64;
+            FixupData = FixupData + sizeof(UINT64);
+          }
+          break;
+
+        default:
+          //
+          // The common code does not handle some of the stranger IPF relocations
+          // PeCoffLoaderRelocateImageEx () adds support for these complex fixups
+          // on IPF and is a No-Op on other architectures.
+          //
+          Status = PeCoffLoaderRelocateImageEx (Reloc, Fixup, &FixupData, Adjust);
+          if (RETURN_ERROR (Status)) {
+            ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+            return Status;
+          }
+        }
+
+        //
+        // Next relocation record
+        //
+        Reloc += 1;
+      }
+
+      //
+      // Next reloc block
+      //
+      RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;
+    }
+    ASSERT ((UINTN)FixupData <= (UINTN)ImageContext->FixupData + ImageContext->FixupDataSize);
+
+    //
+    // Adjust the EntryPoint to match the linked-to address
+    //
+    if (ImageContext->DestinationAddress != 0) {
+       ImageContext->EntryPoint -= (UINT64) ImageContext->ImageAddress;
+       ImageContext->EntryPoint += (UINT64) ImageContext->DestinationAddress;
+    }
+  }
+  
+  // Applies additional environment specific actions to relocate fixups 
+  // to a PE/COFF image if needed
+  PeCoffLoaderRelocateImageExtraAction (ImageContext);
+  
+  return RETURN_SUCCESS;
+}
+
+/**
+  Loads a PE/COFF image into memory.
+
+  Loads the PE/COFF image accessed through the ImageRead service of ImageContext into the buffer
+  specified by the ImageAddress and ImageSize fields of ImageContext.  The caller must allocate
+  the load buffer and fill in the ImageAddress and ImageSize fields prior to calling this function.
+  The EntryPoint, FixupDataSize, CodeView, PdbPointer and HiiResourceData fields of ImageContext are computed.
+  The ImageRead, Handle, PeCoffHeaderOffset,  IsTeImage,  Machine, ImageType, ImageAddress, ImageSize, 
+  DestinationAddress, RelocationsStripped, SectionAlignment, SizeOfHeaders, and DebugDirectoryEntryRva 
+  fields of the ImageContext structure must be valid prior to invoking this service.
+  
+  If ImageContext is NULL, then ASSERT().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageContext              The pointer to the image context structure that describes the PE/COFF
+                                    image that is being loaded.
+
+  @retval RETURN_SUCCESS            The PE/COFF image was loaded into the buffer specified by
+                                    the ImageAddress and ImageSize fields of ImageContext.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_BUFFER_TOO_SMALL   The caller did not provide a large enough buffer.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_LOAD_ERROR         The PE/COFF image is an EFI Runtime image with no relocations.
+                                    Extended status information is in the ImageError field of ImageContext.
+  @retval RETURN_INVALID_PARAMETER  The image address is invalid.
+                                    Extended status information is in the ImageError field of ImageContext.
+
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderLoadImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  RETURN_STATUS                         Status;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
+  PE_COFF_LOADER_IMAGE_CONTEXT          CheckContext;
+  EFI_IMAGE_SECTION_HEADER              *FirstSection;
+  EFI_IMAGE_SECTION_HEADER              *Section;
+  UINTN                                 NumberOfSections;
+  UINTN                                 Index;
+  CHAR8                                 *Base;
+  CHAR8                                 *End;
+  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;
+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;
+  UINTN                                 Size;
+  UINT32                                TempDebugEntryRva;
+  UINT32                                NumberOfRvaAndSizes;
+  UINT16                                Magic;
+  EFI_IMAGE_RESOURCE_DIRECTORY          *ResourceDirectory;
+  EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY    *ResourceDirectoryEntry;
+  EFI_IMAGE_RESOURCE_DIRECTORY_STRING   *ResourceDirectoryString;
+  EFI_IMAGE_RESOURCE_DATA_ENTRY         *ResourceDataEntry;
+  CHAR16                                *String;
+  UINT32                                Offset;
+  UINT32                                TeStrippedOffset;
+
+  ASSERT (ImageContext != NULL);
+
+  //
+  // Assume success
+  //
+  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;
+
+  //
+  // Copy the provided context information into our local version, get what we
+  // can from the original image, and then use that to make sure everything
+  // is legit.
+  //
+  CopyMem (&CheckContext, ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));
+
+  Status = PeCoffLoaderGetImageInfo (&CheckContext);
+  if (RETURN_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Make sure there is enough allocated space for the image being loaded
+  //
+  if (ImageContext->ImageSize < CheckContext.ImageSize) {
+    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_SIZE;
+    return RETURN_BUFFER_TOO_SMALL;
+  }
+  if (ImageContext->ImageAddress == 0) {
+    //
+    // Image cannot be loaded into 0 address.
+    //
+    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;
+    return RETURN_INVALID_PARAMETER;
+  }
+  //
+  // If there's no relocations, then make sure it's not a runtime driver,
+  // and that it's being loaded at the linked address.
+  //
+  if (CheckContext.RelocationsStripped) {
+    //
+    // If the image does not contain relocations and it is a runtime driver
+    // then return an error.
+    //
+    if (CheckContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {
+      ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;
+      return RETURN_LOAD_ERROR;
+    }
+    //
+    // If the image does not contain relocations, and the requested load address
+    // is not the linked address, then return an error.
+    //
+    if (CheckContext.ImageAddress != ImageContext->ImageAddress) {
+      ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;
+      return RETURN_INVALID_PARAMETER;
+    }
+  }
+  //
+  // Make sure the allocated space has the proper section alignment
+  //
+  if (!(ImageContext->IsTeImage)) {
+    if ((ImageContext->ImageAddress & (CheckContext.SectionAlignment - 1)) != 0) {
+      ImageContext->ImageError = IMAGE_ERROR_INVALID_SECTION_ALIGNMENT;
+      return RETURN_INVALID_PARAMETER;
+    }
+  }
+  //
+  // Read the entire PE/COFF or TE header into memory
+  //
+  if (!(ImageContext->IsTeImage)) {
+    Status = ImageContext->ImageRead (
+                            ImageContext->Handle,
+                            0,
+                            &ImageContext->SizeOfHeaders,
+                            (VOID *) (UINTN) ImageContext->ImageAddress
+                            );
+
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset);
+
+    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (
+                      (UINTN)ImageContext->ImageAddress +
+                      ImageContext->PeCoffHeaderOffset +
+                      sizeof(UINT32) +
+                      sizeof(EFI_IMAGE_FILE_HEADER) +
+                      Hdr.Pe32->FileHeader.SizeOfOptionalHeader
+      );
+    NumberOfSections = (UINTN) (Hdr.Pe32->FileHeader.NumberOfSections);
+    TeStrippedOffset = 0;
+  } else {
+    Status = ImageContext->ImageRead (
+                            ImageContext->Handle,
+                            0,
+                            &ImageContext->SizeOfHeaders,
+                            (void *)(UINTN)ImageContext->ImageAddress
+                            );
+
+    Hdr.Te = (EFI_TE_IMAGE_HEADER *)(UINTN)(ImageContext->ImageAddress);
+    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (
+                      (UINTN)ImageContext->ImageAddress +
+                      sizeof(EFI_TE_IMAGE_HEADER)
+                      );
+    NumberOfSections  = (UINTN) (Hdr.Te->NumberOfSections);
+    TeStrippedOffset  = (UINT32) Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER);
+  }
+
+  if (RETURN_ERROR (Status)) {
+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+    return RETURN_LOAD_ERROR;
+  }
+
+  //
+  // Load each section of the image
+  //
+  Section = FirstSection;
+  for (Index = 0; Index < NumberOfSections; Index++) {
+    //
+    // Read the section
+    //
+    Size = (UINTN) Section->Misc.VirtualSize;
+    if ((Size == 0) || (Size > Section->SizeOfRawData)) {
+      Size = (UINTN) Section->SizeOfRawData;
+    }
+
+    //
+    // Compute sections address
+    //
+    Base = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress, TeStrippedOffset);
+    End  = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress + Section->Misc.VirtualSize - 1, TeStrippedOffset);
+
+    //
+    // If the size of the section is non-zero and the base address or end address resolved to 0, then fail.
+    //
+    if ((Size > 0) && ((Base == NULL) || (End == NULL))) {
+      ImageContext->ImageError = IMAGE_ERROR_SECTION_NOT_LOADED;
+      return RETURN_LOAD_ERROR;
+    }
+
+    if (Section->SizeOfRawData > 0) {
+      Status = ImageContext->ImageRead (
+                              ImageContext->Handle,
+                              Section->PointerToRawData - TeStrippedOffset,
+                              &Size,
+                              Base
+                              );
+      if (RETURN_ERROR (Status)) {
+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+        return Status;
+      }
+    }
+
+    //
+    // If raw size is less then virtual size, zero fill the remaining
+    //
+
+    if (Size < Section->Misc.VirtualSize) {
+      ZeroMem (Base + Size, Section->Misc.VirtualSize - Size);
+    }
+
+    //
+    // Next Section
+    //
+    Section += 1;
+  }
+
+  //
+  // Get image's entry point
+  //
+  Magic = PeCoffLoaderGetPeHeaderMagicValue (Hdr);
+  if (!(ImageContext->IsTeImage)) {
+    //
+    // Sizes of AddressOfEntryPoint are different so we need to do this safely
+    //
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      ImageContext->EntryPoint = (PHYSICAL_ADDRESS)(UINTN)PeCoffLoaderImageAddress (
+                                                            ImageContext,
+                                                            (UINTN)Hdr.Pe32->OptionalHeader.AddressOfEntryPoint,
+                                                            0
+                                                            );
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      ImageContext->EntryPoint = (PHYSICAL_ADDRESS)(UINTN)PeCoffLoaderImageAddress (
+                                                            ImageContext,
+                                                            (UINTN)Hdr.Pe32Plus->OptionalHeader.AddressOfEntryPoint,
+                                                            0
+                                                            );
+    }
+  } else {
+    ImageContext->EntryPoint = (PHYSICAL_ADDRESS)(UINTN)PeCoffLoaderImageAddress (
+                                                          ImageContext,
+                                                          (UINTN)Hdr.Te->AddressOfEntryPoint,
+                                                          TeStrippedOffset
+                                                          );
+  }
+
+  //
+  // Determine the size of the fixup data
+  //
+  // Per the PE/COFF spec, you can't assume that a given data directory
+  // is present in the image. You have to check the NumberOfRvaAndSizes in
+  // the optional header to verify a desired directory entry is there.
+  //
+  if (!(ImageContext->IsTeImage)) {
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+    }
+
+    //
+    // Must use UINT64 here, because there might a case that 32bit loader to load 64bit image.
+    //
+    if (NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {
+      ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINT64);
+    } else {
+      ImageContext->FixupDataSize = 0;
+    }
+  } else {
+    DirectoryEntry              = &Hdr.Te->DataDirectory[0];
+    ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINT64);
+  }
+  //
+  // Consumer must allocate a buffer for the relocation fixup log.
+  // Only used for runtime drivers.
+  //
+  ImageContext->FixupData = NULL;
+
+  //
+  // Load the Codeview information if present
+  //
+  if (ImageContext->DebugDirectoryEntryRva != 0) {
+    DebugEntry = PeCoffLoaderImageAddress (
+                ImageContext,
+                ImageContext->DebugDirectoryEntryRva,
+                TeStrippedOffset
+                );
+    if (DebugEntry == NULL) {
+      ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+      return RETURN_LOAD_ERROR;
+    }
+
+    TempDebugEntryRva = DebugEntry->RVA;
+    if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) {
+      Section--;
+      if ((UINTN)Section->SizeOfRawData < Section->Misc.VirtualSize) {
+        TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize;
+      } else {
+        TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData;
+      }
+    }
+
+    if (TempDebugEntryRva != 0) {
+      ImageContext->CodeView = PeCoffLoaderImageAddress (ImageContext, TempDebugEntryRva, TeStrippedOffset); 
+      if (ImageContext->CodeView == NULL) {
+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
+        return RETURN_LOAD_ERROR;
+      }
+
+      if (DebugEntry->RVA == 0) {
+        Size = DebugEntry->SizeOfData;
+        Status = ImageContext->ImageRead (
+                                ImageContext->Handle,
+                                DebugEntry->FileOffset - TeStrippedOffset,
+                                &Size,
+                                ImageContext->CodeView
+                                );
+        //
+        // Should we apply fix up to this field according to the size difference between PE and TE?
+        // Because now we maintain TE header fields unfixed, this field will also remain as they are
+        // in original PE image.
+        //
+
+        if (RETURN_ERROR (Status)) {
+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
+          return RETURN_LOAD_ERROR;
+        }
+
+        DebugEntry->RVA = TempDebugEntryRva;
+      }
+
+      switch (*(UINT32 *) ImageContext->CodeView) {
+      case CODEVIEW_SIGNATURE_NB10:
+        if (DebugEntry->SizeOfData < sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)) {
+          ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+          return RETURN_UNSUPPORTED;
+        }
+        ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY);
+        break;
+
+      case CODEVIEW_SIGNATURE_RSDS:
+        if (DebugEntry->SizeOfData < sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY)) {
+          ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+          return RETURN_UNSUPPORTED;
+        }
+        ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY);
+        break;
+
+      case CODEVIEW_SIGNATURE_MTOC:
+        if (DebugEntry->SizeOfData < sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY)) {
+          ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+          return RETURN_UNSUPPORTED;
+        }
+        ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY);
+        break;
+
+      default:
+        break;
+      }
+    }
+  }
+
+  //
+  // Get Image's HII resource section
+  //
+  ImageContext->HiiResourceData = 0;
+  if (!(ImageContext->IsTeImage)) {
+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+      //
+      // Use PE32 offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE];
+    } else {
+      //
+      // Use PE32+ offset
+      //
+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE];
+    }
+
+    if (NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE && DirectoryEntry->Size != 0) {
+      Base = PeCoffLoaderImageAddress (ImageContext, DirectoryEntry->VirtualAddress, 0);
+      if (Base != NULL) {
+        ResourceDirectory = (EFI_IMAGE_RESOURCE_DIRECTORY *) Base;
+        Offset = sizeof (EFI_IMAGE_RESOURCE_DIRECTORY) + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY) * 
+               (ResourceDirectory->NumberOfNamedEntries + ResourceDirectory->NumberOfIdEntries);
+        if (Offset > DirectoryEntry->Size) {
+          ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+          return RETURN_UNSUPPORTED;
+        }
+        ResourceDirectoryEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) (ResourceDirectory + 1);
+
+        for (Index = 0; Index < ResourceDirectory->NumberOfNamedEntries; Index++) {
+          if (ResourceDirectoryEntry->u1.s.NameIsString) {
+            //
+            // Check the ResourceDirectoryEntry->u1.s.NameOffset before use it.
+            //
+            if (ResourceDirectoryEntry->u1.s.NameOffset >= DirectoryEntry->Size) {
+              ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+              return RETURN_UNSUPPORTED;
+            }
+            ResourceDirectoryString = (EFI_IMAGE_RESOURCE_DIRECTORY_STRING *) (Base + ResourceDirectoryEntry->u1.s.NameOffset);
+            String = &ResourceDirectoryString->String[0];
+
+            if (ResourceDirectoryString->Length == 3 &&
+                String[0] == L'H' &&
+                String[1] == L'I' &&
+                String[2] == L'I') {
+              //
+              // Resource Type "HII" found
+              //
+              if (ResourceDirectoryEntry->u2.s.DataIsDirectory) {
+                //
+                // Move to next level - resource Name
+                //
+                if (ResourceDirectoryEntry->u2.s.OffsetToDirectory >= DirectoryEntry->Size) {
+                  ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+                  return RETURN_UNSUPPORTED;
+                }
+                ResourceDirectory = (EFI_IMAGE_RESOURCE_DIRECTORY *) (Base + ResourceDirectoryEntry->u2.s.OffsetToDirectory);
+                Offset = ResourceDirectoryEntry->u2.s.OffsetToDirectory + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY) + 
+                         sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY) * (ResourceDirectory->NumberOfNamedEntries + ResourceDirectory->NumberOfIdEntries);
+                if (Offset > DirectoryEntry->Size) {
+                  ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+                  return RETURN_UNSUPPORTED;
+                }
+                ResourceDirectoryEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) (ResourceDirectory + 1);
+
+                if (ResourceDirectoryEntry->u2.s.DataIsDirectory) {
+                  //
+                  // Move to next level - resource Language
+                  //
+                  if (ResourceDirectoryEntry->u2.s.OffsetToDirectory >= DirectoryEntry->Size) {
+                    ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+                    return RETURN_UNSUPPORTED;
+                  }
+                  ResourceDirectory = (EFI_IMAGE_RESOURCE_DIRECTORY *) (Base + ResourceDirectoryEntry->u2.s.OffsetToDirectory);
+                  Offset = ResourceDirectoryEntry->u2.s.OffsetToDirectory + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY) + 
+                           sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY) * (ResourceDirectory->NumberOfNamedEntries + ResourceDirectory->NumberOfIdEntries);
+                  if (Offset > DirectoryEntry->Size) {
+                    ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+                    return RETURN_UNSUPPORTED;
+                  }
+                  ResourceDirectoryEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) (ResourceDirectory + 1);
+                }
+              }
+
+              //
+              // Now it ought to be resource Data
+              //
+              if (!ResourceDirectoryEntry->u2.s.DataIsDirectory) {
+                if (ResourceDirectoryEntry->u2.OffsetToData >= DirectoryEntry->Size) {
+                  ImageContext->ImageError = IMAGE_ERROR_UNSUPPORTED;
+                  return RETURN_UNSUPPORTED;
+                }
+                ResourceDataEntry = (EFI_IMAGE_RESOURCE_DATA_ENTRY *) (Base + ResourceDirectoryEntry->u2.OffsetToData);
+                ImageContext->HiiResourceData = (PHYSICAL_ADDRESS) (UINTN) PeCoffLoaderImageAddress (ImageContext, ResourceDataEntry->OffsetToData, 0);
+                break;
+              }
+            }
+          }
+          ResourceDirectoryEntry++;
+        }
+      }
+    }
+  }
+ 
+  return Status;
+}
+
+
+/**
+  Reapply fixups on a fixed up PE32/PE32+ image to allow virutal calling at EFI
+  runtime. 
+  
+  This function reapplies relocation fixups to the PE/COFF image specified by ImageBase 
+  and ImageSize so the image will execute correctly when the PE/COFF image is mapped 
+  to the address specified by VirtualImageBase.  RelocationData must be identical 
+  to the FiuxupData buffer from the PE_COFF_LOADER_IMAGE_CONTEXT structure 
+  after this PE/COFF image was relocated with PeCoffLoaderRelocateImage().
+
+  Note that if the platform does not maintain coherency between the instruction cache(s) and the data
+  cache(s) in hardware, then the caller is responsible for performing cache maintenance operations
+  prior to transferring control to a PE/COFF image that is loaded using this library.
+
+  @param  ImageBase          The base address of a PE/COFF image that has been loaded 
+                             and relocated into system memory.
+  @param  VirtImageBase      The request virtual address that the PE/COFF image is to
+                             be fixed up for.
+  @param  ImageSize          The size, in bytes, of the PE/COFF image.
+  @param  RelocationData     A pointer to the relocation data that was collected when the PE/COFF 
+                             image was relocated using PeCoffLoaderRelocateImage().
+  
+**/
+VOID
+EFIAPI
+PeCoffLoaderRelocateImageForRuntime (
+  IN  PHYSICAL_ADDRESS        ImageBase,
+  IN  PHYSICAL_ADDRESS        VirtImageBase,
+  IN  UINTN                   ImageSize,
+  IN  VOID                    *RelocationData
+  )
+{
+  CHAR8                               *OldBase;
+  CHAR8                               *NewBase;
+  EFI_IMAGE_DOS_HEADER                *DosHdr;
+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;
+  UINT32                              NumberOfRvaAndSizes;
+  EFI_IMAGE_DATA_DIRECTORY            *DataDirectory;
+  EFI_IMAGE_DATA_DIRECTORY            *RelocDir;
+  EFI_IMAGE_BASE_RELOCATION           *RelocBase;
+  EFI_IMAGE_BASE_RELOCATION           *RelocBaseEnd;
+  UINT16                              *Reloc;
+  UINT16                              *RelocEnd;
+  CHAR8                               *Fixup;
+  CHAR8                               *FixupBase;
+  UINT16                              *Fixup16;
+  UINT32                              *Fixup32;
+  UINT64                              *Fixup64;
+  CHAR8                               *FixupData;
+  UINTN                               Adjust;
+  RETURN_STATUS                       Status;
+  UINT16                              Magic;
+
+  OldBase = (CHAR8 *)((UINTN)ImageBase);
+  NewBase = (CHAR8 *)((UINTN)VirtImageBase);
+  Adjust = (UINTN) NewBase - (UINTN) OldBase;
+
+  //
+  // Find the image's relocate dir info
+  //
+  DosHdr = (EFI_IMAGE_DOS_HEADER *)OldBase;
+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
+    //
+    // Valid DOS header so get address of PE header
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)(((CHAR8 *)DosHdr) + DosHdr->e_lfanew);
+  } else {
+    //
+    // No Dos header so assume image starts with PE header.
+    //
+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)OldBase;
+  }
+
+  if (Hdr.Pe32->Signature != EFI_IMAGE_NT_SIGNATURE) {
+    //
+    // Not a valid PE image so Exit
+    //
+    return ;
+  }
+
+  Magic = PeCoffLoaderGetPeHeaderMagicValue (Hdr);
+
+  if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
+    //
+    // Use PE32 offset
+    //
+    NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
+    DataDirectory = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[0]);
+  } else {
+    //
+    // Use PE32+ offset
+    //
+    NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
+    DataDirectory = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[0]);
+  }
+
+  //
+  // Find the relocation block
+  //
+  // Per the PE/COFF spec, you can't assume that a given data directory
+  // is present in the image. You have to check the NumberOfRvaAndSizes in
+  // the optional header to verify a desired directory entry is there.
+  //
+  if (NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {
+    RelocDir      = DataDirectory + EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC;
+    RelocBase     = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)(ImageBase + RelocDir->VirtualAddress);
+    RelocBaseEnd  = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)(ImageBase + RelocDir->VirtualAddress + RelocDir->Size);
+  } else {
+    //
+    // Cannot find relocations, cannot continue to relocate the image, ASSERT for this invalid image.
+    //
+    ASSERT (FALSE);
+    return ;
+  }
+  
+  //
+  // ASSERT for the invalid image when RelocBase and RelocBaseEnd are both NULL.
+  //
+  ASSERT (RelocBase != NULL && RelocBaseEnd != NULL);
+
+  //
+  // Run the whole relocation block. And re-fixup data that has not been
+  // modified. The FixupData is used to see if the image has been modified
+  // since it was relocated. This is so data sections that have been updated
+  // by code will not be fixed up, since that would set them back to
+  // defaults.
+  //
+  FixupData = RelocationData;
+  while (RelocBase < RelocBaseEnd) {
+    //
+    // Add check for RelocBase->SizeOfBlock field.
+    //
+    if ((RelocBase->SizeOfBlock == 0) || (RelocBase->SizeOfBlock > RelocDir->Size)) {
+      //
+      // Data invalid, cannot continue to relocate the image, just return.
+      //
+      return;
+    }
+
+    Reloc     = (UINT16 *) ((UINT8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION));
+    RelocEnd  = (UINT16 *) ((UINT8 *) RelocBase + RelocBase->SizeOfBlock);
+    FixupBase = (CHAR8 *) ((UINTN)ImageBase) + RelocBase->VirtualAddress;
+
+    //
+    // Run this relocation record
+    //
+    while (Reloc < RelocEnd) {
+
+      Fixup = FixupBase + (*Reloc & 0xFFF);
+      switch ((*Reloc) >> 12) {
+
+      case EFI_IMAGE_REL_BASED_ABSOLUTE:
+        break;
+
+      case EFI_IMAGE_REL_BASED_HIGH:
+        Fixup16 = (UINT16 *) Fixup;
+        if (*(UINT16 *) FixupData == *Fixup16) {
+          *Fixup16 = (UINT16) (*Fixup16 + ((UINT16) ((UINT32) Adjust >> 16)));
+        }
+
+        FixupData = FixupData + sizeof (UINT16);
+        break;
+
+      case EFI_IMAGE_REL_BASED_LOW:
+        Fixup16 = (UINT16 *) Fixup;
+        if (*(UINT16 *) FixupData == *Fixup16) {
+          *Fixup16 = (UINT16) (*Fixup16 + ((UINT16) Adjust & 0xffff));
+        }
+
+        FixupData = FixupData + sizeof (UINT16);
+        break;
+
+      case EFI_IMAGE_REL_BASED_HIGHLOW:
+        Fixup32       = (UINT32 *) Fixup;
+        FixupData = ALIGN_POINTER (FixupData, sizeof (UINT32));
+        if (*(UINT32 *) FixupData == *Fixup32) {
+          *Fixup32 = *Fixup32 + (UINT32) Adjust;
+        }
+
+        FixupData = FixupData + sizeof (UINT32);
+        break;
+
+      case EFI_IMAGE_REL_BASED_DIR64:
+        Fixup64       = (UINT64 *)Fixup;
+        FixupData = ALIGN_POINTER (FixupData, sizeof (UINT64));
+        if (*(UINT64 *) FixupData == *Fixup64) {
+          *Fixup64 = *Fixup64 + (UINT64)Adjust;
+        }
+
+        FixupData = FixupData + sizeof (UINT64);
+        break;
+
+      default:
+        //
+        // Only Itanium requires ConvertPeImage_Ex
+        //
+        Status = PeHotRelocateImageEx (Reloc, Fixup, &FixupData, Adjust);
+        if (RETURN_ERROR (Status)) {
+          return ;
+        }
+      }
+      //
+      // Next relocation record
+      //
+      Reloc += 1;
+    }
+    //
+    // next reloc block
+    //
+    RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;
+  }
+}
+
+
+/**
+  Reads contents of a PE/COFF image from a buffer in system memory.
+   
+  This is the default implementation of a PE_COFF_LOADER_READ_FILE function 
+  that assumes FileHandle pointer to the beginning of a PE/COFF image.   
+  This function reads contents of the PE/COFF image that starts at the system memory 
+  address specified by FileHandle.  The read operation copies ReadSize bytes from the 
+  PE/COFF image starting at byte offset FileOffset into the buffer specified by Buffer.  
+  The size of the buffer actually read is returned in ReadSize.
+  
+  The caller must make sure the FileOffset and ReadSize within the file scope.
+
+  If FileHandle is NULL, then ASSERT().
+  If ReadSize is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+
+  @param  FileHandle        The pointer to base of the input stream
+  @param  FileOffset        Offset into the PE/COFF image to begin the read operation.
+  @param  ReadSize          On input, the size in bytes of the requested read operation.  
+                            On output, the number of bytes actually read.
+  @param  Buffer            Output buffer that contains the data read from the PE/COFF image.
+
+  @retval RETURN_SUCCESS    Data is read from FileOffset from the Handle into 
+                            the buffer.
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderImageReadFromMemory (
+  IN     VOID    *FileHandle,
+  IN     UINTN   FileOffset,
+  IN OUT UINTN   *ReadSize,
+  OUT    VOID    *Buffer
+  )
+{
+  ASSERT (ReadSize != NULL);
+  ASSERT (FileHandle != NULL);
+  ASSERT (Buffer != NULL);
+
+  CopyMem (Buffer, ((UINT8 *)FileHandle) + FileOffset, *ReadSize);
+  return RETURN_SUCCESS;
+}
+
+/**
+  Unloads a loaded PE/COFF image from memory and releases its taken resource.
+  Releases any environment specific resources that were allocated when the image 
+  specified by ImageContext was loaded using PeCoffLoaderLoadImage(). 
+ 
+  For NT32 emulator, the PE/COFF image loaded by system needs to release.
+  For real platform, the PE/COFF image loaded by Core doesn't needs to be unloaded, 
+  this function can simply return RETURN_SUCCESS.
+  
+  If ImageContext is NULL, then ASSERT().
+  
+  @param  ImageContext              The pointer to the image context structure that describes the PE/COFF
+                                    image to be unloaded.
+
+  @retval RETURN_SUCCESS            The PE/COFF image was unloaded successfully.
+**/
+RETURN_STATUS
+EFIAPI
+PeCoffLoaderUnloadImage (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  )
+{
+  //
+  // Applies additional environment specific actions to unload a 
+  // PE/COFF image if needed
+  //
+  PeCoffLoaderUnloadImageExtraAction (ImageContext);
+  return RETURN_SUCCESS;
+}
diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
new file mode 100644
index 000000000000..ff08afdd3894
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
@@ -0,0 +1,59 @@
+## @file
+#  PE/COFF Loader Library implementation.
+#  The IPF version library supports loading IPF and EBC PE/COFF image.
+#  The IA32 version library support loading IA32, X64 and EBC PE/COFF images.
+#  The X64 version library support loading IA32, X64 and EBC PE/COFF images.
+#
+#  Caution: This module requires additional review when modified.
+#  This library will have external input - PE/COFF image.
+#  This external input must be validated carefully to avoid security issue like
+#  buffer overflow, integer overflow.
+#
+#  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePeCoffLib
+  MODULE_UNI_FILE                = BasePeCoffLib.uni
+  FILE_GUID                      = 556f5d10-7309-4af4-b80a-8196bd60946f
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeCoffLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+
+[Sources]
+  BasePeCoffLibInternals.h
+  BasePeCoff.c
+
+[Sources.IA32, Sources.X64, Sources.EBC, Sources.AARCH64]
+  PeCoffLoaderEx.c
+
+[Sources.IPF]
+  Ipf/PeCoffLoaderEx.c
+
+[Sources.ARM]
+  Arm/PeCoffLoaderEx.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  PeCoffExtraActionLib
+  BaseMemoryLib
+
diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.uni b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.uni
new file mode 100644
index 000000000000..91f911f1aa0b
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.uni
@@ -0,0 +1,29 @@
+// /** @file
+// PE/COFF Loader Library implementation.
+//
+// The IPF version library supports loading IPF and EBC PE/COFF image.
+// The IA32 version library support loading IA32, X64 and EBC PE/COFF images.
+// The X64 version library support loading IA32, X64 and EBC PE/COFF images.
+// 
+// Caution: This module requires additional review when modified.
+// This library will have external input - PE/COFF image.
+// This external input must be validated carefully to avoid security issue like
+// buffer overflow, integer overflow.
+//
+// Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PE/COFF Loader Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The IPF version library supports loading IPF and EBC PE/COFF images. The IA32 version library support loading IA32, X64 and EBC PE/COFF images. The X64 version library support loading IA32, X64 and EBC PE/COFF images.  Caution: This module requires additional review when modified. This library will have external input: PE/COFF image. This external input must be validated carefully to avoid security issues like buffer overflow and integer overflow."
+
diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoffLibInternals.h b/MdePkg/Library/BasePeCoffLib/BasePeCoffLibInternals.h
new file mode 100644
index 000000000000..a2feecd8f5fc
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoffLibInternals.h
@@ -0,0 +1,133 @@
+/** @file
+  Declaration of internal functions in PE/COFF Lib.
+
+  Copyright (c) 2006 - 2010, 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 __BASE_PECOFF_LIB_INTERNALS__
+#define __BASE_PECOFF_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/PeCoffLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PeCoffExtraActionLib.h>
+#include <IndustryStandard/PeImage.h>
+
+
+
+/**
+  Performs an Itanium-based specific relocation fixup and is a no-op on other
+  instruction sets.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeCoffLoaderRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  );
+
+
+/**
+  Performs an Itanium-based specific re-relocation fixup and is a no-op on other
+  instruction sets. This is used to re-relocated the image into the EFI virtual
+  space for runtime calls.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeHotRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  );
+
+
+/**
+  Returns TRUE if the machine type of PE/COFF image is supported. Supported
+  does not mean the image can be executed it means the PE/COFF loader supports
+  loading and relocating of the image type. It's up to the caller to support
+  the entry point.
+
+  @param  Machine   Machine type from the PE Header.
+
+  @return TRUE if this PE/COFF loader can load the image
+
+**/
+BOOLEAN
+PeCoffLoaderImageFormatSupported (
+  IN  UINT16  Machine
+  );
+
+/**
+  Retrieves the magic value from the PE/COFF header.
+
+  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.
+
+  @return EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC - Image is PE32
+  @return EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC - Image is PE32+
+
+**/
+UINT16
+PeCoffLoaderGetPeHeaderMagicValue (
+  IN  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr
+  );
+
+/**
+  Retrieves the PE or TE Header from a PE/COFF or TE image.
+
+  @param  ImageContext    The context of the image being loaded.
+  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.
+
+  @retval RETURN_SUCCESS  The PE or TE Header is read.
+  @retval Other           The error status from reading the PE/COFF or TE image using the ImageRead function.
+
+**/
+RETURN_STATUS
+PeCoffLoaderGetPeHeader (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext,
+  OUT    EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr
+  );
+
+/**
+  Converts an image address to the loaded address.
+
+  @param  ImageContext      The context of the image being loaded.
+  @param  Address           The address to be converted to the loaded address.
+  @param  TeStrippedOffset  Stripped offset for TE image.
+
+  @return The converted address or NULL if the address can not be converted.
+
+**/
+VOID *
+PeCoffLoaderImageAddress (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,
+  IN     UINTN                                 Address,
+  IN     UINTN                                 TeStrippedOffset
+  );
+
+#endif
diff --git a/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c
new file mode 100644
index 000000000000..4bf091787f06
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c
@@ -0,0 +1,422 @@
+/** @file
+  Fixes Intel Itanium(TM) specific relocation types.
+
+  Copyright (c) 2006 - 2008, 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 "BasePeCoffLibInternals.h"
+
+
+
+#define EXT_IMM64(Value, Address, Size, InstPos, ValPos)  \
+    Value |= (((UINT64)((*(Address) >> InstPos) & (((UINT64)1 << Size) - 1))) << ValPos)
+
+#define INS_IMM64(Value, Address, Size, InstPos, ValPos)  \
+    *(UINT32*)Address = (*(UINT32*)Address & ~(((1 << Size) - 1) << InstPos)) | \
+          ((UINT32)((((UINT64)Value >> ValPos) & (((UINT64)1 << Size) - 1))) << InstPos)
+
+#define IMM64_IMM7B_INST_WORD_X         3
+#define IMM64_IMM7B_SIZE_X              7
+#define IMM64_IMM7B_INST_WORD_POS_X     4
+#define IMM64_IMM7B_VAL_POS_X           0
+
+#define IMM64_IMM9D_INST_WORD_X         3
+#define IMM64_IMM9D_SIZE_X              9
+#define IMM64_IMM9D_INST_WORD_POS_X     18
+#define IMM64_IMM9D_VAL_POS_X           7
+
+#define IMM64_IMM5C_INST_WORD_X         3
+#define IMM64_IMM5C_SIZE_X              5
+#define IMM64_IMM5C_INST_WORD_POS_X     13
+#define IMM64_IMM5C_VAL_POS_X           16
+
+#define IMM64_IC_INST_WORD_X            3
+#define IMM64_IC_SIZE_X                 1
+#define IMM64_IC_INST_WORD_POS_X        12
+#define IMM64_IC_VAL_POS_X              21
+
+#define IMM64_IMM41A_INST_WORD_X        1
+#define IMM64_IMM41A_SIZE_X             10
+#define IMM64_IMM41A_INST_WORD_POS_X    14
+#define IMM64_IMM41A_VAL_POS_X          22
+
+#define IMM64_IMM41B_INST_WORD_X        1
+#define IMM64_IMM41B_SIZE_X             8
+#define IMM64_IMM41B_INST_WORD_POS_X    24
+#define IMM64_IMM41B_VAL_POS_X          32
+
+#define IMM64_IMM41C_INST_WORD_X        2
+#define IMM64_IMM41C_SIZE_X             23
+#define IMM64_IMM41C_INST_WORD_POS_X    0
+#define IMM64_IMM41C_VAL_POS_X          40
+
+#define IMM64_SIGN_INST_WORD_X          3
+#define IMM64_SIGN_SIZE_X               1
+#define IMM64_SIGN_INST_WORD_POS_X      27
+#define IMM64_SIGN_VAL_POS_X            63
+
+/**
+  Performs an Itanium-based specific relocation fixup.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @retval RETURN_SUCCESS Succeed to fix the relocation entry.
+  @retval RETURN_UNSUPPOTED Unrecoganized relocation entry.
+
+**/
+RETURN_STATUS
+PeCoffLoaderRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  UINT64      *Fixup64;
+  UINT64      FixupVal;
+
+  switch ((*Reloc) >> 12) {
+    case EFI_IMAGE_REL_BASED_IA64_IMM64:
+
+      //
+      // Align it to bundle address before fixing up the
+      // 64-bit immediate value of the movl instruction.
+      //
+
+      Fixup = (CHAR8 *)((UINTN) Fixup & (UINTN) ~(15));
+      FixupVal = (UINT64)0;
+
+      //
+      // Extract the lower 32 bits of IMM64 from bundle
+      //
+      EXT_IMM64(FixupVal,
+                (UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X,
+                IMM64_IMM7B_SIZE_X,
+                IMM64_IMM7B_INST_WORD_POS_X,
+                IMM64_IMM7B_VAL_POS_X
+                );
+
+      EXT_IMM64(FixupVal,
+                (UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X,
+                IMM64_IMM9D_SIZE_X,
+                IMM64_IMM9D_INST_WORD_POS_X,
+                IMM64_IMM9D_VAL_POS_X
+                );
+
+      EXT_IMM64(FixupVal,
+                (UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X,
+                IMM64_IMM5C_SIZE_X,
+                IMM64_IMM5C_INST_WORD_POS_X,
+                IMM64_IMM5C_VAL_POS_X
+                );
+
+      EXT_IMM64(FixupVal,
+                (UINT32 *)Fixup + IMM64_IC_INST_WORD_X,
+                IMM64_IC_SIZE_X,
+                IMM64_IC_INST_WORD_POS_X,
+                IMM64_IC_VAL_POS_X
+                );
+
+      EXT_IMM64(FixupVal,
+                (UINT32 *)Fixup + IMM64_IMM41A_INST_WORD_X,
+                IMM64_IMM41A_SIZE_X,
+                IMM64_IMM41A_INST_WORD_POS_X,
+                IMM64_IMM41A_VAL_POS_X
+                );
+
+      //
+      // Update 64-bit address
+      //
+      FixupVal += Adjust;
+
+      //
+      // Insert IMM64 into bundle
+      //
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X),
+                IMM64_IMM7B_SIZE_X,
+                IMM64_IMM7B_INST_WORD_POS_X,
+                IMM64_IMM7B_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X),
+                IMM64_IMM9D_SIZE_X,
+                IMM64_IMM9D_INST_WORD_POS_X,
+                IMM64_IMM9D_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X),
+                IMM64_IMM5C_SIZE_X,
+                IMM64_IMM5C_INST_WORD_POS_X,
+                IMM64_IMM5C_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IC_INST_WORD_X),
+                IMM64_IC_SIZE_X,
+                IMM64_IC_INST_WORD_POS_X,
+                IMM64_IC_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM41A_INST_WORD_X),
+                IMM64_IMM41A_SIZE_X,
+                IMM64_IMM41A_INST_WORD_POS_X,
+                IMM64_IMM41A_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM41B_INST_WORD_X),
+                IMM64_IMM41B_SIZE_X,
+                IMM64_IMM41B_INST_WORD_POS_X,
+                IMM64_IMM41B_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_IMM41C_INST_WORD_X),
+                IMM64_IMM41C_SIZE_X,
+                IMM64_IMM41C_INST_WORD_POS_X,
+                IMM64_IMM41C_VAL_POS_X
+                );
+
+      INS_IMM64(FixupVal,
+                ((UINT32 *)Fixup + IMM64_SIGN_INST_WORD_X),
+                IMM64_SIGN_SIZE_X,
+                IMM64_SIGN_INST_WORD_POS_X,
+                IMM64_SIGN_VAL_POS_X
+                );
+
+      Fixup64 = (UINT64 *) Fixup;
+      if (*FixupData != NULL) {
+        *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));
+        *(UINT64 *)(*FixupData) = *Fixup64;
+        *FixupData = *FixupData + sizeof(UINT64);
+      }
+      break;
+
+    default:
+      return RETURN_UNSUPPORTED;
+  }
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Returns TRUE if the machine type of PE/COFF image is supported. Supported
+  does not mean the image can be executed it means the PE/COFF loader supports
+  loading and relocating of the image type. It's up to the caller to support
+  the entry point. 
+  
+  The itanium version PE/COFF loader/relocater supports itanium and EBC image.
+
+  @param  Machine   Machine type from the PE Header.
+
+  @return TRUE if this PE/COFF loader can load the image
+  @return FALSE unrecoganized machine type of image.
+
+**/
+BOOLEAN
+PeCoffLoaderImageFormatSupported (
+  IN  UINT16  Machine
+  )
+{
+  if ((Machine == IMAGE_FILE_MACHINE_IA64) || (Machine == IMAGE_FILE_MACHINE_EBC)) {
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+
+/**
+  ImageRead function that operates on a memory buffer whos base is passed into
+  FileHandle.
+
+  @param  Reloc             Ponter to baes of the input stream
+  @param  Fixup             Offset to the start of the buffer
+  @param  FixupData         The number of bytes to copy into the buffer
+  @param  Adjust            Location to place results of read
+
+  @retval RETURN_SUCCESS    Data is read from FileOffset from the Handle into
+                            the buffer.
+  @retval RETURN_UNSUPPORTED Un-recoganized relocation entry
+                             type.
+**/
+RETURN_STATUS
+PeHotRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  UINT64  *Fixup64;
+  UINT64  FixupVal;
+
+  switch ((*Reloc) >> 12) {
+  case EFI_IMAGE_REL_BASED_DIR64:
+    Fixup64     = (UINT64 *) Fixup;
+    *FixupData  = ALIGN_POINTER (*FixupData, sizeof (UINT64));
+    if (*(UINT64 *) (*FixupData) == *Fixup64) {
+      *Fixup64 = *Fixup64 + (UINT64) Adjust;
+    }
+
+    *FixupData = *FixupData + sizeof (UINT64);
+    break;
+
+  case EFI_IMAGE_REL_BASED_IA64_IMM64:
+    Fixup64     = (UINT64 *) Fixup;
+    *FixupData  = ALIGN_POINTER (*FixupData, sizeof (UINT64));
+    if (*(UINT64 *) (*FixupData) == *Fixup64) {
+      //
+      // Align it to bundle address before fixing up the
+      // 64-bit immediate value of the movl instruction.
+      //
+      //
+      Fixup     = (CHAR8 *) ((UINT64) Fixup & (UINT64)~(15));
+      FixupVal  = (UINT64) 0;
+
+      //
+      // Extract the lower 32 bits of IMM64 from bundle
+      //
+      EXT_IMM64 (
+        FixupVal,
+        (UINT32 *) Fixup + IMM64_IMM7B_INST_WORD_X,
+        IMM64_IMM7B_SIZE_X,
+        IMM64_IMM7B_INST_WORD_POS_X,
+        IMM64_IMM7B_VAL_POS_X
+        );
+
+      EXT_IMM64 (
+        FixupVal,
+        (UINT32 *) Fixup + IMM64_IMM9D_INST_WORD_X,
+        IMM64_IMM9D_SIZE_X,
+        IMM64_IMM9D_INST_WORD_POS_X,
+        IMM64_IMM9D_VAL_POS_X
+        );
+
+      EXT_IMM64 (
+        FixupVal,
+        (UINT32 *) Fixup + IMM64_IMM5C_INST_WORD_X,
+        IMM64_IMM5C_SIZE_X,
+        IMM64_IMM5C_INST_WORD_POS_X,
+        IMM64_IMM5C_VAL_POS_X
+        );
+
+      EXT_IMM64 (
+        FixupVal,
+        (UINT32 *) Fixup + IMM64_IC_INST_WORD_X,
+        IMM64_IC_SIZE_X,
+        IMM64_IC_INST_WORD_POS_X,
+        IMM64_IC_VAL_POS_X
+        );
+
+      EXT_IMM64 (
+        FixupVal,
+        (UINT32 *) Fixup + IMM64_IMM41A_INST_WORD_X,
+        IMM64_IMM41A_SIZE_X,
+        IMM64_IMM41A_INST_WORD_POS_X,
+        IMM64_IMM41A_VAL_POS_X
+        );
+
+      //
+      // Update 64-bit address
+      //
+      FixupVal += Adjust;
+
+      //
+      // Insert IMM64 into bundle
+      //
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM7B_INST_WORD_X),
+        IMM64_IMM7B_SIZE_X,
+        IMM64_IMM7B_INST_WORD_POS_X,
+        IMM64_IMM7B_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM9D_INST_WORD_X),
+        IMM64_IMM9D_SIZE_X,
+        IMM64_IMM9D_INST_WORD_POS_X,
+        IMM64_IMM9D_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM5C_INST_WORD_X),
+        IMM64_IMM5C_SIZE_X,
+        IMM64_IMM5C_INST_WORD_POS_X,
+        IMM64_IMM5C_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IC_INST_WORD_X),
+        IMM64_IC_SIZE_X,
+        IMM64_IC_INST_WORD_POS_X,
+        IMM64_IC_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM41A_INST_WORD_X),
+        IMM64_IMM41A_SIZE_X,
+        IMM64_IMM41A_INST_WORD_POS_X,
+        IMM64_IMM41A_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM41B_INST_WORD_X),
+        IMM64_IMM41B_SIZE_X,
+        IMM64_IMM41B_INST_WORD_POS_X,
+        IMM64_IMM41B_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_IMM41C_INST_WORD_X),
+        IMM64_IMM41C_SIZE_X,
+        IMM64_IMM41C_INST_WORD_POS_X,
+        IMM64_IMM41C_VAL_POS_X
+        );
+
+      INS_IMM64 (
+        FixupVal,
+        ((UINT32 *) Fixup + IMM64_SIGN_INST_WORD_X),
+        IMM64_SIGN_SIZE_X,
+        IMM64_SIGN_INST_WORD_POS_X,
+        IMM64_SIGN_VAL_POS_X
+        );
+
+      *(UINT64 *) (*FixupData) = *Fixup64;
+    }
+
+    *FixupData = *FixupData + sizeof (UINT64);
+    break;
+
+  default:
+    DEBUG ((EFI_D_ERROR, "PeHotRelocateEx:unknown fixed type\n"));
+    return RETURN_UNSUPPORTED;
+  }
+
+  return RETURN_SUCCESS;
+}
+
+
+
diff --git a/MdePkg/Library/BasePeCoffLib/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/PeCoffLoaderEx.c
new file mode 100644
index 000000000000..ebd19b72d593
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/PeCoffLoaderEx.c
@@ -0,0 +1,90 @@
+/** @file
+  Specific relocation fixups for none Itanium architecture.
+
+  Copyright (c) 2006 - 2010, 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 "BasePeCoffLibInternals.h"
+
+
+/**
+  Performs an Itanium-based specific relocation fixup and is a no-op on other
+  instruction sets.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeCoffLoaderRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Returns TRUE if the machine type of PE/COFF image is supported. Supported
+  does not mean the image can be executed it means the PE/COFF loader supports
+  loading and relocating of the image type. It's up to the caller to support
+  the entry point.
+  
+  The IA32/X64 version PE/COFF loader/relocater both support IA32, X64 and EBC images.
+
+  @param  Machine   The machine type from the PE Header.
+
+  @return TRUE if this PE/COFF loader can load the image
+
+**/
+BOOLEAN
+PeCoffLoaderImageFormatSupported (
+  IN  UINT16  Machine
+  )
+{
+  if ((Machine == IMAGE_FILE_MACHINE_I386) || (Machine == IMAGE_FILE_MACHINE_X64) || 
+      (Machine == IMAGE_FILE_MACHINE_EBC) || (Machine == IMAGE_FILE_MACHINE_ARM64)) {
+    return TRUE; 
+  }
+
+  return FALSE;
+}
+
+/**
+  Performs an Itanium-based specific re-relocation fixup and is a no-op on other
+  instruction sets. This is used to re-relocated the image into the EFI virtual
+  space for runtime calls.
+
+  @param  Reloc       The pointer to the relocation record.
+  @param  Fixup       The pointer to the address to fix up.
+  @param  FixupData   The pointer to a buffer to log the fixups.
+  @param  Adjust      The offset to adjust the fixup.
+
+  @return Status code.
+
+**/
+RETURN_STATUS
+PeHotRelocateImageEx (
+  IN UINT16      *Reloc,
+  IN OUT CHAR8   *Fixup,
+  IN OUT CHAR8   **FixupData,
+  IN UINT64      Adjust
+  )
+{
+  return RETURN_UNSUPPORTED;
+}
+
diff --git a/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf b/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
new file mode 100644
index 000000000000..ebc0cea96ef3
--- /dev/null
+++ b/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
@@ -0,0 +1,45 @@
+## @file
+#  Instance of Performance Library with empty functions.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePerformanceLibNull
+  MODULE_UNI_FILE                = BasePerformanceLibNull.uni
+  FILE_GUID                      = FC120ED3-40E1-46dc-8C9C-AAE3CA139ACF
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PerformanceLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PerformanceLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  PcdLib
+  DebugLib
+
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask  ## CONSUMES
+
diff --git a/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.uni b/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.uni
new file mode 100644
index 000000000000..319468339150
--- /dev/null
+++ b/MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Performance Library with empty functions.
+//
+// Instance of Performance Library with empty functions.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Performance Library with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Instance of Performance Library with empty functions."
+
diff --git a/MdePkg/Library/BasePerformanceLibNull/PerformanceLib.c b/MdePkg/Library/BasePerformanceLibNull/PerformanceLib.c
new file mode 100644
index 000000000000..d4f5e0898538
--- /dev/null
+++ b/MdePkg/Library/BasePerformanceLibNull/PerformanceLib.c
@@ -0,0 +1,306 @@
+/** @file
+  Base Performance Library which provides no service.
+
+  Copyright (c) 2006 - 2012, 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 <Base.h>
+
+
+#include <Library/PerformanceLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+/**
+  Creates a record for the beginning of a performance measurement. 
+  
+  Creates a record that contains the Handle, Token, and Module.
+  If TimeStamp is not zero, then TimeStamp is added to the record as the start time.
+  If TimeStamp is zero, then this function reads the current time stamp
+  and adds that time stamp value to the record as the start time.
+
+  @param  Handle                  The pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   The pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  The pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+
+  @retval RETURN_SUCCESS          The start of the measurement was recorded.
+  @retval RETURN_OUT_OF_RESOURCES There are not enough resources to record the measurement.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+StartPerformanceMeasurement (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp
+  )
+{
+  return RETURN_SUCCESS;
+}
+
+/**
+  Fills in the end time of a performance measurement. 
+  
+  Looks up the record that matches Handle, Token, and Module.
+  If the record can not be found then return RETURN_NOT_FOUND.
+  If the record is found and TimeStamp is not zero,
+  then TimeStamp is added to the record as the end time.
+  If the record is found and TimeStamp is zero, then this function reads
+  the current time stamp and adds that time stamp value to the record as the end time.
+
+  @param  Handle                  The pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   The pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  The pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+
+  @retval RETURN_SUCCESS          The end of the measurement was recorded.
+  @retval RETURN_NOT_FOUND        The specified measurement record could not be found.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+EndPerformanceMeasurement (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp
+  )
+{
+  return RETURN_SUCCESS;
+}
+
+/**
+  Attempts to retrieve a performance measurement log entry from the performance measurement log. 
+  It can also retrieve the log created by StartPerformanceMeasurementEx and EndPerformanceMeasurementEx,
+  and then eliminate the Identifier.
+
+  Attempts to retrieve the performance log entry specified by LogEntryKey.  If LogEntryKey is
+  zero on entry, then an attempt is made to retrieve the first entry from the performance log,
+  and the key for the second entry in the log is returned.  If the performance log is empty,
+  then no entry is retrieved and zero is returned.  If LogEntryKey is not zero, then the performance
+  log entry associated with LogEntryKey is retrieved, and the key for the next entry in the log is
+  returned.  If LogEntryKey is the key for the last entry in the log, then the last log entry is
+  retrieved and an implementation specific non-zero key value that specifies the end of the performance
+  log is returned.  If LogEntryKey is equal this implementation specific non-zero key value, then no entry
+  is retrieved and zero is returned.  In the cases where a performance log entry can be returned,
+  the log entry is returned in Handle, Token, Module, StartTimeStamp, and EndTimeStamp.
+  If LogEntryKey is not a valid log entry key for the performance measurement log, then ASSERT().
+  If Handle is NULL, then ASSERT().
+  If Token is NULL, then ASSERT().
+  If Module is NULL, then ASSERT().
+  If StartTimeStamp is NULL, then ASSERT().
+  If EndTimeStamp is NULL, then ASSERT().
+
+  @param  LogEntryKey             On entry, the key of the performance measurement log entry to retrieve.
+                                  0, then the first performance measurement log entry is retrieved.
+                                  On exit, the key of the next performance lof entry entry.
+  @param  Handle                  The pointer to environment specific context used to identify the component
+                                  being measured.  
+  @param  Token                   The pointer to a Null-terminated ASCII string that identifies the component
+                                  being measured. 
+  @param  Module                  The pointer to a Null-terminated ASCII string that identifies the module
+                                  being measured.
+  @param  StartTimeStamp          The pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was started.
+  @param  EndTimeStamp            The pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was ended.
+
+  @return The key for the next performance log entry (in general case).
+
+**/
+UINTN
+EFIAPI
+GetPerformanceMeasurement (
+  IN  UINTN       LogEntryKey, 
+  OUT CONST VOID  **Handle,
+  OUT CONST CHAR8 **Token,
+  OUT CONST CHAR8 **Module,
+  OUT UINT64      *StartTimeStamp,
+  OUT UINT64      *EndTimeStamp
+  )
+{
+  ASSERT (Handle != NULL);
+  ASSERT (Token != NULL);
+  ASSERT (Module != NULL);
+  ASSERT (StartTimeStamp != NULL);
+  ASSERT (EndTimeStamp != NULL);
+
+  return 0;
+}
+
+/**
+  Creates a record for the beginning of a performance measurement.
+
+  Creates a record that contains the Handle, Token, Module and Identifier.
+  If TimeStamp is not zero, then TimeStamp is added to the record as the start time.
+  If TimeStamp is zero, then this function reads the current time stamp
+  and adds that time stamp value to the record as the start time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+  @param  Identifier              32-bit identifier. If the value is 0, the created record
+                                  is same as the one created by StartPerformanceMeasurement.
+
+  @retval RETURN_SUCCESS          The start of the measurement was recorded.
+  @retval RETURN_OUT_OF_RESOURCES There are not enough resources to record the measurement.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+StartPerformanceMeasurementEx (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp,
+  IN UINT32       Identifier
+  )
+{
+  return RETURN_SUCCESS;
+}
+
+/**
+  Fills in the end time of a performance measurement.
+
+  Looks up the record that matches Handle, Token, Module and Identifier.
+  If the record can not be found then return RETURN_NOT_FOUND.
+  If the record is found and TimeStamp is not zero,
+  then TimeStamp is added to the record as the end time.
+  If the record is found and TimeStamp is zero, then this function reads
+  the current time stamp and adds that time stamp value to the record as the end time.
+
+  @param  Handle                  Pointer to environment specific context used
+                                  to identify the component being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string
+                                  that identifies the component being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string
+                                  that identifies the module being measured.
+  @param  TimeStamp               64-bit time stamp.
+  @param  Identifier              32-bit identifier. If the value is 0, the found record
+                                  is same as the one found by EndPerformanceMeasurement.
+
+  @retval RETURN_SUCCESS          The end of  the measurement was recorded.
+  @retval RETURN_NOT_FOUND        The specified measurement record could not be found.
+  @retval RETURN_DEVICE_ERROR     A device error reading the time stamp.
+
+**/
+RETURN_STATUS
+EFIAPI
+EndPerformanceMeasurementEx (
+  IN CONST VOID   *Handle,  OPTIONAL
+  IN CONST CHAR8  *Token,   OPTIONAL
+  IN CONST CHAR8  *Module,  OPTIONAL
+  IN UINT64       TimeStamp,
+  IN UINT32       Identifier
+  )
+{
+  return RETURN_SUCCESS;
+}
+
+/**
+  Attempts to retrieve a performance measurement log entry from the performance measurement log.
+  It can also retrieve the log created by StartPerformanceMeasurement and EndPerformanceMeasurement,
+  and then assign the Identifier with 0.
+
+  Attempts to retrieve the performance log entry specified by LogEntryKey.  If LogEntryKey is
+  zero on entry, then an attempt is made to retrieve the first entry from the performance log,
+  and the key for the second entry in the log is returned.  If the performance log is empty,
+  then no entry is retrieved and zero is returned.  If LogEntryKey is not zero, then the performance
+  log entry associated with LogEntryKey is retrieved, and the key for the next entry in the log is
+  returned.  If LogEntryKey is the key for the last entry in the log, then the last log entry is
+  retrieved and an implementation specific non-zero key value that specifies the end of the performance
+  log is returned.  If LogEntryKey is equal this implementation specific non-zero key value, then no entry
+  is retrieved and zero is returned.  In the cases where a performance log entry can be returned,
+  the log entry is returned in Handle, Token, Module, StartTimeStamp, EndTimeStamp and Identifier.
+  If LogEntryKey is not a valid log entry key for the performance measurement log, then ASSERT().
+  If Handle is NULL, then ASSERT().
+  If Token is NULL, then ASSERT().
+  If Module is NULL, then ASSERT().
+  If StartTimeStamp is NULL, then ASSERT().
+  If EndTimeStamp is NULL, then ASSERT().
+  If Identifier is NULL, then ASSERT().
+
+  @param  LogEntryKey             On entry, the key of the performance measurement log entry to retrieve.
+                                  0, then the first performance measurement log entry is retrieved.
+                                  On exit, the key of the next performance lof entry entry.
+  @param  Handle                  Pointer to environment specific context used to identify the component
+                                  being measured.
+  @param  Token                   Pointer to a Null-terminated ASCII string that identifies the component
+                                  being measured.
+  @param  Module                  Pointer to a Null-terminated ASCII string that identifies the module
+                                  being measured.
+  @param  StartTimeStamp          Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was started.
+  @param  EndTimeStamp            Pointer to the 64-bit time stamp that was recorded when the measurement
+                                  was ended.
+  @param  Identifier              Pointer to the 32-bit identifier that was recorded.
+
+  @return The key for the next performance log entry (in general case).
+
+**/
+UINTN
+EFIAPI
+GetPerformanceMeasurementEx (
+  IN  UINTN       LogEntryKey, 
+  OUT CONST VOID  **Handle,
+  OUT CONST CHAR8 **Token,
+  OUT CONST CHAR8 **Module,
+  OUT UINT64      *StartTimeStamp,
+  OUT UINT64      *EndTimeStamp,
+  OUT UINT32      *Identifier
+  )
+{
+  ASSERT (Handle != NULL);
+  ASSERT (Token != NULL);
+  ASSERT (Module != NULL);
+  ASSERT (StartTimeStamp != NULL);
+  ASSERT (EndTimeStamp != NULL);
+  ASSERT (Identifier != NULL);
+
+  return 0;
+}
+
+/**
+  Returns TRUE if the performance measurement macros are enabled. 
+  
+  This function returns TRUE if the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+  PcdPerformanceLibraryPropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval TRUE                    The PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+                                  PcdPerformanceLibraryPropertyMask is set.
+  @retval FALSE                   The PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of
+                                  PcdPerformanceLibraryPropertyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PerformanceMeasurementEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPerformanceLibraryPropertyMask) & PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED) != 0);
+}
diff --git a/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.inf b/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.inf
new file mode 100644
index 000000000000..4dfdfa2894d8
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.inf
@@ -0,0 +1,50 @@
+## @file
+#  Instance of Post Code Library based on Debug Library.
+#
+#  Post Code Library that uses DebugLib service to send PostCode.
+#  It layers on top of a Debug Library instance.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePostCodeLibDebug
+  MODULE_UNI_FILE                = BasePostCodeLibDebug.uni
+  FILE_GUID                      = 19e3bbba-beb1-43e8-b32d-9acbb22c7639
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PostCodeLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+
+[Sources]
+  PostCode.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+
+[LibraryClasses]
+  PcdLib
+  DebugLib
+
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask  ## CONSUMES
+
diff --git a/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.uni b/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.uni
new file mode 100644
index 000000000000..9a26925bdfcc
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Post Code Library based on Debug Library.
+//
+// Post Code Library that uses DebugLib service to send PostCode.
+// It layers on top of a Debug Library instance.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Post Code Library based on Debug Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Post Code Library that uses the DebugLib service to send PostCode. It layers on top of a Debug Library instance."
+
diff --git a/MdePkg/Library/BasePostCodeLibDebug/PostCode.c b/MdePkg/Library/BasePostCodeLibDebug/PostCode.c
new file mode 100644
index 000000000000..b8477bde7ab6
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibDebug/PostCode.c
@@ -0,0 +1,127 @@
+/** @file
+  The instance of Post Code Library that layers on top of a Debug Library instance.
+
+  Copyright (c) 2006 - 2010, 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 <Base.h>
+
+#include <Library/PostCodeLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+/**
+  Sends an 32-bit value to a POST card.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.  
+  Some implementations of this library function may perform I/O operations 
+  directly to a POST card device.  Other implementations may send Value to 
+  ReportStatusCode(), and the status code reporting mechanism will eventually 
+  display the 32-bit value on the status reporting device.
+  
+  PostCode() must actively prevent recursion.  If PostCode() is called while 
+  processing another any other Post Code Library function, then 
+  PostCode() must return Value immediately.
+
+  @param  Value  The 32-bit value to write to the POST card.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCode (
+  IN UINT32  Value
+  )
+{
+  DEBUG((EFI_D_INFO, "POST %08x\n", Value));
+  return Value;
+}
+
+
+/**
+  Sends an 32-bit value to a POST and associated ASCII string.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.
+  If Description is not NULL, then the ASCII string specified by Description is 
+  also passed to the handler that displays the POST card value.  Some 
+  implementations of this library function may perform I/O operations directly 
+  to a POST card device.  Other implementations may send Value to ReportStatusCode(), 
+  and the status code reporting mechanism will eventually display the 32-bit 
+  value on the status reporting device.  
+
+  PostCodeWithDescription()must actively prevent recursion.  If 
+  PostCodeWithDescription() is called while processing another any other Post 
+  Code Library function, then PostCodeWithDescription() must return Value 
+  immediately.
+
+  @param  Value        The 32-bit value to write to the POST card.
+  @param  Description  The pointer to an ASCII string that is a description of the 
+                       POST code value.  This is an optional parameter that may 
+                       be NULL.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCodeWithDescription (
+  IN UINT32       Value,
+  IN CONST CHAR8  *Description  OPTIONAL
+  )
+{
+  DEBUG((EFI_D_INFO, "POST %08x - %s\n", Value, Description));
+  return Value;
+}
+
+
+/**
+  Returns TRUE if POST Codes are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_ENABLED 
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_ENABLED) != 0);
+}
+
+
+/**
+  Returns TRUE if POST code descriptions are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeDescriptionEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED) != 0);
+}
diff --git a/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.inf b/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.inf
new file mode 100644
index 000000000000..b337639eaa89
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.inf
@@ -0,0 +1,48 @@
+## @file
+#  Instance of Post Code Library using I/O port 0x80.
+#
+#  Post Code Library that writes post code values to I/O port 0x80.
+#
+#  Copyright (c) 2007 - 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePostCodeLibPort80
+  MODULE_UNI_FILE                = BasePostCodeLibPort80.uni
+  FILE_GUID                      = b6e9a733-eb75-41b6-b30c-009bcf3801c8
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PostCodeLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PostCode.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  IoLib
+  PcdLib
+  DebugLib
+
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask  ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdPort80DataWidth ## CONSUMES
diff --git a/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.uni b/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.uni
new file mode 100644
index 000000000000..c86bf7c23248
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Post Code Library using I/O port 0x80.
+//
+// Post Code Library that writes post code values to I/O port 0x80.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Post Code Library using I/O port 0x80"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Post Code Library that writes post code values to I/O port 0x80."
+
diff --git a/MdePkg/Library/BasePostCodeLibPort80/PostCode.c b/MdePkg/Library/BasePostCodeLibPort80/PostCode.c
new file mode 100644
index 000000000000..8160a16dbdeb
--- /dev/null
+++ b/MdePkg/Library/BasePostCodeLibPort80/PostCode.c
@@ -0,0 +1,145 @@
+/** @file
+  Post Code Library instance that writes post code values to I/O port 0x80.
+
+  Copyright (c) 2006 - 2015, 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 <Base.h>
+
+#include <Library/PostCodeLib.h>
+#include <Library/PcdLib.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Sends an 32-bit value to a POST card.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.  
+  Some implementations of this library function may perform I/O operations 
+  directly to a POST card device.  Other implementations may send Value to 
+  ReportStatusCode(), and the status code reporting mechanism will eventually 
+  display the 32-bit value on the status reporting device.
+  
+  PostCode() must actively prevent recursion.  If PostCode() is called while 
+  processing another any other Post Code Library function, then 
+  PostCode() must return Value immediately.
+
+  @param  Value  The 32-bit value to write to the POST card.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCode (
+  IN UINT32  Value
+  )
+{
+  switch (PcdGet8 (PcdPort80DataWidth)) {
+  case 8:
+    IoWrite8 (0x80, (UINT8)(Value));
+    break;
+  case 16:
+    IoWrite16 (0x80, (UINT16)(Value));
+    break;
+  case 32:
+    IoWrite32 (0x80, Value);
+    break;
+  default:
+    //
+    // Assert on the invalid data width
+    //
+    ASSERT (FALSE);
+    break;
+  }
+  
+  return Value;
+}
+
+
+/**
+  Sends an 32-bit value to a POST and associated ASCII string.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.
+  If Description is not NULL, then the ASCII string specified by Description is 
+  also passed to the handler that displays the POST card value.  Some 
+  implementations of this library function may perform I/O operations directly 
+  to a POST card device.  Other implementations may send Value to ReportStatusCode(), 
+  and the status code reporting mechanism will eventually display the 32-bit 
+  value on the status reporting device.  
+
+  PostCodeWithDescription()must actively prevent recursion.  If 
+  PostCodeWithDescription() is called while processing another any other Post 
+  Code Library function, then PostCodeWithDescription() must return Value 
+  immediately.
+
+  @param  Value        The 32-bit value to write to the POST card.
+  @param  Description  The pointer to an ASCII string that is a description of the 
+                       POST code value.  This is an optional parameter that may 
+                       be NULL.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCodeWithDescription (
+  IN UINT32       Value,
+  IN CONST CHAR8  *Description  OPTIONAL
+  )
+{
+  PostCode (Value);
+  return Value;
+}
+
+
+/**
+  Returns TRUE if POST Codes are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_ENABLED 
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_ENABLED) != 0);
+}
+
+
+/**
+  Returns TRUE if POST code descriptions are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeDescriptionEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED) != 0);
+}
diff --git a/MdePkg/Library/BasePrintLib/BasePrintLib.inf b/MdePkg/Library/BasePrintLib/BasePrintLib.inf
new file mode 100644
index 000000000000..b6d2eb9c42a6
--- /dev/null
+++ b/MdePkg/Library/BasePrintLib/BasePrintLib.inf
@@ -0,0 +1,50 @@
+## @file
+#  Print Library implementation.
+#
+#  Copyright (c) 2007 - 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BasePrintLib
+  MODULE_UNI_FILE                = BasePrintLib.uni
+  FILE_GUID                      = a86fbfca-0183-4eeb-aa8a-762e3b7da1f3
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PrintLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+
+[Sources]
+  PrintLibInternal.h
+  PrintLibInternal.c
+  PrintLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+  PcdLib
+
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength     ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength   ## SOMETIMES_CONSUMES
+
diff --git a/MdePkg/Library/BasePrintLib/BasePrintLib.uni b/MdePkg/Library/BasePrintLib/BasePrintLib.uni
new file mode 100644
index 000000000000..75fec00c6c78
--- /dev/null
+++ b/MdePkg/Library/BasePrintLib/BasePrintLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Print Library implementation.
+//
+// Print Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Print Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Print Library implementation."
+
diff --git a/MdePkg/Library/BasePrintLib/PrintLib.c b/MdePkg/Library/BasePrintLib/PrintLib.c
new file mode 100644
index 000000000000..35970c05f0cc
--- /dev/null
+++ b/MdePkg/Library/BasePrintLib/PrintLib.c
@@ -0,0 +1,962 @@
+/** @file
+  Base Print Library instance implementation.
+
+  Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "PrintLibInternal.h"
+
+//
+// Declare a VA_LIST global variable that is used in calls to BasePrintLibSPrintMarker()
+// when the BASE_LIST parameter is valid and the VA_LIST parameter is ignored.  
+// A NULL VA_LIST can not be passed into  BasePrintLibSPrintMarker() because some 
+// compilers define VA_LIST to be a structure.
+//
+VA_LIST gNullVaList;
+
+#define ASSERT_UNICODE_BUFFER(Buffer) ASSERT ((((UINTN) (Buffer)) & 0x01) == 0)
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on
+  a Null-terminated Unicode format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeVSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (StartOfBuffer);
+  ASSERT_UNICODE_BUFFER (FormatString);
+  return BasePrintLibSPrintMarker ((CHAR8 *)StartOfBuffer, BufferSize >> 1, FORMAT_UNICODE | OUTPUT_UNICODE, (CHAR8 *)FormatString, Marker, NULL);
+}
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on
+  a Null-terminated Unicode format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeBSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  BASE_LIST     Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (StartOfBuffer);
+  ASSERT_UNICODE_BUFFER (FormatString);
+  return BasePrintLibSPrintMarker ((CHAR8 *)StartOfBuffer, BufferSize >> 1, FORMAT_UNICODE | OUTPUT_UNICODE, (CHAR8 *)FormatString, gNullVaList, Marker);
+}
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  Unicode format string and variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then the output buffer is unmodified and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeSPrint (
+  OUT CHAR16        *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   NumberOfPrinted;
+
+  VA_START (Marker, FormatString);
+  NumberOfPrinted = UnicodeVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);
+  VA_END (Marker);
+  return NumberOfPrinted;
+}
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeVSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  IN  VA_LIST      Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (StartOfBuffer);
+  return BasePrintLibSPrintMarker ((CHAR8 *)StartOfBuffer, BufferSize >> 1, OUTPUT_UNICODE, FormatString, Marker, NULL);
+}
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeBSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  IN  BASE_LIST    Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (StartOfBuffer);
+  return BasePrintLibSPrintMarker ((CHAR8 *)StartOfBuffer, BufferSize >> 1, OUTPUT_UNICODE, FormatString, gNullVaList, Marker);
+}
+
+/**
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  ASCII format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of Unicode characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 1 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and BufferSize >
+  (PcdMaximumUnicodeStringLength * sizeof (CHAR16) + 1), then ASSERT(). Also, the output
+  buffer is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          Unicode string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of Unicode characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeSPrintAsciiFormat (
+  OUT CHAR16       *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   NumberOfPrinted;
+
+  VA_START (Marker, FormatString);
+  NumberOfPrinted = UnicodeVSPrintAsciiFormat (StartOfBuffer, BufferSize, FormatString, Marker);
+  VA_END (Marker);
+  return NumberOfPrinted;
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Converts a decimal value to a Null-terminated Unicode string.
+  
+  Converts the decimal number specified by Value to a Null-terminated Unicode 
+  string specified by Buffer containing at most Width characters. No padding of spaces 
+  is ever performed. If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
+  The number of Unicode characters in Buffer is returned not including the Null-terminator.
+  If the conversion contains more than Width characters, then only the first
+  Width characters are returned, and the total number of characters 
+  required to perform the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be 
+  formatted in hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer  The pointer to the output buffer for the produced Null-terminated
+                  Unicode string.
+  @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
+  @param  Value   The 64-bit signed value to convert to a string.
+  @param  Width   The maximum number of Unicode characters to place in Buffer, not including
+                  the Null-terminator.
+  
+  @return The number of Unicode characters in Buffer not including the Null-terminator.
+
+**/
+UINTN
+EFIAPI
+UnicodeValueToString (
+  IN OUT CHAR16  *Buffer,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  )
+{
+  ASSERT_UNICODE_BUFFER(Buffer);
+  return BasePrintLibConvertValueToString ((CHAR8 *)Buffer, Flags, Value, Width, 2);
+}
+
+#endif
+
+/**
+  Converts a decimal value to a Null-terminated Unicode string.
+
+  Converts the decimal number specified by Value to a Null-terminated Unicode
+  string specified by Buffer containing at most Width characters. No padding of
+  spaces is ever performed. If Width is 0 then a width of
+  MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more than
+  Width characters, then only the first Width characters are placed in Buffer.
+  Additional conversion parameters are specified in Flags.
+
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be formatted in
+  hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in
+  Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, then
+  Buffer is padded with '0' characters so the combination of the optional '-'
+  sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated Unicode string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of Unicode characters to place in
+                      Buffer, not including the Null-terminator.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If PcdMaximumUnicodeStringLength is not
+                                   zero, and BufferSize is greater than
+                                   (PcdMaximumUnicodeStringLength *
+                                   sizeof (CHAR16) + 1).
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+EFIAPI
+UnicodeValueToStringS (
+  IN OUT CHAR16  *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  )
+{
+  ASSERT_UNICODE_BUFFER(Buffer);
+  return BasePrintLibConvertValueToStringS ((CHAR8 *)Buffer, BufferSize, Flags, Value, Width, 2);
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiVSPrint (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR8   *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  return BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, 0, FormatString, Marker, NULL);
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiBSPrint (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR8   *FormatString,
+  IN  BASE_LIST     Marker
+  )
+{
+  return BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, 0, FormatString, gNullVaList, Marker);
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  ASCII format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more than
+  PcdMaximumAsciiStringLength Ascii characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated ASCII format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiSPrint (
+  OUT CHAR8        *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   NumberOfPrinted;
+
+  VA_START (Marker, FormatString);
+  NumberOfPrinted = AsciiVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);
+  VA_END (Marker);
+  return NumberOfPrinted;
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and a VA_LIST argument list.
+
+  This function is similar as vsnprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiVSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (FormatString);
+  return BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, FORMAT_UNICODE, (CHAR8 *)FormatString, Marker, NULL);
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and a BASE_LIST argument list.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on
+  the contents of the format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  Marker          BASE_LIST marker for the variable argument list.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiBSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  IN  BASE_LIST     Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (FormatString);
+  return BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, FORMAT_UNICODE, (CHAR8 *)FormatString, gNullVaList, Marker);
+}
+
+/**
+  Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
+  Unicode format string and  variable argument list.
+
+  This function is similar as snprintf_s defined in C11.
+
+  Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
+  and BufferSize.
+  The ASCII string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list based on the contents of the
+  format string.
+  The number of ASCII characters in the produced output buffer is returned not including
+  the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If BufferSize > 0 and StartOfBuffer is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If BufferSize > 0 and FormatString is NULL, then ASSERT(). Also, the output buffer is
+  unmodified and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and BufferSize >
+  (PcdMaximumAsciiStringLength * sizeof (CHAR8)), then ASSERT(). Also, the output buffer
+  is unmodified and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
+  ASSERT(). Also, the output buffer is unmodified and 0 is returned.
+
+  If BufferSize is 0, then no output buffer is produced and 0 is returned.
+
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+                          ASCII string.
+  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
+  @param  FormatString    A Null-terminated Unicode format string.
+  @param  ...             Variable argument list whose contents are accessed based on the
+                          format string specified by FormatString.
+
+  @return The number of ASCII characters in the produced output buffer not including the
+          Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiSPrintUnicodeFormat (
+  OUT CHAR8         *StartOfBuffer,
+  IN  UINTN         BufferSize,
+  IN  CONST CHAR16  *FormatString,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   NumberOfPrinted;
+
+  VA_START (Marker, FormatString);
+  NumberOfPrinted = AsciiVSPrintUnicodeFormat (StartOfBuffer, BufferSize, FormatString, Marker);
+  VA_END (Marker);
+  return NumberOfPrinted;
+}
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function is deprecated for security reason.
+
+  Converts a decimal value to a Null-terminated ASCII string.
+  
+  Converts the decimal number specified by Value to a Null-terminated ASCII string 
+  specified by Buffer containing at most Width characters. No padding of spaces 
+  is ever performed.
+  If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
+  The number of ASCII characters in Buffer is returned not including the Null-terminator.
+  If the conversion contains more than Width characters, then only the first Width
+  characters are returned, and the total number of characters required to perform
+  the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be 
+  formatted in hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+  
+  If Buffer is NULL, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If both COMMA_TYPE and RADIX_HEX are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer  The pointer to the output buffer for the produced Null-terminated
+                  ASCII string.
+  @param  Flags   The bitmask of flags that specify left justification, zero pad, and commas.
+  @param  Value   The 64-bit signed value to convert to a string.
+  @param  Width   The maximum number of ASCII characters to place in Buffer, not including
+                  the Null-terminator.
+  
+  @return The number of ASCII characters in Buffer not including the Null-terminator.
+
+**/
+UINTN
+EFIAPI
+AsciiValueToString (
+  OUT CHAR8      *Buffer,
+  IN  UINTN      Flags,
+  IN  INT64      Value,
+  IN  UINTN      Width
+  )
+{
+  return BasePrintLibConvertValueToString (Buffer, Flags, Value, Width, 1);
+}
+
+#endif
+
+/**
+  Converts a decimal value to a Null-terminated Ascii string.
+
+  Converts the decimal number specified by Value to a Null-terminated Ascii
+  string specified by Buffer containing at most Width characters. No padding of
+  spaces is ever performed. If Width is 0 then a width of
+  MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more than
+  Width characters, then only the first Width characters are placed in Buffer.
+  Additional conversion parameters are specified in Flags.
+
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If RADIX_HEX is set in Flags, then the output buffer will be formatted in
+  hexadecimal format.
+  If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in
+  Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, then
+  Buffer is padded with '0' characters so the combination of the optional '-'
+  sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If an error would be returned, then the function will also ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated Ascii string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of Ascii characters to place in
+                      Buffer, not including the Null-terminator.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If PcdMaximumAsciiStringLength is not
+                                   zero, and BufferSize is greater than
+                                   PcdMaximumAsciiStringLength.
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+EFIAPI
+AsciiValueToStringS (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width
+  )
+{
+  return BasePrintLibConvertValueToStringS (Buffer, BufferSize, Flags, Value, Width, 1);
+}
+
+/**
+  Returns the number of characters that would be produced by if the formatted 
+  output were produced not including the Null-terminator.
+
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+
+  If FormatString is NULL, then ASSERT() and 0 is returned.
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more
+  than PcdMaximumUnicodeStringLength Unicode characters not including the
+  Null-terminator, then ASSERT() and 0 is returned.
+
+  @param[in]  FormatString    A Null-terminated Unicode format string.
+  @param[in]  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of characters that would be produced, not including the 
+          Null-terminator.
+**/
+UINTN
+EFIAPI
+SPrintLength (
+  IN  CONST CHAR16   *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  ASSERT_UNICODE_BUFFER (FormatString);
+  return BasePrintLibSPrintMarker (NULL, 0, FORMAT_UNICODE | OUTPUT_UNICODE | COUNT_ONLY_NO_PRINT, (CHAR8 *)FormatString, Marker, NULL);
+}
+
+/**
+  Returns the number of characters that would be produced by if the formatted 
+  output were produced not including the Null-terminator.
+
+  If FormatString is NULL, then ASSERT() and 0 is returned.
+  If PcdMaximumAsciiStringLength is not zero, and FormatString contains more
+  than PcdMaximumAsciiStringLength Ascii characters not including the
+  Null-terminator, then ASSERT() and 0 is returned.
+
+  @param[in]  FormatString    A Null-terminated ASCII format string.
+  @param[in]  Marker          VA_LIST marker for the variable argument list.
+
+  @return The number of characters that would be produced, not including the 
+          Null-terminator.
+**/
+UINTN
+EFIAPI
+SPrintLengthAsciiFormat (
+  IN  CONST CHAR8   *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  return BasePrintLibSPrintMarker (NULL, 0, OUTPUT_UNICODE | COUNT_ONLY_NO_PRINT, (CHAR8 *)FormatString, Marker, NULL);
+}
diff --git a/MdePkg/Library/BasePrintLib/PrintLibInternal.c b/MdePkg/Library/BasePrintLib/PrintLibInternal.c
new file mode 100644
index 000000000000..798d7bd91bf2
--- /dev/null
+++ b/MdePkg/Library/BasePrintLib/PrintLibInternal.c
@@ -0,0 +1,1262 @@
+/** @file
+  Print Library internal worker functions.
+
+  Copyright (c) 2006 - 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 "PrintLibInternal.h"
+
+#define WARNING_STATUS_NUMBER         5
+#define ERROR_STATUS_NUMBER           33
+
+//
+// Safe print checks
+//
+#define RSIZE_MAX             (PcdGet32 (PcdMaximumUnicodeStringLength))
+#define ASCII_RSIZE_MAX       (PcdGet32 (PcdMaximumAsciiStringLength))
+
+#define SAFE_PRINT_CONSTRAINT_CHECK(Expression, RetVal)  \
+  do { \
+    ASSERT (Expression); \
+    if (!(Expression)) { \
+      return RetVal; \
+    } \
+  } while (FALSE)
+
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 * CONST mStatusString[] = {
+  "Success",                      //  RETURN_SUCCESS                = 0
+  "Warning Unknown Glyph",        //  RETURN_WARN_UNKNOWN_GLYPH     = 1
+  "Warning Delete Failure",       //  RETURN_WARN_DELETE_FAILURE    = 2
+  "Warning Write Failure",        //  RETURN_WARN_WRITE_FAILURE     = 3
+  "Warning Buffer Too Small",     //  RETURN_WARN_BUFFER_TOO_SMALL  = 4
+  "Warning Stale Data",           //  RETURN_WARN_STALE_DATA        = 5
+  "Load Error",                   //  RETURN_LOAD_ERROR             = 1  | MAX_BIT
+  "Invalid Parameter",            //  RETURN_INVALID_PARAMETER      = 2  | MAX_BIT
+  "Unsupported",                  //  RETURN_UNSUPPORTED            = 3  | MAX_BIT
+  "Bad Buffer Size",              //  RETURN_BAD_BUFFER_SIZE        = 4  | MAX_BIT
+  "Buffer Too Small",             //  RETURN_BUFFER_TOO_SMALL,      = 5  | MAX_BIT
+  "Not Ready",                    //  RETURN_NOT_READY              = 6  | MAX_BIT
+  "Device Error",                 //  RETURN_DEVICE_ERROR           = 7  | MAX_BIT
+  "Write Protected",              //  RETURN_WRITE_PROTECTED        = 8  | MAX_BIT
+  "Out of Resources",             //  RETURN_OUT_OF_RESOURCES       = 9  | MAX_BIT
+  "Volume Corrupt",               //  RETURN_VOLUME_CORRUPTED       = 10 | MAX_BIT
+  "Volume Full",                  //  RETURN_VOLUME_FULL            = 11 | MAX_BIT
+  "No Media",                     //  RETURN_NO_MEDIA               = 12 | MAX_BIT
+  "Media changed",                //  RETURN_MEDIA_CHANGED          = 13 | MAX_BIT
+  "Not Found",                    //  RETURN_NOT_FOUND              = 14 | MAX_BIT
+  "Access Denied",                //  RETURN_ACCESS_DENIED          = 15 | MAX_BIT
+  "No Response",                  //  RETURN_NO_RESPONSE            = 16 | MAX_BIT
+  "No mapping",                   //  RETURN_NO_MAPPING             = 17 | MAX_BIT
+  "Time out",                     //  RETURN_TIMEOUT                = 18 | MAX_BIT
+  "Not started",                  //  RETURN_NOT_STARTED            = 19 | MAX_BIT
+  "Already started",              //  RETURN_ALREADY_STARTED        = 20 | MAX_BIT
+  "Aborted",                      //  RETURN_ABORTED                = 21 | MAX_BIT
+  "ICMP Error",                   //  RETURN_ICMP_ERROR             = 22 | MAX_BIT
+  "TFTP Error",                   //  RETURN_TFTP_ERROR             = 23 | MAX_BIT
+  "Protocol Error",               //  RETURN_PROTOCOL_ERROR         = 24 | MAX_BIT
+  "Incompatible Version",         //  RETURN_INCOMPATIBLE_VERSION   = 25 | MAX_BIT
+  "Security Violation",           //  RETURN_SECURITY_VIOLATION     = 26 | MAX_BIT
+  "CRC Error",                    //  RETURN_CRC_ERROR              = 27 | MAX_BIT
+  "End of Media",                 //  RETURN_END_OF_MEDIA           = 28 | MAX_BIT
+  "Reserved (29)",                //  RESERVED                      = 29 | MAX_BIT
+  "Reserved (30)",                //  RESERVED                      = 30 | MAX_BIT
+  "End of File",                  //  RETURN_END_OF_FILE            = 31 | MAX_BIT
+  "Invalid Language",             //  RETURN_INVALID_LANGUAGE       = 32 | MAX_BIT
+  "Compromised Data"              //  RETURN_COMPROMISED_DATA       = 33 | MAX_BIT
+};
+
+
+/**
+  Internal function that places the character into the Buffer.
+
+  Internal function that places ASCII or Unicode character into the Buffer.
+
+  @param  Buffer      The buffer to place the Unicode or ASCII string.
+  @param  EndBuffer   The end of the input Buffer. No characters will be
+                      placed after that. 
+  @param  Length      The count of character to be placed into Buffer.
+                      (Negative value indicates no buffer fill.)
+  @param  Character   The character to be placed into Buffer.
+  @param  Increment   The character increment in Buffer.
+
+  @return Buffer.
+
+**/
+CHAR8 *
+BasePrintLibFillBuffer (
+  OUT CHAR8   *Buffer,
+  IN  CHAR8   *EndBuffer,
+  IN  INTN    Length,
+  IN  UINTN   Character,
+  IN  INTN    Increment
+  )
+{
+  INTN  Index;
+  
+  for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {
+    *Buffer = (CHAR8) Character;
+    if (Increment != 1) {
+      *(Buffer + 1) = (CHAR8)(Character >> 8);
+    }
+    Buffer += Increment;
+  }
+
+  return Buffer;
+}
+
+/**
+  Internal function that convert a number to a string in Buffer.
+
+  Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.
+
+  @param  Buffer    Location to place the ASCII string of Value.
+  @param  Value     The value to convert to a Decimal or Hexadecimal string in Buffer.
+  @param  Radix     Radix of the value
+
+  @return A pointer to the end of buffer filled with ASCII string.
+
+**/
+CHAR8 *
+BasePrintLibValueToString (
+  IN OUT CHAR8  *Buffer, 
+  IN INT64      Value, 
+  IN UINTN      Radix
+  )
+{
+  UINT32  Remainder;
+
+  //
+  // Loop to convert one digit at a time in reverse order
+  //
+  *Buffer = 0;
+  do {
+    Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);
+    *(++Buffer) = mHexStr[Remainder];
+  } while (Value != 0);
+
+  //
+  // Return pointer of the end of filled buffer.
+  //
+  return Buffer;
+}
+
+/**
+  Internal function that converts a decimal value to a Null-terminated string.
+  
+  Converts the decimal number specified by Value to a Null-terminated  
+  string specified by Buffer containing at most Width characters.
+  If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
+  The total number of characters placed in Buffer is returned.
+  If the conversion contains more than Width characters, then only the first
+  Width characters are returned, and the total number of characters 
+  required to perform the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If Value is < 0, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+
+  If Buffer is NULL, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer    The pointer to the output buffer for the produced Null-terminated
+                    string.
+  @param  Flags     The bitmask of flags that specify left justification, zero pad,
+                    and commas.
+  @param  Value     The 64-bit signed value to convert to a string.
+  @param  Width     The maximum number of characters to place in Buffer, not including
+                    the Null-terminator.
+  @param  Increment The character increment in Buffer.
+  
+  @return Total number of characters required to perform the conversion.
+
+**/
+UINTN
+BasePrintLibConvertValueToString (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width,
+  IN UINTN       Increment
+  )
+{
+  CHAR8  *OriginalBuffer;
+  CHAR8  *EndBuffer;
+  CHAR8  ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
+  CHAR8  *ValueBufferPtr;
+  UINTN  Count;
+  UINTN  Digits;
+  UINTN  Index;
+  UINTN  Radix;
+
+  //
+  // Make sure Buffer is not NULL and Width < MAXIMUM
+  //
+  ASSERT (Buffer != NULL);
+  ASSERT (Width < MAXIMUM_VALUE_CHARACTERS);
+  //
+  // Make sure Flags can only contain supported bits.
+  //
+  ASSERT ((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0);
+
+  //
+  // If both COMMA_TYPE and RADIX_HEX are set, then ASSERT ()
+  //
+  ASSERT (((Flags & COMMA_TYPE) == 0) || ((Flags & RADIX_HEX) == 0));
+
+  OriginalBuffer = Buffer;
+  
+  //
+  // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.
+  //
+  if (Width == 0 || (Flags & COMMA_TYPE) != 0) {
+    Flags &= ~((UINTN) PREFIX_ZERO);
+  }
+  //
+  // If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
+  //
+  if (Width == 0) {
+    Width = MAXIMUM_VALUE_CHARACTERS - 1;
+  }
+  //
+  // Set the tag for the end of the input Buffer.
+  //
+  EndBuffer = Buffer + Width * Increment;
+  
+  //
+  // Convert decimal negative
+  //
+  if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {
+    Value = -Value;
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);
+    Width--;
+  }
+  
+  //
+  // Count the length of the value string.
+  //
+  Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;
+  ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);
+  Count = ValueBufferPtr - ValueBuffer;
+  
+  //
+  // Append Zero
+  //
+  if ((Flags & PREFIX_ZERO) != 0) {
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);
+  }
+  
+  //
+  // Print Comma type for every 3 characters
+  //
+  Digits = Count % 3;
+  if (Digits != 0) {
+    Digits = 3 - Digits;
+  }
+  for (Index = 0; Index < Count; Index++) {
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment);
+    if ((Flags & COMMA_TYPE) != 0) {
+      Digits++;
+      if (Digits == 3) {
+        Digits = 0;
+        if ((Index + 1) < Count) {
+          Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);
+        }
+      }
+    }
+  }
+  
+  //
+  // Print Null-terminator
+  //
+  BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);
+
+  return ((Buffer - OriginalBuffer) / Increment);
+}
+
+/**
+  Internal function that converts a decimal value to a Null-terminated string.
+
+  Converts the decimal number specified by Value to a Null-terminated string
+  specified by Buffer containing at most Width characters. If Width is 0 then a
+  width of MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more
+  than Width characters, then only the first Width characters are placed in
+  Buffer. Additional conversion parameters are specified in Flags.
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If Value is < 0, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
+  then Buffer is padded with '0' characters so the combination of the optional
+  '-' sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If an error would be returned, the function will ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of characters to place in Buffer,
+                      not including the Null-terminator.
+  @param  Increment   The character increment in Buffer.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If Increment is 1 and
+                                   PcdMaximumAsciiStringLength is not zero,
+                                   BufferSize is greater than
+                                   PcdMaximumAsciiStringLength.
+                                   If Increment is not 1 and
+                                   PcdMaximumUnicodeStringLength is not zero,
+                                   BufferSize is greater than
+                                   (PcdMaximumUnicodeStringLength *
+                                   sizeof (CHAR16) + 1).
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+BasePrintLibConvertValueToStringS (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width,
+  IN UINTN       Increment
+  )
+{
+  CHAR8  *EndBuffer;
+  CHAR8  ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
+  CHAR8  *ValueBufferPtr;
+  UINTN  Count;
+  UINTN  Digits;
+  UINTN  Index;
+  UINTN  Radix;
+
+  //
+  // 1. Buffer shall not be a null pointer.
+  //
+  SAFE_PRINT_CONSTRAINT_CHECK ((Buffer != NULL), RETURN_INVALID_PARAMETER);
+
+  //
+  // 2. BufferSize shall not be greater than (RSIZE_MAX * sizeof (CHAR16)) for
+  //    Unicode output string or shall not be greater than ASCII_RSIZE_MAX for
+  //    Ascii output string.
+  //
+  if (Increment == 1) {
+    //
+    // Ascii output string
+    //
+    if (ASCII_RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);
+    }
+  } else {
+    //
+    // Unicode output string
+    //
+    if (RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= RSIZE_MAX * sizeof (CHAR16) + 1), RETURN_INVALID_PARAMETER);
+    }
+  }
+
+  //
+  // 3. Flags shall be set properly.
+  //
+  SAFE_PRINT_CONSTRAINT_CHECK (((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0), RETURN_INVALID_PARAMETER);
+  SAFE_PRINT_CONSTRAINT_CHECK ((((Flags & COMMA_TYPE) == 0) || ((Flags & RADIX_HEX) == 0)), RETURN_INVALID_PARAMETER);
+
+  //
+  // 4. Width shall be smaller than MAXIMUM_VALUE_CHARACTERS.
+  //
+  SAFE_PRINT_CONSTRAINT_CHECK ((Width < MAXIMUM_VALUE_CHARACTERS), RETURN_INVALID_PARAMETER);
+
+  //
+  // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.
+  //
+  if (Width == 0 || (Flags & COMMA_TYPE) != 0) {
+    Flags &= ~((UINTN) PREFIX_ZERO);
+  }
+  //
+  // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
+  //
+  if (Width == 0) {
+    Width = MAXIMUM_VALUE_CHARACTERS - 1;
+  }
+
+  //
+  // Count the characters of the output string.
+  //
+  Count = 0;
+  Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;
+
+  if ((Flags & PREFIX_ZERO) != 0) {
+    Count = Width;
+  } else {
+    if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {
+      Count++;  // minus sign
+      ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, -Value, Radix);
+    } else {
+      ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);
+    }
+    Digits = ValueBufferPtr - ValueBuffer;
+    Count += Digits;
+
+    if ((Flags & COMMA_TYPE) != 0) {
+      Count += (Digits - 1) / 3;  // commas
+    }
+  }
+
+  Width = MIN (Count, Width);
+
+  //
+  // 5. BufferSize shall be large enough to hold the converted string.
+  //
+  SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize >= (Width + 1) * Increment), RETURN_BUFFER_TOO_SMALL);
+
+  //
+  // Set the tag for the end of the input Buffer.
+  //
+  EndBuffer = Buffer + Width * Increment;
+
+  //
+  // Convert decimal negative
+  //
+  if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {
+    Value = -Value;
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);
+    Width--;
+  }
+
+  //
+  // Count the length of the value string.
+  //
+  ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);
+  Count = ValueBufferPtr - ValueBuffer;
+
+  //
+  // Append Zero
+  //
+  if ((Flags & PREFIX_ZERO) != 0) {
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);
+  }
+
+  //
+  // Print Comma type for every 3 characters
+  //
+  Digits = Count % 3;
+  if (Digits != 0) {
+    Digits = 3 - Digits;
+  }
+  for (Index = 0; Index < Count; Index++) {
+    Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment);
+    if ((Flags & COMMA_TYPE) != 0) {
+      Digits++;
+      if (Digits == 3) {
+        Digits = 0;
+        if ((Index + 1) < Count) {
+          Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);
+        }
+      }
+    }
+  }
+
+  //
+  // Print Null-terminator
+  //
+  BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Worker function that produces a Null-terminated string in an output buffer 
+  based on a Null-terminated format string and a VA_LIST argument list.
+
+  VSPrint function to process format and place the results in Buffer. Since a 
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus 
+  this is the main print working routine.
+
+  If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
+
+  @param[out] Buffer          The character buffer to print the results of the 
+                              parsing of Format into.
+  @param[in]  BufferSize      The maximum number of characters to put into 
+                              buffer.
+  @param[in]  Flags           Initial flags value.
+                              Can only have FORMAT_UNICODE, OUTPUT_UNICODE, 
+                              and COUNT_ONLY_NO_PRINT set.
+  @param[in]  Format          A Null-terminated format string.
+  @param[in]  VaListMarker    VA_LIST style variable argument list consumed by
+                              processing Format.
+  @param[in]  BaseListMarker  BASE_LIST style variable argument list consumed
+                              by processing Format.
+
+  @return The number of characters printed not including the Null-terminator.
+          If COUNT_ONLY_NO_PRINT was set returns the same, but without any
+          modification to Buffer.
+
+**/
+UINTN
+BasePrintLibSPrintMarker (
+  OUT CHAR8        *Buffer,
+  IN  UINTN        BufferSize,
+  IN  UINTN        Flags,
+  IN  CONST CHAR8  *Format,
+  IN  VA_LIST      VaListMarker,   OPTIONAL
+  IN  BASE_LIST    BaseListMarker  OPTIONAL
+  )
+{
+  CHAR8             *OriginalBuffer;
+  CHAR8             *EndBuffer;
+  CHAR8             ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
+  UINT32            BytesPerOutputCharacter;
+  UINTN             BytesPerFormatCharacter;
+  UINTN             FormatMask;
+  UINTN             FormatCharacter;
+  UINTN             Width;
+  UINTN             Precision;
+  INT64             Value;
+  CONST CHAR8       *ArgumentString;
+  UINTN             Character;
+  GUID              *TmpGuid;
+  TIME              *TmpTime;
+  UINTN             Count;
+  UINTN             ArgumentMask;
+  INTN              BytesPerArgumentCharacter;
+  UINTN             ArgumentCharacter;
+  BOOLEAN           Done;
+  UINTN             Index;
+  CHAR8             Prefix;
+  BOOLEAN           ZeroPad;
+  BOOLEAN           Comma;
+  UINTN             Digits;
+  UINTN             Radix;
+  RETURN_STATUS     Status;
+  UINT32            GuidData1;
+  UINT16            GuidData2;
+  UINT16            GuidData3;
+  UINTN             LengthToReturn;
+
+  //
+  // If you change this code be sure to match the 2 versions of this function.
+  // Nearly identical logic is found in the BasePrintLib and 
+  // DxePrintLibPrint2Protocol (both PrintLib instances).
+  //
+
+  //
+  // 1. Buffer shall not be a null pointer when both BufferSize > 0 and
+  //    COUNT_ONLY_NO_PRINT is not set in Flags.
+  //
+  if ((BufferSize > 0) && ((Flags & COUNT_ONLY_NO_PRINT) == 0)) {
+    SAFE_PRINT_CONSTRAINT_CHECK ((Buffer != NULL), 0);
+  }
+
+  //
+  // 2. Format shall not be a null pointer when BufferSize > 0 or when
+  //    COUNT_ONLY_NO_PRINT is set in Flags.
+  //
+  if ((BufferSize > 0) || ((Flags & COUNT_ONLY_NO_PRINT) != 0)) {
+    SAFE_PRINT_CONSTRAINT_CHECK ((Format != NULL), 0);
+  }
+
+  //
+  // 3. BufferSize shall not be greater than RSIZE_MAX for Unicode output or
+  //    ASCII_RSIZE_MAX for Ascii output.
+  //
+  if ((Flags & OUTPUT_UNICODE) != 0) {
+    if (RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= RSIZE_MAX), 0);
+    }
+    BytesPerOutputCharacter = 2;
+  } else {
+    if (ASCII_RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= ASCII_RSIZE_MAX), 0);
+    }
+    BytesPerOutputCharacter = 1;
+  }
+
+  //
+  // 4. Format shall not contain more than RSIZE_MAX Unicode characters or
+  //    ASCII_RSIZE_MAX Ascii characters.
+  //
+  if ((Flags & FORMAT_UNICODE) != 0) {
+    if (RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((StrnLenS ((CHAR16 *)Format, RSIZE_MAX + 1) <= RSIZE_MAX), 0);
+    }
+    BytesPerFormatCharacter = 2;
+    FormatMask = 0xffff;
+  } else {
+    if (ASCII_RSIZE_MAX != 0) {
+      SAFE_PRINT_CONSTRAINT_CHECK ((AsciiStrnLenS (Format, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), 0);
+    }
+    BytesPerFormatCharacter = 1;
+    FormatMask = 0xff;
+  }
+
+  if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {
+    if (BufferSize == 0) {
+      Buffer = NULL;
+    }
+  } else {
+    //
+    // We can run without a Buffer for counting only.
+    //
+    if (BufferSize == 0) {
+      return 0;
+    }
+  }
+
+  LengthToReturn = 0;
+  EndBuffer = NULL;
+  OriginalBuffer = NULL;
+
+  //
+  // Reserve space for the Null terminator.
+  //
+  if (Buffer != NULL) {
+    BufferSize--;
+    OriginalBuffer = Buffer;
+
+    //
+    // Set the tag for the end of the input Buffer.
+    //
+    EndBuffer = Buffer + BufferSize * BytesPerOutputCharacter;
+  }
+
+  //
+  // Get the first character from the format string
+  //
+  FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+
+  //
+  // Loop until the end of the format string is reached or the output buffer is full
+  //
+  while (FormatCharacter != 0) {
+    if ((Buffer != NULL) && (Buffer >= EndBuffer)) {
+      break;
+    }
+    //
+    // Clear all the flag bits except those that may have been passed in
+    //
+    Flags &= (UINTN) (OUTPUT_UNICODE | FORMAT_UNICODE | COUNT_ONLY_NO_PRINT);
+
+    //
+    // Set the default width to zero, and the default precision to 1
+    //
+    Width     = 0;
+    Precision = 1;
+    Prefix    = 0;
+    Comma     = FALSE;
+    ZeroPad   = FALSE;
+    Count     = 0;
+    Digits    = 0;
+
+    switch (FormatCharacter) {
+    case '%':
+      //
+      // Parse Flags and Width
+      //
+      for (Done = FALSE; !Done; ) {
+        Format += BytesPerFormatCharacter;
+        FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+        switch (FormatCharacter) {
+        case '.': 
+          Flags |= PRECISION; 
+          break;
+        case '-': 
+          Flags |= LEFT_JUSTIFY; 
+          break;
+        case '+': 
+          Flags |= PREFIX_SIGN;  
+          break;
+        case ' ': 
+          Flags |= PREFIX_BLANK; 
+          break;
+        case ',': 
+          Flags |= COMMA_TYPE; 
+          break;
+        case 'L':
+        case 'l': 
+          Flags |= LONG_TYPE;    
+          break;
+        case '*':
+          if ((Flags & PRECISION) == 0) {
+            Flags |= PAD_TO_WIDTH;
+            if (BaseListMarker == NULL) {
+              Width = VA_ARG (VaListMarker, UINTN);
+            } else {
+              Width = BASE_ARG (BaseListMarker, UINTN);
+            }
+          } else {
+            if (BaseListMarker == NULL) {
+              Precision = VA_ARG (VaListMarker, UINTN);
+            } else {
+              Precision = BASE_ARG (BaseListMarker, UINTN);
+            }
+          }
+          break;
+        case '0':
+          if ((Flags & PRECISION) == 0) {
+            Flags |= PREFIX_ZERO;
+          }
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+          for (Count = 0; ((FormatCharacter >= '0') &&  (FormatCharacter <= '9')); ){
+            Count = (Count * 10) + FormatCharacter - '0';
+            Format += BytesPerFormatCharacter;
+            FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+          }
+          Format -= BytesPerFormatCharacter;
+          if ((Flags & PRECISION) == 0) {
+            Flags |= PAD_TO_WIDTH;
+            Width = Count;
+          } else {
+            Precision = Count;
+          }
+          break;
+       
+        case '\0':
+          //
+          // Make no output if Format string terminates unexpectedly when
+          // looking up for flag, width, precision and type. 
+          //
+          Format   -= BytesPerFormatCharacter;
+          Precision = 0;
+          //
+          // break skipped on purpose.
+          //
+        default:
+          Done = TRUE;
+          break;
+        }
+      } 
+
+      //
+      // Handle each argument type
+      //
+      switch (FormatCharacter) {
+      case 'p':
+        //
+        // Flag space, +, 0, L & l are invalid for type p.
+        //
+        Flags &= ~((UINTN) (PREFIX_BLANK | PREFIX_SIGN | PREFIX_ZERO | LONG_TYPE));
+        if (sizeof (VOID *) > 4) {
+          Flags |= LONG_TYPE;
+        }
+        //
+        // break skipped on purpose
+        //
+      case 'X':
+        Flags |= PREFIX_ZERO;
+        //
+        // break skipped on purpose
+        //
+      case 'x':
+        Flags |= RADIX_HEX;
+        //
+        // break skipped on purpose
+        //
+      case 'u':
+        if ((Flags & RADIX_HEX) == 0) {
+          Flags &= ~((UINTN) (PREFIX_SIGN));
+          Flags |= UNSIGNED_TYPE;
+        }
+        //
+        // break skipped on purpose
+        //
+      case 'd':
+        if ((Flags & LONG_TYPE) == 0) {
+          //
+          // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
+          // This assumption is made so the format string definition is compatible with the ANSI C
+          // Specification for formatted strings.  It is recommended that the Base Types be used 
+          // everywhere, but in this one case, compliance with ANSI C is more important, and 
+          // provides an implementation that is compatible with that largest possible set of CPU 
+          // architectures.  This is why the type "int" is used in this one case.
+          //
+          if (BaseListMarker == NULL) {
+            Value = VA_ARG (VaListMarker, int);
+          } else {
+            Value = BASE_ARG (BaseListMarker, int);
+          }
+        } else {
+          if (BaseListMarker == NULL) {
+            Value = VA_ARG (VaListMarker, INT64);
+          } else {
+            Value = BASE_ARG (BaseListMarker, INT64);
+          }
+        }
+        if ((Flags & PREFIX_BLANK) != 0) {
+          Prefix = ' ';
+        }
+        if ((Flags & PREFIX_SIGN) != 0) {
+          Prefix = '+';
+        }
+        if ((Flags & COMMA_TYPE) != 0) {
+          Comma = TRUE;
+        }
+        if ((Flags & RADIX_HEX) == 0) {
+          Radix = 10;
+          if (Comma) {
+            Flags &= ~((UINTN) PREFIX_ZERO);
+            Precision = 1;
+          }
+          if (Value < 0 && (Flags & UNSIGNED_TYPE) == 0) {
+            Flags |= PREFIX_SIGN;
+            Prefix = '-';
+            Value = -Value;
+          } else if ((Flags & UNSIGNED_TYPE) != 0 && (Flags & LONG_TYPE) == 0) {
+            //
+            // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
+            // This assumption is made so the format string definition is compatible with the ANSI C
+            // Specification for formatted strings.  It is recommended that the Base Types be used 
+            // everywhere, but in this one case, compliance with ANSI C is more important, and 
+            // provides an implementation that is compatible with that largest possible set of CPU 
+            // architectures.  This is why the type "unsigned int" is used in this one case.
+            //
+            Value = (unsigned int)Value;
+          }
+        } else {
+          Radix = 16;
+          Comma = FALSE;
+          if ((Flags & LONG_TYPE) == 0 && Value < 0) {
+            //
+            // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
+            // This assumption is made so the format string definition is compatible with the ANSI C
+            // Specification for formatted strings.  It is recommended that the Base Types be used 
+            // everywhere, but in this one case, compliance with ANSI C is more important, and 
+            // provides an implementation that is compatible with that largest possible set of CPU 
+            // architectures.  This is why the type "unsigned int" is used in this one case.
+            //
+            Value = (unsigned int)Value;
+          }
+        }
+        //
+        // Convert Value to a reversed string
+        //
+        Count = BasePrintLibValueToString (ValueBuffer, Value, Radix) - ValueBuffer;
+        if (Value == 0 && Precision == 0) {
+          Count = 0;
+        }
+        ArgumentString = (CHAR8 *)ValueBuffer + Count;
+        
+        Digits = Count % 3;
+        if (Digits != 0) {
+          Digits = 3 - Digits;
+        }
+        if (Comma && Count != 0) {
+          Count += ((Count - 1) / 3);
+        }
+        if (Prefix != 0) {
+          Count++;
+          Precision++;
+        }
+        Flags |= ARGUMENT_REVERSED;
+        ZeroPad = TRUE;
+        if ((Flags & PREFIX_ZERO) != 0) {
+          if ((Flags & LEFT_JUSTIFY) == 0) {
+            if ((Flags & PAD_TO_WIDTH) != 0) {
+              if ((Flags & PRECISION) == 0) {
+                Precision = Width;
+              }
+            }
+          }
+        }
+        break;
+
+      case 's':
+      case 'S':
+        Flags |= ARGUMENT_UNICODE;
+        //
+        // break skipped on purpose
+        //
+      case 'a':
+        if (BaseListMarker == NULL) {
+          ArgumentString = VA_ARG (VaListMarker, CHAR8 *);
+        } else {
+          ArgumentString = BASE_ARG (BaseListMarker, CHAR8 *);
+        }
+        if (ArgumentString == NULL) {
+          Flags &= ~((UINTN) ARGUMENT_UNICODE);
+          ArgumentString = "<null string>";
+        }
+        //
+        // Set the default precision for string to be zero if not specified.
+        //
+        if ((Flags & PRECISION) == 0) {
+          Precision = 0;
+        }
+        break;
+
+      case 'c':
+        if (BaseListMarker == NULL) {
+          Character = VA_ARG (VaListMarker, UINTN) & 0xffff;
+        } else {
+          Character = BASE_ARG (BaseListMarker, UINTN) & 0xffff;
+        }
+        ArgumentString = (CHAR8 *)&Character;
+        Flags |= ARGUMENT_UNICODE;
+        break;
+
+      case 'g':
+        if (BaseListMarker == NULL) {
+          TmpGuid = VA_ARG (VaListMarker, GUID *);
+        } else {
+          TmpGuid = BASE_ARG (BaseListMarker, GUID *);
+        }
+        if (TmpGuid == NULL) {
+          ArgumentString = "<null guid>";
+        } else {
+          GuidData1 = ReadUnaligned32 (&(TmpGuid->Data1));
+          GuidData2 = ReadUnaligned16 (&(TmpGuid->Data2));
+          GuidData3 = ReadUnaligned16 (&(TmpGuid->Data3));
+          BasePrintLibSPrint (
+            ValueBuffer,
+            MAXIMUM_VALUE_CHARACTERS, 
+            0,
+            "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+            GuidData1,
+            GuidData2,
+            GuidData3,
+            TmpGuid->Data4[0],
+            TmpGuid->Data4[1],
+            TmpGuid->Data4[2],
+            TmpGuid->Data4[3],
+            TmpGuid->Data4[4],
+            TmpGuid->Data4[5],
+            TmpGuid->Data4[6],
+            TmpGuid->Data4[7]
+            );
+          ArgumentString = ValueBuffer;
+        }
+        break;
+
+      case 't':
+        if (BaseListMarker == NULL) {
+          TmpTime = VA_ARG (VaListMarker, TIME *); 
+        } else {
+          TmpTime = BASE_ARG (BaseListMarker, TIME *); 
+        }
+        if (TmpTime == NULL) {
+          ArgumentString = "<null time>";
+        } else {
+          BasePrintLibSPrint (
+            ValueBuffer,
+            MAXIMUM_VALUE_CHARACTERS,
+            0,
+            "%02d/%02d/%04d  %02d:%02d",
+            TmpTime->Month,
+            TmpTime->Day,
+            TmpTime->Year,
+            TmpTime->Hour,
+            TmpTime->Minute
+            );
+          ArgumentString = ValueBuffer;
+        }
+        break;
+
+      case 'r':
+        if (BaseListMarker == NULL) {
+          Status = VA_ARG (VaListMarker, RETURN_STATUS);
+        } else {
+          Status = BASE_ARG (BaseListMarker, RETURN_STATUS);
+        }
+        ArgumentString = ValueBuffer;
+        if (RETURN_ERROR (Status)) {
+          //
+          // Clear error bit
+          //
+          Index = Status & ~MAX_BIT;
+          if (Index > 0 && Index <= ERROR_STATUS_NUMBER) {
+            ArgumentString = mStatusString [Index + WARNING_STATUS_NUMBER];
+          }
+        } else {
+          Index = Status;
+          if (Index <= WARNING_STATUS_NUMBER) {
+            ArgumentString = mStatusString [Index];
+          }
+        }
+        if (ArgumentString == ValueBuffer) {
+          BasePrintLibSPrint ((CHAR8 *) ValueBuffer, MAXIMUM_VALUE_CHARACTERS, 0, "%08X", Status);
+        }
+        break;
+
+      case '\r':
+        Format += BytesPerFormatCharacter;
+        FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+        if (FormatCharacter == '\n') {
+          //
+          // Translate '\r\n' to '\r\n'
+          //
+          ArgumentString = "\r\n";
+        } else {
+          //
+          // Translate '\r' to '\r'
+          //
+          ArgumentString = "\r";
+          Format   -= BytesPerFormatCharacter;
+        }
+        break;
+
+      case '\n':
+        //
+        // Translate '\n' to '\r\n' and '\n\r' to '\r\n'
+        //
+        ArgumentString = "\r\n";
+        Format += BytesPerFormatCharacter;
+        FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+        if (FormatCharacter != '\r') {
+          Format   -= BytesPerFormatCharacter;
+        }
+        break;
+
+      case '%':
+      default:
+        //
+        // if the type is '%' or unknown, then print it to the screen
+        //
+        ArgumentString = (CHAR8 *)&FormatCharacter;
+        Flags |= ARGUMENT_UNICODE;
+        break;
+      }
+      break;
+ 
+    case '\r':
+      Format += BytesPerFormatCharacter;
+      FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+      if (FormatCharacter == '\n') {
+        //
+        // Translate '\r\n' to '\r\n'
+        //
+        ArgumentString = "\r\n";
+      } else {
+        //
+        // Translate '\r' to '\r'
+        //
+        ArgumentString = "\r";
+        Format   -= BytesPerFormatCharacter;
+      }
+      break;
+
+    case '\n':
+      //
+      // Translate '\n' to '\r\n' and '\n\r' to '\r\n'
+      //
+      ArgumentString = "\r\n";
+      Format += BytesPerFormatCharacter;
+      FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+      if (FormatCharacter != '\r') {
+        Format   -= BytesPerFormatCharacter;
+      }
+      break;
+
+    default:
+      ArgumentString = (CHAR8 *)&FormatCharacter;
+      Flags |= ARGUMENT_UNICODE;
+      break;
+    }
+
+    //
+    // Retrieve the ArgumentString attriubutes
+    //
+    if ((Flags & ARGUMENT_UNICODE) != 0) {
+      ArgumentMask = 0xffff;
+      BytesPerArgumentCharacter = 2;
+    } else {
+      ArgumentMask = 0xff;
+      BytesPerArgumentCharacter = 1;
+    }
+    if ((Flags & ARGUMENT_REVERSED) != 0) {
+      BytesPerArgumentCharacter = -BytesPerArgumentCharacter;
+    } else {
+      //
+      // Compute the number of characters in ArgumentString and store it in Count
+      // ArgumentString is either null-terminated, or it contains Precision characters
+      //
+      for (Count = 0; Count < Precision || ((Flags & PRECISION) == 0); Count++) {
+        ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) | ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask;
+        if (ArgumentCharacter == 0) {
+          break;
+        }
+      }
+    }
+
+    if (Precision < Count) {
+      Precision = Count;
+    }
+
+    //
+    // Pad before the string
+    //
+    if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH)) {
+      LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);
+      if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+        Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);
+      }
+    }
+
+    if (ZeroPad) {
+      if (Prefix != 0) {
+        LengthToReturn += (1 * BytesPerOutputCharacter);
+        if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+          Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);
+        }
+      }
+      LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);
+      if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+        Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, '0', BytesPerOutputCharacter);
+      }
+    } else {
+      LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);
+      if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+        Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, ' ', BytesPerOutputCharacter);
+      }
+      if (Prefix != 0) {
+        LengthToReturn += (1 * BytesPerOutputCharacter);
+        if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+          Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);
+        }
+      }
+    }
+
+    //
+    // Output the Prefix character if it is present
+    //
+    Index = 0;
+    if (Prefix != 0) {
+      Index++;
+    }
+
+    //
+    // Copy the string into the output buffer performing the required type conversions
+    //
+    while (Index < Count) {
+      ArgumentCharacter = ((*ArgumentString & 0xff) | (*(ArgumentString + 1) << 8)) & ArgumentMask;
+
+      LengthToReturn += (1 * BytesPerOutputCharacter);
+      if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+        Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ArgumentCharacter, BytesPerOutputCharacter);
+      }
+      ArgumentString    += BytesPerArgumentCharacter;
+      Index++;
+      if (Comma) {
+        Digits++;
+        if (Digits == 3) {
+          Digits = 0;
+          Index++;
+          if (Index < Count) {
+            LengthToReturn += (1 * BytesPerOutputCharacter);
+            if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+              Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', BytesPerOutputCharacter);
+            }
+          }
+        }
+      }
+    }
+
+    //
+    // Pad after the string
+    //
+    if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH | LEFT_JUSTIFY)) {
+      LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);
+      if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
+        Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);
+      }
+    }
+
+    //
+    // Get the next character from the format string
+    //
+    Format += BytesPerFormatCharacter;
+
+    //
+    // Get the next character from the format string
+    //
+    FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
+  }
+
+  if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {
+    return (LengthToReturn / BytesPerOutputCharacter);
+  }
+
+  ASSERT (Buffer != NULL);
+  //
+  // Null terminate the Unicode or ASCII string
+  //
+  BasePrintLibFillBuffer (Buffer, EndBuffer + BytesPerOutputCharacter, 1, 0, BytesPerOutputCharacter);
+
+  return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter);
+}
+
+/**
+  Worker function that produces a Null-terminated string in an output buffer 
+  based on a Null-terminated format string and variable argument list.
+
+  VSPrint function to process format and place the results in Buffer. Since a 
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus 
+  this is the main print working routine
+
+  @param  StartOfBuffer The character buffer to print the results of the parsing
+                        of Format into.
+  @param  BufferSize    The maximum number of characters to put into buffer.
+                        Zero means no limit.
+  @param  Flags         Initial flags value.
+                        Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
+  @param  FormatString  A Null-terminated format string.
+  @param  ...           The variable argument list.
+
+  @return The number of characters printed.
+
+**/
+UINTN
+EFIAPI
+BasePrintLibSPrint (
+  OUT CHAR8        *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  UINTN        Flags,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  )
+{
+  VA_LIST  Marker;
+  UINTN    NumberOfPrinted;
+
+  VA_START (Marker, FormatString);
+  NumberOfPrinted = BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, Flags, FormatString, Marker, NULL);
+  VA_END (Marker);
+  return NumberOfPrinted;
+}
diff --git a/MdePkg/Library/BasePrintLib/PrintLibInternal.h b/MdePkg/Library/BasePrintLib/PrintLibInternal.h
new file mode 100644
index 000000000000..c8aea67493ef
--- /dev/null
+++ b/MdePkg/Library/BasePrintLib/PrintLibInternal.h
@@ -0,0 +1,277 @@
+/** @file
+  Base Print Library instance Internal Functions definition.
+
+  Copyright (c) 2006 - 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 __PRINT_LIB_INTERNAL_H__
+#define __PRINT_LIB_INTERNAL_H__
+
+#include <Base.h>
+#include <Library/PrintLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+
+//
+// Print primitives
+//
+#define PREFIX_SIGN           BIT1
+#define PREFIX_BLANK          BIT2
+#define LONG_TYPE             BIT4
+#define OUTPUT_UNICODE        BIT6
+#define FORMAT_UNICODE        BIT8
+#define PAD_TO_WIDTH          BIT9
+#define ARGUMENT_UNICODE      BIT10
+#define PRECISION             BIT11
+#define ARGUMENT_REVERSED     BIT12
+#define COUNT_ONLY_NO_PRINT   BIT13
+#define UNSIGNED_TYPE         BIT14
+
+//
+// Record date and time information
+//
+typedef struct {
+  UINT16  Year;
+  UINT8   Month;
+  UINT8   Day;
+  UINT8   Hour;
+  UINT8   Minute;
+  UINT8   Second;
+  UINT8   Pad1;
+  UINT32  Nanosecond;
+  INT16   TimeZone;
+  UINT8   Daylight;
+  UINT8   Pad2;
+} TIME;
+
+/**
+  Worker function that produces a Null-terminated string in an output buffer 
+  based on a Null-terminated format string and a VA_LIST argument list.
+
+  VSPrint function to process format and place the results in Buffer. Since a 
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus 
+  this is the main print working routine.
+
+  If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
+
+  @param[out] Buffer          The character buffer to print the results of the 
+                              parsing of Format into.
+  @param[in]  BufferSize      The maximum number of characters to put into 
+                              buffer.
+  @param[in]  Flags           Initial flags value.
+                              Can only have FORMAT_UNICODE, OUTPUT_UNICODE, 
+                              and COUNT_ONLY_NO_PRINT set.
+  @param[in]  Format          A Null-terminated format string.
+  @param[in]  VaListMarker    VA_LIST style variable argument list consumed by
+                              processing Format.
+  @param[in]  BaseListMarker  BASE_LIST style variable argument list consumed
+                              by processing Format.
+
+  @return The number of characters printed not including the Null-terminator.
+          If COUNT_ONLY_NO_PRINT was set returns the same, but without any
+          modification to Buffer.
+
+**/
+UINTN
+BasePrintLibSPrintMarker (
+  OUT CHAR8        *Buffer,
+  IN  UINTN        BufferSize,
+  IN  UINTN        Flags,
+  IN  CONST CHAR8  *Format,
+  IN  VA_LIST      VaListMarker,   OPTIONAL
+  IN  BASE_LIST    BaseListMarker  OPTIONAL
+  );
+
+/**
+  Worker function that produces a Null-terminated string in an output buffer 
+  based on a Null-terminated format string and variable argument list.
+
+  VSPrint function to process format and place the results in Buffer. Since a 
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus 
+  this is the main print working routine
+
+  @param  StartOfBuffer The character buffer to print the results of the parsing
+                        of Format into.
+  @param  BufferSize    The maximum number of characters to put into buffer.
+                        Zero means no limit.
+  @param  Flags         Initial flags value.
+                        Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
+  @param  FormatString  Null-terminated format string.
+  @param  ...           The variable argument list.
+
+  @return The number of characters printed.
+
+**/
+UINTN
+EFIAPI
+BasePrintLibSPrint (
+  OUT CHAR8        *StartOfBuffer,
+  IN  UINTN        BufferSize,
+  IN  UINTN        Flags,
+  IN  CONST CHAR8  *FormatString,
+  ...
+  );
+
+/**
+  Internal function that places the character into the Buffer.
+
+  Internal function that places ASCII or Unicode character into the Buffer.
+
+  @param  Buffer      Buffer to place the Unicode or ASCII string.
+  @param  EndBuffer   The end of the input Buffer. No characters will be
+                      placed after that. 
+  @param  Length      The count of character to be placed into Buffer.
+                      (Negative value indicates no buffer fill.)
+  @param  Character   The character to be placed into Buffer.
+  @param  Increment   The character increment in Buffer.
+
+  @return Buffer      Buffer filled with the input Character.
+
+**/
+CHAR8 *
+BasePrintLibFillBuffer (
+  OUT CHAR8   *Buffer,
+  IN  CHAR8   *EndBuffer,
+  IN  INTN    Length,
+  IN  UINTN   Character,
+  IN  INTN    Increment
+  );
+
+/**
+  Internal function that convert a number to a string in Buffer.
+
+  Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.
+
+  @param  Buffer    Location to place the ASCII string of Value.
+  @param  Value     The value to convert to a Decimal or Hexadecimal string in Buffer.
+  @param  Radix     Radix of the value
+
+  @return A pointer to the end of buffer filled with ASCII string.
+
+**/
+CHAR8 *
+BasePrintLibValueToString (
+  IN OUT CHAR8  *Buffer, 
+  IN INT64      Value, 
+  IN UINTN      Radix
+  );
+
+/**
+  Internal function that converts a decimal value to a Null-terminated string.
+  
+  Converts the decimal number specified by Value to a Null-terminated  
+  string specified by Buffer containing at most Width characters.
+  If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
+  The total number of characters placed in Buffer is returned.
+  If the conversion contains more than Width characters, then only the first
+  Width characters are returned, and the total number of characters 
+  required to perform the conversion is returned.
+  Additional conversion parameters are specified in Flags.  
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
+  are inserted every 3rd digit starting from the right.
+  If Value is < 0, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, 
+  then Buffer is padded with '0' characters so the combination of the optional '-' 
+  sign character, '0' characters, digit characters for Value, and the Null-terminator
+  add up to Width characters.
+
+  If Buffer is NULL, then ASSERT().
+  If unsupported bits are set in Flags, then ASSERT().
+  If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
+
+  @param  Buffer    The pointer to the output buffer for the produced Null-terminated
+                    string.
+  @param  Flags     The bitmask of flags that specify left justification, zero pad,
+                    and commas.
+  @param  Value     The 64-bit signed value to convert to a string.
+  @param  Width     The maximum number of characters to place in Buffer, not including
+                    the Null-terminator.
+  @param  Increment Character increment in Buffer.
+  
+  @return Total number of characters required to perform the conversion.
+
+**/
+UINTN
+BasePrintLibConvertValueToString (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width,
+  IN UINTN       Increment
+  );
+
+/**
+  Internal function that converts a decimal value to a Null-terminated string.
+
+  Converts the decimal number specified by Value to a Null-terminated string
+  specified by Buffer containing at most Width characters. If Width is 0 then a
+  width of MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more
+  than Width characters, then only the first Width characters are placed in
+  Buffer. Additional conversion parameters are specified in Flags.
+  The Flags bit LEFT_JUSTIFY is always ignored.
+  All conversions are left justified in Buffer.
+  If Width is 0, PREFIX_ZERO is ignored in Flags.
+  If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and
+  commas are inserted every 3rd digit starting from the right.
+  If Value is < 0, then the fist character in Buffer is a '-'.
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
+  then Buffer is padded with '0' characters so the combination of the optional
+  '-' sign character, '0' characters, digit characters for Value, and the
+  Null-terminator add up to Width characters.
+
+  If an error would be returned, the function will ASSERT().
+
+  @param  Buffer      The pointer to the output buffer for the produced
+                      Null-terminated string.
+  @param  BufferSize  The size of Buffer in bytes, including the
+                      Null-terminator.
+  @param  Flags       The bitmask of flags that specify left justification,
+                      zero pad, and commas.
+  @param  Value       The 64-bit signed value to convert to a string.
+  @param  Width       The maximum number of characters to place in Buffer,
+                      not including the Null-terminator.
+  @param  Increment   The character increment in Buffer.
+
+  @retval RETURN_SUCCESS           The decimal value is converted.
+  @retval RETURN_BUFFER_TOO_SMALL  If BufferSize cannot hold the converted
+                                   value.
+  @retval RETURN_INVALID_PARAMETER If Buffer is NULL.
+                                   If Increment is 1 and
+                                   PcdMaximumAsciiStringLength is not zero,
+                                   BufferSize is greater than
+                                   PcdMaximumAsciiStringLength.
+                                   If Increment is not 1 and
+                                   PcdMaximumUnicodeStringLength is not zero,
+                                   BufferSize is greater than
+                                   (PcdMaximumUnicodeStringLength *
+                                   sizeof (CHAR16) + 1).
+                                   If unsupported bits are set in Flags.
+                                   If both COMMA_TYPE and RADIX_HEX are set in
+                                   Flags.
+                                   If Width >= MAXIMUM_VALUE_CHARACTERS.
+
+**/
+RETURN_STATUS
+BasePrintLibConvertValueToStringS (
+  IN OUT CHAR8   *Buffer,
+  IN UINTN       BufferSize,
+  IN UINTN       Flags,
+  IN INT64       Value,
+  IN UINTN       Width,
+  IN UINTN       Increment
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLib.c b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLib.c
new file mode 100644
index 000000000000..3c908660b6b4
--- /dev/null
+++ b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLib.c
@@ -0,0 +1,392 @@
+/** @file
+  Null Base Report Status Code Library instance with empty functions.
+
+  Copyright (c) 2009 - 2010, 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 <Base.h>
+#include <Library/ReportStatusCodeLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Converts a status code to an 8-bit POST code value.
+
+  Converts the status code specified by CodeType and Value to an 8-bit POST code
+  and returns the 8-bit POST code in PostCode.  If CodeType is an
+  EFI_PROGRESS_CODE or CodeType is an EFI_ERROR_CODE, then bits 0..4 of PostCode
+  are set to bits 16..20 of Value, and bits 5..7 of PostCode are set to bits
+  24..26 of Value., and TRUE is returned.  Otherwise, FALSE is returned.
+
+  If PostCode is NULL, then ASSERT().
+
+  @param  CodeType  The type of status code being converted.
+  @param  Value     The status code value being converted.
+  @param  PostCode  A pointer to the 8-bit POST code value to return.
+
+  @retval  TRUE   The status code specified by CodeType and Value was converted
+                  to an 8-bit POST code and returned in  PostCode.
+  @retval  FALSE  The status code specified by CodeType and Value could not be
+                  converted to an 8-bit POST code value.
+
+**/
+BOOLEAN
+EFIAPI
+CodeTypeToPostCode (
+  IN  EFI_STATUS_CODE_TYPE   CodeType,
+  IN  EFI_STATUS_CODE_VALUE  Value,
+  OUT UINT8                  *PostCode
+  )
+{
+  ASSERT (PostCode != NULL);
+
+  return FALSE;
+}
+
+
+/**
+  Extracts ASSERT() information from a status code structure.
+
+  Converts the status code specified by CodeType, Value, and Data to the ASSERT()
+  arguments specified by Filename, Description, and LineNumber.  If CodeType is
+  an EFI_ERROR_CODE, and CodeType has a severity of EFI_ERROR_UNRECOVERED, and
+  Value has an operation mask of EFI_SW_EC_ILLEGAL_SOFTWARE_STATE, extract
+  Filename, Description, and LineNumber from the optional data area of the
+  status code buffer specified by Data.  The optional data area of Data contains
+  a Null-terminated ASCII string for the FileName, followed by a Null-terminated
+  ASCII string for the Description, followed by a 32-bit LineNumber.  If the
+  ASSERT() information could be extracted from Data, then return TRUE.
+  Otherwise, FALSE is returned.
+
+  If Data is NULL, then ASSERT().
+  If Filename is NULL, then ASSERT().
+  If Description is NULL, then ASSERT().
+  If LineNumber is NULL, then ASSERT().
+
+  @param  CodeType     The type of status code being converted.
+  @param  Value        The status code value being converted.
+  @param  Data         The pointer to the status code data buffer.
+  @param  Filename     The pointer to the source file name that generated the ASSERT().
+  @param  Description  The pointer to the description of the ASSERT().
+  @param  LineNumber   The pointer to the source line number that generated the ASSERT().
+
+  @retval  TRUE   The status code specified by CodeType, Value, and Data was
+                  converted ASSERT() arguments specified by Filename, Description,
+                  and LineNumber.
+  @retval  FALSE  The status code specified by CodeType, Value, and Data could
+                  not be converted to ASSERT() arguments.
+
+**/
+BOOLEAN
+EFIAPI
+ReportStatusCodeExtractAssertInfo (
+  IN EFI_STATUS_CODE_TYPE        CodeType,
+  IN EFI_STATUS_CODE_VALUE       Value,
+  IN CONST EFI_STATUS_CODE_DATA  *Data,
+  OUT CHAR8                      **Filename,
+  OUT CHAR8                      **Description,
+  OUT UINT32                     *LineNumber
+  )
+{
+  return FALSE;
+}
+
+
+/**
+  Extracts DEBUG() information from a status code structure.
+
+  Converts the status code specified by Data to the DEBUG() arguments specified
+  by ErrorLevel, Marker, and Format.  If type GUID in Data is
+  EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID, then extract ErrorLevel, Marker, and
+  Format from the optional data area of the status code buffer specified by Data.
+  The optional data area of Data contains a 32-bit ErrorLevel followed by Marker
+  which is 12 UINTN parameters, followed by a Null-terminated ASCII string for
+  the Format.  If the DEBUG() information could be extracted from Data, then
+  return TRUE.  Otherwise, FALSE is returned.
+
+  If Data is NULL, then ASSERT().
+  If ErrorLevel is NULL, then ASSERT().
+  If Marker is NULL, then ASSERT().
+  If Format is NULL, then ASSERT().
+
+  @param  Data        The pointer to the status code data buffer.
+  @param  ErrorLevel  The pointer to the error level mask for a debug message.
+  @param  Marker      The pointer to the variable argument list associated with Format.
+  @param  Format      The pointer to a Null-terminated ASCII format string of a
+                      debug message.
+
+  @retval  TRUE   The status code specified by Data was converted DEBUG() arguments
+                  specified by ErrorLevel, Marker, and Format.
+  @retval  FALSE  The status code specified by Data could not be converted to
+                  DEBUG() arguments.
+
+**/
+BOOLEAN
+EFIAPI
+ReportStatusCodeExtractDebugInfo (
+  IN CONST EFI_STATUS_CODE_DATA  *Data,
+  OUT UINT32                     *ErrorLevel,
+  OUT BASE_LIST                  *Marker,
+  OUT CHAR8                      **Format
+  )
+{
+  ASSERT (Data       != NULL);
+  ASSERT (ErrorLevel != NULL);
+  ASSERT (Marker     != NULL);
+  ASSERT (Format     != NULL);
+
+  return FALSE;
+}
+
+
+/**
+  Reports a status code.
+
+  Reports the status code specified by the parameters Type and Value.  Status
+  code also require an instance, caller ID, and extended data.  This function
+  passed in a zero instance, NULL extended data, and a caller ID of
+  gEfiCallerIdGuid, which is the GUID for the module.
+
+  ReportStatusCode()must actively prevent recursion.  If ReportStatusCode()
+  is called while processing another any other Report Status Code Library function,
+  then ReportStatusCode() must return immediately.
+
+  @param  Type   The status code type.
+  @param  Value  The status code value.
+
+  @retval  EFI_SUCCESS       The status code was reported.
+  @retval  EFI_DEVICE_ERROR  There status code could not be reported due to a
+                             device error.
+  @retval  EFI_UNSUPPORTED   The report status code is not supported.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCode (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value
+  )
+{
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Reports a status code with a Device Path Protocol as the extended data.
+
+  Allocates and fills in the extended data section of a status code with the
+  Device Path Protocol specified by DevicePath.  This function is responsible
+  for allocating a buffer large enough for the standard header and the device
+  path.  The standard header is filled in with a GUID of
+  gEfiStatusCodeSpecificDataGuid.  The status code is reported with a zero
+  instance and a caller ID of gEfiCallerIdGuid.
+
+  ReportStatusCodeWithDevicePath()must actively prevent recursion.  If
+  ReportStatusCodeWithDevicePath() is called while processing another any other
+  Report Status Code Library function, then ReportStatusCodeWithDevicePath()
+  must return EFI_DEVICE_ERROR immediately.
+
+  If DevicePath is NULL, then ASSERT().
+
+  @param  Type        Status code type.
+  @param  Value       Status code value.
+  @param  DevicePath  The pointer to the Device Path Protocol to be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended
+                                 data specified by DevicePath.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeWithDevicePath (
+  IN EFI_STATUS_CODE_TYPE            Type,
+  IN EFI_STATUS_CODE_VALUE           Value,
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  ASSERT (DevicePath != NULL);
+  
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Reports a status code with an extended data buffer.
+
+  Allocates and fills in the extended data section of a status code with the
+  extended data specified by ExtendedData and ExtendedDataSize.  ExtendedData
+  is assumed to be one of the data structures specified in Related Definitions.
+  These data structure do not have the standard header, so this function is
+  responsible for allocating a buffer large enough for the standard header and
+  the extended data passed into this function.  The standard header is filled
+  in with a GUID of  gEfiStatusCodeSpecificDataGuid.  The status code is reported
+  with a zero instance and a caller ID of gEfiCallerIdGuid.
+
+  ReportStatusCodeWithExtendedData()must actively prevent recursion.  If
+  ReportStatusCodeWithExtendedData() is called while processing another any other
+  Report Status Code Library function, then ReportStatusCodeWithExtendedData()
+  must return EFI_DEVICE_ERROR immediately.
+
+  If ExtendedData is NULL, then ASSERT().
+  If ExtendedDataSize is 0, then ASSERT().
+
+  @param  Type              Status code type.
+  @param  Value             Status code value.
+  @param  ExtendedData      The pointer to the extended data buffer to be reported.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer to
+                            be reported.
+
+  @retval  EFI_SUCCESS           The status code was reported with the extended
+                                 data specified by ExtendedData and ExtendedDataSize.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the
+                                 extended data section.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeWithExtendedData (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN CONST VOID             *ExtendedData,
+  IN UINTN                  ExtendedDataSize
+  )
+{
+  ASSERT (ExtendedData     != NULL);
+  ASSERT (ExtendedDataSize != 0);
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Reports a status code with full parameters.
+
+  The function reports a status code.  If ExtendedData is NULL and ExtendedDataSize
+  is 0, then an extended data buffer is not reported.  If ExtendedData is not
+  NULL and ExtendedDataSize is not 0, then an extended data buffer is allocated.
+  ExtendedData is assumed not have the standard status code header, so this function
+  is responsible for allocating a buffer large enough for the standard header and
+  the extended data passed into this function.  The standard header is filled in
+  with a GUID specified by ExtendedDataGuid.  If ExtendedDataGuid is NULL, then a
+  GUID of gEfiStatusCodeSpecificDataGuid is used.  The status code is reported with
+  an instance specified by Instance and a caller ID specified by CallerId.  If
+  CallerId is NULL, then a caller ID of gEfiCallerIdGuid is used.
+
+  ReportStatusCodeEx()must actively prevent recursion.  If ReportStatusCodeEx()
+  is called while processing another any other Report Status Code Library function,
+  then ReportStatusCodeEx() must return EFI_DEVICE_ERROR immediately.
+
+  If ExtendedData is NULL and ExtendedDataSize is not zero, then ASSERT().
+  If ExtendedData is not NULL and ExtendedDataSize is zero, then ASSERT().
+
+  @param  Type              The status code type.
+  @param  Value             The status code value.
+  @param  Instance          Status code instance number.
+  @param  CallerId          The pointer to a GUID that identifies the caller of this
+                            function.  If this parameter is NULL, then a caller
+                            ID of gEfiCallerIdGuid is used.
+  @param  ExtendedDataGuid  The pointer to the GUID for the extended data buffer.
+                            If this parameter is NULL, then a the status code
+                            standard header is filled in with
+                            gEfiStatusCodeSpecificDataGuid.
+  @param  ExtendedData      The pointer to the extended data buffer.  This is an
+                            optional parameter that may be NULL.
+  @param  ExtendedDataSize  The size, in bytes, of the extended data buffer.
+
+  @retval  EFI_SUCCESS           The status code was reported.
+  @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate
+                                 the extended data section if it was specified.
+  @retval  EFI_UNSUPPORTED       The report status code is not supported.
+
+**/
+EFI_STATUS
+EFIAPI
+ReportStatusCodeEx (
+  IN EFI_STATUS_CODE_TYPE   Type,
+  IN EFI_STATUS_CODE_VALUE  Value,
+  IN UINT32                 Instance,
+  IN CONST EFI_GUID         *CallerId          OPTIONAL,
+  IN CONST EFI_GUID         *ExtendedDataGuid  OPTIONAL,
+  IN CONST VOID             *ExtendedData      OPTIONAL,
+  IN UINTN                  ExtendedDataSize
+  )
+{
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Returns TRUE if status codes of type EFI_PROGRESS_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportProgressCodeEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**
+  Returns TRUE if status codes of type EFI_ERROR_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportErrorCodeEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**
+  Returns TRUE if status codes of type EFI_DEBUG_CODE are enabled
+
+  This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED
+  bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is set.
+  @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of
+                  PcdReportStatusCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+ReportDebugCodeEnabled (
+  VOID
+  )
+{
+  return FALSE;
+}
+
diff --git a/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.inf b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.inf
new file mode 100644
index 000000000000..ece6f8c4ace4
--- /dev/null
+++ b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.inf
@@ -0,0 +1,39 @@
+## @file
+#  Report Status Code Library with empty functions.
+#
+# Copyright (c) 2009 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseReportStatusCodeLibNull
+  MODULE_UNI_FILE                = BaseReportStatusCodeLibNull.uni
+  FILE_GUID                      = 1DE0B8C2-FFB6-4bdf-97F5-0FFB33979038
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ReportStatusCodeLib
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseReportStatusCodeLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.uni b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.uni
new file mode 100644
index 000000000000..50818f328e0a
--- /dev/null
+++ b/MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Report Status Code Library with empty functions.
+//
+// Report Status Code Library with empty functions.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Report Status Code Library with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Report Status Code Library with empty functions."
+
diff --git a/MdePkg/Library/BaseRngLib/BaseRng.c b/MdePkg/Library/BaseRngLib/BaseRng.c
new file mode 100644
index 000000000000..b21c54a8ec13
--- /dev/null
+++ b/MdePkg/Library/BaseRngLib/BaseRng.c
@@ -0,0 +1,189 @@
+/** @file
+  Random number generator services that uses RdRand instruction access
+  to provide high-quality random numbers.
+
+Copyright (c) 2015, 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 <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+//
+// Bit mask used to determine if RdRand instruction is supported.
+//
+#define RDRAND_MASK                  BIT30
+
+//
+// Limited retry number when valid random data is returned.
+// Uses the recommended value defined in Section 7.3.17 of "Intel 64 and IA-32
+// Architectures Software Developer's Mannual".
+//
+#define RDRAND_RETRY_LIMIT           10
+
+/**
+  The constructor function checks whether or not RDRAND instruction is supported
+  by the host hardware.
+
+  The constructor function checks whether or not RDRAND instruction is supported.
+  It will ASSERT() if RDRAND instruction is not supported.
+  It will always return RETURN_SUCCESS.
+
+  @retval RETURN_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+RETURN_STATUS
+EFIAPI
+BaseRngLibConstructor (
+  VOID
+  )
+{
+  UINT32  RegEcx;
+
+  //
+  // Determine RDRAND support by examining bit 30 of the ECX register returned by
+  // CPUID. A value of 1 indicates that processor support RDRAND instruction.
+  //
+  AsmCpuid (1, 0, 0, &RegEcx, 0);
+  ASSERT ((RegEcx & RDRAND_MASK) == RDRAND_MASK);
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Generates a 16-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 16-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber16 (
+  OUT     UINT16                    *Rand
+  )
+{
+  UINT32  Index;
+
+  ASSERT (Rand != NULL);
+
+  //
+  // A loop to fetch a 16 bit random value with a retry count limit.
+  //
+  for (Index = 0; Index < RDRAND_RETRY_LIMIT; Index++) {
+    if (AsmRdRand16 (Rand)) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+/**
+  Generates a 32-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 32-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber32 (
+  OUT     UINT32                    *Rand
+  )
+{
+  UINT32  Index;
+
+  ASSERT (Rand != NULL);
+
+  //
+  // A loop to fetch a 32 bit random value with a retry count limit.
+  //
+  for (Index = 0; Index < RDRAND_RETRY_LIMIT; Index++) {
+    if (AsmRdRand32 (Rand)) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+/**
+  Generates a 64-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 64-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber64 (
+  OUT     UINT64                    *Rand
+  )
+{
+  UINT32  Index;
+
+  ASSERT (Rand != NULL);
+
+  //
+  // A loop to fetch a 64 bit random value with a retry count limit.
+  //
+  for (Index = 0; Index < RDRAND_RETRY_LIMIT; Index++) {
+    if (AsmRdRand64 (Rand)) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+/**
+  Generates a 128-bit random number.
+
+  if Rand is NULL, then ASSERT().
+
+  @param[out] Rand     Buffer pointer to store the 128-bit random value.
+
+  @retval TRUE         Random number generated successfully.
+  @retval FALSE        Failed to generate the random number.
+
+**/
+BOOLEAN
+EFIAPI
+GetRandomNumber128 (
+  OUT     UINT64                    *Rand
+  )
+{
+  ASSERT (Rand != NULL);
+
+  //
+  // Read first 64 bits
+  //
+  if (!GetRandomNumber64 (Rand)) {
+    return FALSE;
+  }
+
+  //
+  // Read second 64 bits
+  //
+  return GetRandomNumber64 (++Rand);
+}
diff --git a/MdePkg/Library/BaseRngLib/BaseRngLib.inf b/MdePkg/Library/BaseRngLib/BaseRngLib.inf
new file mode 100644
index 000000000000..0d5a2a261550
--- /dev/null
+++ b/MdePkg/Library/BaseRngLib/BaseRngLib.inf
@@ -0,0 +1,41 @@
+## @file
+#  Instance of RNG (Random Number Generator) Library.
+#
+#  BaseRng Library that uses CPU RdRand instruction access to provide
+#  high-quality random numbers.
+#
+#  Copyright (c) 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseRngLib
+  MODULE_UNI_FILE                = BaseRngLib.uni
+  FILE_GUID                      = 626440D8-1971-41D9-9AB2-FB25F4AE79BC
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = RngLib
+  CONSTRUCTOR                    = BaseRngLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources.Ia32, Sources.X64]
+  BaseRng.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
diff --git a/MdePkg/Library/BaseRngLib/BaseRngLib.uni b/MdePkg/Library/BaseRngLib/BaseRngLib.uni
new file mode 100644
index 000000000000..db36a38aa855
--- /dev/null
+++ b/MdePkg/Library/BaseRngLib/BaseRngLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of RNG (Random Number Generator) Library.
+//
+// BaseRng Library that uses CPU RdRand instruction access to provide
+// high-quality random numbers.
+//
+// Copyright (c) 2015, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of RNG Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "BaseRng Library that uses CPU RdRand instruction access to provide high-quality random numbers"
+
diff --git a/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.inf b/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.inf
new file mode 100644
index 000000000000..888c1e930b4d
--- /dev/null
+++ b/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.inf
@@ -0,0 +1,43 @@
+## @file
+# BootScriptLib instance that always produces NOP operation.
+#
+# This library is primarily used by platform that does not support ACPI S3
+# resume.  All the library interfaces simply return EFI_SUCCESS without
+# performing any operation.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseS3BootScriptLibNull
+  MODULE_UNI_FILE                = BaseS3BootScriptLibNull.uni
+  FILE_GUID                      = 9A6DC1AC-94C0-43b1-8714-4C70FD58A815
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = S3BootScriptLib
+
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BootScriptLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.uni b/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.uni
new file mode 100644
index 000000000000..217e987d35f3
--- /dev/null
+++ b/MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.uni
@@ -0,0 +1,24 @@
+// /** @file
+// BootScriptLib instance that always produces NOP operation.
+//
+// This library is primarily used by platform that does not support ACPI S3
+// resume.  All the library interfaces simply return EFI_SUCCESS without
+// performing any operation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "BootScriptLib instance that always produces NOP operation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library is primarily used by a platform that does not support ACPI S3 resume.  All the library interfaces simply return EFI_SUCCESS without performing any operation."
+
diff --git a/MdePkg/Library/BaseS3BootScriptLibNull/BootScriptLib.c b/MdePkg/Library/BaseS3BootScriptLibNull/BootScriptLib.c
new file mode 100644
index 000000000000..4ede036a106e
--- /dev/null
+++ b/MdePkg/Library/BaseS3BootScriptLibNull/BootScriptLib.c
@@ -0,0 +1,568 @@
+/** @file
+  Null function implementation for EFI S3 boot script. 
+
+  Copyright (c) 2007 - 2014, 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 <Base.h>
+#include <Library/S3BootScriptLib.h>
+
+/**
+  Save I/O write to boot script 
+
+  @param Width  the width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address The base address of the I/O operations.
+  @param Count   The number of I/O operations to perform.
+  @param Buffer  The source buffer from which to write data.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH             Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  VOID                              *Buffer
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Adds a record for an I/O modify operation into a S3 boot script table
+
+  @param Width   The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address The base address of the I/O operations.
+  @param Data    A pointer to the data to be OR-ed.
+  @param DataMask  A pointer to the data mask to be AND-ed with the data read from the register
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH             Width,
+  IN  UINT64                           Address,
+  IN  VOID                            *Data,
+  IN  VOID                            *DataMask
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Adds a record for a memory write operation into a specified boot script table.
+
+  @param Width   The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address The base address of the memory operations
+  @param Count   The number of memory operations to perform.
+  @param Buffer  The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH              Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  VOID                              *Buffer
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for a memory modify operation into a specified boot script table.
+
+  @param Width     The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address   The base address of the memory operations. Address needs alignment if required
+  @param Data      A pointer to the data to be OR-ed.
+  @param DataMask  A pointer to the data mask to be AND-ed with the data read from the register.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH             Width,
+  IN  UINT64                            Address,
+  IN  VOID                              *Data,
+  IN  VOID                              *DataMask
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for a PCI configuration space write operation into a specified boot script table.
+
+  @param Width     The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address   The address within the PCI configuration space.
+  @param Count     The number of PCI operations to perform.
+  @param Buffer    The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfgWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH             Width,
+  IN  UINT64                           Address,
+  IN  UINTN                            Count,
+  IN  VOID                            *Buffer
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param Width     The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Address   The address within the PCI configuration space.
+  @param Data      A pointer to the data to be OR-ed.The size depends on Width.
+  @param DataMask    A pointer to the data mask to be AND-ed.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN__SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfgReadWrite (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH          Width,
+  IN  UINT64                            Address,
+  IN  VOID                              *Data,
+  IN  VOID                              *DataMask
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param Width     The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Segment   The PCI segment number for Address.
+  @param Address   The address within the PCI configuration space.
+  @param Count     The number of PCI operations to perform.
+  @param Buffer    The source buffer from which to write the data.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfg2Write (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH        Width,
+  IN UINT16                          Segment,
+  IN UINT64                          Address,
+  IN UINTN                           Count,
+  IN VOID                           *Buffer
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for a PCI configuration space modify operation into a specified boot script table.
+
+  @param Width     The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
+  @param Segment   The PCI segment number for Address.
+  @param Address   The address within the PCI configuration space.
+  @param Data      A pointer to the data to be OR-ed. The size depends on Width.
+  @param DataMask    A pointer to the data mask to be AND-ed.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciCfg2ReadWrite (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH            Width,
+  IN UINT16                          Segment,
+  IN UINT64                          Address,
+  IN VOID                           *Data,
+  IN VOID                           *DataMask
+  )
+{ 
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for an SMBus command execution into a specified boot script table.
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length, and PEC.
+  @param Operation      Indicates which particular SMBus protocol it will use to execute the SMBus
+                        transactions.
+  @param Length         A pointer to signify the number of bytes that this operation will do.
+  @param Buffer         Contains the value of data to execute to the SMBUS slave device.
+  
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveSmbusExecute (
+  IN  UINTN                             SmBusAddress, 
+  IN  EFI_SMBUS_OPERATION               Operation,
+  IN  UINTN                             *Length,
+  IN  VOID                              *Buffer
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for an execution stall on the processor into a specified boot script table.
+
+  @param Duration   Duration in microseconds of the stall
+  
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveStall (
+  IN  UINTN                             Duration
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for dispatching specified arbitrary code into a specified boot script table.
+
+  @param EntryPoint   Entry point of the code to be dispatched.
+  
+  @retval RETURN_OUT_OF_RESOURCES   Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS            Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveDispatch (
+  IN  VOID *EntryPoint
+  )
+{
+  return RETURN_SUCCESS;
+}
+/**
+  Adds a record for dispatching specified arbitrary code into a specified boot script table.
+
+  @param EntryPoint   Entry point of the code to be dispatched.
+  @param Context      Argument to be passed into the EntryPoint of the code to be dispatched.
+  
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveDispatch2 (
+  IN  VOID                              *EntryPoint,
+  IN  VOID                              *Context
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Adds a record for memory reads of the memory location and continues when the exit criteria is
+  satisfied or after a defined duration.
+ 
+  Please aware, below interface is different with PI specification, Vol 5:
+  EFI_S3_SAVE_STATE_PROTOCOL.Write() for EFI_BOOT_SCRIPT_MEM_POLL_OPCODE.
+  "Duration" below is microseconds, while "Delay" in PI specification means
+  the number of 100ns units to poll.
+
+  @param Width     The width of the memory operations.
+  @param Address   The base address of the memory operations.
+  @param BitMask   A pointer to the bit mask to be AND-ed with the data read from the register.
+  @param BitValue  A pointer to the data value after to be Masked.
+  @param Duration  Duration in microseconds of the stall.
+  @param LoopTimes The times of the register polling.
+
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveMemPoll (
+  IN  S3_BOOT_SCRIPT_LIB_WIDTH             Width,
+  IN  UINT64                            Address,
+  IN  VOID                              *BitMask,
+  IN  VOID                              *BitValue,
+  IN  UINTN                             Duration,
+  IN  UINT64                            LoopTimes
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Store arbitrary information in the boot script table. This opcode is a no-op on dispatch and is only
+  used for debugging script issues.
+  
+  @param InformationLength   Length of the data in bytes
+  @param Information       Information to be logged in the boot scrpit
+ 
+  @retval RETURN_UNSUPPORTED   If  entering runtime, this method will not support.
+  @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+  @retval RETURN_SUCCESS           Opcode is added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveInformation (
+  IN  UINT32                   InformationLength, 
+  IN  VOID                    *Information
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for I/O reads the I/O location and continues when the exit criteria is satisfied or after a
+  defined duration.
+  
+  @param  Width                 The width of the I/O operations. 
+  @param  Address               The base address of the I/O operations.
+  @param  Data                  The comparison value used for the polling exit criteria.
+  @param  DataMask              Mask used for the polling criteria. The bits in the bytes below Width which are zero
+                                in Data are ignored when polling the memory address.
+  @param  Delay                 The number of 100ns units to poll. Note that timer available may be of poorer
+                                granularity so the delay may be longer.
+
+ @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+ @retval RETURN_SUCCESS          Opcode is added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveIoPoll (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH       Width,
+  IN UINT64                     Address,
+  IN VOID                      *Data,
+  IN VOID                      *DataMask, 
+  IN UINT64                     Delay   
+  )
+{
+	return RETURN_SUCCESS;
+}
+
+/**
+  Adds a record for PCI configuration space reads and continues when the exit criteria is satisfied or
+  after a defined duration.
+
+  @param  Width                 The width of the I/O operations. 
+  @param  Address               The address within the PCI configuration space.
+  @param  Data                  The comparison value used for the polling exit criteria.
+  @param  DataMask              Mask used for the polling criteria. The bits in the bytes below Width which are zero
+                                in Data are ignored when polling the memory address
+  @param  Delay                 The number of 100ns units to poll. Note that timer available may be of poorer
+                                granularity so the delay may be longer.
+
+ @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+ @retval RETURN_SUCCESS           Opcode is added.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePciPoll (
+   IN S3_BOOT_SCRIPT_LIB_WIDTH   Width,
+   IN UINT64                     Address,
+   IN VOID                      *Data,
+   IN VOID                      *DataMask,
+   IN UINT64                     Delay
+ )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Adds a record for PCI configuration space reads and continues when the exit criteria is satisfied or
+  after a defined duration.
+
+  @param  Width                 The width of the I/O operations. 
+  @param  Segment               The PCI segment number for Address.
+  @param  Address               The address within the PCI configuration space.
+  @param  Data                  The comparison value used for the polling exit criteria.
+  @param  DataMask              Mask used for the polling criteria. The bits in the bytes below Width which are zero
+                                in Data are ignored when polling the memory address
+  @param  Delay                 The number of 100ns units to poll. Note that timer available may be of poorer
+                                granularity so the delay may be longer.
+
+ @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
+ @retval RETURN_SUCCESS           Opcode is added.
+ @note   A known Limitations in the implementation: When interpreting the opcode  EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE
+         EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE and EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE, the 'Segment' parameter is assumed as 
+         Zero, or else, assert.
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSavePci2Poll (
+   IN S3_BOOT_SCRIPT_LIB_WIDTH      Width,
+   IN UINT16                        Segment,
+   IN UINT64                        Address,
+   IN VOID                         *Data,
+   IN VOID                         *DataMask,
+   IN UINT64                        Delay
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Save ASCII string information specified by Buffer to
+  boot script with opcode EFI_BOOT_SCRIPT_INFORMATION_OPCODE
+
+  @param  String         the ascii string to store into the S3 boot script table
+
+  @retval RETURN_NOT_FOUND  BootScriptSave Protocol not exist.
+  @retval RETURN_SUCCESS     BootScriptSave Protocol exist, always returns RETURN_SUCCESS
+
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptSaveInformationAsciiString (
+  IN  CONST CHAR8               *String
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  This is an function to close the S3 boot script table. The function could only be called in 
+  BOOT time phase. To comply with the Framework spec definition on 
+  EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable(), this function will fulfill following things:
+  1. Closes the specified boot script table
+  2. It allocates a new memory pool to duplicate all the boot scripts in the specified table. 
+     Once this function is called, the table maintained by the library will be destroyed 
+     after it is copied into the allocated pool.
+  3. Any attempts to add a script record after calling this function will cause a new table 
+     to be created by the library.
+  4. The base address of the allocated pool will be returned in Address. Note that after 
+     using the boot script table, the CALLER is responsible for freeing the pool that is allocated
+     by this function. 
+
+  In Spec PI1.1, this EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable() is retired. By then it is not
+  necessary to provide this API in BootScriptLib. To provides this API for now is only to meet
+  the requirement from Framework Spec.
+  
+  If anyone does call CloseTable() on a real platform, then the caller is responsible for figuring out 
+  how to get the script to run on an S3 resume because the boot script maintained by the lib will be 
+  destroyed.
+ 
+  @return the base address of the new copy of the boot script table.   
+
+**/
+UINT8*
+EFIAPI
+S3BootScriptCloseTable (
+  VOID
+  )
+{
+	return 0;
+}
+/**
+  Executes the S3 boot script table.
+
+  @param RETURN_SUCCESS           The boot script table was executed successfully.
+  @param RETURN_UNSUPPORTED       Invalid script table or opcode.  
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptExecute (
+   VOID
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Move the last boot script entry to the position 
+
+  @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE) or after (FALSE) the position
+                                in the boot script table specified by Position. If Position is NULL or points to
+                                NULL then the new opcode is inserted at the beginning of the table (if TRUE) or end
+                                of the table (if FALSE).
+  @param  Position              On entry, specifies the position in the boot script table where the opcode will be
+                                inserted, either before or after, depending on BeforeOrAfter. On exit, specifies
+                                the position of the inserted opcode in the boot script table.
+
+  @retval RETURN_OUT_OF_RESOURCES  The table is not available.
+  @retval RETURN_INVALID_PARAMETER The Position is not a valid position in the boot script table.
+  @retval RETURN_SUCCESS           Opcode is inserted.
+**/
+RETURN_STATUS
+EFIAPI
+S3BootScriptMoveLastOpcode (
+  IN     BOOLEAN                        BeforeOrAfter,
+  IN OUT VOID                         **Position OPTIONAL
+)
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Find a label within the boot script table and, if not present, optionally create it.
+
+  @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE)
+                                or after (FALSE) the position in the boot script table 
+                                specified by Position.
+  @param  CreateIfNotFound      Specifies whether the label will be created if the label 
+                                does not exists (TRUE) or not (FALSE).
+  @param  Position              On entry, specifies the position in the boot script table
+                                where the opcode will be inserted, either before or after,
+                                depending on BeforeOrAfter. On exit, specifies the position
+                                of the inserted opcode in the boot script table.
+  @param  Label                 Points to the label which will be inserted in the boot script table.
+
+  @retval EFI_SUCCESS           The operation succeeded. A record was added into the
+                                specified script table.
+  @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script is not supported.
+                                If the opcode is unknow or not supported because of the PCD 
+                                Feature Flags.
+  @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
+
+**/
+RETURN_STATUS
+EFIAPI 
+S3BootScriptLabel (
+  IN       BOOLEAN                      BeforeOrAfter,
+  IN       BOOLEAN                      CreateIfNotFound,
+  IN OUT   VOID                       **Position OPTIONAL,
+  IN CONST CHAR8                       *Label
+  )
+{
+	return RETURN_SUCCESS;
+}
+/**
+  Compare two positions in the boot script table and return their relative position.
+  @param  Position1             The positions in the boot script table to compare
+  @param  Position2             The positions in the boot script table to compare
+  @param  RelativePosition      On return, points to the result of the comparison
+
+  @retval EFI_SUCCESS           The operation succeeded. A record was added into the
+                                specified script table.
+  @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script is not supported.
+                                If the opcode is unknow or not supported because of the PCD 
+                                Feature Flags.
+  @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
+
+**/
+RETURN_STATUS
+EFIAPI 
+S3BootScriptCompare (
+  IN  UINT8                       *Position1,
+  IN  UINT8                       *Position2,
+  OUT UINTN                       *RelativePosition
+  )
+{
+	return RETURN_SUCCESS;
+}
diff --git a/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.inf b/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.inf
new file mode 100644
index 000000000000..bc458b971b7b
--- /dev/null
+++ b/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.inf
@@ -0,0 +1,46 @@
+## @file
+# Instance of S3 I/O Library based on I/O and S3 BootScript Library.
+#
+# S3 I/O and MMIO Library Services that do I/O and also 
+# enable the I/O operatation to be replayed during an S3 resume.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseS3IoLib
+  MODULE_UNI_FILE                = BaseS3IoLib.uni
+  FILE_GUID                      = B13F938E-47DF-4516-A397-8927A4E42B61
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = S3IoLib 
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  S3IoLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  IoLib
+  S3BootScriptLib
+
diff --git a/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.uni b/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.uni
new file mode 100644
index 000000000000..5add6883fdc2
--- /dev/null
+++ b/MdePkg/Library/BaseS3IoLib/BaseS3IoLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of S3 I/O Library based on I/O and S3 BootScript Library.
+//
+// S3 I/O and MMIO Library Services that do I/O and also
+// enable the I/O operatation to be replayed during an S3 resume.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of S3 I/O Library based on I/O and S3 BootScript Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "S3 I/O and MMIO Library Services that do I/O and also enable the I/O operation to be replayed during an S3 resume."
+
diff --git a/MdePkg/Library/BaseS3IoLib/S3IoLib.c b/MdePkg/Library/BaseS3IoLib/S3IoLib.c
new file mode 100644
index 000000000000..a3d636324bf8
--- /dev/null
+++ b/MdePkg/Library/BaseS3IoLib/S3IoLib.c
@@ -0,0 +1,3312 @@
+/** @file
+  I/O and MMIO Library Services that do I/O and also enable the I/O operatation
+  to be replayed during an S3 resume.
+  
+  Copyright (c) 2006 -2012, 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 <Base.h>
+
+#include <Library/S3IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/IoLib.h>
+#include <Library/S3BootScriptLib.h>
+
+
+/**
+  Saves an I/O port value to the boot script.
+
+  This internal worker function saves an I/O port value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Width         The width of I/O port.
+  @param  Port          The I/O port to write.
+  @param  Buffer        The buffer containing value.
+
+**/
+VOID
+InternalSaveIoWriteValueToBootScript (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN UINTN                  Port,
+  IN VOID                   *Buffer
+  )
+{
+  RETURN_STATUS                Status;
+  
+  Status = S3BootScriptSaveIoWrite (
+             Width,
+             Port,
+             1,
+             Buffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+}
+  
+/**
+  Saves an 8-bit I/O port value to the boot script.
+
+  This internal worker function saves an 8-bit I/O port value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT8
+InternalSaveIoWrite8ValueToBootScript (
+  IN UINTN              Port,
+  IN UINT8              Value
+  )
+{
+  InternalSaveIoWriteValueToBootScript (S3BootScriptWidthUint8, Port, &Value);
+
+  return Value;
+}
+
+/**
+  Reads an 8-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+S3IoRead8 (
+  IN UINTN              Port
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoRead8 (Port));
+}
+
+/**
+  Writes an 8-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoWrite8 (
+  IN UINTN              Port,
+  IN UINT8              Value
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoWrite8 (Port, Value));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port and saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoOr8 (
+  IN UINTN              Port,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoOr8 (Port, OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port  and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoAnd8 (
+  IN UINTN              Port,
+  IN UINT8              AndData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoAnd8 (Port, AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit I/O port and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoAndThenOr8 (
+  IN UINTN              Port,
+  IN UINT8              AndData,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoAndThenOr8 (Port, AndData, OrData));
+}
+
+/**
+  Reads a bit field of an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port          The I/O port to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldRead8 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoBitFieldRead8 (Port, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldWrite8 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              Value
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoBitFieldWrite8 (Port, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldOr8 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoBitFieldOr8 (Port, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port  and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldAnd8 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              AndData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoBitFieldAnd8 (Port, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+S3IoBitFieldAndThenOr8 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              AndData,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveIoWrite8ValueToBootScript (Port, IoBitFieldAndThenOr8 (Port, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 16-bit I/O port value to the boot script.
+
+  This internal worker function saves a 16-bit I/O port value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT16
+InternalSaveIoWrite16ValueToBootScript (
+  IN UINTN              Port,
+  IN UINT16             Value
+  )
+{
+  InternalSaveIoWriteValueToBootScript (S3BootScriptWidthUint16, Port, &Value);
+  
+  return Value;
+}
+
+/**
+  Reads a 16-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+S3IoRead16 (
+  IN UINTN              Port
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoRead16 (Port));
+}
+
+/**
+  Writes a 16-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoWrite16 (
+  IN UINTN              Port,
+  IN UINT16             Value
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoWrite16 (Port, Value));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoOr16 (
+  IN UINTN              Port,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoOr16 (Port, OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port  and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoAnd16 (
+  IN UINTN              Port,
+  IN UINT16             AndData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoAnd16 (Port, AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit I/O port and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoAndThenOr16 (
+  IN UINTN              Port,
+  IN UINT16             AndData,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoAndThenOr16 (Port, AndData, OrData));
+}
+
+/**
+  Reads a bit field of an I/O register saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port          The I/O port to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldRead16 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoBitFieldRead16 (Port, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to an I/O register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldWrite16 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             Value
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoBitFieldWrite16 (Port, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldOr16 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoBitFieldOr16 (Port, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldAnd16 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             AndData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoBitFieldAnd16 (Port, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port  and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+S3IoBitFieldAndThenOr16 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             AndData,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveIoWrite16ValueToBootScript (Port, IoBitFieldAndThenOr16 (Port, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 32-bit I/O port value to the boot script.
+
+  This internal worker function saves a 32-bit I/O port value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT32
+InternalSaveIoWrite32ValueToBootScript (
+  IN UINTN              Port,
+  IN UINT32             Value
+  )
+{
+  InternalSaveIoWriteValueToBootScript (S3BootScriptWidthUint32, Port, &Value);
+  
+  return Value;
+}
+
+/**
+  Reads a 32-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+S3IoRead32 (
+  IN UINTN              Port
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoRead32 (Port));
+}
+
+/**
+  Writes a 32-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoWrite32 (
+  IN UINTN              Port,
+  IN UINT32             Value
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoWrite32 (Port, Value));
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoOr32 (
+  IN UINTN              Port,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoOr32 (Port, OrData));
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoAnd32 (
+  IN UINTN              Port,
+  IN UINT32             AndData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoAnd32 (Port, AndData));
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit I/O port and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoAndThenOr32 (
+  IN UINTN              Port,
+  IN UINT32             AndData,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoAndThenOr32 (Port, AndData, OrData));
+}
+
+/**
+  Reads a bit field of an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port          The I/O port to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldRead32 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoBitFieldRead32 (Port, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldWrite32 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             Value
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoBitFieldWrite32 (Port, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldOr32 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoBitFieldOr32 (Port, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldAnd32 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             AndData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoBitFieldAnd32 (Port, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+S3IoBitFieldAndThenOr32 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             AndData,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveIoWrite32ValueToBootScript (Port, IoBitFieldAndThenOr32 (Port, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 64-bit I/O port value to the boot script.
+
+  This internal worker function saves a 64-bit I/O port value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT64
+InternalSaveIoWrite64ValueToBootScript (
+  IN UINTN              Port,
+  IN UINT64             Value
+  )
+{
+  InternalSaveIoWriteValueToBootScript (S3BootScriptWidthUint64, Port, &Value);
+  
+  return Value;
+}
+
+/**
+  Reads a 64-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+S3IoRead64 (
+  IN UINTN              Port
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoRead64 (Port));
+}
+
+/**
+  Writes a 64-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  Value         The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoWrite64 (
+  IN UINTN              Port,
+  IN UINT64             Value
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoWrite64 (Port, Value));
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port and saves the value in the S3 script to 
+  be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoOr64 (
+  IN UINTN              Port,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoOr64 (Port, OrData));
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoAnd64 (
+  IN UINTN              Port,
+  IN UINT64             AndData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoAnd64 (Port, AndData));
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit I/O port and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoAndThenOr64 (
+  IN UINTN              Port,
+  IN UINT64             AndData,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoAndThenOr64 (Port, AndData, OrData));
+}
+
+/**
+  Reads a bit field of an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port          The I/O port to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldRead64 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoBitFieldRead64 (Port, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to an I/O register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldWrite64 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             Value
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoBitFieldWrite64 (Port, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  OrData        The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldOr64 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoBitFieldOr64 (Port, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port and saves the value in the 
+  S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  AndData       The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldAnd64 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             AndData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoBitFieldAnd64 (Port, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port and saves the value in the S3 script to be replayed on S3 
+  resume.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port          The I/O port to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  AndData       The value to AND with the read value from the I/O port.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+S3IoBitFieldAndThenOr64 (
+  IN UINTN              Port,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             AndData,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveIoWrite64ValueToBootScript (Port, IoBitFieldAndThenOr64 (Port, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves an MMIO register value to the boot script.
+
+  This internal worker function saves an MMIO register value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Width         The width of MMIO register.
+  @param  Address       The MMIO register to write.
+  @param  Buffer        The buffer containing value.
+
+**/
+VOID
+InternalSaveMmioWriteValueToBootScript (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN UINTN                  Address,
+  IN VOID                   *Buffer
+  )
+{
+  RETURN_STATUS            Status;
+
+  Status = S3BootScriptSaveMemWrite (
+             Width,
+             Address,
+             1,
+             Buffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+}
+
+/**
+  Saves an 8-bit MMIO register value to the boot script.
+
+  This internal worker function saves an 8-bit MMIO register value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT8
+InternalSaveMmioWrite8ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT8              Value
+  )
+{
+  InternalSaveMmioWriteValueToBootScript (S3BootScriptWidthUint8, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads an 8-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+S3MmioRead8 (
+  IN UINTN              Address
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioRead8 (Address));
+}
+
+/**
+  Writes an 8-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value to write to the MMIO register.
+
+  @return The value written the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioWrite8 (
+  IN UINTN              Address,
+  IN UINT8              Value
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioWrite8 (Address, Value));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioOr8 (
+  IN UINTN              Address,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioOr8 (Address, OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioAnd8 (
+  IN UINTN              Address,
+  IN UINT8              AndData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioAnd8 (Address, AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit MMIO register and saves 
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioAndThenOr8 (
+  IN UINTN              Address,
+  IN UINT8              AndData,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioAndThenOr8 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address       MMIO register to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldRead8 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioBitFieldRead8 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to an MMIO register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldWrite8 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              Value
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioBitFieldWrite8 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldOr8 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioBitFieldOr8 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldAnd8 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              AndData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioBitFieldAnd8 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register  and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..7.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..7.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+S3MmioBitFieldAndThenOr8 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT8              AndData,
+  IN UINT8              OrData
+  )
+{
+  return InternalSaveMmioWrite8ValueToBootScript (Address, MmioBitFieldAndThenOr8 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 16-bit MMIO register value to the boot script.
+
+  This internal worker function saves a 16-bit MMIO register value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT16
+InternalSaveMmioWrite16ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT16             Value
+  )
+{
+  InternalSaveMmioWriteValueToBootScript (S3BootScriptWidthUint16, Address, &Value);
+  
+  return Value;
+}
+
+/**
+  Reads a 16-bit MMIO register and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+S3MmioRead16 (
+  IN UINTN              Address
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioRead16 (Address));
+}
+
+/**
+  Writes a 16-bit MMIO register and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized and saves the value in the S3 script to be
+  replayed on S3 resume.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value to write to the MMIO register.
+
+  @return The value written the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioWrite16 (
+  IN UINTN              Address,
+  IN UINT16             Value
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioWrite16 (Address, Value));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioOr16 (
+  IN UINTN              Address,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioOr16 (Address, OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioAnd16 (
+  IN UINTN              Address,
+  IN UINT16             AndData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioAnd16 (Address, AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioAndThenOr16 (
+  IN UINTN              Address,
+  IN UINT16             AndData,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioAndThenOr16 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address       MMIO register to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldRead16 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioBitFieldRead16 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a MMIO register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldWrite16 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             Value
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioBitFieldWrite16 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldOr16 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioBitFieldOr16 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldAnd16 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             AndData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioBitFieldAnd16 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..15.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..15.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+S3MmioBitFieldAndThenOr16 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT16             AndData,
+  IN UINT16             OrData
+  )
+{
+  return InternalSaveMmioWrite16ValueToBootScript (Address, MmioBitFieldAndThenOr16 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 32-bit MMIO register value to the boot script.
+
+  This internal worker function saves a 32-bit MMIO register value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT32
+InternalSaveMmioWrite32ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT32             Value
+  )
+{
+  InternalSaveMmioWriteValueToBootScript (S3BootScriptWidthUint32, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads a 32-bit MMIO register saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+S3MmioRead32 (
+  IN UINTN              Address
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioRead32 (Address));
+}
+
+/**
+  Writes a 32-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value to write to the MMIO register.
+
+  @return The value written the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioWrite32 (
+  IN UINTN              Address,
+  IN UINT32             Value
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioWrite32 (Address, Value));
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioOr32 (
+  IN UINTN              Address,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioOr32 (Address, OrData));
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioAnd32 (
+  IN UINTN              Address,
+  IN UINT32             AndData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioAnd32 (Address, AndData));
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioAndThenOr32 (
+  IN UINTN              Address,
+  IN UINT32             AndData,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioAndThenOr32 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address       MMIO register to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldRead32 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioBitFieldRead32 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldWrite32 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             Value
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioBitFieldWrite32 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldOr32 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioBitFieldOr32 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldAnd32 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             AndData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioBitFieldAnd32 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..31.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..31.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+S3MmioBitFieldAndThenOr32 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT32             AndData,
+  IN UINT32             OrData
+  )
+{
+  return InternalSaveMmioWrite32ValueToBootScript (Address, MmioBitFieldAndThenOr32 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 64-bit MMIO register value to the boot script.
+
+  This internal worker function saves a 64-bit MMIO register value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT64
+InternalSaveMmioWrite64ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT64             Value
+  )
+{
+  InternalSaveMmioWriteValueToBootScript (S3BootScriptWidthUint64, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads a 64-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+S3MmioRead64 (
+  IN UINTN              Address
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioRead64 (Address));
+}
+
+/**
+  Writes a 64-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  Value         The value to write to the MMIO register.
+
+  @return The value written the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioWrite64 (
+  IN UINTN              Address,
+  IN UINT64             Value
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioWrite64 (Address, Value));
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register and saves the value in the S3 script 
+  to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioOr64 (
+  IN UINTN              Address,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioOr64 (Address, OrData));
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register and saves the value in the S3 script to be 
+  replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioAnd64 (
+  IN UINTN              Address,
+  IN UINT64             AndData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioAnd64 (Address, AndData));
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioAndThenOr64 (
+  IN UINTN              Address,
+  IN UINT64             AndData,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioAndThenOr64 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address       MMIO register to read.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldRead64 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioBitFieldRead64 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a MMIO register and saves the value in the S3 script to
+  be replayed on S3 resume.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  Value         New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldWrite64 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             Value
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioBitFieldWrite64 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register and 
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  OrData        The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldOr64 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioBitFieldOr64 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldAnd64 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             AndData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioBitFieldAnd64 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address       The MMIO register to write.
+  @param  StartBit      The ordinal of the least significant bit in the bit field.
+                        Range 0..63.
+  @param  EndBit        The ordinal of the most significant bit in the bit field.
+                        Range 0..63.
+  @param  AndData       The value to AND with the read value from the MMIO register.
+  @param  OrData        The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+S3MmioBitFieldAndThenOr64 (
+  IN UINTN              Address,
+  IN UINTN              StartBit,
+  IN UINTN              EndBit,
+  IN UINT64             AndData,
+  IN UINT64             OrData
+  )
+{
+  return InternalSaveMmioWrite64ValueToBootScript (Address, MmioBitFieldAndThenOr64 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+S3MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8       *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioReadBuffer8 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint8,
+             StartAddress,
+             Length / sizeof (UINT8),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+S3MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16       *ReturnBuffer;
+  RETURN_STATUS   Status;
+
+  ReturnBuffer = MmioReadBuffer16 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint16,
+             StartAddress,
+             Length / sizeof (UINT16),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+S3MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32      *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioReadBuffer32 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint32,
+             StartAddress,
+             Length / sizeof (UINT32),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+S3MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64      *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioReadBuffer64 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint64,
+             StartAddress,
+             Length / sizeof (UINT64),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+S3MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  UINT8       *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioWriteBuffer8 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint8,
+             StartAddress,
+             Length / sizeof (UINT8),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+S3MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16      *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioWriteBuffer16 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint16,
+             StartAddress,
+             Length / sizeof (UINT16),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+S3MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32      *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioWriteBuffer32 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint32,
+             StartAddress,
+             Length / sizeof (UINT32),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+S3MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64      *ReturnBuffer;
+  RETURN_STATUS  Status;
+
+  ReturnBuffer = MmioWriteBuffer64 (StartAddress, Length, Buffer);
+
+  Status = S3BootScriptSaveMemWrite (
+             S3BootScriptWidthUint64,
+             StartAddress,
+             Length / sizeof (UINT64),
+             ReturnBuffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.inf b/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.inf
new file mode 100644
index 000000000000..75995d2edd55
--- /dev/null
+++ b/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.inf
@@ -0,0 +1,47 @@
+## @file
+# Instance of S3 PCI Library based on PCI and S3 BootScript Library.
+#
+# S3 PCI Services that perform PCI Configuration cycles and 
+# also enable the PCI operation to be replayed during an S3 resume.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseS3PciLib
+  MODULE_UNI_FILE                = BaseS3PciLib.uni
+  FILE_GUID                      = F66B6BD2-513F-441d-B367-2D5BD4998A50
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = S3PciLib 
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  S3PciLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  PciLib
+  S3BootScriptLib
+  DebugLib
+
diff --git a/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.uni b/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.uni
new file mode 100644
index 000000000000..1ca4d8ff748f
--- /dev/null
+++ b/MdePkg/Library/BaseS3PciLib/BaseS3PciLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of S3 PCI Library based on PCI and S3 BootScript Library.
+//
+// S3 PCI Services that perform PCI Configuration cycles and
+// also enable the PCI operation to be replayed during an S3 resume.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of S3 PCI Library based on PCI and S3 BootScript Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "S3 PCI Services that perform PCI Configuration cycles and also enable the PCI operation to be replayed during an S3 resume."
+
diff --git a/MdePkg/Library/BaseS3PciLib/S3PciLib.c b/MdePkg/Library/BaseS3PciLib/S3PciLib.c
new file mode 100644
index 000000000000..a2f956bee14e
--- /dev/null
+++ b/MdePkg/Library/BaseS3PciLib/S3PciLib.c
@@ -0,0 +1,1269 @@
+/** @file
+  PCI configuration Library Services that do PCI configuration and also enable
+  the PCI operations to be replayed during an S3 resume. This library class
+  maps directly on top of the PciLib class. 
+
+  Copyright (c) 2006 - 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 <Base.h>
+
+#include <Library/DebugLib.h>
+#include <Library/S3BootScriptLib.h>
+#include <Library/PciLib.h>
+#include <Library/S3PciLib.h>
+
+#define PCILIB_TO_COMMON_ADDRESS(Address) \
+        ((((UINTN) ((Address>>20) & 0xff)) << 24) + (((UINTN) ((Address>>15) & 0x1f)) << 16) + (((UINTN) ((Address>>12) & 0x07)) << 8) + ((UINTN) (Address & 0xfff )))
+
+/**
+  Saves a PCI configuration value to the boot script.
+
+  This internal worker function saves a PCI configuration value in
+  the S3 script to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Width   The width of PCI configuration.
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Buffer  The buffer containing value.
+
+**/
+VOID
+InternalSavePciWriteValueToBootScript (
+  IN S3_BOOT_SCRIPT_LIB_WIDTH  Width,
+  IN UINTN                  Address,
+  IN VOID                   *Buffer
+  )
+{
+  RETURN_STATUS                Status;
+
+  Status = S3BootScriptSavePciCfgWrite (
+             Width,
+             PCILIB_TO_COMMON_ADDRESS(Address),
+             1,
+             Buffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+}
+
+/**
+  Saves an 8-bit PCI configuration value to the boot script.
+
+  This internal worker function saves an 8-bit PCI configuration value in
+  the S3 script to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value saved to boot script.
+
+  @return Value.
+
+**/
+UINT8
+InternalSavePciWrite8ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT8              Value
+  )
+{
+  InternalSavePciWriteValueToBootScript (S3BootScriptWidthUint8, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads an 8-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciRead8 (
+  IN UINTN                     Address
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciRead8 (Address));
+}
+
+/**
+  Writes an 8-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciWrite8 (
+  IN UINTN                     Address,
+  IN UINT8                     Value
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciWrite8 (Address, Value));
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciOr8 (
+  IN UINTN                     Address,
+  IN UINT8                     OrData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciOr8 (Address, OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciAnd8 (
+  IN UINTN                     Address,
+  IN UINT8                     AndData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciAnd8 (Address, AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciAndThenOr8 (
+  IN UINTN                     Address,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciAndThenOr8 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldRead8 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciBitFieldRead8 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldWrite8 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     Value
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciBitFieldWrite8 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldOr8 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     OrData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciBitFieldOr8 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldAnd8 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciBitFieldAnd8 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in an 8-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+S3PciBitFieldAndThenOr8 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return InternalSavePciWrite8ValueToBootScript (Address, PciBitFieldAndThenOr8 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 16-bit PCI configuration value to the boot script.
+
+  This internal worker function saves a 16-bit PCI configuration value in
+  the S3 script to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return Value.
+
+**/
+UINT16
+InternalSavePciWrite16ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT16             Value
+  )
+{
+  InternalSavePciWriteValueToBootScript (S3BootScriptWidthUint16, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads a 16-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciRead16 (
+  IN UINTN                     Address
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciRead16 (Address));
+}
+
+/**
+  Writes a 16-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciWrite16 (
+  IN UINTN                     Address,
+  IN UINT16                    Value
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciWrite16 (Address, Value));
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciOr16 (
+  IN UINTN                     Address,
+  IN UINT16                    OrData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciOr16 (Address, OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciAnd16 (
+  IN UINTN                     Address,
+  IN UINT16                    AndData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciAnd16 (Address, AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciAndThenOr16 (
+  IN UINTN                     Address,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciAndThenOr16 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldRead16 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciBitFieldRead16 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldWrite16 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    Value
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciBitFieldWrite16 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldOr16 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    OrData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciBitFieldOr16 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldAnd16 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciBitFieldAnd16 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 16-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+S3PciBitFieldAndThenOr16 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return InternalSavePciWrite16ValueToBootScript (Address, PciBitFieldAndThenOr16 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Saves a 32-bit PCI configuration value to the boot script.
+
+  This internal worker function saves a 32-bit PCI configuration value in the S3 script
+  to be replayed on S3 resume. 
+
+  If the saving process fails, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return Value.
+
+**/
+UINT32
+InternalSavePciWrite32ValueToBootScript (
+  IN UINTN              Address,
+  IN UINT32             Value
+  )
+{
+  InternalSavePciWriteValueToBootScript (S3BootScriptWidthUint32, Address, &Value);
+
+  return Value;
+}
+
+/**
+  Reads a 32-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciRead32 (
+  IN UINTN                     Address
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciRead32 (Address));
+}
+
+/**
+  Writes a 32-bit PCI configuration register and saves the value in the S3
+  script to be replayed on S3 resume.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciWrite32 (
+  IN UINTN                     Address,
+  IN UINT32                    Value
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciWrite32 (Address, Value));
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciOr32 (
+  IN UINTN                     Address,
+  IN UINT32                    OrData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciOr32 (Address, OrData));
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciAnd32 (
+  IN UINTN                     Address,
+  IN UINT32                    AndData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciAnd32 (Address, AndData));
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciAndThenOr32 (
+  IN UINTN                     Address,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciAndThenOr32 (Address, AndData, OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldRead32 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciBitFieldRead32 (Address, StartBit, EndBit));
+}
+
+/**
+  Writes a bit field to a PCI configuration register and saves the value in
+  the S3 script to be replayed on S3 resume.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldWrite32 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    Value
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciBitFieldWrite32 (Address, StartBit, EndBit, Value));
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port and saves the value
+  in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldOr32 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    OrData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciBitFieldOr32 (Address, StartBit, EndBit, OrData));
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register and
+  saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldAnd32 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciBitFieldAnd32 (Address, StartBit, EndBit, AndData));
+}
+
+/**
+  Reads a bit field in a 32-bit Address, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+S3PciBitFieldAndThenOr32 (
+  IN UINTN                     Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return InternalSavePciWrite32ValueToBootScript (Address, PciBitFieldAndThenOr32 (Address, StartBit, EndBit, AndData, OrData));
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer
+  and saves the value in the S3 script to be replayed on S3 resume.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+S3PciReadBuffer (
+  IN  UINTN                    StartAddress,
+  IN  UINTN                    Size,
+  OUT VOID                     *Buffer
+  )
+{
+  RETURN_STATUS    Status;
+
+  Status = S3BootScriptSavePciCfgWrite (
+             S3BootScriptWidthUint8,
+             PCILIB_TO_COMMON_ADDRESS (StartAddress),
+             PciReadBuffer (StartAddress, Size, Buffer),
+             Buffer
+             );
+ ASSERT (Status == RETURN_SUCCESS);
+
+  return Size;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space and saves the value in the S3 script to be replayed on S3
+  resume.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+S3PciWriteBuffer (
+  IN UINTN                     StartAddress,
+  IN UINTN                     Size,
+  IN VOID                      *Buffer
+  )
+{
+  RETURN_STATUS    Status;
+
+  Status = S3BootScriptSavePciCfgWrite (
+             S3BootScriptWidthUint8,
+             PCILIB_TO_COMMON_ADDRESS (StartAddress),
+             PciWriteBuffer (StartAddress, Size, Buffer),
+             Buffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+  
+  return Size;
+}
diff --git a/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.inf b/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.inf
new file mode 100644
index 000000000000..b8897d41447b
--- /dev/null
+++ b/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.inf
@@ -0,0 +1,47 @@
+## @file
+# Instance of S3 Smbus Library based on SmBus and S3 BootScript Library.
+#
+# S3 Smbus Library Services that do SMBus transactions and also enable the
+# operatation to be replayed during an S3 resume. 
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseS3SmbusLib
+  MODULE_UNI_FILE                = BaseS3SmbusLib.uni
+  FILE_GUID                      = 01190654-FED0-40d3-BA7F-2925539E5830
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = S3SmbusLib 
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  S3SmbusLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+  SmbusLib
+  S3BootScriptLib
+
diff --git a/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.uni b/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.uni
new file mode 100644
index 000000000000..ca7c157e93ab
--- /dev/null
+++ b/MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of S3 Smbus Library based on SmBus and S3 BootScript Library.
+//
+// S3 Smbus Library Services that do SMBus transactions and also enable the
+// operatation to be replayed during an S3 resume.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of S3 SMBus Library based on SMBus and S3 BootScript Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "S3 SMBus Library Services that do SMBus transactions and also enable the operation to be replayed during an S3 resume."
+
diff --git a/MdePkg/Library/BaseS3SmbusLib/S3SmbusLib.c b/MdePkg/Library/BaseS3SmbusLib/S3SmbusLib.c
new file mode 100644
index 000000000000..dfb10e5bfa4a
--- /dev/null
+++ b/MdePkg/Library/BaseS3SmbusLib/S3SmbusLib.c
@@ -0,0 +1,502 @@
+/** @file
+  Smbus Library Services that do SMBus transactions and also enable the operatation
+  to be replayed during an S3 resume. This library class maps directly on top
+  of the SmbusLib class. 
+
+  Copyright (c) 2007, 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 <Base.h>
+
+#include <Library/DebugLib.h>
+#include <Library/S3BootScriptLib.h>
+#include <Library/SmbusLib.h>
+#include <Library/S3SmbusLib.h>
+
+/**
+  Saves an SMBus operation to S3 script to be replayed on S3 resume. 
+
+  This function provides a standard way to save SMBus operation to S3 boot Script.
+  The data can either be of the Length byte, word, or a block of data.
+  If it falis to save S3 boot script, then ASSERT ().
+
+  @param  SmbusOperation  Signifies which particular SMBus hardware protocol instance that it will use to
+                          execute the SMBus transactions.
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Length          Signifies the number of bytes that this operation will do. The maximum number of
+                          bytes can be revision specific and operation specific.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave device. Not all operations
+                          require this argument. The length of this buffer is identified by Length.
+
+**/
+VOID
+InternalSaveSmBusExecToBootScript (
+  IN     EFI_SMBUS_OPERATION        SmbusOperation,
+  IN     UINTN                      SmBusAddress,
+  IN     UINTN                      Length,
+  IN OUT VOID                       *Buffer
+  )
+{
+  RETURN_STATUS                Status;
+
+  Status = S3BootScriptSaveSmbusExecute (
+             SmBusAddress,
+             SmbusOperation,
+            &Length,
+             Buffer
+             );
+  ASSERT (Status == RETURN_SUCCESS);
+}
+
+/**
+  Executes an SMBUS quick read command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+**/
+VOID
+EFIAPI
+S3SmBusQuickRead (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  SmBusQuickRead (SmBusAddress, Status);
+  
+  InternalSaveSmBusExecToBootScript (EfiSmbusQuickRead, SmBusAddress, 0, NULL);
+}
+
+/**
+  Executes an SMBUS quick write command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+**/
+VOID
+EFIAPI
+S3SmBusQuickWrite (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  SmBusQuickWrite (SmBusAddress, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusQuickWrite, SmBusAddress, 0, NULL);
+}
+  
+/**
+  Executes an SMBUS receive byte command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+S3SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  Byte = SmBusReceiveByte (SmBusAddress, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusReceiveByte, SmBusAddress, 1, &Byte);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS send byte command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value           The 8-bit value to send.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+S3SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  Byte = SmBusSendByte (SmBusAddress, Value, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusSendByte, SmBusAddress, 1, &Byte);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS read data byte command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+S3SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  Byte = SmBusReadDataByte (SmBusAddress, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusReadByte, SmBusAddress, 1, &Byte);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS write data byte command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value           The 8-bit value to write.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+S3SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  Byte = SmBusWriteDataByte (SmBusAddress, Value, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusWriteByte, SmBusAddress, 1, &Byte);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS read data word command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+  
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+S3SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+  
+  Word = SmBusReadDataWord (SmBusAddress, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusReadWord, SmBusAddress, 2, &Word);
+
+  return Word;
+}
+
+/**
+  Executes an SMBUS write data word command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value           The 16-bit value to write.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+S3SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  Word = SmBusWriteDataWord (SmBusAddress, Value, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusWriteWord, SmBusAddress, 2, &Word);
+
+  return Word;
+}
+
+/**
+  Executes an SMBUS process call command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value           The 16-bit value to write.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+S3SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  Word = SmBusProcessCall (SmBusAddress, Value, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusProcessCall, SmBusAddress, 2, &Value);
+
+  return Word; 
+}
+
+/**
+  Executes an SMBUS read block command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer          Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+S3SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN   Length;
+
+  Length = SmBusReadBlock (SmBusAddress, Buffer, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusReadBlock, SmBusAddress, Length, Buffer);
+
+  return Length;
+}
+
+/**
+  Executes an SMBUS write block command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.  
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer          Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+S3SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN  Length;
+
+  Length = SmBusWriteBlock (SmBusAddress, Buffer, Status);
+
+  InternalSaveSmBusExecToBootScript (EfiSmbusWriteBlock, SmBusAddress, SMBUS_LIB_LENGTH (SmBusAddress), Buffer);
+  
+  return Length;
+}
+
+/**
+  Executes an SMBUS block process call command and saves the value in the S3 script to be replayed
+  on S3 resume.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    Address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  WriteBuffer     Pointer to the buffer of bytes to write to the SMBUS.
+  @param  ReadBuffer      Pointer to the buffer of bytes to read from the SMBUS.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+S3SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN   Length;
+  
+  Length = SmBusBlockProcessCall (SmBusAddress, WriteBuffer, ReadBuffer, Status);
+  
+  InternalSaveSmBusExecToBootScript (EfiSmbusBWBRProcessCall, SmBusAddress, SMBUS_LIB_LENGTH (SmBusAddress), ReadBuffer);
+
+  return Length;
+}
diff --git a/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.inf b/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.inf
new file mode 100644
index 000000000000..919063d61155
--- /dev/null
+++ b/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.inf
@@ -0,0 +1,45 @@
+## @file
+# Instance of S3 Stall Library based on Timer and S3 BootScript Library.
+#
+# Stall Services that do stall and also enable the Stall operatation
+# to be replayed during an S3 resume. 
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseS3StallLib
+  MODULE_UNI_FILE                = BaseS3StallLib.uni
+  FILE_GUID                      = 498C6AC3-CC29-4821-BE6F-7C6F4ECF2C14
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = S3StallLib 
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  S3StallLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  TimerLib
+  S3BootScriptLib
+
diff --git a/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.uni b/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.uni
new file mode 100644
index 000000000000..89fbe14a30ae
--- /dev/null
+++ b/MdePkg/Library/BaseS3StallLib/BaseS3StallLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of S3 Stall Library based on Timer and S3 BootScript Library.
+//
+// Stall Services that do stall and also enable the Stall operatation
+// to be replayed during an S3 resume.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of S3 Stall Library based on Timer and S3 BootScript Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Stall Services that do stall and also enable the Stall operation to be replayed during an S3 resume."
+
diff --git a/MdePkg/Library/BaseS3StallLib/S3StallLib.c b/MdePkg/Library/BaseS3StallLib/S3StallLib.c
new file mode 100644
index 000000000000..6a35e543ec1e
--- /dev/null
+++ b/MdePkg/Library/BaseS3StallLib/S3StallLib.c
@@ -0,0 +1,52 @@
+/** @file
+  Stall Services that do stall and also enable the Stall operatation
+  to be replayed during an S3 resume. This library class maps directly on top
+  of the Timer class. 
+
+  Copyright (c) 2007, 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 <Base.h>
+
+#include <Library/TimerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/S3BootScriptLib.h>
+#include <Library/S3StallLib.h>
+
+
+/**
+  Stalls the CPU for at least the given number of microseconds and and saves
+  the value in the S3 script to be replayed on S3 resume.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return MicroSeconds
+
+**/
+UINTN
+EFIAPI
+S3Stall (
+  IN UINTN                     MicroSeconds
+  )
+{
+  RETURN_STATUS    Status;
+  
+  Status = S3BootScriptSaveStall (MicroSecondDelay (MicroSeconds));
+  ASSERT (Status == RETURN_SUCCESS);
+  
+  return MicroSeconds;
+}
+
+
diff --git a/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.c b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.c
new file mode 100644
index 000000000000..2f7d9daa812b
--- /dev/null
+++ b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.c
@@ -0,0 +1,197 @@
+/** @file
+  Null Serial Port library instance with empty functions.
+
+  Copyright (c) 2006 - 2015, 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 <Base.h>
+#include <Library/SerialPortLib.h>
+
+/**
+  Initialize the serial device hardware.
+  
+  If no initialization is required, then return RETURN_SUCCESS.
+  If the serial device was successfully initialized, then return RETURN_SUCCESS.
+  If the serial device could not be initialized, then return RETURN_DEVICE_ERROR.
+  
+  @retval RETURN_SUCCESS        The serial device was initialized.
+  @retval RETURN_DEVICE_ERROR   The serial device could not be initialized.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortInitialize (
+  VOID
+  )
+{
+  return RETURN_SUCCESS;
+}
+
+/**
+  Write data from buffer to serial device. 
+ 
+  Writes NumberOfBytes data bytes from Buffer to the serial device.  
+  The number of bytes actually written to the serial device is returned.
+  If the return value is less than NumberOfBytes, then the write operation failed.
+  If Buffer is NULL, then ASSERT(). 
+  If NumberOfBytes is zero, then return 0.
+
+  @param  Buffer           The pointer to the data buffer to be written.
+  @param  NumberOfBytes    The number of bytes to written to the serial device.
+
+  @retval 0                NumberOfBytes is 0.
+  @retval >0               The number of bytes written to the serial device.  
+                           If this value is less than NumberOfBytes, then the write operation failed.
+
+**/
+UINTN
+EFIAPI
+SerialPortWrite (
+  IN UINT8     *Buffer,
+  IN UINTN     NumberOfBytes
+)
+{
+  return 0;
+}
+
+
+/**
+  Read data from serial device and save the datas in buffer.
+ 
+  Reads NumberOfBytes data bytes from a serial device into the buffer
+  specified by Buffer. The number of bytes actually read is returned. 
+  If the return value is less than NumberOfBytes, then the rest operation failed.
+  If Buffer is NULL, then ASSERT(). 
+  If NumberOfBytes is zero, then return 0.
+
+  @param  Buffer           The pointer to the data buffer to store the data read from the serial device.
+  @param  NumberOfBytes    The number of bytes which will be read.
+
+  @retval 0                Read data failed; No data is to be read.
+  @retval >0               The actual number of bytes read from serial device.
+
+**/
+UINTN
+EFIAPI
+SerialPortRead (
+  OUT UINT8     *Buffer,
+  IN  UINTN     NumberOfBytes
+)
+{
+  return 0;
+}
+
+/**
+  Polls a serial device to see if there is any data waiting to be read.
+
+  Polls a serial device to see if there is any data waiting to be read.
+  If there is data waiting to be read from the serial device, then TRUE is returned.
+  If there is no data waiting to be read from the serial device, then FALSE is returned.
+
+  @retval TRUE             Data is waiting to be read from the serial device.
+  @retval FALSE            There is no data waiting to be read from the serial device.
+
+**/
+BOOLEAN
+EFIAPI
+SerialPortPoll (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+/**
+  Sets the control bits on a serial device.
+
+  @param Control                Sets the bits of Control that are settable.
+
+  @retval RETURN_SUCCESS        The new control bits were set on the serial device.
+  @retval RETURN_UNSUPPORTED    The serial device does not support this operation.
+  @retval RETURN_DEVICE_ERROR   The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortSetControl (
+  IN UINT32 Control
+  )
+{
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieve the status of the control bits on a serial device.
+
+  @param Control                A pointer to return the current control signals from the serial device.
+
+  @retval RETURN_SUCCESS        The control bits were read from the serial device.
+  @retval RETURN_UNSUPPORTED    The serial device does not support this operation.
+  @retval RETURN_DEVICE_ERROR   The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortGetControl (
+  OUT UINT32 *Control
+  )
+{
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity,
+  data bits, and stop bits on a serial device.
+
+  @param BaudRate           The requested baud rate. A BaudRate value of 0 will use the
+                            device's default interface speed.
+                            On output, the value actually set.
+  @param ReveiveFifoDepth   The requested depth of the FIFO on the receive side of the
+                            serial interface. A ReceiveFifoDepth value of 0 will use
+                            the device's default FIFO depth.
+                            On output, the value actually set.
+  @param Timeout            The requested time out for a single character in microseconds.
+                            This timeout applies to both the transmit and receive side of the
+                            interface. A Timeout value of 0 will use the device's default time
+                            out value.
+                            On output, the value actually set.
+  @param Parity             The type of parity to use on this serial device. A Parity value of
+                            DefaultParity will use the device's default parity value.
+                            On output, the value actually set.
+  @param DataBits           The number of data bits to use on the serial device. A DataBits
+                            vaule of 0 will use the device's default data bit setting.
+                            On output, the value actually set.
+  @param StopBits           The number of stop bits to use on this serial device. A StopBits
+                            value of DefaultStopBits will use the device's default number of
+                            stop bits.
+                            On output, the value actually set.
+
+  @retval RETURN_SUCCESS            The new attributes were set on the serial device.
+  @retval RETURN_UNSUPPORTED        The serial device does not support this operation.
+  @retval RETURN_INVALID_PARAMETER  One or more of the attributes has an unsupported value.
+  @retval RETURN_DEVICE_ERROR       The serial device is not functioning correctly.
+
+**/
+RETURN_STATUS
+EFIAPI
+SerialPortSetAttributes (
+  IN OUT UINT64             *BaudRate,
+  IN OUT UINT32             *ReceiveFifoDepth,
+  IN OUT UINT32             *Timeout,
+  IN OUT EFI_PARITY_TYPE    *Parity,
+  IN OUT UINT8              *DataBits,
+  IN OUT EFI_STOP_BITS_TYPE *StopBits
+  )
+{
+  return RETURN_UNSUPPORTED;
+}
+
diff --git a/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
new file mode 100644
index 000000000000..6d9207705a7d
--- /dev/null
+++ b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
@@ -0,0 +1,36 @@
+## @file
+#  Null instance of Serial Port Library with empty functions.
+#
+#  Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseSerialPortLibNull
+  MODULE_UNI_FILE                = BaseSerialPortLibNull.uni
+  FILE_GUID                      = E4541241-8897-411a-91F8-7D7E45837146
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SerialPortLib
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseSerialPortLibNull.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.uni b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.uni
new file mode 100644
index 000000000000..5af091f661e3
--- /dev/null
+++ b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Null instance of Serial Port Library with empty functions.
+//
+// Null instance of Serial Port Library with empty functions.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Null instance of Serial Port Library with empty functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Null instance of Serial Port Library with empty functions."
+
diff --git a/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.c b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.c
new file mode 100644
index 000000000000..29b68b37b5fe
--- /dev/null
+++ b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.c
@@ -0,0 +1,544 @@
+/** @file
+Null implementation of SmBusLib class library.
+
+Copyright (c) 2013, 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 <Base.h>
+#include <Library/SmbusLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Executes an SMBUS quick read command.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS  The SMBUS command was executed.
+                        RETURN_TIMEOUT  A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickRead (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+}
+
+/**
+  Executes an SMBUS quick write command.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickWrite (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+}
+
+/**
+  Executes an SMBUS receive byte command.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS send byte command.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to send.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS read data byte command.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS write data byte command.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS read data word command.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+  
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS write data word command.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS process call command.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS read block command.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS The SMBUS command was executed.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS write block command.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.  
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        Pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
+
+/**
+  Executes an SMBUS block process call command.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  Address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  WriteBuffer   Pointer to the buffer of bytes to write to the SMBUS.
+  @param  ReadBuffer    Pointer to the buffer of bytes to read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT A timeout occurred while executing the SMBUS command.
+                        RETURN_DEVICE_ERROR  The request was not completed because a failure
+                        reflected in the Host Status Register bit.  Device errors are a result
+                        of a transaction collision, illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (WriteBuffer != NULL);
+  ASSERT (ReadBuffer  != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+  if (Status != NULL) {
+    *Status = RETURN_UNSUPPORTED;
+  }
+  return 0;
+}
diff --git a/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.inf b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.inf
new file mode 100644
index 000000000000..2a66ba71f018
--- /dev/null
+++ b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.inf
@@ -0,0 +1,35 @@
+## @file
+# Null implementation of the SMBUS Library.
+#
+# Copyright (c) 2013 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseSmbusLibNull
+  MODULE_UNI_FILE                = BaseSmbusLibNull.uni
+  FILE_GUID                      = E2ECA273-A1C0-407E-9A5C-F10C55142196
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmbusLib
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseSmbusLibNull.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
diff --git a/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.uni b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.uni
new file mode 100644
index 000000000000..00e6d6bc5c45
--- /dev/null
+++ b/MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Null implementation of the SMBUS Library.
+//
+// Null implementation of the SMBUS Library.
+//
+// Copyright (c) 2013 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Null implementation of the SMBUS Library."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Null implementation of the SMBUS Library."
+
diff --git a/MdePkg/Library/BaseStackCheckLib/BaseStackCheckGcc.c b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckGcc.c
new file mode 100644
index 000000000000..ad3f2684ce7f
--- /dev/null
+++ b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckGcc.c
@@ -0,0 +1,55 @@
+/** @file
+ Base Stack Check library for GCC/clang.
+
+ Use -fstack-protector-all compiler flag to make the compiler insert the
+ __stack_chk_guard "canary" value into the stack and check the value prior
+ to exiting the function. If the "canary" is overwritten __stack_chk_fail()
+ is called. This is GCC specific code.
+
+ Copyright (c) 2012, Apple Inc. 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 <Base.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+/// "canary" value that is inserted by the compiler into the stack frame.
+VOID *__stack_chk_guard = (VOID*)0x0AFF;
+
+// If ASLR was enabled we could use
+//void (*__stack_chk_guard)(void) = __stack_chk_fail;
+
+/**
+ Error path for compiler generated stack "canary" value check code. If the
+ stack canary has been overwritten this function gets called on exit of the
+ function.
+**/
+VOID
+__stack_chk_fail (
+ VOID
+ )
+{
+  UINT8 DebugPropertyMask;
+
+  DEBUG ((DEBUG_ERROR, "STACK FAULT: Buffer Overflow in function %a.\n", __builtin_return_address(0)));
+
+  //
+  // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings even if
+  // BaseDebugLibNull is in use.
+  //
+  DebugPropertyMask = PcdGet8 (PcdDebugPropertyMask);
+  if ((DebugPropertyMask & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
+    CpuBreakpoint ();
+  } else if ((DebugPropertyMask & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
+   CpuDeadLoop ();
+  }
+}
diff --git a/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
new file mode 100644
index 000000000000..1838f7ea1629
--- /dev/null
+++ b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
@@ -0,0 +1,44 @@
+## @file
+#  Stack Check Library
+#
+#  Stack Check Library
+#
+#  Copyright (c) 2014, ARM Ltd. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseStackCheckLib
+  MODULE_UNI_FILE                = BaseStackCheckLib.uni
+  FILE_GUID                      = 5f6579f7-b648-4fdb-9f19-4c17e27e8eff
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = NULL
+
+
+#
+#  VALID_ARCHITECTURES           = ARM AARCH64
+#
+
+[Sources]
+  BaseStackCheckGcc.c | GCC
+  BaseStackCheckGcc.c | RVCT
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+
+[FixedPcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask  ## CONSUMES
diff --git a/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.uni b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.uni
new file mode 100644
index 000000000000..1c50362c62fd
--- /dev/null
+++ b/MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Stack Check Library
+//
+// Stack Check Library
+//
+// Copyright (c) 2014, ARM Ltd. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Stack Check Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Stack Check Library"
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/AArch64/Synchronization.S b/MdePkg/Library/BaseSynchronizationLib/AArch64/Synchronization.S
new file mode 100644
index 000000000000..2edd526605c6
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/AArch64/Synchronization.S
@@ -0,0 +1,205 @@
+//  Implementation of synchronization functions for ARM architecture (AArch64)
+//
+//  Copyright (c) 2012-2015, ARM Limited. All rights reserved.
+//  Copyright (c) 2015, Linaro Limited. All rights reserved.
+//
+//  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.
+//
+//
+
+.text
+.align 3
+
+GCC_ASM_EXPORT(InternalSyncCompareExchange16)
+GCC_ASM_EXPORT(InternalSyncCompareExchange32)
+GCC_ASM_EXPORT(InternalSyncCompareExchange64)
+GCC_ASM_EXPORT(InternalSyncIncrement)
+GCC_ASM_EXPORT(InternalSyncDecrement)
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT16
+//EFIAPI
+//InternalSyncCompareExchange16 (
+//  IN      volatile UINT16           *Value,
+//  IN      UINT16                    CompareValue,
+//  IN      UINT16                    ExchangeValue
+//  )
+ASM_PFX(InternalSyncCompareExchange16):
+  uxth    w1, w1
+  uxth    w2, w2
+  dmb     sy
+
+InternalSyncCompareExchange16Again:
+  ldxrh   w3, [x0]
+  cmp     w3, w1
+  bne     InternalSyncCompareExchange16Fail
+
+InternalSyncCompareExchange16Exchange:
+  stxrh   w4, w2, [x0]
+  cbnz    w4, InternalSyncCompareExchange16Again
+
+InternalSyncCompareExchange16Fail:
+  dmb     sy
+  mov     w0, w3
+  ret
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncCompareExchange32 (
+//  IN      volatile UINT32           *Value,
+//  IN      UINT32                    CompareValue,
+//  IN      UINT32                    ExchangeValue
+//  )
+ASM_PFX(InternalSyncCompareExchange32):
+  dmb     sy
+
+InternalSyncCompareExchange32Again:
+  ldxr    w3, [x0]
+  cmp     w3, w1
+  bne     InternalSyncCompareExchange32Fail
+
+InternalSyncCompareExchange32Exchange:
+  stxr    w4, w2, [x0]
+  cbnz    w4, InternalSyncCompareExchange32Again
+
+InternalSyncCompareExchange32Fail:
+  dmb     sy
+  mov     w0, w3
+  ret
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT64
+//EFIAPI
+//InternalSyncCompareExchange64 (
+//  IN      volatile UINT64           *Value,
+//  IN      UINT64                    CompareValue,
+//  IN      UINT64                    ExchangeValue
+//  )
+ASM_PFX(InternalSyncCompareExchange64):
+  dmb     sy
+
+InternalSyncCompareExchange64Again:
+  ldxr    x3, [x0]
+  cmp     x3, x1
+  bne     InternalSyncCompareExchange64Fail
+
+InternalSyncCompareExchange64Exchange:
+  stxr    w4, x2, [x0]
+  cbnz    w4, InternalSyncCompareExchange64Again
+
+InternalSyncCompareExchange64Fail:
+  dmb     sy
+  mov     x0, x3
+  ret
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncIncrement (
+//  IN      volatile UINT32           *Value
+//  )
+ASM_PFX(InternalSyncIncrement):
+  dmb     sy
+TryInternalSyncIncrement:
+  ldxr    w1, [x0]
+  add     w1, w1, #1
+  stxr    w2, w1, [x0]
+  cbnz    w2, TryInternalSyncIncrement
+  mov     w0, w1
+  dmb     sy
+  ret
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncDecrement (
+//  IN      volatile UINT32           *Value
+//  )
+ASM_PFX(InternalSyncDecrement):
+  dmb     sy
+TryInternalSyncDecrement:
+  ldxr    w1, [x0]
+  sub     w1, w1, #1
+  stxr    w2, w1, [x0]
+  cbnz    w2, TryInternalSyncDecrement
+  mov     w0, w1
+  dmb     sy
+  ret
diff --git a/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.S b/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.S
new file mode 100644
index 000000000000..b63feba411a9
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.S
@@ -0,0 +1,213 @@
+//  Implementation of synchronization functions for ARM architecture
+//
+//  Copyright (c) 2012-2015, ARM Limited. All rights reserved.
+//  Copyright (c) 2015, Linaro Limited. All rights reserved.
+//
+//  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.
+//
+//
+
+.text
+.align 3
+
+GCC_ASM_EXPORT(InternalSyncCompareExchange16)
+GCC_ASM_EXPORT(InternalSyncCompareExchange32)
+GCC_ASM_EXPORT(InternalSyncCompareExchange64)
+GCC_ASM_EXPORT(InternalSyncIncrement)
+GCC_ASM_EXPORT(InternalSyncDecrement)
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT16
+//EFIAPI
+//InternalSyncCompareExchange16 (
+//  IN      volatile UINT16           *Value,
+//  IN      UINT16                    CompareValue,
+//  IN      UINT16                    ExchangeValue
+//  )
+ASM_PFX(InternalSyncCompareExchange16):
+  dmb
+
+InternalSyncCompareExchange16Again:
+  ldrexh  r3, [r0]
+  cmp     r3, r1
+  bne     InternalSyncCompareExchange16Fail
+
+InternalSyncCompareExchange16Exchange:
+  strexh  ip, r2, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange16Again
+
+InternalSyncCompareExchange16Fail:
+  dmb
+  mov     r0, r3
+  bx      lr
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncCompareExchange32 (
+//  IN      volatile UINT32           *Value,
+//  IN      UINT32                    CompareValue,
+//  IN      UINT32                    ExchangeValue
+//  )
+ASM_PFX(InternalSyncCompareExchange32):
+  dmb
+
+InternalSyncCompareExchange32Again:
+  ldrex   r3, [r0]
+  cmp     r3, r1
+  bne     InternalSyncCompareExchange32Fail
+
+InternalSyncCompareExchange32Exchange:
+  strex   ip, r2, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange32Again
+
+InternalSyncCompareExchange32Fail:
+  dmb
+  mov     r0, r3
+  bx      lr
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT64
+//EFIAPI
+//InternalSyncCompareExchange64 (
+//  IN      volatile UINT64           *Value,         // r0
+//  IN      UINT64                    CompareValue,   // r2-r3
+//  IN      UINT64                    ExchangeValue   // stack
+//  )
+ASM_PFX(InternalSyncCompareExchange64):
+  push    { r4-r7 }
+  ldrd    r4, r5, [sp, #16]
+  dmb
+
+InternalSyncCompareExchange64Again:
+  ldrexd  r6, r7, [r0]
+  cmp     r6, r2
+  cmpeq   r7, r3
+  bne     InternalSyncCompareExchange64Fail
+
+InternalSyncCompareExchange64Exchange:
+  strexd  ip, r4, r5, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange64Again
+
+InternalSyncCompareExchange64Fail:
+  dmb
+  mov     r0, r6
+  mov     r1, r7
+  pop     { r4-r7 }
+  bx      lr
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncIncrement (
+//  IN      volatile UINT32           *Value
+//  )
+ASM_PFX(InternalSyncIncrement):
+  dmb
+TryInternalSyncIncrement:
+  ldrex   r1, [r0]
+  add     r1, r1, #1
+  strex   r2, r1, [r0]
+  cmp     r2, #0
+  bne     TryInternalSyncIncrement
+  dmb
+  mov     r0, r1
+  bx      lr
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncDecrement (
+//  IN      volatile UINT32           *Value
+//  )
+ASM_PFX(InternalSyncDecrement):
+  dmb
+TryInternalSyncDecrement:
+  ldrex   r1, [r0]
+  sub     r1, r1, #1
+  strex   r2, r1, [r0]
+  cmp     r2, #0
+  bne     TryInternalSyncDecrement
+  dmb
+  mov     r0, r1
+  bx      lr
diff --git a/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.asm b/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.asm
new file mode 100644
index 000000000000..fac8794971ef
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Arm/Synchronization.asm
@@ -0,0 +1,214 @@
+//  Implementation of synchronization functions for ARM architecture
+//
+//  Copyright (c) 2012-2015, ARM Limited. All rights reserved.
+//  Copyright (c) 2015, Linaro Limited. All rights reserved.
+//
+//  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.
+//
+//
+
+    EXPORT  InternalSyncCompareExchange16
+    EXPORT  InternalSyncCompareExchange32
+    EXPORT  InternalSyncCompareExchange64
+    EXPORT  InternalSyncIncrement
+    EXPORT  InternalSyncDecrement
+
+    AREA   ArmSynchronization, CODE, READONLY
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT16
+//EFIAPI
+//InternalSyncCompareExchange16 (
+//  IN      volatile UINT16           *Value,
+//  IN      UINT16                    CompareValue,
+//  IN      UINT16                    ExchangeValue
+//  )
+InternalSyncCompareExchange16
+  dmb
+
+InternalSyncCompareExchange16Again
+  ldrexh  r3, [r0]
+  cmp     r3, r1
+  bne     InternalSyncCompareExchange16Fail
+
+InternalSyncCompareExchange16Exchange
+  strexh  ip, r2, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange16Again
+
+InternalSyncCompareExchange16Fail
+  dmb
+  mov     r0, r3
+  bx      lr
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncCompareExchange32 (
+//  IN      volatile UINT32           *Value,
+//  IN      UINT32                    CompareValue,
+//  IN      UINT32                    ExchangeValue
+//  )
+InternalSyncCompareExchange32
+  dmb
+
+InternalSyncCompareExchange32Again
+  ldrex   r3, [r0]
+  cmp     r3, r1
+  bne     InternalSyncCompareExchange32Fail
+
+InternalSyncCompareExchange32Exchange
+  strex   ip, r2, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange32Again
+
+InternalSyncCompareExchange32Fail
+  dmb
+  mov     r0, r3
+  bx      lr
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+//UINT64
+//EFIAPI
+//InternalSyncCompareExchange64 (
+//  IN      volatile UINT64           *Value,         // r0
+//  IN      UINT64                    CompareValue,   // r2-r3
+//  IN      UINT64                    ExchangeValue   // stack
+//  )
+InternalSyncCompareExchange64
+  push    { r4-r7 }
+  ldrd    r4, r5, [sp, #16]
+  dmb
+
+InternalSyncCompareExchange64Again
+  ldrexd  r6, r7, [r0]
+  cmp     r6, r2
+  cmpeq   r7, r3
+  bne     InternalSyncCompareExchange64Fail
+
+InternalSyncCompareExchange64Exchange
+  strexd  ip, r4, r5, [r0]
+  cmp     ip, #0
+  bne     InternalSyncCompareExchange64Again
+
+InternalSyncCompareExchange64Fail
+  dmb
+  mov     r0, r6
+  mov     r1, r7
+  pop     { r4-r7 }
+  bx      lr
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncIncrement (
+//  IN      volatile UINT32           *Value
+//  )
+InternalSyncIncrement
+  dmb
+TryInternalSyncIncrement
+  ldrex   r1, [r0]
+  add     r1, r1, #1
+  strex   r2, r1, [r0]
+  cmp     r2, #0
+  bne     TryInternalSyncIncrement
+  dmb
+  mov     r0, r1
+  bx      lr
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+//UINT32
+//EFIAPI
+//InternalSyncDecrement (
+//  IN      volatile UINT32           *Value
+//  )
+InternalSyncDecrement
+  dmb
+TryInternalSyncDecrement
+  ldrex   r1, [r0]
+  sub     r1, r1, #1
+  strex   r2, r1, [r0]
+  cmp     r2, #0
+  bne     TryInternalSyncDecrement
+  dmb
+  mov     r0, r1
+  bx      lr
+
+  END
diff --git a/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf
new file mode 100755
index 000000000000..25898e7fe317
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf
@@ -0,0 +1,121 @@
+## @file
+#  Base Synchronization Library implementation.
+#
+#  Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
+#  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseSynchronizationLib
+  MODULE_UNI_FILE                = BaseSynchronizationLib.uni
+  FILE_GUID                      = FC9990DF-C5FF-44cf-8799-CBB45B577F87
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SynchronizationLib
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC ARM AARCH64
+#
+[Sources]
+  BaseSynchronizationLibInternals.h
+
+[Sources.IA32]
+  Ia32/InternalGetSpinLockProperties.c | MSFT
+  Ia32/InterlockedCompareExchange64.c | MSFT 
+  Ia32/InterlockedCompareExchange32.c | MSFT 
+  Ia32/InterlockedCompareExchange16.c | MSFT
+  Ia32/InterlockedDecrement.c | MSFT 
+  Ia32/InterlockedIncrement.c | MSFT 
+  SynchronizationMsc.c  | MSFT
+
+  Ia32/InterlockedCompareExchange64.nasm| INTEL
+  Ia32/InterlockedCompareExchange64.asm | INTEL 
+  Ia32/InterlockedCompareExchange32.nasm| INTEL
+  Ia32/InterlockedCompareExchange32.asm | INTEL 
+  Ia32/InterlockedCompareExchange16.nasm| INTEL
+  Ia32/InterlockedCompareExchange16.asm | INTEL
+  Ia32/InterlockedDecrement.nasm| INTEL
+  Ia32/InterlockedDecrement.asm | INTEL 
+  Ia32/InterlockedIncrement.nasm| INTEL
+  Ia32/InterlockedIncrement.asm | INTEL 
+  Synchronization.c | INTEL
+
+  Ia32/InternalGetSpinLockProperties.c | GCC
+  Ia32/GccInline.c | GCC
+  SynchronizationGcc.c  | GCC
+
+[Sources.X64]
+  Ia32/InternalGetSpinLockProperties.c | MSFT
+  X64/InterlockedCompareExchange64.c | MSFT
+  X64/InterlockedCompareExchange32.c | MSFT
+  X64/InterlockedCompareExchange16.c | MSFT
+  
+  X64/InterlockedCompareExchange64.nasm| INTEL
+  X64/InterlockedCompareExchange64.asm | INTEL
+  X64/InterlockedCompareExchange32.nasm| INTEL
+  X64/InterlockedCompareExchange32.asm | INTEL
+  X64/InterlockedCompareExchange16.nasm| INTEL
+  X64/InterlockedCompareExchange16.asm | INTEL
+  
+  X64/InterlockedDecrement.c | MSFT 
+  X64/InterlockedIncrement.c | MSFT 
+  SynchronizationMsc.c | MSFT 
+
+  X64/InterlockedDecrement.nasm| INTEL
+  X64/InterlockedDecrement.asm | INTEL 
+  X64/InterlockedIncrement.nasm| INTEL
+  X64/InterlockedIncrement.asm | INTEL 
+  Synchronization.c | INTEL 
+
+  Ia32/InternalGetSpinLockProperties.c | GCC
+  X64/GccInline.c | GCC
+  SynchronizationGcc.c  | GCC 
+
+[Sources.IPF]
+  Ipf/Synchronization.c
+  Ipf/InterlockedCompareExchange64.s
+  Ipf/InterlockedCompareExchange32.s
+  Ipf/InterlockedCompareExchange16.s
+
+  Ipf/InternalGetSpinLockProperties.c | MSFT
+  Ipf/InternalGetSpinLockProperties.c | GCC
+
+  Synchronization.c     | INTEL 
+  SynchronizationMsc.c  | MSFT 
+  SynchronizationGcc.c  | GCC 
+
+[Sources.EBC]
+  Synchronization.c
+  Ebc/Synchronization.c
+
+[Sources.ARM]
+  Synchronization.c
+  Arm/Synchronization.asm       | RVCT
+  Arm/Synchronization.S         | GCC
+
+[Sources.AARCH64]
+  Synchronization.c
+  AArch64/Synchronization.S
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PcdLib
+  TimerLib
+  DebugLib
+  BaseMemoryLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout  ## SOMETIMES_CONSUMES
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.uni b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.uni
new file mode 100644
index 000000000000..e12e05f76a7a
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Base Synchronization Library implementation.
+//
+// Base Synchronization Library implementation.
+//
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Base Synchronization Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Synchronization Library implementation."
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLibInternals.h b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLibInternals.h
new file mode 100644
index 000000000000..74625e036d6c
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLibInternals.h
@@ -0,0 +1,153 @@
+/** @file
+  Declaration of internal functions in BaseSynchronizationLib.
+
+  Copyright (c) 2006 - 2016, 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 __BASE_SYNCHRONIZATION_LIB_INTERNALS__
+#define __BASE_SYNCHRONIZATION_LIB_INTERNALS__
+
+#include <Base.h>
+#include <Library/SynchronizationLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/TimerLib.h>
+#include <Library/PcdLib.h>
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32           *Value
+  );
+
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32           *Value
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 16-bit value used in compare operation.
+  @param  ExchangeValue A 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN      volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 32-bit value used in compare operation.
+  @param  ExchangeValue A 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN      volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  );
+
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 64-bit value used in compare operation.
+  @param  ExchangeValue A 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN      volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  );
+
+/**
+  Internal function to retrieve the architecture specific spin lock alignment
+  requirements for optimal spin lock performance.
+
+  @return The architecture specific spin lock alignment.
+  
+**/
+UINTN
+InternalGetSpinLockProperties (
+  VOID
+  );
+
+#endif
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ebc/Synchronization.c b/MdePkg/Library/BaseSynchronizationLib/Ebc/Synchronization.c
new file mode 100644
index 000000000000..54d2eebefd7b
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ebc/Synchronization.c
@@ -0,0 +1,147 @@
+/** @file
+  Implementation of synchronization functions on EBC.
+
+  Copyright (c) 2006 - 2010, 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.
+
+**/
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit
+  unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit
+  unsigned integer specified by Value.  If Value is equal to
+  CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange
+  operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the
+                        compare exchange operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN      volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  return *Value != CompareValue ? *Value :
+           ((*Value = ExchangeValue), CompareValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit
+  unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit
+  unsigned integer specified by Value.  If Value is equal to
+  CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange
+  operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the
+                        compare exchange operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN      volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  return *Value != CompareValue ? *Value :
+           ((*Value = ExchangeValue), CompareValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified 
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and 
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned. 
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN      volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  return *Value != CompareValue ? *Value :
+           ((*Value = ExchangeValue), CompareValue);
+}
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  return ++*Value;
+}
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  return --*Value;
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/GccInline.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/GccInline.c
new file mode 100644
index 000000000000..d1003ab53886
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/GccInline.c
@@ -0,0 +1,215 @@
+/** @file
+  GCC inline implementation of BaseSynchronizationLib processor specific functions.
+  
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+
+**/
+
+
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32    *Value
+  )
+{
+  UINT32  Result;
+
+  __asm__ __volatile__ (
+    "lock               \n\t"
+    "incl    %2         \n\t"
+    "movl    %2, %%eax      "
+    : "=a" (Result),          // %0
+      "=m" (*Value)           // %1
+    : "m"  (*Value)           // %2 
+    : "memory",
+      "cc"
+    );
+    
+  return Result;    
+
+}
+
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32       *Value
+  )
+{
+   UINT32  Result;
+  
+  __asm__ __volatile__ (
+    "lock               \n\t"
+    "decl    %2         \n\t"
+    "movl    %2, %%eax      "
+    : "=a" (Result),          // %0
+      "=m" (*Value)           // %1
+    : "m"  (*Value)           // %2 
+    : "memory",
+      "cc"
+    );
+    
+  return Result;
+}
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN OUT volatile  UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+
+  __asm__ __volatile__ (
+    "                     \n\t"
+    "lock                 \n\t"
+    "cmpxchgw    %1, %2   \n\t"
+    : "=a" (CompareValue)
+    : "q"  (ExchangeValue),
+      "m"  (*Value),
+      "0"  (CompareValue)
+    : "memory",
+      "cc"
+    );
+
+  return CompareValue;
+}
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN OUT volatile  UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+
+  __asm__ __volatile__ (
+    "                     \n\t"
+    "lock                 \n\t"
+    "cmpxchgl    %1, %2   \n\t"
+    : "=a" (CompareValue)     // %0
+    : "q"  (ExchangeValue),   // %1
+      "m"  (*Value),          // %2
+      "0"  (CompareValue)     // %4 
+    : "memory",
+      "cc"
+    );
+
+  return CompareValue;
+}
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  __asm__ __volatile__ (
+    "                       \n\t"
+    "push        %%ebx      \n\t" 
+    "movl        %2,%%ebx   \n\t"   
+    "lock                   \n\t"
+    "cmpxchg8b   (%1)       \n\t"
+    "pop         %%ebx      \n\t"
+    : "+A"  (CompareValue)                    // %0
+    : "S"   (Value),                          // %1
+      "r"   ((UINT32) ExchangeValue),         // %2
+      "c"   ((UINT32) (ExchangeValue >> 32))  // %3
+    : "memory",
+      "cc"
+    );
+  
+  return CompareValue;
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.asm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.asm
new file mode 100644
index 000000000000..688d467f9c32
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.asm
@@ -0,0 +1,46 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2015, Linaro Ltd. 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange16.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; InternalSyncCompareExchange16 (
+;   IN      volatile UINT16           *Value,
+;   IN      UINT16                    CompareValue,
+;   IN      UINT16                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange16   PROC
+    mov     ecx, [esp + 4]
+    mov     ax, [esp + 8]
+    mov     dx, [esp + 12]
+    lock    cmpxchg [ecx], dx
+    ret
+InternalSyncCompareExchange16   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.c
new file mode 100644
index 000000000000..81a890ad9d2b
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.c
@@ -0,0 +1,51 @@
+/** @file
+  InterlockedCompareExchange16 function
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2015, Linaro Ltd. 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN      volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  _asm {
+    mov     ecx, Value
+    mov     ax, CompareValue
+    mov     dx, ExchangeValue
+    lock    cmpxchg [ecx], dx
+  }
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.nasm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.nasm
new file mode 100644
index 000000000000..5beeede74f88
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange16.nasm
@@ -0,0 +1,43 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2015, Linaro Ltd. 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange16.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; InternalSyncCompareExchange16 (
+;   IN      volatile UINT16           *Value,
+;   IN      UINT16                    CompareValue,
+;   IN      UINT16                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange16)
+ASM_PFX(InternalSyncCompareExchange16):
+    mov     ecx, [esp + 4]
+    mov     ax, [esp + 8]
+    mov     dx, [esp + 12]
+    lock    cmpxchg [ecx], dx
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.asm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.asm
new file mode 100644
index 000000000000..97cc56cf34b9
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.asm
@@ -0,0 +1,45 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange32.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .486
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncCompareExchange32 (
+;   IN      volatile UINT32           *Value,
+;   IN      UINT32                    CompareValue,
+;   IN      UINT32                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange32   PROC
+    mov     ecx, [esp + 4]
+    mov     eax, [esp + 8]
+    mov     edx, [esp + 12]
+    lock    cmpxchg [ecx], edx
+    ret
+InternalSyncCompareExchange32   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.c
new file mode 100644
index 000000000000..3dd737bf6784
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.c
@@ -0,0 +1,50 @@
+/** @file
+  InterlockedCompareExchange32 function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN      volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  _asm {
+    mov     ecx, Value
+    mov     eax, CompareValue
+    mov     edx, ExchangeValue
+    lock    cmpxchg [ecx], edx
+  }
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.nasm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.nasm
new file mode 100644
index 000000000000..62cbb11502ca
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange32.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange32.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncCompareExchange32 (
+;   IN      volatile UINT32           *Value,
+;   IN      UINT32                    CompareValue,
+;   IN      UINT32                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange32)
+ASM_PFX(InternalSyncCompareExchange32):
+    mov     ecx, [esp + 4]
+    mov     eax, [esp + 8]
+    mov     edx, [esp + 12]
+    lock    cmpxchg [ecx], edx
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.asm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.asm
new file mode 100644
index 000000000000..d7faaf20f614
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.asm
@@ -0,0 +1,47 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange64.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .586P
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalSyncCompareExchange64 (
+;   IN      volatile UINT64           *Value,
+;   IN      UINT64                    CompareValue,
+;   IN      UINT64                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange64   PROC    USES    esi ebx
+    mov     esi, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     ebx, [esp + 24]
+    mov     ecx, [esp + 28]
+    lock    cmpxchg8b   qword ptr [esi]
+    ret
+InternalSyncCompareExchange64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.c
new file mode 100644
index 000000000000..68c527434135
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.c
@@ -0,0 +1,50 @@
+/** @file
+  InterlockedCompareExchange64 function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 64-bit value used in a compare operation.
+  @param  ExchangeValue A 64-bit value used in an exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN      volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  _asm {
+    mov     esi, Value
+    mov     eax, dword ptr [CompareValue + 0]
+    mov     edx, dword ptr [CompareValue + 4]
+    mov     ebx, dword ptr [ExchangeValue + 0]
+    mov     ecx, dword ptr [ExchangeValue + 4]
+    lock    cmpxchg8b   qword ptr [esi]
+  }
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.nasm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.nasm
new file mode 100644
index 000000000000..c55d55c3ef22
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedCompareExchange64.nasm
@@ -0,0 +1,48 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange64.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalSyncCompareExchange64 (
+;   IN      volatile UINT64           *Value,
+;   IN      UINT64                    CompareValue,
+;   IN      UINT64                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange64)
+ASM_PFX(InternalSyncCompareExchange64):
+    push    esi
+    push    ebx
+    mov     esi, [esp + 12]
+    mov     eax, [esp + 16]
+    mov     edx, [esp + 20]
+    mov     ebx, [esp + 24]
+    mov     ecx, [esp + 28]
+    lock    cmpxchg8b [esi]
+    pop     ebx
+    pop     esi
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.asm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.asm
new file mode 100644
index 000000000000..e86375eb2cb2
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedDecrement.Asm
+;
+; Abstract:
+;
+;   InterlockedDecrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncDecrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+InternalSyncDecrement   PROC
+    mov     eax, [esp + 4]
+    lock    dec     dword ptr [eax]
+    mov     eax, [eax]
+    ret
+InternalSyncDecrement   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.c
new file mode 100644
index 000000000000..5bb3371916b2
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.c
@@ -0,0 +1,42 @@
+/** @file
+  InterlockedDecrement function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    lock    dec     dword ptr [eax]
+    mov     eax, [eax]
+  }
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.nasm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.nasm
new file mode 100644
index 000000000000..951f207bd7b4
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedDecrement.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedDecrement.Asm
+;
+; Abstract:
+;
+;   InterlockedDecrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncDecrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncDecrement)
+ASM_PFX(InternalSyncDecrement):
+    mov     eax, [esp + 4]
+    lock    dec     dword [eax]
+    mov     eax, [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.asm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.asm
new file mode 100644
index 000000000000..0a0b3905ff92
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedIncrement.Asm
+;
+; Abstract:
+;
+;   InterlockedIncrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .386
+    .model  flat,C
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncIncrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+InternalSyncIncrement   PROC
+    mov     eax, [esp + 4]
+    lock    inc     dword ptr [eax]
+    mov     eax, [eax]
+    ret
+InternalSyncIncrement   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.c
new file mode 100644
index 000000000000..789082a1a562
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.c
@@ -0,0 +1,43 @@
+/** @file
+  InterLockedIncrement function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  _asm {
+    mov     eax, Value
+    lock    inc     dword ptr [eax]
+    mov     eax, [eax]
+  }
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.nasm b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.nasm
new file mode 100644
index 000000000000..78e444ad02c3
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InterlockedIncrement.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedIncrement.Asm
+;
+; Abstract:
+;
+;   InterlockedIncrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncIncrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncIncrement)
+ASM_PFX(InternalSyncIncrement):
+    mov     eax, [esp + 4]
+    lock    inc     dword [eax]
+    mov     eax, [eax]
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ia32/InternalGetSpinLockProperties.c b/MdePkg/Library/BaseSynchronizationLib/Ia32/InternalGetSpinLockProperties.c
new file mode 100644
index 000000000000..ea3cd38f3e38
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ia32/InternalGetSpinLockProperties.c
@@ -0,0 +1,64 @@
+/** @file
+  Internal function to get spin lock alignment.
+
+  Copyright (c) 2016, 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 "BaseSynchronizationLibInternals.h"
+
+/**
+  Internal function to retrieve the architecture specific spin lock alignment
+  requirements for optimal spin lock performance.
+
+  @return The architecture specific spin lock alignment.
+  
+**/
+UINTN
+InternalGetSpinLockProperties (
+  VOID
+  )
+{
+  UINT32  RegEax;
+  UINT32  RegEbx;
+  UINTN   FamilyId;
+  UINTN   ModelId;
+  UINTN   CacheLineSize;
+
+  //
+  // Retrieve CPUID Version Information
+  //
+  AsmCpuid (0x01, &RegEax, &RegEbx, NULL, NULL);
+  //
+  // EBX: Bits 15 - 08: CLFLUSH line size (Value * 8 = cache line size)
+  //
+  CacheLineSize = ((RegEbx >> 8) & 0xff) * 8;
+  //
+  // Retrieve CPU Family and Model
+  //
+  FamilyId = (RegEax >> 8) & 0xf;
+  ModelId  = (RegEax >> 4) & 0xf;
+  if (FamilyId == 0x0f) {
+    //
+    // In processors based on Intel NetBurst microarchitecture, use two cache lines
+    // 
+    ModelId = ModelId | ((RegEax >> 12) & 0xf0);
+    if (ModelId <= 0x04 || ModelId == 0x06) {
+      CacheLineSize *= 2;
+    }
+  }
+
+  if (CacheLineSize < 32) {
+    CacheLineSize = 32;
+  }
+
+  return CacheLineSize;
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange16.s b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange16.s
new file mode 100644
index 000000000000..1e56942a98cb
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange16.s
@@ -0,0 +1,30 @@
+/// @file
+///   Contains an implementation of InterlockedCompareExchange16 on Itanium-
+///   based architecture.
+///
+/// Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+/// Copyright (c) 2015, Linaro Ltd. 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.
+///
+/// Module Name:  InterlockedCompareExchange16.s
+///
+///
+
+.auto
+.text
+
+.proc   InternalSyncCompareExchange16
+.type   InternalSyncCompareExchange16, @function
+InternalSyncCompareExchange16::
+        zxt2                r33 = r33
+        mov                 ar.ccv = r33
+        cmpxchg2.rel        r8  = [r32], r34
+        mf
+        br.ret.sptk.many    b0
+.endp   InternalSyncCompareExchange16
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange32.s b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange32.s
new file mode 100644
index 000000000000..ddcf036162f6
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange32.s
@@ -0,0 +1,29 @@
+/// @file
+///   Contains an implementation of InterlockedCompareExchange32 on Itanium-
+///   based architecture.
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name:  InterlockedCompareExchange32.s
+///
+///
+
+.auto
+.text
+
+.proc   InternalSyncCompareExchange32
+.type   InternalSyncCompareExchange32, @function
+InternalSyncCompareExchange32::
+        zxt4                r33 = r33
+        mov                 ar.ccv = r33
+        cmpxchg4.rel        r8  = [r32], r34
+        mf
+        br.ret.sptk.many    b0
+.endp   InternalSyncCompareExchange32
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange64.s b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange64.s
new file mode 100644
index 000000000000..d25372809cb1
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ipf/InterlockedCompareExchange64.s
@@ -0,0 +1,28 @@
+/// @file
+///   Contains an implementation of InterlockedCompareExchange64 on Itanium-
+///   based architecture.
+///
+/// Copyright (c) 2006 - 2008, 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.
+///
+/// Module Name:  InterlockedCompareExchange64.s
+///
+///
+
+.auto
+.text
+
+.proc   InternalSyncCompareExchange64
+.type   InternalSyncCompareExchange64, @function
+InternalSyncCompareExchange64::
+        mov                 ar.ccv = r33
+        cmpxchg8.rel        r8  = [r32], r34
+        mf
+        br.ret.sptk.many    b0
+.endp   InternalSyncCompareExchange64
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ipf/InternalGetSpinLockProperties.c b/MdePkg/Library/BaseSynchronizationLib/Ipf/InternalGetSpinLockProperties.c
new file mode 100644
index 000000000000..d75114bf46d4
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ipf/InternalGetSpinLockProperties.c
@@ -0,0 +1,29 @@
+/** @file
+  Internal function to get spin lock alignment.
+
+  Copyright (c) 2016, 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.
+
+**/
+
+/**
+  Internal function to retrieve the architecture specific spin lock alignment
+  requirements for optimal spin lock performance.
+
+  @return The architecture specific spin lock alignment.
+  
+**/
+UINTN
+InternalGetSpinLockProperties (
+  VOID
+  )
+{
+  return 32;
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/Ipf/Synchronization.c b/MdePkg/Library/BaseSynchronizationLib/Ipf/Synchronization.c
new file mode 100644
index 000000000000..72b07b2d4e1d
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Ipf/Synchronization.c
@@ -0,0 +1,77 @@
+/** @file
+  Implementation of synchronization functions on Itanium.
+
+  Copyright (c) 2006 - 2010, 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 "BaseSynchronizationLibInternals.h"
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  UINT32                            OriginalValue;
+
+  do {
+    OriginalValue = *Value;
+  } while (OriginalValue != InternalSyncCompareExchange32 (
+                              Value,
+                              OriginalValue,
+                              OriginalValue + 1
+                              ));
+  return OriginalValue + 1;
+}
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  UINT32                            OriginalValue;
+
+  do {
+    OriginalValue = *Value;
+  } while (OriginalValue != InternalSyncCompareExchange32 (
+                              Value,
+                              OriginalValue,
+                              OriginalValue - 1
+                              ));
+  return OriginalValue - 1;
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/Synchronization.c b/MdePkg/Library/BaseSynchronizationLib/Synchronization.c
new file mode 100644
index 000000000000..5b020b33f7de
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/Synchronization.c
@@ -0,0 +1,418 @@
+/** @file
+  Implementation of synchronization functions.
+
+  Copyright (c) 2006 - 2016, 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 "BaseSynchronizationLibInternals.h"
+
+#define SPIN_LOCK_RELEASED          ((UINTN) 1)
+#define SPIN_LOCK_ACQUIRED          ((UINTN) 2)
+
+/**
+  Retrieves the architecture specific spin lock alignment requirements for
+  optimal spin lock performance.
+
+  This function retrieves the spin lock alignment requirements for optimal
+  performance on a given CPU architecture. The spin lock alignment is byte alignment. 
+  It must be a power of two and is returned by this function. If there are no alignment
+  requirements, then 1 must be returned. The spin lock synchronization
+  functions must function correctly if the spin lock size and alignment values
+  returned by this function are not used at all. These values are hints to the
+  consumers of the spin lock synchronization functions to obtain optimal spin
+  lock performance.
+
+  @return The architecture specific spin lock alignment.
+
+**/
+UINTN
+EFIAPI
+GetSpinLockProperties (
+  VOID
+  )
+{
+  return 32;
+}
+
+/**
+  Initializes a spin lock to the released state and returns the spin lock.
+
+  This function initializes the spin lock specified by SpinLock to the released
+  state, and returns SpinLock. Optimal performance can be achieved by calling
+  GetSpinLockProperties() to determine the size and alignment requirements for
+  SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to initialize to the released
+                    state.
+
+  @return SpinLock is in release state.
+
+**/
+SPIN_LOCK *
+EFIAPI
+InitializeSpinLock (
+  OUT      SPIN_LOCK                 *SpinLock
+  )
+{
+  ASSERT (SpinLock != NULL);
+  *SpinLock = SPIN_LOCK_RELEASED;
+  return SpinLock;
+}
+
+/**
+  Waits until a spin lock can be placed in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns SpinLock. Otherwise, this function waits
+  indefinitely for the spin lock to be released, and then places it in the
+  acquired state and returns SpinLock. All state transitions of SpinLock must
+  be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+  If PcdSpinLockTimeout is not zero, and SpinLock is can not be acquired in
+  PcdSpinLockTimeout microseconds, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @return SpinLock acquired the lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+AcquireSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  UINT64  Current;
+  UINT64  Previous;
+  UINT64  Total;
+  UINT64  Start;
+  UINT64  End;
+  UINT64  Timeout;
+  INT64   Cycle;
+  INT64   Delta;
+
+  if (PcdGet32 (PcdSpinLockTimeout) == 0) {
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+    }
+  } else if (!AcquireSpinLockOrFail (SpinLock)) {
+    //
+    // Get the current timer value
+    //
+    Current = GetPerformanceCounter();
+
+    //
+    // Initialize local variables
+    //
+    Start = 0;
+    End   = 0;
+    Total = 0;
+
+    //
+    // Retrieve the performance counter properties and compute the number of performance
+    // counter ticks required to reach the timeout
+    //
+    Timeout = DivU64x32 (
+                MultU64x32 (
+                  GetPerformanceCounterProperties (&Start, &End),
+                  PcdGet32 (PcdSpinLockTimeout)
+                  ),
+                1000000
+                );
+    Cycle = End - Start;
+    if (Cycle < 0) {
+      Cycle = -Cycle;
+    }
+    Cycle++;
+
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+      Previous = Current;
+      Current  = GetPerformanceCounter();
+      Delta = (INT64) (Current - Previous);
+      if (Start > End) {
+        Delta = -Delta;
+      }
+      if (Delta < 0) {
+        Delta += Cycle;
+      }
+      Total += Delta;
+      ASSERT (Total < Timeout);
+    }
+  }
+  return SpinLock;
+}
+
+/**
+  Attempts to place a spin lock in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns TRUE. Otherwise, FALSE is returned. All state
+  transitions of SpinLock must be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @retval TRUE  SpinLock was placed in the acquired state.
+  @retval FALSE SpinLock could not be acquired.
+
+**/
+BOOLEAN
+EFIAPI
+AcquireSpinLockOrFail (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK    LockValue;
+
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (SPIN_LOCK_ACQUIRED == LockValue || SPIN_LOCK_RELEASED == LockValue);
+
+  return (BOOLEAN)(
+           InterlockedCompareExchangePointer (
+             (VOID**)SpinLock,
+             (VOID*)SPIN_LOCK_RELEASED,
+             (VOID*)SPIN_LOCK_ACQUIRED
+             ) == (VOID*)SPIN_LOCK_RELEASED
+           );
+}
+
+/**
+  Releases a spin lock.
+
+  This function places the spin lock specified by SpinLock in the release state
+  and returns SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to release.
+
+  @return SpinLock released lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+ReleaseSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK    LockValue;
+
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (SPIN_LOCK_ACQUIRED == LockValue || SPIN_LOCK_RELEASED == LockValue);
+
+  *SpinLock = SPIN_LOCK_RELEASED;
+  return SpinLock;
+}
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncIncrement (Value);
+}
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncDecrement (Value);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InterlockedCompareExchange16 (
+  IN OUT  volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange16 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InterlockedCompareExchange32 (
+  IN OUT  volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange32 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InterlockedCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange64 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a pointer value.
+
+  Performs an atomic compare exchange operation on the pointer value specified
+  by Value. If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned. If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange operation must be
+  performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the pointer value for the compare exchange
+                        operation.
+  @param  CompareValue  Pointer value used in compare operation.
+  @param  ExchangeValue Pointer value used in exchange operation.
+
+  @return The original *Value before exchange.
+**/
+VOID *
+EFIAPI
+InterlockedCompareExchangePointer (
+  IN OUT  VOID                      * volatile *Value,
+  IN      VOID                      *CompareValue,
+  IN      VOID                      *ExchangeValue
+  )
+{
+  UINT8  SizeOfValue;
+
+  SizeOfValue = sizeof (*Value);
+
+  switch (SizeOfValue) {
+    case sizeof (UINT32):
+      return (VOID*)(UINTN)InterlockedCompareExchange32 (
+                             (volatile UINT32 *)Value,
+                             (UINT32)(UINTN)CompareValue,
+                             (UINT32)(UINTN)ExchangeValue
+                             );
+    case sizeof (UINT64):
+      return (VOID*)(UINTN)InterlockedCompareExchange64 (
+                             (volatile UINT64 *)Value,
+                             (UINT64)(UINTN)CompareValue,
+                             (UINT64)(UINTN)ExchangeValue
+                             );
+    default:
+      ASSERT (FALSE);
+      return NULL;
+  }
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/SynchronizationGcc.c b/MdePkg/Library/BaseSynchronizationLib/SynchronizationGcc.c
new file mode 100644
index 000000000000..009341a9b02d
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/SynchronizationGcc.c
@@ -0,0 +1,434 @@
+/** @file
+  Implementation of synchronization functions.
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 "BaseSynchronizationLibInternals.h"
+
+//
+// GCC inline assembly for Read Write Barrier  
+//
+#define _ReadWriteBarrier() do { __asm__ __volatile__ ("": : : "memory"); } while(0)
+
+#define SPIN_LOCK_RELEASED          ((UINTN) 1)
+#define SPIN_LOCK_ACQUIRED          ((UINTN) 2)
+
+/**
+  Retrieves the architecture specific spin lock alignment requirements for
+  optimal spin lock performance.
+
+  This function retrieves the spin lock alignment requirements for optimal
+  performance on a given CPU architecture. The spin lock alignment is byte alignment. 
+  It must be a power of two and is returned by this function. If there are no alignment
+  requirements, then 1 must be returned. The spin lock synchronization
+  functions must function correctly if the spin lock size and alignment values
+  returned by this function are not used at all. These values are hints to the
+  consumers of the spin lock synchronization functions to obtain optimal spin
+  lock performance.
+
+  @return The architecture specific spin lock alignment.
+
+**/
+UINTN
+EFIAPI
+GetSpinLockProperties (
+  VOID
+  )
+{
+  return InternalGetSpinLockProperties ();
+}
+
+/**
+  Initializes a spin lock to the released state and returns the spin lock.
+
+  This function initializes the spin lock specified by SpinLock to the released
+  state, and returns SpinLock. Optimal performance can be achieved by calling
+  GetSpinLockProperties() to determine the size and alignment requirements for
+  SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to initialize to the released
+                    state.
+
+  @return SpinLock is in release state.
+
+**/
+SPIN_LOCK *
+EFIAPI
+InitializeSpinLock (
+  OUT      SPIN_LOCK                 *SpinLock
+  )
+{
+  ASSERT (SpinLock != NULL);
+
+  _ReadWriteBarrier();
+  *SpinLock = SPIN_LOCK_RELEASED;
+  _ReadWriteBarrier();
+
+  return SpinLock;
+}
+
+/**
+  Waits until a spin lock can be placed in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns SpinLock. Otherwise, this function waits
+  indefinitely for the spin lock to be released, and then places it in the
+  acquired state and returns SpinLock. All state transitions of SpinLock must
+  be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+  If PcdSpinLockTimeout is not zero, and SpinLock is can not be acquired in
+  PcdSpinLockTimeout microseconds, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @return SpinLock acquired the lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+AcquireSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  UINT64  Current;
+  UINT64  Previous;
+  UINT64  Total;
+  UINT64  Start;
+  UINT64  End;
+  UINT64  Timeout;
+  INT64   Cycle;
+  INT64   Delta;
+
+  if (PcdGet32 (PcdSpinLockTimeout) == 0) {
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+    }
+  } else if (!AcquireSpinLockOrFail (SpinLock)) {
+    //
+    // Get the current timer value
+    //
+    Current = GetPerformanceCounter();
+
+    //
+    // Initialize local variables
+    //
+    Start = 0;
+    End   = 0;
+    Total = 0;
+
+    //
+    // Retrieve the performance counter properties and compute the number of performance
+    // counter ticks required to reach the timeout
+    //
+    Timeout = DivU64x32 (
+                MultU64x32 (
+                  GetPerformanceCounterProperties (&Start, &End),
+                  PcdGet32 (PcdSpinLockTimeout)
+                  ),
+                1000000
+                );
+    Cycle = End - Start;
+    if (Cycle < 0) {
+      Cycle = -Cycle;
+    }
+    Cycle++;
+
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+      Previous = Current;
+      Current  = GetPerformanceCounter();
+      Delta = (INT64) (Current - Previous);
+      if (Start > End) {
+        Delta = -Delta;
+      }
+      if (Delta < 0) {
+        Delta += Cycle;
+      }
+      Total += Delta;
+      ASSERT (Total < Timeout);
+    }
+  }
+  return SpinLock;
+}
+
+/**
+  Attempts to place a spin lock in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns TRUE. Otherwise, FALSE is returned. All state
+  transitions of SpinLock must be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @retval TRUE  SpinLock was placed in the acquired state.
+  @retval FALSE SpinLock could not be acquired.
+
+**/
+BOOLEAN
+EFIAPI
+AcquireSpinLockOrFail (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK   LockValue;
+  VOID        *Result;
+  
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
+
+  _ReadWriteBarrier ();
+  Result = InterlockedCompareExchangePointer (
+             (VOID**)SpinLock,
+             (VOID*)SPIN_LOCK_RELEASED,
+             (VOID*)SPIN_LOCK_ACQUIRED
+           );
+
+  _ReadWriteBarrier ();
+  return (BOOLEAN) (Result == (VOID*) SPIN_LOCK_RELEASED);
+}
+
+/**
+  Releases a spin lock.
+
+  This function places the spin lock specified by SpinLock in the release state
+  and returns SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to release.
+
+  @return SpinLock released the lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+ReleaseSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK    LockValue;
+
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
+
+  _ReadWriteBarrier ();
+  *SpinLock = SPIN_LOCK_RELEASED;
+  _ReadWriteBarrier ();
+
+  return SpinLock;
+}
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncIncrement (Value);
+}
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncDecrement (Value);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 16-bit value used in compare operation.
+  @param  ExchangeValue A 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InterlockedCompareExchange16 (
+  IN OUT  volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange16 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 32-bit value used in compare operation.
+  @param  ExchangeValue A 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InterlockedCompareExchange32 (
+  IN OUT  volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange32 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 64-bit value used in a compare operation.
+  @param  ExchangeValue A 64-bit value used in an exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InterlockedCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange64 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a pointer value.
+
+  Performs an atomic compare exchange operation on the pointer value specified
+  by Value. If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned. If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange operation must be
+  performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the pointer value for the compare exchange
+                        operation.
+  @param  CompareValue  A pointer value used in a compare operation.
+  @param  ExchangeValue A pointer value used in an exchange operation.
+
+  @return The original *Value before exchange.
+**/
+VOID *
+EFIAPI
+InterlockedCompareExchangePointer (
+  IN OUT  VOID                      * volatile *Value,
+  IN      VOID                      *CompareValue,
+  IN      VOID                      *ExchangeValue
+  )
+{
+  UINT8  SizeOfValue;
+
+  SizeOfValue = sizeof (*Value);
+
+  switch (SizeOfValue) {
+    case sizeof (UINT32):
+      return (VOID*)(UINTN)InterlockedCompareExchange32 (
+                             (volatile UINT32 *)Value,
+                             (UINT32)(UINTN)CompareValue,
+                             (UINT32)(UINTN)ExchangeValue
+                             );
+    case sizeof (UINT64):
+      return (VOID*)(UINTN)InterlockedCompareExchange64 (
+                             (volatile UINT64 *)Value,
+                             (UINT64)(UINTN)CompareValue,
+                             (UINT64)(UINTN)ExchangeValue
+                             );
+    default:
+      ASSERT (FALSE);
+      return NULL;
+  }
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/SynchronizationMsc.c b/MdePkg/Library/BaseSynchronizationLib/SynchronizationMsc.c
new file mode 100644
index 000000000000..c9ecdf6f483c
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/SynchronizationMsc.c
@@ -0,0 +1,436 @@
+/** @file
+  Implementation of synchronization functions.
+
+  Copyright (c) 2006 - 2016, 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 "BaseSynchronizationLibInternals.h"
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for read write barrier Intrinsics.
+**/
+
+void    _ReadWriteBarrier (void);
+#pragma intrinsic(_ReadWriteBarrier)
+
+
+#define SPIN_LOCK_RELEASED          ((UINTN) 1)
+#define SPIN_LOCK_ACQUIRED          ((UINTN) 2)
+
+/**
+  Retrieves the architecture specific spin lock alignment requirements for
+  optimal spin lock performance.
+
+  This function retrieves the spin lock alignment requirements for optimal
+  performance on a given CPU architecture. The spin lock alignment is byte alignment. 
+  It must be a power of two and is returned by this function. If there are no alignment
+  requirements, then 1 must be returned. The spin lock synchronization
+  functions must function correctly if the spin lock size and alignment values
+  returned by this function are not used at all. These values are hints to the
+  consumers of the spin lock synchronization functions to obtain optimal spin
+  lock performance.
+
+  @return The architecture specific spin lock alignment.
+
+**/
+UINTN
+EFIAPI
+GetSpinLockProperties (
+  VOID
+  )
+{
+  return InternalGetSpinLockProperties ();
+}
+
+/**
+  Initializes a spin lock to the released state and returns the spin lock.
+
+  This function initializes the spin lock specified by SpinLock to the released
+  state, and returns SpinLock. Optimal performance can be achieved by calling
+  GetSpinLockProperties() to determine the size and alignment requirements for
+  SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to initialize to the released
+                    state.
+
+  @return SpinLock is in release state.
+
+**/
+SPIN_LOCK *
+EFIAPI
+InitializeSpinLock (
+  OUT      SPIN_LOCK                 *SpinLock
+  )
+{
+  ASSERT (SpinLock != NULL);
+
+  _ReadWriteBarrier();
+  *SpinLock = SPIN_LOCK_RELEASED;
+  _ReadWriteBarrier();
+
+  return SpinLock;
+}
+
+/**
+  Waits until a spin lock can be placed in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns SpinLock. Otherwise, this function waits
+  indefinitely for the spin lock to be released, and then places it in the
+  acquired state and returns SpinLock. All state transitions of SpinLock must
+  be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+  If PcdSpinLockTimeout is not zero, and SpinLock is can not be acquired in
+  PcdSpinLockTimeout microseconds, then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @return SpinLock acquired the lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+AcquireSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  UINT64  Current;
+  UINT64  Previous;
+  UINT64  Total;
+  UINT64  Start;
+  UINT64  End;
+  UINT64  Timeout;
+  INT64   Cycle;
+  INT64   Delta;
+
+  if (PcdGet32 (PcdSpinLockTimeout) == 0) {
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+    }
+  } else if (!AcquireSpinLockOrFail (SpinLock)) {
+    //
+    // Get the current timer value
+    //
+    Current = GetPerformanceCounter();
+
+    //
+    // Initialize local variables
+    //
+    Start = 0;
+    End   = 0;
+    Total = 0;
+
+    //
+    // Retrieve the performance counter properties and compute the number of performance
+    // counter ticks required to reach the timeout
+    //
+    Timeout = DivU64x32 (
+                MultU64x32 (
+                  GetPerformanceCounterProperties (&Start, &End),
+                  PcdGet32 (PcdSpinLockTimeout)
+                  ),
+                1000000
+                );
+    Cycle = End - Start;
+    if (Cycle < 0) {
+      Cycle = -Cycle;
+    }
+    Cycle++;
+
+    while (!AcquireSpinLockOrFail (SpinLock)) {
+      CpuPause ();
+      Previous = Current;
+      Current  = GetPerformanceCounter();
+      Delta = (INT64) (Current - Previous);
+      if (Start > End) {
+        Delta = -Delta;
+      }
+      if (Delta < 0) {
+        Delta += Cycle;
+      }
+      Total += Delta;
+      ASSERT (Total < Timeout);
+    }
+  }
+  return SpinLock;
+}
+
+/**
+  Attempts to place a spin lock in the acquired state.
+
+  This function checks the state of the spin lock specified by SpinLock. If
+  SpinLock is in the released state, then this function places SpinLock in the
+  acquired state and returns TRUE. Otherwise, FALSE is returned. All state
+  transitions of SpinLock must be performed using MP safe mechanisms.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to place in the acquired state.
+
+  @retval TRUE  SpinLock was placed in the acquired state.
+  @retval FALSE SpinLock could not be acquired.
+
+**/
+BOOLEAN
+EFIAPI
+AcquireSpinLockOrFail (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK   LockValue;
+  VOID        *Result;
+  
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
+
+  _ReadWriteBarrier ();
+  Result = InterlockedCompareExchangePointer (
+             (VOID**)SpinLock,
+             (VOID*)SPIN_LOCK_RELEASED,
+             (VOID*)SPIN_LOCK_ACQUIRED
+           );
+
+  _ReadWriteBarrier ();
+  return (BOOLEAN) (Result == (VOID*) SPIN_LOCK_RELEASED);
+}
+
+/**
+  Releases a spin lock.
+
+  This function places the spin lock specified by SpinLock in the release state
+  and returns SpinLock.
+
+  If SpinLock is NULL, then ASSERT().
+  If SpinLock was not initialized with InitializeSpinLock(), then ASSERT().
+
+  @param  SpinLock  A pointer to the spin lock to release.
+
+  @return SpinLock released the lock.
+
+**/
+SPIN_LOCK *
+EFIAPI
+ReleaseSpinLock (
+  IN OUT  SPIN_LOCK                 *SpinLock
+  )
+{
+  SPIN_LOCK    LockValue;
+
+  ASSERT (SpinLock != NULL);
+
+  LockValue = *SpinLock;
+  ASSERT (LockValue == SPIN_LOCK_ACQUIRED || LockValue == SPIN_LOCK_RELEASED);
+
+  _ReadWriteBarrier ();
+  *SpinLock = SPIN_LOCK_RELEASED;
+  _ReadWriteBarrier ();
+
+  return SpinLock;
+}
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncIncrement (Value);
+}
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InterlockedDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncDecrement (Value);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 16-bit value used in a compare operation.
+  @param  ExchangeValue A 16-bit value used in an exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InterlockedCompareExchange16 (
+  IN OUT  volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange16 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 32-bit value used in a compare operation.
+  @param  ExchangeValue A 32-bit value used in an exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InterlockedCompareExchange32 (
+  IN OUT  volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange32 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  A 64-bit value used in a compare operation.
+  @param  ExchangeValue A 64-bit value used in an exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InterlockedCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  ASSERT (Value != NULL);
+  return InternalSyncCompareExchange64 (Value, CompareValue, ExchangeValue);
+}
+
+/**
+  Performs an atomic compare exchange operation on a pointer value.
+
+  Performs an atomic compare exchange operation on the pointer value specified
+  by Value. If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned. If Value is not equal to
+  CompareValue, then Value is returned. The compare exchange operation must be
+  performed using MP safe mechanisms.
+
+  If Value is NULL, then ASSERT().
+
+  @param  Value         A pointer to the pointer value for the compare exchange
+                        operation.
+  @param  CompareValue  A pointer value used in a compare operation.
+  @param  ExchangeValue A pointer value used in an exchange operation.
+
+  @return The original *Value before exchange.
+**/
+VOID *
+EFIAPI
+InterlockedCompareExchangePointer (
+  IN OUT  VOID                      * volatile *Value,
+  IN      VOID                      *CompareValue,
+  IN      VOID                      *ExchangeValue
+  )
+{
+  UINT8  SizeOfValue;
+
+  SizeOfValue = (UINT8) sizeof (*Value);
+
+  switch (SizeOfValue) {
+    case sizeof (UINT32):
+      return (VOID*)(UINTN)InterlockedCompareExchange32 (
+                             (volatile UINT32*)Value,
+                             (UINT32)(UINTN)CompareValue,
+                             (UINT32)(UINTN)ExchangeValue
+                             );
+    case sizeof (UINT64):
+      return (VOID*)(UINTN)InterlockedCompareExchange64 (
+                             (volatile UINT64*)Value,
+                             (UINT64)(UINTN)CompareValue,
+                             (UINT64)(UINTN)ExchangeValue
+                             );
+    default:
+      ASSERT (FALSE);
+      return NULL;
+  }
+}
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/GccInline.c b/MdePkg/Library/BaseSynchronizationLib/X64/GccInline.c
new file mode 100644
index 000000000000..5b1635a98043
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/GccInline.c
@@ -0,0 +1,220 @@
+/** @file
+  GCC inline implementation of BaseSynchronizationLib processor specific functions.
+  
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+
+**/
+
+
+
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32    *Value
+  )
+{
+  UINT32  Result;
+
+  __asm__ __volatile__ (
+    "lock               \n\t"
+    "incl    %2         \n\t"
+    "mov     %2, %%eax      "
+    : "=a" (Result),          // %0
+      "=m" (*Value)           // %1
+    : "m"  (*Value)           // %2 
+    : "memory",
+      "cc"
+    );
+    
+  return Result;    
+}
+
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decremented value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32       *Value
+  )
+{
+   UINT32  Result;
+  
+  __asm__ __volatile__ (
+    "lock               \n\t"
+    "decl    %2         \n\t"
+    "mov     %2, %%eax      "
+    : "=a" (Result),          // %0
+      "=m" (*Value)           // %1
+    : "m"  (*Value)           // %2 
+    : "memory",
+      "cc"
+    );
+    
+  return Result;
+}
+
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN OUT volatile  UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+
+
+  __asm__ __volatile__ (
+    "lock                 \n\t"
+    "cmpxchgw    %3, %1       "
+    : "=a" (CompareValue),
+      "=m" (*Value)
+    : "a"  (CompareValue),
+      "r"  (ExchangeValue),
+      "m"  (*Value)
+    : "memory",
+      "cc"
+    );
+
+  return CompareValue;
+}
+
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN OUT volatile  UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+
+
+  __asm__ __volatile__ (
+    "lock                 \n\t"
+    "cmpxchgl    %3, %1       "
+    : "=a" (CompareValue),    // %0
+      "=m" (*Value)           // %1
+    : "a"  (CompareValue),    // %2
+      "r"  (ExchangeValue),   // %3 
+      "m"  (*Value)
+    : "memory",
+      "cc"
+    );
+    
+  return CompareValue;
+}
+
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN OUT  volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+
+  __asm__ __volatile__ (
+    "lock                 \n\t"
+    "cmpxchgq    %3, %1       "
+    : "=a" (CompareValue),    // %0
+      "=m" (*Value)           // %1
+    : "a"  (CompareValue),    // %2
+      "r"  (ExchangeValue),   // %3 
+      "m"  (*Value)
+    : "memory",
+      "cc"
+    );
+  
+  return CompareValue;
+}
+
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.asm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.asm
new file mode 100644
index 000000000000..219527d585c1
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.asm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2015, Linaro Ltd. 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange16.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; InternalSyncCompareExchange16 (
+;   IN      volatile UINT16           *Value,
+;   IN      UINT16                    CompareValue,
+;   IN      UINT16                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange16   PROC
+    mov     ax, dx
+    lock    cmpxchg [rcx], r8w
+    ret
+InternalSyncCompareExchange16   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.c b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.c
new file mode 100644
index 000000000000..d51d6e361061
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.c
@@ -0,0 +1,54 @@
+/** @file
+  InterlockedCompareExchange16 function
+
+  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2015, Linaro Ltd. 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+__int16 _InterlockedCompareExchange16(
+   __int16 volatile * Destination,
+   __int16 Exchange,
+   __int16 Comperand
+);
+
+#pragma intrinsic(_InterlockedCompareExchange16)
+
+/**
+  Performs an atomic compare exchange operation on a 16-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 16-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 16-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  16-bit value used in compare operation.
+  @param  ExchangeValue 16-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT16
+EFIAPI
+InternalSyncCompareExchange16 (
+  IN      volatile UINT16           *Value,
+  IN      UINT16                    CompareValue,
+  IN      UINT16                    ExchangeValue
+  )
+{
+  return _InterlockedCompareExchange16 (Value, ExchangeValue, CompareValue);
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.nasm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.nasm
new file mode 100644
index 000000000000..b9ef3d4f9def
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange16.nasm
@@ -0,0 +1,42 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+; Copyright (c) 2015, Linaro Ltd. 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange16.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange16 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT16
+; EFIAPI
+; InternalSyncCompareExchange16 (
+;   IN      volatile UINT16           *Value,
+;   IN      UINT16                    CompareValue,
+;   IN      UINT16                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange16)
+ASM_PFX(InternalSyncCompareExchange16):
+    mov     ax, dx
+    lock    cmpxchg [rcx], r8w
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.asm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.asm
new file mode 100644
index 000000000000..86a3c2ad0f93
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange32.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncCompareExchange32 (
+;   IN      volatile UINT32           *Value,
+;   IN      UINT32                    CompareValue,
+;   IN      UINT32                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange32   PROC
+    mov     eax, edx
+    lock    cmpxchg [rcx], r8d
+    ret
+InternalSyncCompareExchange32   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.c b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.c
new file mode 100644
index 000000000000..b275d679c055
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.c
@@ -0,0 +1,54 @@
+/** @file
+  InterlockedCompareExchange32 function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+long _InterlockedCompareExchange(
+   long volatile * Destination,
+   long Exchange,
+   long Comperand
+);
+
+#pragma intrinsic(_InterlockedCompareExchange)
+
+/**
+  Performs an atomic compare exchange operation on a 32-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 32-bit unsigned integer
+  specified by Value.  If Value is equal to CompareValue, then Value is set to
+  ExchangeValue and CompareValue is returned.  If Value is not equal to CompareValue,
+  then Value is returned.  The compare exchange operation must be performed using
+  MP safe mechanisms.
+
+  @param  Value         A pointer to the 32-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  32-bit value used in compare operation.
+  @param  ExchangeValue 32-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT32
+EFIAPI
+InternalSyncCompareExchange32 (
+  IN      volatile UINT32           *Value,
+  IN      UINT32                    CompareValue,
+  IN      UINT32                    ExchangeValue
+  )
+{
+  return _InterlockedCompareExchange (Value, ExchangeValue, CompareValue);
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.nasm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.nasm
new file mode 100644
index 000000000000..e199ef95fe8c
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange32.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange32.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange32 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncCompareExchange32 (
+;   IN      volatile UINT32           *Value,
+;   IN      UINT32                    CompareValue,
+;   IN      UINT32                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange32)
+ASM_PFX(InternalSyncCompareExchange32):
+    mov     eax, edx
+    lock    cmpxchg [rcx], r8d
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.asm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.asm
new file mode 100644
index 000000000000..e3a85d6fa76f
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.asm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange64.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalSyncCompareExchange64 (
+;   IN      volatile UINT64           *Value,
+;   IN      UINT64                    CompareValue,
+;   IN      UINT64                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+InternalSyncCompareExchange64   PROC
+    mov     rax, rdx
+    lock    cmpxchg [rcx], r8
+    ret
+InternalSyncCompareExchange64   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.c b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.c
new file mode 100644
index 000000000000..c7b6daac9315
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.c
@@ -0,0 +1,53 @@
+/** @file
+  InterlockedCompareExchange64 function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+__int64 _InterlockedCompareExchange64(
+   __int64 volatile * Destination,
+   __int64 Exchange,
+   __int64 Comperand
+);
+
+#pragma intrinsic(_InterlockedCompareExchange64)
+
+/**
+  Performs an atomic compare exchange operation on a 64-bit unsigned integer.
+
+  Performs an atomic compare exchange operation on the 64-bit unsigned integer specified
+  by Value.  If Value is equal to CompareValue, then Value is set to ExchangeValue and
+  CompareValue is returned.  If Value is not equal to CompareValue, then Value is returned.
+  The compare exchange operation must be performed using MP safe mechanisms.
+
+  @param  Value         A pointer to the 64-bit value for the compare exchange
+                        operation.
+  @param  CompareValue  64-bit value used in compare operation.
+  @param  ExchangeValue 64-bit value used in exchange operation.
+
+  @return The original *Value before exchange.
+
+**/
+UINT64
+EFIAPI
+InternalSyncCompareExchange64 (
+  IN      volatile UINT64           *Value,
+  IN      UINT64                    CompareValue,
+  IN      UINT64                    ExchangeValue
+  )
+{
+  return _InterlockedCompareExchange64 (Value, ExchangeValue, CompareValue);
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.nasm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.nasm
new file mode 100644
index 000000000000..e78de535d965
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedCompareExchange64.nasm
@@ -0,0 +1,41 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedCompareExchange64.Asm
+;
+; Abstract:
+;
+;   InterlockedCompareExchange64 function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT64
+; EFIAPI
+; InternalSyncCompareExchange64 (
+;   IN      volatile UINT64           *Value,
+;   IN      UINT64                    CompareValue,
+;   IN      UINT64                    ExchangeValue
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncCompareExchange64)
+ASM_PFX(InternalSyncCompareExchange64):
+    mov     rax, rdx
+    lock    cmpxchg [rcx], r8
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.asm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.asm
new file mode 100644
index 000000000000..7d6f02c63b0c
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedDecrement.Asm
+;
+; Abstract:
+;
+;   InterlockedDecrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncDecrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+InternalSyncDecrement   PROC
+    lock    dec     dword ptr [rcx]
+    mov     eax, [rcx]
+    ret
+InternalSyncDecrement   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.c b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.c
new file mode 100644
index 000000000000..af0193cb6321
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.c
@@ -0,0 +1,46 @@
+/** @file
+  InterlockedDecrement function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+long _InterlockedDecrement(
+   long * lpAddend
+);
+
+#pragma intrinsic(_InterlockedDecrement)
+
+/**
+  Performs an atomic decrement of an 32-bit unsigned integer.
+
+  Performs an atomic decrement of the 32-bit unsigned integer specified by
+  Value and returns the decrement value. The decrement operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to decrement.
+
+  @return The decrement value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncDecrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  return _InterlockedDecrement ((long *)(UINTN)(Value));
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.nasm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.nasm
new file mode 100644
index 000000000000..0325fdf93e90
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedDecrement.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedDecrement.Asm
+;
+; Abstract:
+;
+;   InterlockedDecrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncDecrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncDecrement)
+ASM_PFX(InternalSyncDecrement):
+    lock    dec     dword [rcx]
+    mov     eax, [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.asm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.asm
new file mode 100644
index 000000000000..bbbc95df0c36
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.asm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedIncrement.Asm
+;
+; Abstract:
+;
+;   InterlockedIncrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    .code
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncIncrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+InternalSyncIncrement   PROC
+    lock    inc     dword ptr [rcx]
+    mov     eax, [rcx]
+    ret
+InternalSyncIncrement   ENDP
+
+    END
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.c b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.c
new file mode 100644
index 000000000000..2a3498a585ab
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.c
@@ -0,0 +1,46 @@
+/** @file
+  InterLockedIncrement function
+
+  Copyright (c) 2006 - 2016, 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.
+
+**/
+
+/**
+  Microsoft Visual Studio 7.1 Function Prototypes for I/O Intrinsics.
+**/
+
+long _InterlockedIncrement(
+   long * lpAddend
+);
+
+#pragma intrinsic(_InterlockedIncrement)
+
+/**
+  Performs an atomic increment of an 32-bit unsigned integer.
+
+  Performs an atomic increment of the 32-bit unsigned integer specified by
+  Value and returns the incremented value. The increment operation must be
+  performed using MP safe mechanisms. The state of the return value is not
+  guaranteed to be MP safe.
+
+  @param  Value A pointer to the 32-bit value to increment.
+
+  @return The incremented value.
+
+**/
+UINT32
+EFIAPI
+InternalSyncIncrement (
+  IN      volatile UINT32           *Value
+  )
+{
+  return _InterlockedIncrement ((long *)(UINTN)(Value));
+}
+
diff --git a/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.nasm b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.nasm
new file mode 100644
index 000000000000..c960cb451196
--- /dev/null
+++ b/MdePkg/Library/BaseSynchronizationLib/X64/InterlockedIncrement.nasm
@@ -0,0 +1,39 @@
+;------------------------------------------------------------------------------
+;
+; Copyright (c) 2006 - 2016, 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.
+;
+; Module Name:
+;
+;   InterlockedIncrement.Asm
+;
+; Abstract:
+;
+;   InterlockedIncrement function
+;
+; Notes:
+;
+;------------------------------------------------------------------------------
+
+    DEFAULT REL
+    SECTION .text
+
+;------------------------------------------------------------------------------
+; UINT32
+; EFIAPI
+; InternalSyncIncrement (
+;   IN      volatile UINT32           *Value
+;   );
+;------------------------------------------------------------------------------
+global ASM_PFX(InternalSyncIncrement)
+ASM_PFX(InternalSyncIncrement):
+    lock    inc     dword [rcx]
+    mov     eax, [rcx]
+    ret
+
diff --git a/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf b/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
new file mode 100644
index 000000000000..0fc8c08a565b
--- /dev/null
+++ b/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
@@ -0,0 +1,45 @@
+## @file
+#  NULL instance of Timer Library as a template.
+#
+#  A non-functional instance of the Timer Library that can be used as a template
+#  for the implementation of a functional timer library instance. This library instance can
+#  also be used to test build DXE, Runtime, DXE SAL, and DXE SMM modules that require timer
+#  services as well as EBC modules that require timer services.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseTimerLibNullTemplate
+  MODULE_UNI_FILE                = BaseTimerLibNullTemplate.uni
+  FILE_GUID                      = f4731d79-537e-4505-bd52-c03f9b1f6b89
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = TimerLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  TimerLibNull.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.uni b/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.uni
new file mode 100644
index 000000000000..eaffc8e3e79a
--- /dev/null
+++ b/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.uni
@@ -0,0 +1,24 @@
+// /** @file
+// NULL instance of Timer Library as a template.
+//
+// A non-functional instance of the Timer Library that can be used as a template
+// for the implementation of a functional timer library instance. This library instance can
+// also be used to test build DXE, Runtime, DXE SAL, and DXE SMM modules that require timer
+// services as well as EBC modules that require timer services.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "NULL instance of Timer Library as a template"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "A non-functional instance of the Timer Library that can be used as a template for the implementation of a functional timer library instance. This library instance can also be used to test build DXE, Runtime, DXE SAL, and DXE SMM modules that require timer services, as well as EBC modules that require timer services."
+
diff --git a/MdePkg/Library/BaseTimerLibNullTemplate/TimerLibNull.c b/MdePkg/Library/BaseTimerLibNullTemplate/TimerLibNull.c
new file mode 100644
index 000000000000..93766b53295e
--- /dev/null
+++ b/MdePkg/Library/BaseTimerLibNullTemplate/TimerLibNull.c
@@ -0,0 +1,134 @@
+/** @file
+  A non-functional instance of the Timer Library.
+
+  Copyright (c) 2007 - 2011, 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 <Base.h>
+#include <Library/TimerLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Stalls the CPU for at least the given number of microseconds.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return The value of MicroSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+MicroSecondDelay (
+  IN      UINTN                     MicroSeconds
+  )
+{
+  ASSERT (FALSE);
+  return MicroSeconds;
+}
+
+/**
+  Stalls the CPU for at least the given number of nanoseconds.
+
+  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
+
+  @param  NanoSeconds The minimum number of nanoseconds to delay.
+
+  @return The value of NanoSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+NanoSecondDelay (
+  IN      UINTN                     NanoSeconds
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Retrieves the current value of a 64-bit free running performance counter.
+
+  The counter can either count up by 1 or count down by 1. If the physical
+  performance counter counts by a larger increment, then the counter values
+  must be translated. The properties of the counter can be retrieved from
+  GetPerformanceCounterProperties().
+
+  @return The current value of the free running performance counter.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounter (
+  VOID
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
+
+/**
+  Retrieves the 64-bit frequency in Hz and the range of performance counter
+  values.
+
+  If StartValue is not NULL, then the value that the performance counter starts
+  with immediately after is it rolls over is returned in StartValue. If
+  EndValue is not NULL, then the value that the performance counter end with
+  immediately before it rolls over is returned in EndValue. The 64-bit
+  frequency of the performance counter in Hz is always returned. If StartValue
+  is less than EndValue, then the performance counter counts up. If StartValue
+  is greater than EndValue, then the performance counter counts down. For
+  example, a 64-bit free running counter that counts up would have a StartValue
+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
+
+  @param  StartValue  The value the performance counter starts with when it
+                      rolls over.
+  @param  EndValue    The value that the performance counter ends with before
+                      it rolls over.
+
+  @return The frequency in Hz.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  OUT      UINT64                    *StartValue,  OPTIONAL
+  OUT      UINT64                    *EndValue     OPTIONAL
+  )
+{
+  ASSERT (FALSE);
+
+  return (UINT64)(-1);
+}
+
+/**
+  Converts elapsed ticks of performance counter to time in nanoseconds.
+
+  This function converts the elapsed ticks of running performance counter to
+  time value in unit of nanoseconds.
+
+  @param  Ticks     The number of elapsed ticks of running performance counter.
+
+  @return The elapsed time in nanoseconds.
+
+**/
+UINT64
+EFIAPI
+GetTimeInNanoSecond (
+  IN      UINT64                     Ticks
+  )
+{
+  ASSERT (FALSE);
+  return 0;
+}
diff --git a/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.c b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.c
new file mode 100644
index 000000000000..671a494a94b3
--- /dev/null
+++ b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.c
@@ -0,0 +1,803 @@
+/** @file
+  UEFI Decompress Library implementation refer to UEFI specification.
+
+  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
+  Portions copyright (c) 2008 - 2009, Apple Inc. 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 <Base.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiDecompressLib.h>
+
+#include "BaseUefiDecompressLibInternals.h"
+
+/**
+  Read NumOfBit of bits from source into mBitBuf.
+
+  Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.
+
+  @param  Sd        The global scratch data.
+  @param  NumOfBits The number of bits to shift and read.
+
+**/
+VOID
+FillBuf (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfBits
+  )
+{
+  //
+  // Left shift NumOfBits of bits in advance
+  //
+  Sd->mBitBuf = (UINT32) (Sd->mBitBuf << NumOfBits);
+
+  //
+  // Copy data needed in bytes into mSbuBitBuf
+  //
+  while (NumOfBits > Sd->mBitCount) {
+
+    Sd->mBitBuf |= (UINT32) (Sd->mSubBitBuf << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount)));
+
+    if (Sd->mCompSize > 0) {
+      //
+      // Get 1 byte into SubBitBuf
+      //
+      Sd->mCompSize--;
+      Sd->mSubBitBuf  = Sd->mSrcBase[Sd->mInBuf++];
+      Sd->mBitCount   = 8;
+
+    } else {
+      //
+      // No more bits from the source, just pad zero bit.
+      //
+      Sd->mSubBitBuf  = 0;
+      Sd->mBitCount   = 8;
+
+    }
+  }
+
+  //
+  // Calculate additional bit count read to update mBitCount
+  //
+  Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits);
+  
+  //
+  // Copy NumOfBits of bits from mSubBitBuf into mBitBuf
+  //
+  Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount;
+}
+
+/**
+  Get NumOfBits of bits out from mBitBuf.
+
+  Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent
+  NumOfBits of bits from source. Returns NumOfBits of bits that are
+  popped out.
+
+  @param  Sd        The global scratch data.
+  @param  NumOfBits The number of bits to pop and read.
+
+  @return The bits that are popped out.
+
+**/
+UINT32
+GetBits (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfBits
+  )
+{
+  UINT32  OutBits;
+
+  //
+  // Pop NumOfBits of Bits from Left
+  //  
+  OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits));
+
+  //
+  // Fill up mBitBuf from source
+  //
+  FillBuf (Sd, NumOfBits);
+
+  return OutBits;
+}
+
+/**
+  Creates Huffman Code mapping table according to code length array.
+
+  Creates Huffman Code mapping table for Extra Set, Char&Len Set
+  and Position Set according to code length array.
+  If TableBits > 16, then ASSERT ().
+
+  @param  Sd        The global scratch data.
+  @param  NumOfChar The number of symbols in the symbol set.
+  @param  BitLen    Code length array.
+  @param  TableBits The width of the mapping table.
+  @param  Table     The table to be created.
+
+  @retval  0 OK.
+  @retval  BAD_TABLE The table is corrupted.
+
+**/
+UINT16
+MakeTable (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfChar,
+  IN  UINT8         *BitLen,
+  IN  UINT16        TableBits,
+  OUT UINT16        *Table
+  )
+{
+  UINT16  Count[17];
+  UINT16  Weight[17];
+  UINT16  Start[18];
+  UINT16  *Pointer;
+  UINT16  Index3;
+  UINT16  Index;
+  UINT16  Len;
+  UINT16  Char;
+  UINT16  JuBits;
+  UINT16  Avail;
+  UINT16  NextCode;
+  UINT16  Mask;
+  UINT16  WordOfStart;
+  UINT16  WordOfCount;
+
+  //
+  // The maximum mapping table width supported by this internal
+  // working function is 16.
+  //
+  ASSERT (TableBits <= 16);
+
+  for (Index = 0; Index <= 16; Index++) {
+    Count[Index] = 0;
+  }
+
+  for (Index = 0; Index < NumOfChar; Index++) {
+    Count[BitLen[Index]]++;
+  }
+  
+  Start[0] = 0;
+  Start[1] = 0;
+
+  for (Index = 1; Index <= 16; Index++) {
+    WordOfStart = Start[Index];
+    WordOfCount = Count[Index];
+    Start[Index + 1] = (UINT16) (WordOfStart + (WordOfCount << (16 - Index)));
+  }
+
+  if (Start[17] != 0) {
+    /*(1U << 16)*/
+    return (UINT16) BAD_TABLE;
+  }
+
+  JuBits = (UINT16) (16 - TableBits);
+  
+  Weight[0] = 0;
+  for (Index = 1; Index <= TableBits; Index++) {
+    Start[Index] >>= JuBits;
+    Weight[Index] = (UINT16) (1U << (TableBits - Index));
+  }
+
+  while (Index <= 16) {
+    Weight[Index] = (UINT16) (1U << (16 - Index));
+    Index++;    
+  }
+
+  Index = (UINT16) (Start[TableBits + 1] >> JuBits);
+
+  if (Index != 0) {
+    Index3 = (UINT16) (1U << TableBits);
+    if (Index < Index3) {
+      SetMem16 (Table + Index, (Index3 - Index) * sizeof (*Table), 0);
+    }
+  }
+
+  Avail = NumOfChar;
+  Mask  = (UINT16) (1U << (15 - TableBits));
+
+  for (Char = 0; Char < NumOfChar; Char++) {
+
+    Len = BitLen[Char];
+    if (Len == 0 || Len >= 17) {
+      continue;
+    }
+
+    NextCode = (UINT16) (Start[Len] + Weight[Len]);
+
+    if (Len <= TableBits) {
+
+      for (Index = Start[Len]; Index < NextCode; Index++) {
+        Table[Index] = Char;
+      }
+
+    } else {
+
+      Index3  = Start[Len];
+      Pointer = &Table[Index3 >> JuBits];
+      Index   = (UINT16) (Len - TableBits);
+
+      while (Index != 0) {
+        if (*Pointer == 0 && Avail < (2 * NC - 1)) {
+          Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;
+          *Pointer = Avail++;
+        }
+        
+        if (*Pointer < (2 * NC - 1)) {
+          if ((Index3 & Mask) != 0) {
+            Pointer = &Sd->mRight[*Pointer];
+          } else {
+            Pointer = &Sd->mLeft[*Pointer];
+          }
+        }
+
+        Index3 <<= 1;
+        Index--;
+      }
+
+      *Pointer = Char;
+
+    }
+
+    Start[Len] = NextCode;
+  }
+  //
+  // Succeeds
+  //
+  return 0;
+}
+
+/**
+  Decodes a position value.
+
+  Get a position value according to Position Huffman Table.
+
+  @param  Sd The global scratch data.
+
+  @return The position value decoded.
+
+**/
+UINT32
+DecodeP (
+  IN  SCRATCH_DATA  *Sd
+  )
+{
+  UINT16  Val;
+  UINT32  Mask;
+  UINT32  Pos;
+
+  Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
+
+  if (Val >= MAXNP) {
+    Mask = 1U << (BITBUFSIZ - 1 - 8);
+
+    do {
+
+      if ((Sd->mBitBuf & Mask) != 0) {
+        Val = Sd->mRight[Val];
+      } else {
+        Val = Sd->mLeft[Val];
+      }
+
+      Mask >>= 1;
+    } while (Val >= MAXNP);
+  }
+  //
+  // Advance what we have read
+  //
+  FillBuf (Sd, Sd->mPTLen[Val]);
+
+  Pos = Val;
+  if (Val > 1) {
+    Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));
+  }
+
+  return Pos;
+}
+
+/**
+  Reads code lengths for the Extra Set or the Position Set.
+
+  Read in the Extra Set or Position Set Length Array, then
+  generate the Huffman code mapping for them.
+
+  @param  Sd      The global scratch data.
+  @param  nn      The number of symbols.
+  @param  nbit    The number of bits needed to represent nn.
+  @param  Special The special symbol that needs to be taken care of.
+
+  @retval  0 OK.
+  @retval  BAD_TABLE Table is corrupted.
+
+**/
+UINT16
+ReadPTLen (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        nn,
+  IN  UINT16        nbit,
+  IN  UINT16        Special
+  )
+{
+  UINT16  Number;
+  UINT16  CharC;
+  UINT16  Index;
+  UINT32  Mask;
+
+  ASSERT (nn <= NPT);
+  //
+  // Read Extra Set Code Length Array size 
+  //
+  Number = (UINT16) GetBits (Sd, nbit);
+
+  if (Number == 0) {
+    //
+    // This represents only Huffman code used
+    //
+    CharC = (UINT16) GetBits (Sd, nbit);
+
+    SetMem16 (&Sd->mPTTable[0] , sizeof (Sd->mPTTable), CharC);
+
+    SetMem (Sd->mPTLen, nn, 0);
+
+    return 0;
+  }
+
+  Index = 0;
+
+  while (Index < Number && Index < NPT) {
+
+    CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));
+
+    //
+    // If a code length is less than 7, then it is encoded as a 3-bit
+    // value. Or it is encoded as a series of "1"s followed by a 
+    // terminating "0". The number of "1"s = Code length - 4.
+    //
+    if (CharC == 7) {
+      Mask = 1U << (BITBUFSIZ - 1 - 3);
+      while (Mask & Sd->mBitBuf) {
+        Mask >>= 1;
+        CharC += 1;
+      }
+    }
+    
+    FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));
+
+    Sd->mPTLen[Index++] = (UINT8) CharC;
+ 
+    //
+    // For Code&Len Set, 
+    // After the third length of the code length concatenation,
+    // a 2-bit value is used to indicated the number of consecutive 
+    // zero lengths after the third length.
+    //
+    if (Index == Special) {
+      CharC = (UINT16) GetBits (Sd, 2);
+      while ((INT16) (--CharC) >= 0 && Index < NPT) {
+        Sd->mPTLen[Index++] = 0;
+      }
+    }
+  }
+
+  while (Index < nn && Index < NPT) {
+    Sd->mPTLen[Index++] = 0;
+  }
+  
+  return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);
+}
+
+/**
+  Reads code lengths for Char&Len Set.
+
+  Read in and decode the Char&Len Set Code Length Array, then
+  generate the Huffman Code mapping table for the Char&Len Set.
+
+  @param  Sd The global scratch data.
+
+**/
+VOID
+ReadCLen (
+  SCRATCH_DATA  *Sd
+  )
+{
+  UINT16           Number;
+  UINT16           CharC;
+  UINT16           Index;
+  UINT32           Mask;
+
+  Number = (UINT16) GetBits (Sd, CBIT);
+
+  if (Number == 0) {
+    //
+    // This represents only Huffman code used
+    //
+    CharC = (UINT16) GetBits (Sd, CBIT);
+
+    SetMem (Sd->mCLen, NC, 0);
+    SetMem16 (&Sd->mCTable[0], sizeof (Sd->mCTable), CharC);
+
+    return ;
+  }
+
+  Index = 0;
+  while (Index < Number && Index < NC) {
+    CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
+    if (CharC >= NT) {
+      Mask = 1U << (BITBUFSIZ - 1 - 8);
+
+      do {
+
+        if (Mask & Sd->mBitBuf) {
+          CharC = Sd->mRight[CharC];
+        } else {
+          CharC = Sd->mLeft[CharC];
+        }
+
+        Mask >>= 1;
+
+      } while (CharC >= NT);
+    }
+    //
+    // Advance what we have read
+    //
+    FillBuf (Sd, Sd->mPTLen[CharC]);
+
+    if (CharC <= 2) {
+
+      if (CharC == 0) {
+        CharC = 1;
+      } else if (CharC == 1) {
+        CharC = (UINT16) (GetBits (Sd, 4) + 3);
+      } else if (CharC == 2) {
+        CharC = (UINT16) (GetBits (Sd, CBIT) + 20);
+      }
+
+      while ((INT16) (--CharC) >= 0 && Index < NC) {
+        Sd->mCLen[Index++] = 0;
+      }
+
+    } else {
+
+      Sd->mCLen[Index++] = (UINT8) (CharC - 2);
+
+    }
+  }
+
+  SetMem (Sd->mCLen + Index, NC - Index, 0);
+
+  MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);
+
+  return ;
+}
+
+/**
+  Decode a character/length value.
+
+  Read one value from mBitBuf, Get one code from mBitBuf. If it is at block boundary, generates
+  Huffman code mapping table for Extra Set, Code&Len Set and
+  Position Set.
+
+  @param  Sd The global scratch data.
+
+  @return The value decoded.
+
+**/
+UINT16
+DecodeC (
+  SCRATCH_DATA  *Sd
+  )
+{
+  UINT16  Index2;
+  UINT32  Mask;
+
+  if (Sd->mBlockSize == 0) {
+    //
+    // Starting a new block
+    // Read BlockSize from block header
+    // 
+    Sd->mBlockSize    = (UINT16) GetBits (Sd, 16);
+
+    //
+    // Read in the Extra Set Code Length Array,
+    // Generate the Huffman code mapping table for Extra Set.
+    //
+    Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);
+    if (Sd->mBadTableFlag != 0) {
+      return 0;
+    }
+
+    //
+    // Read in and decode the Char&Len Set Code Length Array,
+    // Generate the Huffman code mapping table for Char&Len Set.
+    //
+    ReadCLen (Sd);
+
+    //
+    // Read in the Position Set Code Length Array,
+    // Generate the Huffman code mapping table for the Position Set.
+    //
+    Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, Sd->mPBit, (UINT16) (-1));
+    if (Sd->mBadTableFlag != 0) {
+      return 0;
+    }
+  }
+
+  //
+  // Get one code according to Code&Set Huffman Table
+  //
+  Sd->mBlockSize--;
+  Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];
+
+  if (Index2 >= NC) {
+    Mask = 1U << (BITBUFSIZ - 1 - 12);
+
+    do {
+      if ((Sd->mBitBuf & Mask) != 0) {
+        Index2 = Sd->mRight[Index2];
+      } else {
+        Index2 = Sd->mLeft[Index2];
+      }
+
+      Mask >>= 1;
+    } while (Index2 >= NC);
+  }
+  //
+  // Advance what we have read
+  //
+  FillBuf (Sd, Sd->mCLen[Index2]);
+
+  return Index2;
+}
+
+/**
+  Decode the source data and put the resulting data into the destination buffer.
+
+  @param  Sd The global scratch data.
+
+**/
+VOID
+Decode (
+  SCRATCH_DATA  *Sd
+  )
+{
+  UINT16  BytesRemain;
+  UINT32  DataIdx;
+  UINT16  CharC;
+
+  BytesRemain = (UINT16) (-1);
+
+  DataIdx     = 0;
+
+  for (;;) {
+    //
+    // Get one code from mBitBuf
+    // 
+    CharC = DecodeC (Sd);
+    if (Sd->mBadTableFlag != 0) {
+      goto Done;
+    }
+
+    if (CharC < 256) {
+      //
+      // Process an Original character
+      //
+      if (Sd->mOutBuf >= Sd->mOrigSize) {
+        goto Done;
+      } else {
+        //
+        // Write orignal character into mDstBase
+        //
+        Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;
+      }
+
+    } else {
+      //
+      // Process a Pointer
+      //
+      CharC       = (UINT16) (CharC - (BIT8 - THRESHOLD));
+ 
+      //
+      // Get string length
+      //
+      BytesRemain = CharC;
+
+      //
+      // Locate string position
+      //
+      DataIdx     = Sd->mOutBuf - DecodeP (Sd) - 1;
+
+      //
+      // Write BytesRemain of bytes into mDstBase
+      //
+      BytesRemain--;
+      while ((INT16) (BytesRemain) >= 0) {
+        Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];
+        if (Sd->mOutBuf >= Sd->mOrigSize) {
+          goto Done;
+        }
+
+        BytesRemain--;
+      }
+    }
+  }
+
+Done:
+  return ;
+}
+
+/**
+  Given a compressed source buffer, this function retrieves the size of 
+  the uncompressed buffer and the size of the scratch buffer required 
+  to decompress the compressed source buffer.
+
+  Retrieves the size of the uncompressed buffer and the temporary scratch buffer 
+  required to decompress the buffer specified by Source and SourceSize.
+  If the size of the uncompressed buffer or the size of the scratch buffer cannot
+  be determined from the compressed data specified by Source and SourceData, 
+  then RETURN_INVALID_PARAMETER is returned.  Otherwise, the size of the uncompressed
+  buffer is returned in DestinationSize, the size of the scratch buffer is returned
+  in ScratchSize, and RETURN_SUCCESS is returned.
+  This function does not have scratch buffer available to perform a thorough 
+  checking of the validity of the source data.  It just retrieves the "Original Size"
+  field from the beginning bytes of the source data and output it as DestinationSize.
+  And ScratchSize is specific to the decompression implementation.
+
+  If Source is NULL, then ASSERT().
+  If DestinationSize is NULL, then ASSERT().
+  If ScratchSize is NULL, then ASSERT().
+
+  @param  Source          The source buffer containing the compressed data.
+  @param  SourceSize      The size, in bytes, of the source buffer.
+  @param  DestinationSize A pointer to the size, in bytes, of the uncompressed buffer
+                          that will be generated when the compressed buffer specified
+                          by Source and SourceSize is decompressed.
+  @param  ScratchSize     A pointer to the size, in bytes, of the scratch buffer that
+                          is required to decompress the compressed buffer specified 
+                          by Source and SourceSize.
+
+  @retval  RETURN_SUCCESS The size of the uncompressed data was returned 
+                          in DestinationSize, and the size of the scratch 
+                          buffer was returned in ScratchSize.
+  @retval  RETURN_INVALID_PARAMETER 
+                          The size of the uncompressed data or the size of 
+                          the scratch buffer cannot be determined from 
+                          the compressed data specified by Source 
+                          and SourceSize.
+**/
+RETURN_STATUS
+EFIAPI
+UefiDecompressGetInfo (
+  IN  CONST VOID  *Source,
+  IN  UINT32      SourceSize,
+  OUT UINT32      *DestinationSize,
+  OUT UINT32      *ScratchSize
+  )
+{
+  UINT32  CompressedSize;
+
+  ASSERT (Source != NULL);
+  ASSERT (DestinationSize != NULL);
+  ASSERT (ScratchSize != NULL);
+
+  if (SourceSize < 8) {
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CompressedSize   = ReadUnaligned32 ((UINT32 *)Source);
+  if (SourceSize < (CompressedSize + 8)) {
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  *ScratchSize  = sizeof (SCRATCH_DATA);
+  *DestinationSize = ReadUnaligned32 ((UINT32 *)Source + 1);
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Decompresses a compressed source buffer.
+
+  Extracts decompressed data to its original form.
+  This function is designed so that the decompression algorithm can be implemented
+  without using any memory services.  As a result, this function is not allowed to
+  call any memory allocation services in its implementation.  It is the caller's 
+  responsibility to allocate and free the Destination and Scratch buffers.
+  If the compressed source data specified by Source is successfully decompressed 
+  into Destination, then RETURN_SUCCESS is returned.  If the compressed source data 
+  specified by Source is not in a valid compressed data format,
+  then RETURN_INVALID_PARAMETER is returned.
+
+  If Source is NULL, then ASSERT().
+  If Destination is NULL, then ASSERT().
+  If the required scratch buffer size > 0 and Scratch is NULL, then ASSERT().
+
+  @param  Source      The source buffer containing the compressed data.
+  @param  Destination The destination buffer to store the decompressed data.
+  @param  Scratch     A temporary scratch buffer that is used to perform the decompression.
+                      This is an optional parameter that may be NULL if the 
+                      required scratch buffer size is 0.
+                     
+  @retval  RETURN_SUCCESS Decompression completed successfully, and 
+                          the uncompressed buffer is returned in Destination.
+  @retval  RETURN_INVALID_PARAMETER 
+                          The source buffer specified by Source is corrupted 
+                          (not in a valid compressed format).
+**/
+RETURN_STATUS
+EFIAPI
+UefiDecompress (
+  IN CONST VOID  *Source,
+  IN OUT VOID    *Destination,
+  IN OUT VOID    *Scratch  OPTIONAL
+  )
+{
+  UINT32           CompSize;
+  UINT32           OrigSize;
+  SCRATCH_DATA     *Sd;
+  CONST UINT8      *Src;
+  UINT8            *Dst;
+
+  ASSERT (Source != NULL);
+  ASSERT (Destination != NULL);
+  ASSERT (Scratch != NULL);
+
+  Src     = Source;
+  Dst     = Destination;
+
+  Sd = (SCRATCH_DATA *) Scratch;
+
+  CompSize  = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24);
+  OrigSize  = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);
+
+  //
+  // If compressed file size is 0, return
+  //
+  if (OrigSize == 0) {
+    return RETURN_SUCCESS;
+  }
+
+  Src = Src + 8;
+  SetMem (Sd, sizeof (SCRATCH_DATA), 0);
+
+  //
+  // The length of the field 'Position Set Code Length Array Size' in Block Header.
+  // For UEFI 2.0 de/compression algorithm(Version 1), mPBit = 4
+  //
+  Sd->mPBit     = 4;
+  Sd->mSrcBase  = (UINT8 *)Src;
+  Sd->mDstBase  = Dst;
+  //
+  // CompSize and OrigSize are calculated in bytes
+  //
+  Sd->mCompSize = CompSize;
+  Sd->mOrigSize = OrigSize;
+
+  //
+  // Fill the first BITBUFSIZ bits
+  //
+  FillBuf (Sd, BITBUFSIZ);
+
+  //
+  // Decompress it
+  //
+  Decode (Sd);
+
+  if (Sd->mBadTableFlag != 0) {
+    //
+    // Something wrong with the source
+    //
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  return RETURN_SUCCESS;
+}
diff --git a/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
new file mode 100644
index 000000000000..9d01703d26d4
--- /dev/null
+++ b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
@@ -0,0 +1,43 @@
+## @file
+#  UEFI Decompress Library implementation.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = BaseUefiDecompressLib
+  MODULE_UNI_FILE                = BaseUefiDecompressLib.uni
+  FILE_GUID                      = 9ae5147d-b240-467f-a484-b024fdc42ee0
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiDecompressLib 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  BaseUefiDecompressLibInternals.h
+  BaseUefiDecompressLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+  BaseMemoryLib
+
diff --git a/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.uni b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.uni
new file mode 100644
index 000000000000..3d7db178302e
--- /dev/null
+++ b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// UEFI Decompress Library implementation.
+//
+// UEFI Decompress Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI Decompress Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "UEFI Decompress Library implementation."
+
diff --git a/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLibInternals.h b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLibInternals.h
new file mode 100644
index 000000000000..91d7ad9c0407
--- /dev/null
+++ b/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLibInternals.h
@@ -0,0 +1,211 @@
+/** @file
+  Internal data structure defintions for Base UEFI Decompress Library.
+
+  Copyright (c) 2006 - 2010, 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 __BASE_UEFI_DECOMPRESS_LIB_INTERNALS_H__
+#define __BASE_UEFI_DECOMPRESS_LIB_INTERNALS_H__
+
+//
+// Decompression algorithm begins here
+//
+#define BITBUFSIZ 32
+#define MAXMATCH  256
+#define THRESHOLD 3
+#define CODE_BIT  16
+#define BAD_TABLE - 1
+
+//
+// C: Char&Len Set; P: Position Set; T: exTra Set
+//
+#define NC      (0xff + MAXMATCH + 2 - THRESHOLD)
+#define CBIT    9
+#define MAXPBIT 5
+#define TBIT    5
+#define MAXNP   ((1U << MAXPBIT) - 1)
+#define NT      (CODE_BIT + 3)
+#if NT > MAXNP
+#define NPT NT
+#else
+#define NPT MAXNP
+#endif
+
+typedef struct {
+  UINT8   *mSrcBase;  // The starting address of compressed data
+  UINT8   *mDstBase;  // The starting address of decompressed data
+  UINT32  mOutBuf;
+  UINT32  mInBuf;
+
+  UINT16  mBitCount;
+  UINT32  mBitBuf;
+  UINT32  mSubBitBuf;
+  UINT16  mBlockSize;
+  UINT32  mCompSize;
+  UINT32  mOrigSize;
+
+  UINT16  mBadTableFlag;
+
+  UINT16  mLeft[2 * NC - 1];
+  UINT16  mRight[2 * NC - 1];
+  UINT8   mCLen[NC];
+  UINT8   mPTLen[NPT];
+  UINT16  mCTable[4096];
+  UINT16  mPTTable[256];
+
+  ///
+  /// The length of the field 'Position Set Code Length Array Size' in Block Header.
+  /// For UEFI 2.0 de/compression algorithm, mPBit = 4.
+  ///
+  UINT8   mPBit;
+} SCRATCH_DATA;
+
+/**
+  Read NumOfBit of bits from source into mBitBuf.
+
+  Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.
+
+  @param  Sd        The global scratch data.
+  @param  NumOfBits The number of bits to shift and read.
+
+**/
+VOID
+FillBuf (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfBits
+  );
+
+/**
+  Get NumOfBits of bits out from mBitBuf.
+
+  Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent
+  NumOfBits of bits from source. Returns NumOfBits of bits that are
+  popped out.
+
+  @param  Sd        The global scratch data.
+  @param  NumOfBits The number of bits to pop and read.
+
+  @return The bits that are popped out.
+
+**/
+UINT32
+GetBits (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfBits
+  );
+
+/**
+  Creates Huffman Code mapping table according to code length array.
+
+  Creates Huffman Code mapping table for Extra Set, Char&Len Set
+  and Position Set according to code length array.
+  If TableBits > 16, then ASSERT ().
+
+  @param  Sd        The global scratch data.
+  @param  NumOfChar The number of symbols in the symbol set.
+  @param  BitLen    Code length array.
+  @param  TableBits The width of the mapping table.
+  @param  Table     The table to be created.
+
+  @retval  0 OK.
+  @retval  BAD_TABLE The table is corrupted.
+
+**/
+UINT16
+MakeTable (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        NumOfChar,
+  IN  UINT8         *BitLen,
+  IN  UINT16        TableBits,
+  OUT UINT16        *Table
+  );
+
+/**
+  Decodes a position value.
+
+  Get a position value according to Position Huffman Table.
+
+  @param  Sd The global scratch data.
+
+  @return The position value decoded.
+
+**/
+UINT32
+DecodeP (
+  IN  SCRATCH_DATA  *Sd
+  );
+
+/**
+  Reads code lengths for the Extra Set or the Position Set.
+
+  Read in the Extra Set or Position Set Length Array, then
+  generate the Huffman code mapping for them.
+
+  @param  Sd      The global scratch data.
+  @param  nn      The number of symbols.
+  @param  nbit    The number of bits needed to represent nn.
+  @param  Special The special symbol that needs to be taken care of.
+
+  @retval  0 OK.
+  @retval  BAD_TABLE Table is corrupted.
+
+**/
+UINT16
+ReadPTLen (
+  IN  SCRATCH_DATA  *Sd,
+  IN  UINT16        nn,
+  IN  UINT16        nbit,
+  IN  UINT16        Special
+  );
+
+/**
+  Reads code lengths for Char&Len Set.
+
+  Read in and decode the Char&Len Set Code Length Array, then
+  generate the Huffman Code mapping table for the Char&Len Set.
+
+  @param  Sd The global scratch data.
+
+**/
+VOID
+ReadCLen (
+  SCRATCH_DATA  *Sd
+  );
+
+/**
+  Decode a character/length value.
+
+  Read one value from mBitBuf, Get one code from mBitBuf. If it is at block boundary, generates
+  Huffman code mapping table for Extra Set, Code&Len Set and
+  Position Set.
+
+  @param  Sd The global scratch data.
+
+  @return The value decoded.
+
+**/
+UINT16
+DecodeC (
+  SCRATCH_DATA  *Sd
+  );
+
+/**
+  Decode the source data and put the resulting data into the destination buffer.
+
+  @param  Sd The global scratch data.
+
+**/
+VOID
+Decode (
+  SCRATCH_DATA  *Sd
+  );
+
+#endif
diff --git a/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.c b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.c
new file mode 100644
index 000000000000..840ce9aba386
--- /dev/null
+++ b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.c
@@ -0,0 +1,79 @@
+/** @file
+  Entry point to the DXE Core.
+
+Copyright (c) 2006 - 2008, 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 <PiDxe.h>
+
+
+#include <Library/DxeCoreEntryPoint.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+
+//
+// Cache copy of HobList pointer. 
+// 
+VOID *gHobList = NULL;
+
+/**
+  The entry point of PE/COFF Image for the DXE Core. 
+
+  This function is the entry point for the DXE Core. This function is required to call
+  ProcessModuleEntryPointList() and ProcessModuleEntryPointList() is never expected to return.
+  The DXE Core is responsible for calling ProcessLibraryConstructorList() as soon as the EFI
+  System Table and the image handle for the DXE Core itself have been established.
+  If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system.
+
+  @param  HobStart  The pointer to the beginning of the HOB List passed in from the PEI Phase. 
+
+**/
+VOID
+EFIAPI
+_ModuleEntryPoint (
+  IN VOID  *HobStart
+  )
+{
+  //
+  // Cache a pointer to the HobList
+  //
+  gHobList = HobStart;
+
+  //
+  // Call the DXE Core entry point
+  //
+  ProcessModuleEntryPointList (HobStart);
+
+  //
+  // Should never return
+  //
+  ASSERT(FALSE);
+  CpuDeadLoop ();
+}
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+
+  This function is required to call _ModuleEntryPoint() passing in HobStart.
+
+  @param  HobStart  The pointer to the beginning of the HOB List passed in from the PEI Phase. 
+
+**/
+VOID
+EFIAPI
+EfiMain (
+  IN VOID  *HobStart
+  )
+{
+  _ModuleEntryPoint (HobStart);
+}
diff --git a/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf
new file mode 100644
index 000000000000..f88b12280578
--- /dev/null
+++ b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf
@@ -0,0 +1,41 @@
+## @file
+# Module entry point library for DXE core.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeCoreEntryPoint
+  MODULE_UNI_FILE                = DxeCoreEntryPoint.uni
+  FILE_GUID                      = d258d6af-2fc0-4019-9c1f-1101c3dd19b5
+  MODULE_TYPE                    = DXE_CORE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DxeCoreEntryPoint|DXE_CORE 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  DxeCoreEntryPoint.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+
diff --git a/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.uni b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.uni
new file mode 100644
index 000000000000..3af375f1e9b3
--- /dev/null
+++ b/MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Module entry point library for DXE core.
+//
+// Module entry point library for DXE core.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Module entry point library for DXE core"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Module entry point library for DXE core."
+
diff --git a/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf b/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf
new file mode 100644
index 000000000000..df7ecdabb0f9
--- /dev/null
+++ b/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf
@@ -0,0 +1,44 @@
+## @file
+# Instance of HOB Library for DXE Core.
+#
+# HOB Library implementation for the DXE Core. Does not have a constructor.
+#  Uses gHobList defined in the DXE Core Entry Point Library.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeCoreHobLib
+  MODULE_UNI_FILE                = DxeCoreHobLib.uni
+  FILE_GUID                      = 882ee1a3-35b2-412c-b8a2-7a8d34a7c390
+  MODULE_TYPE                    = DXE_CORE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = HobLib|DXE_CORE 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  HobLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  DebugLib
+  DxeCoreEntryPoint
+
diff --git a/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.uni b/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.uni
new file mode 100644
index 000000000000..5d90208f1db8
--- /dev/null
+++ b/MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of HOB Library for DXE Core.
+//
+// HOB Library implementation for the DXE Core. Does not have a constructor.
+// Uses gHobList defined in the DXE Core Entry Point Library.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of HOB Library for DXE Core"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "HOB Library implementation for the DXE Core. Does not have a constructor. Uses gHobList defined in the DXE Core Entry Point Library."
+
diff --git a/MdePkg/Library/DxeCoreHobLib/HobLib.c b/MdePkg/Library/DxeCoreHobLib/HobLib.c
new file mode 100644
index 000000000000..0a87b25ab567
--- /dev/null
+++ b/MdePkg/Library/DxeCoreHobLib/HobLib.c
@@ -0,0 +1,568 @@
+/** @file
+  HOB Library implementation for DxeCore driver.
+
+Copyright (c) 2006 - 2016, 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 <PiDxe.h>
+
+#include <Library/HobLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DxeCoreEntryPoint.h>
+
+/**
+  Returns the pointer to the HOB list.
+
+  This function returns the pointer to first HOB in the list.
+  For PEI phase, the PEI service GetHobList() can be used to retrieve the pointer 
+  to the HOB list.  For the DXE phase, the HOB list pointer can be retrieved through
+  the EFI System Table by looking up theHOB list GUID in the System Configuration Table.
+  Since the System Configuration Table does not exist that the time the DXE Core is 
+  launched, the DXE Core uses a global variable from the DXE Core Entry Point Library 
+  to manage the pointer to the HOB list.
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+  
+  @return The pointer to the HOB list.
+
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  )
+{
+  ASSERT (gHobList != NULL);
+  return gHobList;
+}
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+
+  This function searches the first instance of a HOB type from the starting HOB pointer. 
+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If HobStart is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+  @param  HobStart      The starting HOB pointer to search from.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  IN UINT16                 Type,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  Hob;
+
+  ASSERT (HobStart != NULL);
+
+  Hob.Raw = (UINT8 *) HobStart;
+  //
+  // Parse the HOB list until end of list or matching type is found.
+  //
+  while (!END_OF_HOB_LIST (Hob)) {
+    if (Hob.Header->HobType == Type) {
+      return Hob.Raw;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+  }
+  return NULL;
+}
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+
+  This function searches the first instance of a HOB type among the whole HOB list. 
+  If there does not exist such HOB type in the HOB list, it will return NULL. 
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  IN UINT16                 Type
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextHob (Type, HobList);
+}
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+  
+  This function searches the first instance of a HOB from the starting HOB pointer. 
+  Such HOB should satisfy two conditions: 
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION, and its GUID Name equals to the input Guid. 
+  If such a HOB from the starting HOB pointer does not exist, it will return NULL. 
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If Guid is NULL, then ASSERT().
+  If HobStart is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+  @param  HobStart      A pointer to a Guid.
+
+  @return The next instance of the matched GUID HOB from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  IN CONST EFI_GUID         *Guid,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  GuidHob;
+
+  GuidHob.Raw = (UINT8 *) HobStart;
+  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
+    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
+      break;
+    }
+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
+  }
+  return GuidHob.Raw;
+}
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+  
+  This function searches the first instance of a HOB among the whole HOB list. 
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If such a HOB from the starting HOB pointer does not exist, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+
+  @return The first instance of the matched GUID HOB among the whole HOB list.
+
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  IN CONST EFI_GUID         *Guid
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextGuidHob (Guid, HobList);
+}
+
+/**
+  Get the system boot mode from the HOB list.
+
+  This function returns the system boot mode information from the 
+  PHIT HOB in HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+  
+  @param  VOID
+
+  @return The Boot Mode.
+
+**/
+EFI_BOOT_MODE
+EFIAPI
+GetBootModeHob (
+  VOID
+  )
+{
+  EFI_HOB_HANDOFF_INFO_TABLE    *HandOffHob;
+
+  HandOffHob = (EFI_HOB_HANDOFF_INFO_TABLE *) GetHobList ();
+
+  return  HandOffHob->BootMode;
+}
+
+/**
+  Builds a HOB for a loaded PE32 module.
+
+  This function builds a HOB for a loaded PE32 module.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If ModuleName is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ModuleName              The GUID File Name of the module.
+  @param  MemoryAllocationModule  The 64 bit physical address of the module.
+  @param  ModuleLength            The length of the module in bytes.
+  @param  EntryPoint              The 64 bit physical address of the module entry point.
+
+**/
+VOID
+EFIAPI
+BuildModuleHob (
+  IN CONST EFI_GUID         *ModuleName,
+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
+  IN UINT64                 ModuleLength,
+  IN EFI_PHYSICAL_ADDRESS   EntryPoint
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory with Owner GUID.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+  @param  OwnerGUID           GUID for the owner of this resource.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorWithOwnerHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes,
+  IN EFI_GUID                     *OwnerGUID
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification and returns 
+  the start address of GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification 
+  and returns the start address of GUID HOB data so that caller can fill the customized data. 
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase.
+  For DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidHob (
+  IN CONST EFI_GUID              *Guid,
+  IN UINTN                       DataLength
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+  return NULL;
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB 
+  data field, and returns the start address of the GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification and copies the input
+  data to the HOB data field and returns the start address of the GUID HOB data.  It can only be 
+  invoked during PEI phase; for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.  
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase.
+  For DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If Data is NULL and DataLength > 0, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  Data          The data to be copied into the data field of the GUID HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidDataHob (
+  IN CONST EFI_GUID              *Guid,
+  IN VOID                        *Data,
+  IN UINTN                       DataLength
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+  return NULL;
+}
+
+/**
+  Builds a Firmware Volume HOB.
+
+  This function builds a Firmware Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildFvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a EFI_HOB_TYPE_FV2 HOB.
+
+  This function builds a EFI_HOB_TYPE_FV2 HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+  @param  FvName        The name of the Firmware Volume.
+  @param  FileName      The name of the file.
+  
+**/
+VOID
+EFIAPI
+BuildFv2Hob (
+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN          UINT64                      Length,
+  IN CONST    EFI_GUID                    *FvName,
+  IN CONST    EFI_GUID                    *FileName
+  )
+{
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a Capsule Volume HOB.
+
+  This function builds a Capsule Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If the platform does not support Capsule Volume HOBs, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The base address of the Capsule Volume.
+  @param  Length        The size of the Capsule Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildCvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the CPU.
+
+  This function builds a HOB for the CPU.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
+
+**/
+VOID
+EFIAPI
+BuildCpuHob (
+  IN UINT8                       SizeOfMemorySpace,
+  IN UINT8                       SizeOfIoSpace
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the Stack.
+
+  This function builds a HOB for the stack.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the Stack.
+  @param  Length        The length of the stack in bytes.
+
+**/
+VOID
+EFIAPI
+BuildStackHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the BSP store.
+
+  This function builds a HOB for BSP store.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the BSP.
+  @param  Length        The length of the BSP store in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildBspStoreHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the memory allocation.
+
+  This function builds a HOB for the memory allocation.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() because PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the memory.
+  @param  Length        The length of the memory allocation in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildMemoryAllocationHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.inf b/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.inf
new file mode 100644
index 000000000000..fdbcbe8db3bc
--- /dev/null
+++ b/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.inf
@@ -0,0 +1,46 @@
+## @file
+#  The library implements the Extended SAL Library Class for boot service only modules.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeExtendedSalLib
+  MODULE_UNI_FILE                = DxeExtendedSalLib.uni
+  FILE_GUID                      = 8FDED21D-7AB5-4c26-8CF7-20EC4DB9861D
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ExtendedSalLib|DXE_DRIVER UEFI_DRIVER UEFI_APPLICATION 
+  CONSTRUCTOR                    = DxeExtendedSalLibConstruct
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.IPF]
+  ExtendedSalLib.c
+  Ipf/AsmExtendedSalLib.s
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+
+[Protocols]
+  gEfiExtendedSalBootServiceProtocolGuid        ## CONSUMES
+
+[Depex.common.DXE_DRIVER]
+  gEfiExtendedSalBootServiceProtocolGuid
+
diff --git a/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.uni b/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.uni
new file mode 100644
index 000000000000..dbcdce266048
--- /dev/null
+++ b/MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// The library implements the Extended SAL Library Class for boot service only modules.
+//
+// This library implements the Extended SAL Library Class for boot service only modules.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Implements the Extended SAL Library Class for boot service only modules"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library implements the Extended SAL Library Class for boot service only modules."
+
diff --git a/MdePkg/Library/DxeExtendedSalLib/ExtendedSalLib.c b/MdePkg/Library/DxeExtendedSalLib/ExtendedSalLib.c
new file mode 100644
index 000000000000..1741b835ed57
--- /dev/null
+++ b/MdePkg/Library/DxeExtendedSalLib/ExtendedSalLib.c
@@ -0,0 +1,1001 @@
+/** @file
+  The library implements the Extended SAL Library Class for boot service only modules.
+
+  Copyright (c) 2007 - 2012, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalBootService.h>
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/ExtendedSalLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Stores the physical plabel of ESAL entrypoint.
+
+  This assembly function stores the physical plabel of ESAL entrypoint
+  where GetEsalEntryPoint() can easily retrieve.
+
+  @param  EntryPoint  Physical address of ESAL entrypoint
+  @param  Gp          Physical GP of ESAL entrypoint
+
+  @return r8 = EFI_SAL_SUCCESS
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SetEsalPhysicalEntryPoint (
+  IN  UINT64  EntryPoint,
+  IN  UINT64  Gp
+  );
+
+/**
+  Retrieves plabel of ESAL entrypoint.
+
+  This function retrives plabel of ESAL entrypoint stored by
+  SetEsalPhysicalEntryPoint().
+
+  @return r8  = EFI_SAL_SUCCESS
+          r9  = Physical Plabel
+          r10 = Virtual Plabel
+          r11 = PSR
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+GetEsalEntryPoint (
+  VOID
+  );
+
+EXTENDED_SAL_BOOT_SERVICE_PROTOCOL  *mEsalBootService = NULL;
+EFI_PLABEL                          mPlabel;
+
+/**
+  Constructor function to get Extended SAL Boot Service Protocol, and initializes
+  physical plabel of ESAL entrypoint.
+  
+  This function first locates Extended SAL Boot Service Protocol and caches it in global variable.
+  Then it initializes the physical plable of ESAL entrypoint, and stores
+  it where GetEsalEntryPoint() can easily retrieve.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS  Plable of ESAL entrypoint successfully stored.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeExtendedSalLibConstruct (
+  IN EFI_HANDLE           ImageHandle,
+  IN EFI_SYSTEM_TABLE     *SystemTable
+  )
+{
+  EFI_PLABEL  *Plabel;
+  EFI_STATUS  Status;
+
+  //
+  // The protocol contains a function pointer, which is an indirect procedure call.
+  // An indirect procedure call goes through a plabel, and pointer to a function is
+  // a pointer to a plabel. To implement indirect procedure calls that can work in
+  // both physical and virtual mode, two plabels are required (one physical and one
+  // virtual). So lets grap the physical PLABEL for the EsalEntryPoint and store it
+  // away. We cache it in a module global, so we can register the vitrual version.
+  //
+  Status = gBS->LocateProtocol (&gEfiExtendedSalBootServiceProtocolGuid, NULL, (VOID **) &mEsalBootService);
+  ASSERT_EFI_ERROR (Status);
+
+  Plabel              = (EFI_PLABEL *) (UINTN) mEsalBootService->ExtendedSalProc;
+  mPlabel.EntryPoint  = Plabel->EntryPoint;
+  mPlabel.GP          = Plabel->GP;
+  //
+  // Stores the physical plabel of ESAL entrypoint where GetEsalEntryPoint() can easily retrieve.
+  //
+  SetEsalPhysicalEntryPoint (mPlabel.EntryPoint, mPlabel.GP);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Registers function of ESAL class and it's associated global.
+  
+  This function registers function of ESAL class, together with its associated global.
+  It is worker function for RegisterEsalClass().
+  It is only for boot time.
+
+  @param  FunctionId     ID of function to register
+  @param  ClassGuidLo    GUID of ESAL class, lower 64-bits
+  @param  ClassGuidHi    GUID of ESAL class, upper 64-bits
+  @param  Function       Function to register with ClassGuid/FunctionId pair
+  @param  ModuleGlobal   Module global for the function.
+
+  @return Status returned by RegisterExtendedSalProc() of Extended SAL Boot Service Protocol
+
+**/
+EFI_STATUS
+RegisterEsalFunction (
+  IN  UINT64                                    FunctionId,
+  IN  UINT64                                    ClassGuidLo,
+  IN  UINT64                                    ClassGuidHi,
+  IN  SAL_INTERNAL_EXTENDED_SAL_PROC            Function,
+  IN  VOID                                      *ModuleGlobal
+  )
+{
+  return mEsalBootService->RegisterExtendedSalProc (
+                             mEsalBootService,
+                             ClassGuidLo,
+                             ClassGuidHi,
+                             FunctionId,
+                             Function,
+                             ModuleGlobal
+                             );
+}
+
+/**
+  Registers ESAL Class and it's associated global.
+  
+  This function registers one or more Extended SAL services in a given
+  class along with the associated global context.
+  This function is only available prior to ExitBootServices().
+
+  @param  ClassGuidLo          GUID of function class, lower 64-bits
+  @param  ClassGuidHi          GUID of function class, upper 64-bits
+  @param  ModuleGlobal         Module global for the class.
+  @param  ...                  List of Function/FunctionId pairs, ended by NULL
+  
+  @retval EFI_SUCCESS          The Extended SAL services were registered.
+  @retval EFI_UNSUPPORTED      This function was called after ExitBootServices().
+  @retval EFI_OUT_OF_RESOURCES There are not enough resources available to register one or more of the specified services.
+  @retval Other                ClassGuid could not be installed onto a new handle.  
+
+**/
+EFI_STATUS
+EFIAPI
+RegisterEsalClass (
+  IN  CONST UINT64    ClassGuidLo,
+  IN  CONST UINT64    ClassGuidHi,
+  IN  VOID            *ModuleGlobal,  OPTIONAL
+  ...
+  )
+{
+  VA_LIST                         Args;
+  EFI_STATUS                      Status;
+  SAL_INTERNAL_EXTENDED_SAL_PROC  Function;
+  UINT64                          FunctionId;
+  EFI_HANDLE                      NewHandle;
+  EFI_GUID                        ClassGuid;
+
+  VA_START (Args, ModuleGlobal);
+
+  //
+  // Register all functions of the class to register.
+  //
+  Status = EFI_SUCCESS;
+  while (!EFI_ERROR (Status)) {
+    Function = (SAL_INTERNAL_EXTENDED_SAL_PROC) VA_ARG (Args, SAL_INTERNAL_EXTENDED_SAL_PROC);
+    //
+    // NULL serves as the end mark of function list
+    //
+    if (Function == NULL) {
+      break;
+    }
+
+    FunctionId = VA_ARG (Args, UINT64);
+
+    Status = RegisterEsalFunction (FunctionId, ClassGuidLo, ClassGuidHi, Function, ModuleGlobal);
+  }
+
+  VA_END (Args);
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  NewHandle = NULL;
+  *((UINT64 *)(&ClassGuid) + 0) = ClassGuidLo;
+  *((UINT64 *)(&ClassGuid) + 1) = ClassGuidHi;
+  return gBS->InstallProtocolInterface (
+                &NewHandle,
+                &ClassGuid,
+                EFI_NATIVE_INTERFACE,
+                NULL
+                );
+}
+
+/**
+  Calls an Extended SAL Class service that was previously registered with RegisterEsalClass().
+  
+  This function gets the entrypoint of Extended SAL, and calls an Extended SAL Class service
+  that was previously registered with RegisterEsalClass() through this entrypoint.
+
+  @param  ClassGuidLo     GUID of function, lower 64-bits
+  @param  ClassGuidHi     GUID of function, upper 64-bits
+  @param  FunctionId      Function in ClassGuid to call
+  @param  Arg2            Argument 2 ClassGuid/FunctionId defined
+  @param  Arg3            Argument 3 ClassGuid/FunctionId defined
+  @param  Arg4            Argument 4 ClassGuid/FunctionId defined
+  @param  Arg5            Argument 5 ClassGuid/FunctionId defined
+  @param  Arg6            Argument 6 ClassGuid/FunctionId defined
+  @param  Arg7            Argument 7 ClassGuid/FunctionId defined
+  @param  Arg8            Argument 8 ClassGuid/FunctionId defined
+  
+  @retval EFI_SAL_SUCCESS ESAL procedure successfully called.
+  @retval EFI_SAL_ERROR   The address of ExtendedSalProc() can not be correctly
+                          initialized.
+  @retval Other           Status returned from ExtendedSalProc() service of
+                          EXTENDED_SAL_BOOT_SERVICE_PROTOCOL.  
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalCall (
+  IN UINT64  ClassGuidLo,
+  IN UINT64  ClassGuidHi,
+  IN UINT64  FunctionId,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  )
+{
+  SAL_RETURN_REGS       ReturnReg;
+  EXTENDED_SAL_PROC     EsalProc;
+
+  //
+  // Get the entrypoint of Extended SAL
+  //
+  ReturnReg = GetEsalEntryPoint ();
+  if (*(UINT64 *)ReturnReg.r9 == 0 && *(UINT64 *)(ReturnReg.r9 + 8) == 0) {
+    //
+    // The ESAL Entry Point could not be initialized
+    //
+    ReturnReg.Status = EFI_SAL_ERROR;
+    return ReturnReg;
+  }
+
+  //
+  // Test PSR.it which is BIT36
+  //
+  if ((ReturnReg.r11 & BIT36) != 0) {
+    //
+    // Virtual mode plabel to entry point
+    //
+    EsalProc = (EXTENDED_SAL_PROC) ReturnReg.r10;
+  } else {
+    //
+    // Physical mode plabel to entry point
+    //
+    EsalProc = (EXTENDED_SAL_PROC) ReturnReg.r9;
+  }
+
+  return EsalProc (
+           ClassGuidLo,
+           ClassGuidHi,
+           FunctionId,
+           Arg2,
+           Arg3,
+           Arg4,
+           Arg5,
+           Arg6,
+           Arg7,
+           Arg8
+           );
+}
+
+/**
+  Wrapper for the EsalStallFunctionId service of Extended SAL Stall Services Class.
+  
+  This function is a wrapper for the EsalStallFunctionId service of Extended SAL
+  Stall Services Class. See EsalStallFunctionId of Extended SAL Specification.
+
+  @param  Microseconds                  The number of microseconds to delay.
+
+  @retval EFI_SAL_SUCCESS               Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT      Invalid argument.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR Virtual address not registered
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalStall (
+  IN UINTN  Microseconds
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_LO, 
+           EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_HI, 
+           StallFunctionId, 
+           Microseconds, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalSetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress                If TRUE, then PalEntryPoint is a physical address.
+                                         If FALSE, then PalEntryPoint is a virtual address.
+  @param  PalEntryPoint                  The PAL Entry Point being set.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was set.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress,
+  IN UINT64   PalEntryPoint
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO, 
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+           SetNewPalEntryFunctionId, 
+           PhysicalAddress, 
+           PalEntryPoint, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalGetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress                If TRUE, then PalEntryPoint is a physical address.
+                                         If FALSE, then PalEntryPoint is a virtual address.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was retrieved and returned in
+                                         SAL_RETURN_REGS.r9.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+  @return r9                             PAL entry point retrieved.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+           GetNewPalEntryFunctionId, 
+           PhysicalAddress, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalGetStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalGetStateBufferFunctionId of Extended SAL Specification.
+
+  @param  McaType               See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+  @param  McaBuffer             A pointer to the base address of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r9.
+  @param  BufferSize            A pointer to the size, in bytes, of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r10.
+
+  @retval EFI_SAL_SUCCESS       The memory buffer to store error records was returned in r9 and r10.
+  @retval EFI_OUT_OF_RESOURCES  A memory buffer for string error records in not available
+  @return r9                    Base address of the returned buffer
+  @return r10                   Size of the returned buffer in bytes
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetStateBuffer (
+  IN  UINT64  McaType,
+  OUT UINT8   **McaBuffer,
+  OUT UINTN   *BufferSize
+  )
+{
+  SAL_RETURN_REGS Regs;
+
+  Regs = EsalCall (
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetStateBufferFunctionId, 
+           McaType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+
+  *McaBuffer  = (UINT8 *) Regs.r9;
+  *BufferSize = Regs.r10;
+
+  return Regs;
+}
+
+/**
+  Wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalSaveStateBufferFunctionId of Extended SAL Specification.
+
+  @param  McaType      See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+
+  @retval EFI_SUCCESS  The memory buffer containing the error record was written to nonvolatile storage.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSaveStateBuffer (
+  IN  UINT64  McaType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+           EsalSaveStateBufferFunctionId, 
+           McaType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetVectorsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetVectorsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetVectorsFunctionId of Extended SAL Specification.
+
+  @param  VectorType               The vector type to retrieve.
+                                   0 - MCA, 1 - BSP INIT, 2 - BOOT_RENDEZ, 3 - AP INIT.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_SET_VECTORS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetVectors (
+  IN  UINT64  VectorType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetVectorsFunctionId, 
+           VectorType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+
+  @param  ParamInfoType            The parameter type to retrieve.
+                                   1 - rendezvous interrupt
+                                   2 - wake up
+                                   3 - Corrected Platform Error Vector.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetParams (
+  IN  UINT64  ParamInfoType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalMcGetParamsFunctionId, 
+           ParamInfoType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetMcParams (
+  VOID
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalMcGetMcParamsFunctionId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetMcCheckinFlagsFunctionId of Extended SAL Specification.
+
+  @param  CpuIndex         The index of the CPU of set of enabled CPUs to check.
+
+  @retval EFI_SAL_SUCCESS  The checkin status of the requested CPU was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMcCheckinFlags (
+  IN  UINT64  CpuIndex
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetMcCheckinFlagsFunctionId, 
+           CpuIndex, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalAddCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalAddCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalAddCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId                 The Global ID for the CPU being added.
+  @param  Enabled                     The enable flag for the CPU being added.
+                                      TRUE means the CPU is enabled.
+                                      FALSE means the CPU is disabled.
+  @param  PalCompatibility            The PAL Compatibility value for the CPU being added.
+
+  @retval EFI_SAL_SUCCESS             The CPU was added to the database.
+  @retval EFI_SAL_NOT_ENOUGH_SCRATCH  There are not enough resource available to add the CPU.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalAddCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           AddCpuDataFunctionId, 
+           CpuGlobalId, 
+           Enabled, 
+           PalCompatibility, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalRemoveCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being removed.
+
+  @retval EFI_SAL_SUCCESS         The CPU was removed from the database.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalRemoveCpuData (
+  IN UINT64  CpuGlobalId
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           RemoveCpuDataFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalModifyCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being modified.
+  @param  Enabled                 The enable flag for the CPU being modified.
+                                  TRUE means the CPU is enabled.
+                                  FALSE means the CPU is disabled.
+  @param  PalCompatibility        The PAL Compatibility value for the CPU being modified.
+
+  @retval EFI_SAL_SUCCESS         The CPU database was updated.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalModifyCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           ModifyCpuDataFunctionId, 
+           CpuGlobalId, 
+           Enabled, 
+           PalCompatibility, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIdFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId             The Global ID for the CPU being looked up.
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataById (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetCpuDataByIDFunctionId, 
+           CpuGlobalId, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIndexFunctionId of Extended SAL Specification.
+
+  @param  Index                   The Global ID for the CPU being modified.
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataByIndex (
+  IN UINT64   Index,
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetCpuDataByIndexFunctionId, 
+           Index, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalWhoAmIFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalWhoAmIFunctionId service of Extended SAL
+  MP Services Class. See EsalWhoAmIFunctionId of Extended SAL Specification.
+
+  @param  IndexByEnabledCpu       If TRUE, then the index of set of enabled CPUs of database is returned.
+                                  If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The Global ID for the calling CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The calling CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalWhoAmI (
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           CurrentProcInfoFunctionId, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalNumProcessors service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalNumProcessors service of Extended SAL
+  MP Services Class. See EsalNumProcessors of Extended SAL Specification.
+
+  @retval EFI_SAL_SUCCESS    The information on the number of CPUs in the platform
+                             was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalNumProcessors (
+  VOID
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           NumProcessorsFunctionId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalSetMinStateFnctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalSetMinStateFnctionId service of Extended SAL
+  MP Services Class. See EsalSetMinStateFnctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId              The Global ID for the CPU whose MINSTATE pointer is being set.
+  @param  MinStatePointer          The physical address of the MINSTATE buffer for the CPU
+                                   specified by CpuGlobalId.
+
+  @retval EFI_SAL_SUCCESS          The MINSTATE pointer was set for the specified CPU.
+  @retval EFI_SAL_NO_INFORMATION   The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetMinState (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  MinStatePointer
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           SetMinStateFunctionId, 
+           CpuGlobalId, 
+           MinStatePointer, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetMinStateFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetMinStateFunctionId service of Extended SAL
+  MP Services Class. See EsalGetMinStateFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId            The Global ID for the CPU whose MINSTATE pointer is being retrieved.
+
+  @retval EFI_SAL_SUCCESS        The MINSTATE pointer for the specified CPU was retrieved.
+  @retval EFI_SAL_NO_INFORMATION The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMinState (
+  IN UINT64  CpuGlobalId
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetMinStateFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcsGetStateInfoFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId               The Global ID for the CPU whose MCA state buffer is being retrieved.
+  @param  StateBufferPointer        A pointer to the returned MCA state buffer.
+  @param  RequiredStateBufferSize   A pointer to the size, in bytes, of the returned MCA state buffer.
+
+  @retval EFI_SUCCESS               MINSTATE successfully got and size calculated.
+  @retval EFI_SAL_NO_INFORMATION    Fail to get MINSTATE.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaGetStateInfo (
+  IN  UINT64                CpuGlobalId,
+  OUT EFI_PHYSICAL_ADDRESS  *StateBufferPointer,
+  OUT UINT64                *RequiredStateBufferSize
+  )
+{
+  SAL_RETURN_REGS  Regs;
+
+  Regs = EsalCall (
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_HI,
+           McaGetStateInfoFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+
+  *StateBufferPointer      = (EFI_PHYSICAL_ADDRESS) Regs.r9;
+  *RequiredStateBufferSize = (UINT64) Regs.r10;
+
+  return Regs;
+}
+
+/**
+  Wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcaRegisterCpuFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId              The Global ID for the CPU whose MCA state buffer is being set.
+  @param  StateBufferPointer       A pointer to the MCA state buffer.
+
+  @retval EFI_SAL_NO_INFORMATION   Cannot get the processor info with the CpuId
+  @retval EFI_SUCCESS              Save the processor's state info successfully
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaRegisterCpu (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  StateBufferPointer
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_HI,
+           McaRegisterCpuFunctionId, 
+           CpuGlobalId, 
+           StateBufferPointer, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
diff --git a/MdePkg/Library/DxeExtendedSalLib/Ipf/AsmExtendedSalLib.s b/MdePkg/Library/DxeExtendedSalLib/Ipf/AsmExtendedSalLib.s
new file mode 100644
index 000000000000..1ae3cd6e4c52
--- /dev/null
+++ b/MdePkg/Library/DxeExtendedSalLib/Ipf/AsmExtendedSalLib.s
@@ -0,0 +1,97 @@
+/// @file
+///  Assembly procedures to get and set ESAL entry point.
+///
+/// Copyright (c) 2006 - 2011, 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.
+///
+
+.auto
+.text
+
+#include  "IpfMacro.i"
+
+//
+// Exports
+//
+ASM_GLOBAL GetEsalEntryPoint
+
+//-----------------------------------------------------------------------------
+//++
+// GetEsalEntryPoint
+//
+// Return Esal global and PSR register.
+//
+// On Entry :
+//
+//
+// Return Value:
+//        r8  = EFI_SAL_SUCCESS
+//        r9  = Physical Plabel
+//        r10 = Virtual Plabel
+//        r11 = psr
+// 
+// As per static calling conventions. 
+// 
+//--
+//---------------------------------------------------------------------------
+PROCEDURE_ENTRY (GetEsalEntryPoint)
+
+      NESTED_SETUP (0,8,0,0)
+
+EsalCalcStart:
+      mov   r8  = ip;;
+      add   r8  = (EsalEntryPoint - EsalCalcStart), r8;;
+      mov   r9  = r8;;
+      add   r10 = 0x10, r8;;
+      mov   r11 = psr;;
+      mov   r8  = r0;;
+
+      NESTED_RETURN
+
+PROCEDURE_EXIT (GetEsalEntryPoint)
+
+//-----------------------------------------------------------------------------
+//++
+// SetEsalPhysicalEntryPoint
+//
+// Set the dispatcher entry point
+//
+// On Entry:
+//  in0 = Physical address of Esal Dispatcher
+//  in1 = Physical GP
+//
+// Return Value: 
+//   r8 = EFI_SAL_SUCCESS
+// 
+// As per static calling conventions. 
+// 
+//--
+//---------------------------------------------------------------------------
+PROCEDURE_ENTRY (SetEsalPhysicalEntryPoint)
+
+      NESTED_SETUP (2,8,0,0)
+
+EsalCalcStart1:
+      mov   r8   = ip;;
+      add   r8   = (EsalEntryPoint - EsalCalcStart1), r8;;
+      st8   [r8] = in0;;
+      add   r8   = 0x08, r8;;
+      st8   [r8] = in1;;
+      mov   r8   = r0;;
+
+      NESTED_RETURN
+
+PROCEDURE_EXIT (SetEsalPhysicalEntryPoint)
+
+.align 32
+EsalEntryPoint: 
+    data8 0   // Physical Entry
+    data8 0   //         GP
+    data8 0   // Virtual Entry
+    data8 0   //         GP
diff --git a/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.c b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.c
new file mode 100644
index 000000000000..c07859a90762
--- /dev/null
+++ b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.c
@@ -0,0 +1,454 @@
+/** @file
+  Provide generic extract guided section functions for Dxe phase.
+
+  Copyright (c) 2007 - 2012, 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 <PiDxe.h>
+
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/ExtractGuidedSectionLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+#define EXTRACT_HANDLER_TABLE_SIZE   0x10
+
+UINT32               mNumberOfExtractHandler = 0;
+UINT32               mMaxNumberOfExtractHandler = 0;
+
+GUID                 *mExtractHandlerGuidTable = NULL;
+EXTRACT_GUIDED_SECTION_DECODE_HANDLER   *mExtractDecodeHandlerTable = NULL;
+EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *mExtractGetInfoHandlerTable = NULL;
+
+/**
+  Reallocates more global memory to store the registered guid and Handler list.
+
+  @retval  RETURN_SUCCESS            Reallocated more global memory space to store guid and function tables.
+  @retval  RETURN_OUT_OF_RESOURCES   Not enough memory to allocate.
+**/
+RETURN_STATUS
+EFIAPI
+ReallocateExtractHandlerTable (
+  )
+{ 
+  //
+  // Reallocate memory for GuidTable
+  //
+  mExtractHandlerGuidTable = ReallocatePool (
+                               mMaxNumberOfExtractHandler * sizeof (GUID), 
+                               (mMaxNumberOfExtractHandler + EXTRACT_HANDLER_TABLE_SIZE) * sizeof (GUID), 
+                               mExtractHandlerGuidTable
+                             );
+
+  if (mExtractHandlerGuidTable == NULL) {
+    goto Done;
+  }
+
+  //
+  // Reallocate memory for Decode handler Table
+  //
+  mExtractDecodeHandlerTable = ReallocatePool (
+                               mMaxNumberOfExtractHandler * sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER), 
+                               (mMaxNumberOfExtractHandler + EXTRACT_HANDLER_TABLE_SIZE) * sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER), 
+                               mExtractDecodeHandlerTable
+                             );
+
+  if (mExtractDecodeHandlerTable == NULL) {
+    goto Done;
+  }
+
+  //
+  // Reallocate memory for GetInfo handler Table
+  //
+  mExtractGetInfoHandlerTable = ReallocatePool (
+                               mMaxNumberOfExtractHandler * sizeof (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER), 
+                               (mMaxNumberOfExtractHandler + EXTRACT_HANDLER_TABLE_SIZE) * sizeof (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER), 
+                               mExtractGetInfoHandlerTable
+                             );
+
+  if (mExtractGetInfoHandlerTable == NULL) {
+    goto Done;
+  }
+  
+  //
+  // Increase max handler number
+  //
+  mMaxNumberOfExtractHandler = mMaxNumberOfExtractHandler + EXTRACT_HANDLER_TABLE_SIZE;
+  return RETURN_SUCCESS;
+
+Done:
+  if (mExtractHandlerGuidTable != NULL) {
+    FreePool (mExtractHandlerGuidTable);
+  }
+  if (mExtractDecodeHandlerTable != NULL) {
+    FreePool (mExtractDecodeHandlerTable);
+  }
+  if (mExtractGetInfoHandlerTable != NULL) {
+    FreePool (mExtractGetInfoHandlerTable);
+  }
+  
+  return RETURN_OUT_OF_RESOURCES;
+}
+/**
+  Constructor allocates the global memory to store the registered guid and Handler list.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval  RETURN_SUCCESS            Allocated the global memory space to store guid and function tables.
+  @retval  RETURN_OUT_OF_RESOURCES   Not enough memory to allocate.
+**/
+RETURN_STATUS
+EFIAPI
+DxeExtractGuidedSectionLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  return ReallocateExtractHandlerTable ();
+}
+
+/**
+  Retrieve the list GUIDs that have been registered through ExtractGuidedSectionRegisterHandlers().
+
+  Sets ExtractHandlerGuidTable so it points at a callee allocated array of registered GUIDs.
+  The total number of GUIDs in the array are returned. Since the array of GUIDs is callee allocated
+  and caller must treat this array of GUIDs as read-only data. 
+  If ExtractHandlerGuidTable is NULL, then ASSERT().
+
+  @param[out]  ExtractHandlerGuidTable  A pointer to the array of GUIDs that have been registered through
+                                        ExtractGuidedSectionRegisterHandlers().
+
+  @return The number of the supported extract guided Handler.
+
+**/
+UINTN
+EFIAPI
+ExtractGuidedSectionGetGuidList (
+  OUT  GUID  **ExtractHandlerGuidTable
+  )
+{
+  ASSERT (ExtractHandlerGuidTable != NULL);
+
+  *ExtractHandlerGuidTable = mExtractHandlerGuidTable;
+  return mNumberOfExtractHandler;
+}
+
+/**
+  Registers handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and EXTRACT_GUIDED_SECTION_DECODE_HANDLER
+  for a specific GUID section type.
+
+  Registers the handlers specified by GetInfoHandler and DecodeHandler with the GUID specified by SectionGuid.
+  If the GUID value specified by SectionGuid has already been registered, then return RETURN_ALREADY_STARTED.
+  If there are not enough resources available to register the handlers  then RETURN_OUT_OF_RESOURCES is returned.
+  
+  If SectionGuid is NULL, then ASSERT().
+  If GetInfoHandler is NULL, then ASSERT().
+  If DecodeHandler is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the the handlers
+                             of the GUIDed section type being registered.
+  @param[in]  GetInfoHandler The pointer to a function that examines a GUIDed section and returns the
+                             size of the decoded buffer and the size of an optional scratch buffer
+                             required to actually decode the data in a GUIDed section.
+  @param[in]  DecodeHandler  The pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. 
+
+  @retval  RETURN_SUCCESS           The handlers were registered.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to register the handlers.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionRegisterHandlers (
+  IN CONST  GUID                                     *SectionGuid,
+  IN        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  GetInfoHandler,
+  IN        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    DecodeHandler
+  )
+{
+  UINT32 Index;
+  VOID   *GuidData;
+
+  //
+  // Check input parameter.
+  //
+  ASSERT (SectionGuid != NULL);
+  ASSERT (GetInfoHandler != NULL);
+  ASSERT (DecodeHandler != NULL);
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  for (Index = 0; Index < mNumberOfExtractHandler; Index ++) {
+    if (CompareGuid (&mExtractHandlerGuidTable[Index], SectionGuid)) {
+      //
+      // If the guided handler has been registered before, only update its handler.
+      //
+      mExtractDecodeHandlerTable [Index] = DecodeHandler;
+      mExtractGetInfoHandlerTable [Index] = GetInfoHandler;
+      return RETURN_SUCCESS;
+    }
+  }
+  
+  //
+  // Check the global table is enough to contain new Handler.
+  //
+  if (mNumberOfExtractHandler >= mMaxNumberOfExtractHandler) {
+    if (ReallocateExtractHandlerTable () != RETURN_SUCCESS) {
+      return RETURN_OUT_OF_RESOURCES;
+    }
+  }
+  
+  //
+  // Register new Handler and guid value.
+  //
+  CopyGuid (&mExtractHandlerGuidTable [mNumberOfExtractHandler], SectionGuid);
+  mExtractDecodeHandlerTable [mNumberOfExtractHandler] = DecodeHandler;
+  mExtractGetInfoHandlerTable [mNumberOfExtractHandler++] = GetInfoHandler;
+
+  //
+  // Install the Guided Section GUID configuration table to record the GUID itself.
+  // Then the content of the configuration table buffer will be the same as the GUID value itself.
+  //
+  GuidData = AllocateCopyPool (sizeof (GUID), (VOID *) SectionGuid);
+  if (GuidData != NULL) {
+    gBS->InstallConfigurationTable ((EFI_GUID *) SectionGuid, GuidData);
+  }
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieves a GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to retrieve and return the size of the decoded buffer and the size of an
+  optional scratch buffer required to actually decode the data in a GUIDed section.
+
+  Examines a GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler 
+  of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to retrieve the OututBufferSize, ScratchSize, and Attributes values. The return status from the handler of
+  type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER is returned.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBufferSize is NULL, then ASSERT().
+  If ScratchBufferSize is NULL, then ASSERT().
+  If SectionAttribute is NULL, then ASSERT().
+
+  @param[in]  InputSection       A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBufferSize   A pointer to the size, in bytes, of an output buffer required if the buffer
+                                 specified by InputSection were decoded.
+  @param[out] ScratchBufferSize  A pointer to the size, in bytes, required as scratch space if the buffer specified by
+                                 InputSection were decoded.
+  @param[out] SectionAttribute   A pointer to the attributes of the GUIDed section.  See the Attributes field of
+                                 EFI_GUID_DEFINED_SECTION in the PI Specification.
+
+  @retval  RETURN_SUCCESS      Successfully obtained the required information.
+  @retval  RETURN_UNSUPPORTED  The GUID from the section specified by InputSection does not match any of
+                               the GUIDs registered with ExtractGuidedSectionRegisterHandlers().
+  @retval  Others              The return status from the handler associated with the GUID retrieved from
+                               the section specified by InputSection.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetInfo (
+  IN  CONST VOID    *InputSection,
+  OUT       UINT32  *OutputBufferSize,
+  OUT       UINT32  *ScratchBufferSize,
+  OUT       UINT16  *SectionAttribute   
+  )
+{
+  UINT32 Index;
+  EFI_GUID *SectionDefinitionGuid;
+
+  ASSERT (InputSection != NULL);  
+  ASSERT (OutputBufferSize != NULL);
+  ASSERT (ScratchBufferSize != NULL);
+  ASSERT (SectionAttribute != NULL);
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+ 
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  for (Index = 0; Index < mNumberOfExtractHandler; Index ++) {
+    if (CompareGuid (&mExtractHandlerGuidTable[Index], SectionDefinitionGuid)) {
+      //
+      // Call the match handler to getinfo for the input section data.
+      //
+      return mExtractGetInfoHandlerTable [Index] (
+                InputSection,
+                OutputBufferSize,
+                ScratchBufferSize,
+                SectionAttribute
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves the GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to decode the data in a GUIDed section and return the result in a caller
+  allocated output buffer.
+
+  Decodes the GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler
+  of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to decode InputSection into the buffer specified by OutputBuffer and the authentication status of this
+  decode operation is returned in AuthenticationStatus.  If the decoded buffer is identical to the data in InputSection,
+  then OutputBuffer is set to point at the data in InputSection.  Otherwise, the decoded data will be placed in caller
+  allocated buffer specified by OutputBuffer.    This function is responsible for computing the  EFI_AUTH_STATUS_PLATFORM_OVERRIDE
+  bit of in AuthenticationStatus.  The return status from the handler of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER is returned. 
+   
+  If InputSection is NULL, then ASSERT().
+  If OutputBuffer is NULL, then ASSERT().
+  If ScratchBuffer is NULL and this decode operation requires a scratch buffer, then ASSERT().
+  If AuthenticationStatus is NULL, then ASSERT().  
+
+  @param[in]  InputSection   A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBuffer   A pointer to a buffer that contains the result of a decode operation. 
+  @param[in]  ScratchBuffer  A caller allocated buffer that may be required by this function as a scratch buffer to perform the decode operation. 
+  @param[out] AuthenticationStatus 
+                             A pointer to the authentication status of the decoded output buffer. See the definition
+                             of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI section of the PI
+                             Specification.
+
+  @retval  RETURN_SUCCESS           The buffer specified by InputSection was decoded.
+  @retval  RETURN_UNSUPPORTED       The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER The section specified by InputSection can not be decoded.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionDecode (
+  IN  CONST VOID    *InputSection,
+  OUT       VOID    **OutputBuffer,
+  IN        VOID    *ScratchBuffer,        OPTIONAL
+  OUT       UINT32  *AuthenticationStatus  
+  )
+{
+  UINT32 Index;
+  EFI_GUID *SectionDefinitionGuid;
+  
+  //
+  // Check the input parameters
+  //
+  ASSERT (InputSection != NULL);
+  ASSERT (OutputBuffer != NULL);
+  ASSERT (AuthenticationStatus != NULL);
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+
+  //
+  // Search the match registered extract handler for the input guided section.
+  //
+  for (Index = 0; Index < mNumberOfExtractHandler; Index ++) {
+    if (CompareGuid (&mExtractHandlerGuidTable[Index], SectionDefinitionGuid)) {
+      //
+      // Call the match handler to extract raw data for the input section data.
+      //
+      return mExtractDecodeHandlerTable [Index] (
+                InputSection,
+                OutputBuffer,
+                ScratchBuffer,
+                AuthenticationStatus
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and 
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER for a specific GUID section type.
+  
+  Retrieves the handlers associated with SectionGuid and returns them in 
+  GetInfoHandler and DecodeHandler.
+
+  If the GUID value specified by SectionGuid has not been registered, then 
+  return RETURN_NOT_FOUND.
+  
+  If SectionGuid is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the handlersof the GUIDed 
+                             section type being retrieved.
+  @param[out] GetInfoHandler Pointer to a function that examines a GUIDed section and returns 
+                             the size of the decoded buffer and the size of an optional scratch 
+                             buffer required to actually decode the data in a GUIDed section.  
+                             This is an optional parameter that may be NULL. If it is NULL, then 
+                             the previously registered handler is not returned.
+  @param[out] DecodeHandler  Pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. This is an optional parameter that may be NULL.
+                             If it is NULL, then the previously registered handler is not returned.
+
+  @retval  RETURN_SUCCESS     The handlers were retrieved.
+  @retval  RETURN_NOT_FOUND   No handlers have been registered with the specified GUID.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetHandlers (
+  IN CONST   GUID                                     *SectionGuid,
+  OUT        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  *GetInfoHandler,  OPTIONAL
+  OUT        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    *DecodeHandler    OPTIONAL
+  )
+{
+  UINT32 Index; 
+
+  //
+  // Check input parameter.
+  //
+  ASSERT (SectionGuid != NULL);
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  for (Index = 0; Index < mNumberOfExtractHandler; Index ++) {
+    if (CompareGuid (&mExtractHandlerGuidTable[Index], SectionGuid)) {
+      
+      //
+      // If the guided handler has been registered before, then return the registered handlers.
+      //
+      if (GetInfoHandler != NULL) {
+        *GetInfoHandler = mExtractGetInfoHandlerTable[Index];
+      }
+      if (DecodeHandler != NULL) {
+        *DecodeHandler = mExtractDecodeHandlerTable[Index];
+      }
+      return RETURN_SUCCESS;
+    }
+  }
+  return RETURN_NOT_FOUND;
+}
diff --git a/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
new file mode 100644
index 000000000000..f38ac252b81a
--- /dev/null
+++ b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
@@ -0,0 +1,47 @@
+## @file
+# Instance of ExtractGuidedSection Library for DXE phase.
+#
+# This library provides generic extract guided section functions for DXE module.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeExtractGuidedSectionLib
+  MODULE_UNI_FILE                = DxeExtractGuidedSectionLib.uni
+  FILE_GUID                      = f773469b-e265-4b0c-b0a6-2f971fbfe72b
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ExtractGuidedSectionLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+  CONSTRUCTOR                    = DxeExtractGuidedSectionLibConstructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DxeExtractGuidedSectionLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  MemoryAllocationLib
+  BaseMemoryLib
+  DebugLib
+  UefiBootServicesTableLib
+
diff --git a/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.uni b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.uni
new file mode 100644
index 000000000000..c37815a382c0
--- /dev/null
+++ b/MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of ExtractGuidedSection Library for DXE phase.
+//
+// This library provides generic extract guided section functions for DXE module.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of ExtractGuidedSection Library for DXE phase"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library provides generic extract guided section functions for a DXE module."
+
diff --git a/MdePkg/Library/DxeHobLib/DxeHobLib.inf b/MdePkg/Library/DxeHobLib/DxeHobLib.inf
new file mode 100644
index 000000000000..98aeb7fbc057
--- /dev/null
+++ b/MdePkg/Library/DxeHobLib/DxeHobLib.inf
@@ -0,0 +1,48 @@
+## @file
+# Instance of HOB Library using HOB list from EFI Configuration Table.
+#
+# HOB Library implementation that retrieves the HOB List
+#  from the System Configuration Table in the EFI System Table.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeHobLib
+  MODULE_UNI_FILE                = DxeHobLib.uni
+  FILE_GUID                      = f12b59c9-76d0-4661-ad7c-f04d1bef0558
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = HobLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER SMM_CORE DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+  CONSTRUCTOR                    = HobLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  HobLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  DebugLib
+  UefiLib
+    
+[Guids]
+  gEfiHobListGuid                               ## CONSUMES  ## SystemTable
+
diff --git a/MdePkg/Library/DxeHobLib/DxeHobLib.uni b/MdePkg/Library/DxeHobLib/DxeHobLib.uni
new file mode 100644
index 000000000000..a7592fb065d4
--- /dev/null
+++ b/MdePkg/Library/DxeHobLib/DxeHobLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of HOB Library using HOB list from EFI Configuration Table.
+//
+// HOB Library implementation that retrieves the HOB List
+// from the System Configuration Table in the EFI System Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of HOB Library using HOB list from EFI Configuration Table"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The HOB Library implementation that retrieves the HOB List from the System Configuration Table in the EFI System Table."
+
diff --git a/MdePkg/Library/DxeHobLib/HobLib.c b/MdePkg/Library/DxeHobLib/HobLib.c
new file mode 100644
index 000000000000..85f6bdfc30d1
--- /dev/null
+++ b/MdePkg/Library/DxeHobLib/HobLib.c
@@ -0,0 +1,603 @@
+/** @file
+  HOB Library implemenation for Dxe Phase.
+
+Copyright (c) 2006 - 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 <PiDxe.h>
+
+#include <Guid/HobList.h>
+
+#include <Library/HobLib.h>
+#include <Library/UefiLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+
+VOID  *mHobList = NULL;
+
+/**
+  Returns the pointer to the HOB list.
+
+  This function returns the pointer to first HOB in the list.
+  For PEI phase, the PEI service GetHobList() can be used to retrieve the pointer 
+  to the HOB list.  For the DXE phase, the HOB list pointer can be retrieved through
+  the EFI System Table by looking up theHOB list GUID in the System Configuration Table.
+  Since the System Configuration Table does not exist that the time the DXE Core is 
+  launched, the DXE Core uses a global variable from the DXE Core Entry Point Library 
+  to manage the pointer to the HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  This function also caches the pointer to the HOB list retrieved.
+
+  @return The pointer to the HOB list.
+
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  )
+{
+  EFI_STATUS  Status;
+
+  if (mHobList == NULL) {
+    Status = EfiGetSystemConfigurationTable (&gEfiHobListGuid, &mHobList);
+    ASSERT_EFI_ERROR (Status);
+    ASSERT (mHobList != NULL);
+  }
+  return mHobList;
+}
+
+/**
+  The constructor function caches the pointer to HOB list by calling GetHobList()
+  and will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor successfully gets HobList.
+
+**/
+EFI_STATUS
+EFIAPI
+HobLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  GetHobList ();
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+
+  This function searches the first instance of a HOB type from the starting HOB pointer. 
+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If HobStart is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+  @param  HobStart      The starting HOB pointer to search from.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  IN UINT16                 Type,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  Hob;
+
+  ASSERT (HobStart != NULL);
+   
+  Hob.Raw = (UINT8 *) HobStart;
+  //
+  // Parse the HOB list until end of list or matching type is found.
+  //
+  while (!END_OF_HOB_LIST (Hob)) {
+    if (Hob.Header->HobType == Type) {
+      return Hob.Raw;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+  }
+  return NULL;
+}
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+
+  This function searches the first instance of a HOB type among the whole HOB list. 
+  If there does not exist such HOB type in the HOB list, it will return NULL. 
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  IN UINT16                 Type
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextHob (Type, HobList);
+}
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+  
+  This function searches the first instance of a HOB from the starting HOB pointer. 
+  Such HOB should satisfy two conditions: 
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If Guid is NULL, then ASSERT().
+  If HobStart is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+  @param  HobStart      A pointer to a Guid.
+
+  @return The next instance of the matched GUID HOB from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  IN CONST EFI_GUID         *Guid,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  GuidHob;
+
+  GuidHob.Raw = (UINT8 *) HobStart;
+  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
+    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
+      break;
+    }
+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
+  }
+  return GuidHob.Raw;
+}
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+  
+  This function searches the first instance of a HOB among the whole HOB list. 
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+
+  @return The first instance of the matched GUID HOB among the whole HOB list.
+
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  IN CONST EFI_GUID         *Guid
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextGuidHob (Guid, HobList);
+}
+
+/**
+  Get the system boot mode from the HOB list.
+
+  This function returns the system boot mode information from the 
+  PHIT HOB in HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+  
+  @param  VOID
+
+  @return The Boot Mode.
+
+**/
+EFI_BOOT_MODE
+EFIAPI
+GetBootModeHob (
+  VOID
+  )
+{
+  EFI_HOB_HANDOFF_INFO_TABLE    *HandOffHob;
+
+  HandOffHob = (EFI_HOB_HANDOFF_INFO_TABLE *) GetHobList ();
+
+  return  HandOffHob->BootMode;
+}
+
+/**
+  Builds a HOB for a loaded PE32 module.
+
+  This function builds a HOB for a loaded PE32 module.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If ModuleName is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ModuleName              The GUID File Name of the module.
+  @param  MemoryAllocationModule  The 64 bit physical address of the module.
+  @param  ModuleLength            The length of the module in bytes.
+  @param  EntryPoint              The 64 bit physical address of the module entry point.
+
+**/
+VOID
+EFIAPI
+BuildModuleHob (
+  IN CONST EFI_GUID         *ModuleName,
+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
+  IN UINT64                 ModuleLength,
+  IN EFI_PHYSICAL_ADDRESS   EntryPoint
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory with Owner GUID.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+  @param  OwnerGUID           GUID for the owner of this resource.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorWithOwnerHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes,
+  IN EFI_GUID                     *OwnerGUID
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification and returns 
+  the start address of GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification 
+  and returns the start address of GUID HOB data so that caller can fill the customized data. 
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidHob (
+  IN CONST EFI_GUID              *Guid,
+  IN UINTN                       DataLength
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+  return NULL;
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB 
+  data field, and returns the start address of the GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification and copies the input
+  data to the HOB data field and returns the start address of the GUID HOB data.  It can only be 
+  invoked during PEI phase; for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.  
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If Data is NULL and DataLength > 0, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  Data          The data to be copied into the data field of the GUID HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidDataHob (
+  IN CONST EFI_GUID              *Guid,
+  IN VOID                        *Data,
+  IN UINTN                       DataLength
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+  return NULL;
+}
+
+/**
+  Builds a Firmware Volume HOB.
+
+  This function builds a Firmware Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildFvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a EFI_HOB_TYPE_FV2 HOB.
+
+  This function builds a EFI_HOB_TYPE_FV2 HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+  @param  FvName        The name of the Firmware Volume.
+  @param  FileName      The name of the file.
+  
+**/
+VOID
+EFIAPI
+BuildFv2Hob (
+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN          UINT64                      Length,
+  IN CONST    EFI_GUID                    *FvName,
+  IN CONST    EFI_GUID                    *FileName
+  )
+{
+  ASSERT (FALSE);
+}
+
+
+/**
+  Builds a Capsule Volume HOB.
+
+  This function builds a Capsule Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If the platform does not support Capsule Volume HOBs, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The base address of the Capsule Volume.
+  @param  Length        The size of the Capsule Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildCvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the CPU.
+
+  This function builds a HOB for the CPU.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
+
+**/
+VOID
+EFIAPI
+BuildCpuHob (
+  IN UINT8                       SizeOfMemorySpace,
+  IN UINT8                       SizeOfIoSpace
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the Stack.
+
+  This function builds a HOB for the stack.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the Stack.
+  @param  Length        The length of the stack in bytes.
+
+**/
+VOID
+EFIAPI
+BuildStackHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the BSP store.
+
+  This function builds a HOB for BSP store.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the BSP.
+  @param  Length        The length of the BSP store in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildBspStoreHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
+
+/**
+  Builds a HOB for the memory allocation.
+
+  This function builds a HOB for the memory allocation.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the memory.
+  @param  Length        The length of the memory allocation in bytes.
+  @param  MemoryType    Type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildMemoryAllocationHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  //
+  // PEI HOB is read only for DXE phase
+  //
+  ASSERT (FALSE);
+}
diff --git a/MdePkg/Library/DxeHstiLib/DxeHstiLib.inf b/MdePkg/Library/DxeHstiLib/DxeHstiLib.inf
new file mode 100644
index 000000000000..52ce6884950d
--- /dev/null
+++ b/MdePkg/Library/DxeHstiLib/DxeHstiLib.inf
@@ -0,0 +1,48 @@
+## @file
+# DXE instance of Hsti Library.
+#
+# Copyright (c) 2015, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeHstiLib
+  MODULE_UNI_FILE                = DxeHstiLib.uni
+  FILE_GUID                      = 7DE1C620-F587-4116-A36D-40F3467B9A0C
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = HstiLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+
+[Sources]
+  HstiAip.c
+  HstiDxe.c
+  HstiDxe.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  BaseMemoryLib
+  MemoryAllocationLib
+  DebugLib
+  UefiBootServicesTableLib
+
+[Guids]
+## SOMETIMES_PRODUCES ## GUID
+## SOMETIMES_CONSUMES ## GUID
+  gAdapterInfoPlatformSecurityGuid
+
+[Protocols]
+## SOMETIMES_PRODUCES
+## SOMETIMES_CONSUMES
+  gEfiAdapterInformationProtocolGuid
+
diff --git a/MdePkg/Library/DxeHstiLib/DxeHstiLib.uni b/MdePkg/Library/DxeHstiLib/DxeHstiLib.uni
new file mode 100644
index 000000000000..6a09ddd8cdf7
--- /dev/null
+++ b/MdePkg/Library/DxeHstiLib/DxeHstiLib.uni
@@ -0,0 +1,19 @@
+// /** @file
+// DXE instance of Hsti Library.
+//
+// Copyright (c) 2015, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "DXE instance of Hsti Library."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The HSTI Library implementation that create, get, or update HSTI table in DXE phase."
+
diff --git a/MdePkg/Library/DxeHstiLib/HstiAip.c b/MdePkg/Library/DxeHstiLib/HstiAip.c
new file mode 100644
index 000000000000..241c03fb123a
--- /dev/null
+++ b/MdePkg/Library/DxeHstiLib/HstiAip.c
@@ -0,0 +1,175 @@
+/** @file
+
+  Copyright (c) 2015, 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 "HstiDxe.h"
+
+/**
+  Returns the current state information for the adapter.
+
+  This function returns information of type InformationType from the adapter.
+  If an adapter does not support the requested informational type, then
+  EFI_UNSUPPORTED is returned. 
+
+  @param[in]  This                   A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[in]  InformationType        A pointer to an EFI_GUID that defines the contents of InformationBlock.
+  @param[out] InformationBlock       The service returns a pointer to the buffer with the InformationBlock
+                                     structure which contains details about the data specific to InformationType.
+  @param[out] InformationBlockSize   The driver returns the size of the InformationBlock in bytes.
+
+  @retval EFI_SUCCESS                The InformationType information was retrieved.
+  @retval EFI_UNSUPPORTED            The InformationType is not known.
+  @retval EFI_DEVICE_ERROR           The device reported an error.
+  @retval EFI_OUT_OF_RESOURCES       The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER      This is NULL. 
+  @retval EFI_INVALID_PARAMETER      InformationBlock is NULL. 
+  @retval EFI_INVALID_PARAMETER      InformationBlockSize is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+HstiAipGetInfo (
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  IN  EFI_GUID                          *InformationType,
+  OUT VOID                              **InformationBlock,
+  OUT UINTN                             *InformationBlockSize
+  )
+{
+  HSTI_AIP_PRIVATE_DATA  *HstiAip;
+
+  if ((This == NULL) || (InformationBlock == NULL) || (InformationBlockSize == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+  if (!CompareGuid (InformationType, &gAdapterInfoPlatformSecurityGuid)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  HstiAip = HSTI_AIP_PRIVATE_DATA_FROM_THIS(This);
+
+  *InformationBlock = AllocateCopyPool (HstiAip->HstiSize, HstiAip->Hsti);
+  if (*InformationBlock == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  *InformationBlockSize = HstiAip->HstiSize;
+  return EFI_SUCCESS;
+}
+
+/**
+  Sets state information for an adapter.
+
+  This function sends information of type InformationType for an adapter.
+  If an adapter does not support the requested information type, then EFI_UNSUPPORTED
+  is returned.
+
+  @param[in]  This                   A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[in]  InformationType        A pointer to an EFI_GUID that defines the contents of InformationBlock.
+  @param[in]  InformationBlock       A pointer to the InformationBlock structure which contains details
+                                     about the data specific to InformationType.
+  @param[in]  InformationBlockSize   The size of the InformationBlock in bytes.
+
+  @retval EFI_SUCCESS                The information was received and interpreted successfully.
+  @retval EFI_UNSUPPORTED            The InformationType is not known.
+  @retval EFI_DEVICE_ERROR           The device reported an error.
+  @retval EFI_INVALID_PARAMETER      This is NULL.
+  @retval EFI_INVALID_PARAMETER      InformationBlock is NULL.
+  @retval EFI_WRITE_PROTECTED        The InformationType cannot be modified using EFI_ADAPTER_INFO_SET_INFO().
+
+**/
+EFI_STATUS
+EFIAPI
+HstiAipSetInfo (
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  IN  EFI_GUID                          *InformationType,
+  IN  VOID                              *InformationBlock,
+  IN  UINTN                             InformationBlockSize
+  )
+{
+  HSTI_AIP_PRIVATE_DATA  *HstiAip;
+  VOID                   *NewHsti;
+
+  if ((This == NULL) || (InformationBlock == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+  if (!CompareGuid (InformationType, &gAdapterInfoPlatformSecurityGuid)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if (!InternalHstiIsValidTable (InformationBlock, InformationBlockSize)) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+
+  HstiAip = HSTI_AIP_PRIVATE_DATA_FROM_THIS(This);
+
+  if (InformationBlockSize > HstiAip->HstiMaxSize) {
+    NewHsti = AllocateZeroPool (InformationBlockSize);
+    if (NewHsti == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+    FreePool (HstiAip->Hsti);
+    HstiAip->Hsti = NewHsti;
+    HstiAip->HstiSize = 0;
+    HstiAip->HstiMaxSize = InformationBlockSize;
+  }
+
+  CopyMem (HstiAip->Hsti, InformationBlock, InformationBlockSize);
+  HstiAip->HstiSize = InformationBlockSize;
+  return EFI_SUCCESS;
+}
+
+/**
+  Get a list of supported information types for this instance of the protocol.
+
+  This function returns a list of InformationType GUIDs that are supported on an
+  adapter with this instance of EFI_ADAPTER_INFORMATION_PROTOCOL. The list is returned
+  in InfoTypesBuffer, and the number of GUID pointers in InfoTypesBuffer is returned in
+  InfoTypesBufferCount.
+
+  @param[in]  This                  A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
+  @param[out] InfoTypesBuffer       A pointer to the array of InformationType GUIDs that are supported
+                                    by This.
+  @param[out] InfoTypesBufferCount  A pointer to the number of GUIDs present in InfoTypesBuffer.
+
+  @retval EFI_SUCCESS               The list of information type GUIDs that are supported on this adapter was
+                                    returned in InfoTypesBuffer. The number of information type GUIDs was
+                                    returned in InfoTypesBufferCount.
+  @retval EFI_INVALID_PARAMETER     This is NULL.
+  @retval EFI_INVALID_PARAMETER     InfoTypesBuffer is NULL.
+  @retval EFI_INVALID_PARAMETER     InfoTypesBufferCount is NULL.
+  @retval EFI_OUT_OF_RESOURCES      There is not enough pool memory to store the results.
+
+**/
+EFI_STATUS
+EFIAPI
+HstiAipGetSupportedTypes (
+  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,
+  OUT EFI_GUID                          **InfoTypesBuffer,
+  OUT UINTN                             *InfoTypesBufferCount
+  )
+{
+  if ((This == NULL) || (InfoTypesBuffer == NULL) || (InfoTypesBufferCount == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  *InfoTypesBuffer = AllocateCopyPool (sizeof(gAdapterInfoPlatformSecurityGuid), &gAdapterInfoPlatformSecurityGuid);
+  if (*InfoTypesBuffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  *InfoTypesBufferCount = 1;
+
+  return EFI_SUCCESS;
+}
+
+EFI_ADAPTER_INFORMATION_PROTOCOL mAdapterInformationProtocol = {
+  HstiAipGetInfo,
+  HstiAipSetInfo,
+  HstiAipGetSupportedTypes,
+};
diff --git a/MdePkg/Library/DxeHstiLib/HstiDxe.c b/MdePkg/Library/DxeHstiLib/HstiDxe.c
new file mode 100644
index 000000000000..2ac4dc24a282
--- /dev/null
+++ b/MdePkg/Library/DxeHstiLib/HstiDxe.c
@@ -0,0 +1,609 @@
+/** @file
+
+  Copyright (c) 2015, 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 "HstiDxe.h"
+
+/**
+  Find HSTI table in AIP protocol, and return the data.
+  This API will return the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param HstiData         HSTI data. This buffer is allocated by callee, and it
+                          is the responsibility of the caller to free it after
+                          using it.
+  @param HstiSize         HSTI size
+
+  @return Aip             The AIP protocol having this HSTI.
+  @return NULL            There is not HSTI table with the Role and ImplementationID published in system.
+**/
+VOID *
+InternalHstiFindAip (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID OPTIONAL,
+  OUT VOID                    **HstiData OPTIONAL,
+  OUT UINTN                   *HstiSize OPTIONAL
+  )
+{
+  EFI_STATUS                        Status;
+  EFI_ADAPTER_INFORMATION_PROTOCOL  *Aip;
+  UINTN                             NoHandles;
+  EFI_HANDLE                        *Handles;
+  UINTN                             Index;
+  EFI_GUID                          *InfoTypesBuffer;
+  UINTN                             InfoTypesBufferCount;
+  UINTN                             InfoTypesIndex;
+  EFI_ADAPTER_INFORMATION_PROTOCOL  *AipCandidate;
+  VOID                              *InformationBlock;
+  UINTN                             InformationBlockSize;
+  ADAPTER_INFO_PLATFORM_SECURITY    *Hsti;
+
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiAdapterInformationProtocolGuid,
+                  NULL,
+                  &NoHandles,
+                  &Handles
+                  );
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+
+  Hsti = NULL;
+  Aip = NULL;
+  InformationBlock = NULL;
+  InformationBlockSize = 0;
+  for (Index = 0; Index < NoHandles; Index++) {
+    Status = gBS->HandleProtocol (
+                    Handles[Index],
+                    &gEfiAdapterInformationProtocolGuid,
+                    (VOID **)&Aip
+                    );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    //
+    // Check AIP
+    //
+    Status = Aip->GetSupportedTypes (
+                    Aip,
+                    &InfoTypesBuffer,
+                    &InfoTypesBufferCount
+                    );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    AipCandidate = NULL;
+    for (InfoTypesIndex = 0; InfoTypesIndex < InfoTypesBufferCount; InfoTypesIndex++) {
+      if (CompareGuid (&InfoTypesBuffer[InfoTypesIndex], &gAdapterInfoPlatformSecurityGuid)) {
+        AipCandidate = Aip;
+        break;
+      }
+    }
+    FreePool (InfoTypesBuffer);
+
+    if (AipCandidate == NULL) {
+      continue;
+    }
+
+    //
+    // Check HSTI Role
+    //
+    Aip = AipCandidate;
+    Status = Aip->GetInformation (
+                    Aip,
+                    &gAdapterInfoPlatformSecurityGuid,
+                    &InformationBlock,
+                    &InformationBlockSize
+                    );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    Hsti = InformationBlock;
+    if ((Hsti->Role == Role) && 
+        ((ImplementationID == NULL) || (StrCmp (ImplementationID, Hsti->ImplementationID) == 0))) {
+      break;
+    } else {
+      Hsti = NULL;
+      FreePool (InformationBlock);
+      continue;
+    }
+  }
+  FreePool (Handles);
+
+  if (Hsti == NULL) {
+    return NULL;
+  }
+
+  if (HstiData != NULL) {
+    *HstiData = InformationBlock;
+  }
+  if (HstiSize != NULL) {
+    *HstiSize = InformationBlockSize;
+  }
+  return Aip;
+}
+
+/**
+  Return if input HSTI data follows HSTI specification.
+
+  @param HstiData  HSTI data
+  @param HstiSize  HSTI size
+
+  @retval TRUE  HSTI data follows HSTI specification.
+  @retval FALSE HSTI data does not follow HSTI specification.
+**/
+BOOLEAN
+InternalHstiIsValidTable (
+  IN VOID                     *HstiData,
+  IN UINTN                    HstiSize
+  )
+{
+  ADAPTER_INFO_PLATFORM_SECURITY  *Hsti;
+  UINTN                           Index;
+  CHAR16                          *ErrorString;
+  CHAR16                          ErrorChar;
+  UINTN                           ErrorStringSize;
+  UINTN                           ErrorStringLength;
+
+  Hsti = HstiData;
+
+  //
+  // basic check for header
+  //
+  if (HstiData == NULL) {
+    DEBUG ((EFI_D_ERROR, "HstiData == NULL\n"));
+    return FALSE;
+  }
+  if (HstiSize < sizeof(ADAPTER_INFO_PLATFORM_SECURITY)) {
+    DEBUG ((EFI_D_ERROR, "HstiSize < sizeof(ADAPTER_INFO_PLATFORM_SECURITY)\n"));
+    return FALSE;
+  }
+  if (((HstiSize - sizeof(ADAPTER_INFO_PLATFORM_SECURITY)) / 3) < Hsti->SecurityFeaturesSize) {
+    DEBUG ((EFI_D_ERROR, "((HstiSize - sizeof(ADAPTER_INFO_PLATFORM_SECURITY)) / 3) < SecurityFeaturesSize\n"));
+    return FALSE;
+  }
+
+  //
+  // Check Version
+  //
+  if (Hsti->Version != PLATFORM_SECURITY_VERSION_VNEXTCS) {
+    DEBUG ((EFI_D_ERROR, "Version != PLATFORM_SECURITY_VERSION_VNEXTCS\n"));
+    return FALSE;
+  }
+
+  //
+  // Check Role
+  //
+  if ((Hsti->Role < PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE) ||
+      (Hsti->Role > PLATFORM_SECURITY_ROLE_IMPLEMENTOR_ODM)) {
+    DEBUG ((EFI_D_ERROR, "Role < PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE ||\n"));
+    DEBUG ((EFI_D_ERROR, "Role > PLATFORM_SECURITY_ROLE_IMPLEMENTOR_ODM\n"));
+    return FALSE;
+  }
+
+  //
+  // Check ImplementationID
+  //
+  for (Index = 0; Index < sizeof(Hsti->ImplementationID)/sizeof(Hsti->ImplementationID[0]); Index++) {
+    if (Hsti->ImplementationID[Index] == 0) {
+      break;
+    }
+  }
+  if (Index == sizeof(Hsti->ImplementationID)/sizeof(Hsti->ImplementationID[0])) {
+    DEBUG ((EFI_D_ERROR, "ImplementationID is no NUL CHAR\n"));
+    return FALSE;
+  }
+
+  ErrorStringSize = HstiSize - sizeof(ADAPTER_INFO_PLATFORM_SECURITY) - Hsti->SecurityFeaturesSize * 3;
+  ErrorString = (CHAR16 *)((UINTN)Hsti + sizeof(ADAPTER_INFO_PLATFORM_SECURITY) - Hsti->SecurityFeaturesSize * 3);
+
+  //
+  // basic check for ErrorString
+  //
+  if (ErrorStringSize == 0) {
+    DEBUG ((EFI_D_ERROR, "ErrorStringSize == 0\n"));
+    return FALSE;
+  }
+  if ((ErrorStringSize & BIT0) != 0) {
+    DEBUG ((EFI_D_ERROR, "(ErrorStringSize & BIT0) != 0\n"));
+    return FALSE;
+  }
+
+  //
+  // ErrorString might not be CHAR16 aligned.
+  //
+  CopyMem (&ErrorChar, ErrorString, sizeof(ErrorChar));
+  for (ErrorStringLength = 0; (ErrorChar != 0) && (ErrorStringLength < (ErrorStringSize/2)); ErrorStringLength++) {
+    ErrorString++;
+    CopyMem (&ErrorChar, ErrorString, sizeof(ErrorChar));
+  }
+
+  //
+  // check the length of ErrorString
+  //
+  if (ErrorChar != 0) {
+    DEBUG ((EFI_D_ERROR, "ErrorString has no NUL CHAR\n"));
+    return FALSE;
+  }
+  if (ErrorStringLength == (ErrorStringSize/2)) {
+    DEBUG ((EFI_D_ERROR, "ErrorString Length incorrect\n"));
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+/**
+  Publish HSTI table in AIP protocol.
+
+  One system should have only one PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE.
+
+  If the Role is NOT PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE,
+  SecurityFeaturesRequired field will be ignored.
+
+  @param Hsti      HSTI data
+  @param HstiSize  HSTI size
+
+  @retval EFI_SUCCESS          The HSTI data is published in AIP protocol.
+  @retval EFI_ALREADY_STARTED  There is already HSTI table with Role and ImplementationID published in system.
+  @retval EFI_VOLUME_CORRUPTED The input HSTI data does not follow HSTI specification.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to publish HSTI data in AIP protocol.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetTable (
+  IN VOID                     *Hsti,
+  IN UINTN                    HstiSize
+  )
+{
+  EFI_STATUS                       Status;
+  EFI_HANDLE                       Handle;
+  HSTI_AIP_PRIVATE_DATA            *HstiAip;
+  EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
+  UINT32                           Role;
+  CHAR16                           *ImplementationID;
+  UINT32                           SecurityFeaturesSize;
+  UINT8                            *SecurityFeaturesRequired;
+
+  if (!InternalHstiIsValidTable (Hsti, HstiSize)) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+
+  Role = ((ADAPTER_INFO_PLATFORM_SECURITY *)Hsti)->Role;
+  ImplementationID = ((ADAPTER_INFO_PLATFORM_SECURITY *)Hsti)->ImplementationID;
+  Aip = InternalHstiFindAip (Role, ImplementationID, NULL, NULL);
+  if (Aip != NULL) {
+    return EFI_ALREADY_STARTED;
+  }
+
+  HstiAip = AllocateZeroPool (sizeof(HSTI_AIP_PRIVATE_DATA));
+  if (HstiAip == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  HstiAip->Hsti = AllocateCopyPool (HstiSize, Hsti);
+  if (HstiAip->Hsti == NULL) {
+    FreePool (HstiAip);
+    return EFI_OUT_OF_RESOURCES;
+  }
+  if (Role != PLATFORM_SECURITY_ROLE_PLATFORM_REFERENCE) {
+    SecurityFeaturesRequired = (UINT8 *)HstiAip->Hsti + sizeof(ADAPTER_INFO_PLATFORM_SECURITY);
+    SecurityFeaturesSize = ((ADAPTER_INFO_PLATFORM_SECURITY *)Hsti)->SecurityFeaturesSize;
+    ZeroMem (SecurityFeaturesRequired, SecurityFeaturesSize);
+  }
+
+  HstiAip->Signature = HSTI_AIP_PRIVATE_SIGNATURE;
+  CopyMem (&HstiAip->Aip, &mAdapterInformationProtocol, sizeof(EFI_ADAPTER_INFORMATION_PROTOCOL));
+  HstiAip->HstiSize = HstiSize;
+  HstiAip->HstiMaxSize = HstiSize;
+  
+  Handle = NULL;
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                  &Handle,
+                  &gEfiAdapterInformationProtocolGuid,
+                  &HstiAip->Aip,
+                  NULL
+                  );
+  if (EFI_ERROR (Status)) {
+    FreePool (HstiAip->Hsti);
+    FreePool (HstiAip);
+  }
+
+  return Status;
+}
+
+/**
+  Search HSTI table in AIP protocol, and return the data.
+  This API will return the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param Hsti             HSTI data. This buffer is allocated by callee, and it
+                          is the responsibility of the caller to free it after
+                          using it.
+  @param HstiSize         HSTI size
+
+  @retval EFI_SUCCESS          The HSTI data in AIP protocol is returned.
+  @retval EFI_NOT_FOUND        There is not HSTI table with the Role and ImplementationID published in system.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibGetTable (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID OPTIONAL,
+  OUT VOID                    **Hsti,
+  OUT UINTN                   *HstiSize
+  )
+{
+  EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
+
+  Aip = InternalHstiFindAip (Role, ImplementationID, Hsti, HstiSize);
+  if (Aip == NULL) {
+    return EFI_NOT_FOUND;
+  }
+  return EFI_SUCCESS;
+}
+
+/**
+  Record FeaturesVerified in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ByteIndex        Byte index of FeaturesVerified of HSTI data.
+  @param BitMask          Bit mask of FeaturesVerified of HSTI data.
+  @param Set              TRUE means to set the FeaturesVerified bit.
+                          FALSE means to clear the FeaturesVerified bit.
+
+  @retval EFI_SUCCESS          The FeaturesVerified of HSTI data updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_UNSUPPORTED      The ByteIndex is invalid.
+**/
+EFI_STATUS
+InternalHstiRecordFeaturesVerified (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN UINT32                   ByteIndex,
+  IN UINT8                    Bit,
+  IN BOOLEAN                  Set
+  )
+{
+  EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
+  ADAPTER_INFO_PLATFORM_SECURITY   *Hsti;
+  UINTN                            HstiSize;
+  UINT8                            *SecurityFeaturesVerified;
+  EFI_STATUS                       Status;
+
+  Aip = InternalHstiFindAip (Role, ImplementationID, (VOID **)&Hsti, &HstiSize);
+  if (Aip == NULL) {
+    return EFI_NOT_STARTED;
+  }
+
+  if (ByteIndex >= Hsti->SecurityFeaturesSize) {
+    return EFI_UNSUPPORTED;
+  }
+
+  SecurityFeaturesVerified = (UINT8 *)((UINTN)Hsti + sizeof(ADAPTER_INFO_PLATFORM_SECURITY) + Hsti->SecurityFeaturesSize * 2);
+
+  if (Set) {
+    SecurityFeaturesVerified[ByteIndex] = (UINT8)(SecurityFeaturesVerified[ByteIndex] | (Bit));
+  } else {
+    SecurityFeaturesVerified[ByteIndex] = (UINT8)(SecurityFeaturesVerified[ByteIndex] & (~Bit));
+  }
+
+  Status = Aip->SetInformation (
+                  Aip,
+                  &gAdapterInfoPlatformSecurityGuid,
+                  Hsti,
+                  HstiSize
+                  );
+  return Status;
+}
+
+/**
+  Set FeaturesVerified in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ByteIndex        Byte index of FeaturesVerified of HSTI data.
+  @param BitMask          Bit mask of FeaturesVerified of HSTI data.
+
+  @retval EFI_SUCCESS          The FeaturesVerified of HSTI data updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_UNSUPPORTED      The ByteIndex is invalid.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetFeaturesVerified (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN UINT32                   ByteIndex,
+  IN UINT8                    BitMask
+  )
+{
+  return InternalHstiRecordFeaturesVerified (
+           Role,
+           ImplementationID,
+           ByteIndex,
+           BitMask,
+           TRUE
+           );
+}
+
+/**
+  Clear FeaturesVerified in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ByteIndex        Byte index of FeaturesVerified of HSTI data.
+  @param BitMask          Bit mask of FeaturesVerified of HSTI data.
+
+  @retval EFI_SUCCESS          The FeaturesVerified of HSTI data updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_UNSUPPORTED      The ByteIndex is invalid.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibClearFeaturesVerified (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN UINT32                   ByteIndex,
+  IN UINT8                    BitMask
+  )
+{
+  return InternalHstiRecordFeaturesVerified (
+           Role,
+           ImplementationID,
+           ByteIndex,
+           BitMask,
+           FALSE
+           );
+}
+
+/**
+  Record ErrorString in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ErrorString      ErrorString of HSTI data.
+  @param Append           TRUE means to append the ErrorString to HSTI table.
+                          FALSE means to set the ErrorString in HSTI table.
+
+  @retval EFI_SUCCESS          The ErrorString of HSTI data is published in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to update ErrorString.
+**/
+EFI_STATUS
+InternalHstiRecordErrorString (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN CHAR16                   *ErrorString,
+  IN BOOLEAN                  Append
+  )
+{
+  EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
+  ADAPTER_INFO_PLATFORM_SECURITY   *Hsti;
+  UINTN                            HstiSize;
+  UINTN                            StringSize;
+  VOID                             *NewHsti;
+  UINTN                            NewHstiSize;
+  UINTN                            Offset;
+  EFI_STATUS                       Status;
+
+  Aip = InternalHstiFindAip (Role, ImplementationID, (VOID **)&Hsti, &HstiSize);
+  if (Aip == NULL) {
+    return EFI_NOT_STARTED;
+  }
+
+  if (Append) {
+    Offset = HstiSize - sizeof(CHAR16);
+  } else {
+    Offset = sizeof(ADAPTER_INFO_PLATFORM_SECURITY) + Hsti->SecurityFeaturesSize * 3;
+  }
+  StringSize = StrSize (ErrorString);
+
+  NewHstiSize = Offset + StringSize;
+  NewHsti = AllocatePool (NewHstiSize);
+  if (NewHsti == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  CopyMem (NewHsti, Hsti, Offset);
+  CopyMem ((UINT8 *)NewHsti + Offset, ErrorString, StringSize);
+
+  Status = Aip->SetInformation (
+                  Aip,
+                  &gAdapterInfoPlatformSecurityGuid,
+                  NewHsti,
+                  NewHstiSize
+                  );
+  return Status;
+}
+
+/**
+  Append ErrorString in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ErrorString      ErrorString of HSTI data.
+
+  @retval EFI_SUCCESS          The ErrorString of HSTI data is updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to update ErrorString.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibAppendErrorString (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN CHAR16                   *ErrorString
+  )
+{
+  return InternalHstiRecordErrorString (
+           Role,
+           ImplementationID,
+           ErrorString,
+           TRUE
+           );
+}
+
+/**
+  Set a new ErrorString in published HSTI table.
+  This API will update the HSTI table with indicated Role and ImplementationID,
+  NULL ImplementationID means to find the first HSTI table with indicated Role.
+
+  @param Role             Role of HSTI data.
+  @param ImplementationID ImplementationID of HSTI data.
+                          NULL means find the first one match Role.
+  @param ErrorString      ErrorString of HSTI data.
+
+  @retval EFI_SUCCESS          The ErrorString of HSTI data is updated in AIP protocol.
+  @retval EFI_NOT_STARTED      There is not HSTI table with the Role and ImplementationID published in system.
+  @retval EFI_OUT_OF_RESOURCES There is not enough system resource to update ErrorString.
+**/
+EFI_STATUS
+EFIAPI
+HstiLibSetErrorString (
+  IN UINT32                   Role,
+  IN CHAR16                   *ImplementationID, OPTIONAL
+  IN CHAR16                   *ErrorString
+  )
+{
+  return InternalHstiRecordErrorString (
+           Role,
+           ImplementationID,
+           ErrorString,
+           FALSE
+           );
+}
diff --git a/MdePkg/Library/DxeHstiLib/HstiDxe.h b/MdePkg/Library/DxeHstiLib/HstiDxe.h
new file mode 100644
index 000000000000..c2e48870b680
--- /dev/null
+++ b/MdePkg/Library/DxeHstiLib/HstiDxe.h
@@ -0,0 +1,65 @@
+/** @file
+
+  Copyright (c) 2015, 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 _HSTI_DXE_H_
+#define _HSTI_DXE_H_
+
+#include <PiDxe.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+#include <IndustryStandard/Hsti.h>
+
+#include <Protocol/AdapterInformation.h>
+
+#define HSTI_AIP_PRIVATE_SIGNATURE  SIGNATURE_32('H', 'S', 'T', 'I')
+
+typedef struct {
+  UINT32                            Signature;
+  LIST_ENTRY                        Link;
+  EFI_ADAPTER_INFORMATION_PROTOCOL  Aip;
+  VOID                              *Hsti;
+  UINTN                             HstiSize;
+  UINTN                             HstiMaxSize;
+} HSTI_AIP_PRIVATE_DATA;
+
+#define HSTI_AIP_PRIVATE_DATA_FROM_THIS(a) \
+  CR (a, \
+      HSTI_AIP_PRIVATE_DATA, \
+      Aip, \
+      HSTI_AIP_PRIVATE_SIGNATURE \
+      )
+
+#define HSTI_DEFAULT_ERROR_STRING_LEN  255
+
+extern EFI_ADAPTER_INFORMATION_PROTOCOL mAdapterInformationProtocol;
+
+/**
+  Return if input HSTI data follows HSTI specification.
+
+  @param HstiData  HSTI data
+  @param HstiSize  HSTI size
+
+  @retval TRUE  HSTI data follows HSTI specification.
+  @retval FALSE HSTI data does not follow HSTI specification.
+**/
+BOOLEAN
+InternalHstiIsValidTable (
+  IN VOID                     *HstiData,
+  IN UINTN                    HstiSize
+  );
+
+#endif
\ No newline at end of file
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/DxeCpuIo2LibInternal.h b/MdePkg/Library/DxeIoLibCpuIo2/DxeCpuIo2LibInternal.h
new file mode 100644
index 000000000000..10fb040f6b6d
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/DxeCpuIo2LibInternal.h
@@ -0,0 +1,172 @@
+/** @file
+  Internal include file of DXE CPU IO2 Library.
+  
+  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 _DXE_CPUIO2_LIB_INTERNAL_H_
+#define _DXE_CPUIO2_LIB_INTERNAL_H_
+
+#include <PiDxe.h>
+
+#include <Protocol/CpuIo2.h>
+
+#include <Library/IoLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The read value is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI CPU I/O space.
+
+**/
+UINT64
+EFIAPI
+IoReadWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width
+  );
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width and value specified by Width
+  and Data respectively. Data is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+
+  @return The parameter of Data.
+
+**/
+UINT64
+EFIAPI
+IoWriteWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINT64                     Data
+  );
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The port is read Count times, and the read data is stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to read I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  );
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width specified by Width.
+  The port is written Count times, and the write data is retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to write I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoWriteFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  );
+
+/**
+  Reads memory-mapped registers in the EFI system memory space.
+
+  Reads the MMIO registers specified by Address with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioReadWorker (
+  IN      UINTN                     Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width
+  );
+
+/**
+  Writes memory-mapped registers in the EFI system memory space.
+
+  Writes the MMIO registers specified by Address with registers width and value specified by Width
+  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+  
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioWriteWorker (
+  IN      UINTN                     Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width,
+  IN      UINT64                    Data
+  );
+
+#endif
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.inf b/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.inf
new file mode 100644
index 000000000000..578f0645a702
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.inf
@@ -0,0 +1,53 @@
+## @file
+# I/O Library instance based on EFI_CPU_IO2_PROTOCOL.
+#
+# I/O Library implementation that uses the CPU I/O2 Protocol for I/O and MMIO operations.
+#
+# Copyright (c) 2010 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeIoLibCpuIo2
+  MODULE_UNI_FILE                = DxeIoLibCpuIo2.uni
+  FILE_GUID                      = 33D33BF3-349E-4768-9459-836A9F7558FB
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = IoLib|DXE_DRIVER DXE_SAL_DRIVER
+  CONSTRUCTOR                    = IoLibConstructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  IoLibMmioBuffer.c
+  DxeCpuIo2LibInternal.h
+  IoHighLevel.c
+  IoLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+  UefiBootServicesTableLib
+
+[Protocols]
+  gEfiCpuIo2ProtocolGuid         ## CONSUMES
+
+[Depex]
+  gEfiCpuIo2ProtocolGuid
+
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.uni b/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.uni
new file mode 100644
index 000000000000..5d9aebb899ed
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.uni
@@ -0,0 +1,22 @@
+// /** @file
+// I/O Library instance based on EFI_CPU_IO2_PROTOCOL.
+//
+// I/O Library implementation that uses the CPU I/O2 Protocol for I/O and MMIO operations.
+//
+// Copyright (c) 2010 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "I/O Library instance based on EFI_CPU_IO2_PROTOCOL"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "I/O Library implementation that uses the CPU I/O2 Protocol for I/O and MMIO operations."
+
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/IoHighLevel.c b/MdePkg/Library/DxeIoLibCpuIo2/IoHighLevel.c
new file mode 100644
index 000000000000..8d88a3562cd3
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/IoHighLevel.c
@@ -0,0 +1,2307 @@
+/** @file
+  High-level Io/Mmio functions.
+
+  All assertions for bit field operations are handled bit field functions in the
+  Base Library.
+
+  Copyright (c) 2010 - 2012, 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 "DxeCpuIo2LibInternal.h"
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) | OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) & AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) ((IoRead8 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) | OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) & AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) ((IoRead16 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) | OrData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) & AndData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) | OrData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) & AndData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) | OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) & AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) ((MmioRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) | OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) & AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) ((MmioRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) | OrData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) & AndData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) | OrData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) & AndData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/IoLib.c b/MdePkg/Library/DxeIoLibCpuIo2/IoLib.c
new file mode 100644
index 000000000000..3602643d8a7e
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/IoLib.c
@@ -0,0 +1,869 @@
+/** @file
+  I/O Library instance based on EFI_CPU_IO2_PROTOCOL.
+  
+  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 "DxeCpuIo2LibInternal.h"
+
+//
+// Globle varible to cache pointer to CpuIo2 protocol.
+//
+EFI_CPU_IO2_PROTOCOL  *mCpuIo = NULL;
+
+/**
+  The constructor function caches the pointer to CpuIo2 protocol.
+
+  The constructor function locates CpuIo2 protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+IoLibConstructor (
+  IN      EFI_HANDLE                ImageHandle,
+  IN      EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = gBS->LocateProtocol (&gEfiCpuIo2ProtocolGuid, NULL, (VOID **) &mCpuIo);
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The read value is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI CPU I/O space.
+
+**/
+UINT64
+EFIAPI
+IoReadWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      Data;
+
+  Status = mCpuIo->Io.Read (mCpuIo, Width, Port, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width and value specified by Width
+  and Data respectively. Data is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+
+  @return The parameter of Data.
+
+**/
+UINT64
+EFIAPI
+IoWriteWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINT64                     Data
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = mCpuIo->Io.Write (mCpuIo, Width, Port, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The port is read Count times, and the read data is stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to read I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = mCpuIo->Io.Read (mCpuIo, Width, Port, Count, Buffer);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width specified by Width.
+  The port is written Count times, and the write data is retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to write I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoWriteFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = mCpuIo->Io.Write (mCpuIo, Width, Port, Count, Buffer);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Reads memory-mapped registers in the EFI system memory space.
+
+  Reads the MMIO registers specified by Address with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioReadWorker (
+  IN      UINTN                      Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      Data;
+
+  Status = mCpuIo->Mem.Read (mCpuIo, Width, Address, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Writes memory-mapped registers in the EFI system memory space.
+
+  Writes the MMIO registers specified by Address with registers width and value specified by Width
+  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+  
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioWriteWorker (
+  IN      UINTN                      Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINT64                     Data
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = mCpuIo->Mem.Write (mCpuIo, Width, Address, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  return (UINT8)IoReadWorker (Port, EfiCpuIoWidthUint8);
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)IoWriteWorker (Port, EfiCpuIoWidthUint8, Value);
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoReadWorker (Port, EfiCpuIoWidthUint16);
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoWriteWorker (Port, EfiCpuIoWidthUint16, Value);
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+ 
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoReadWorker (Port, EfiCpuIoWidthUint32);
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoWriteWorker (Port, EfiCpuIoWidthUint32, Value);
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoReadWorker (Port, EfiCpuIoWidthUint64);
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoWriteWorker (Port, EfiCpuIoWidthUint64, Value);
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return (UINT8)MmioReadWorker (Address, EfiCpuIoWidthUint8);
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)MmioWriteWorker (Address, EfiCpuIoWidthUint8, Value);
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioReadWorker (Address, EfiCpuIoWidthUint16);
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioWriteWorker (Address, EfiCpuIoWidthUint16, Value);
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioReadWorker (Address, EfiCpuIoWidthUint32);
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+ 
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioWriteWorker (Address, EfiCpuIoWidthUint32, Value);
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioReadWorker (Address, EfiCpuIoWidthUint64);
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioWriteWorker (Address, EfiCpuIoWidthUint64, Value);
+}
diff --git a/MdePkg/Library/DxeIoLibCpuIo2/IoLibMmioBuffer.c b/MdePkg/Library/DxeIoLibCpuIo2/IoLibMmioBuffer.c
new file mode 100644
index 000000000000..c1c4752769be
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibCpuIo2/IoLibMmioBuffer.c
@@ -0,0 +1,413 @@
+/** @file
+  I/O Library MMIO Buffer Functions.
+
+  Copyright (c) 2010, 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 "DxeCpuIo2LibInternal.h"
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 8-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8   *ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ReturnBuffer = Buffer;
+
+  while (Length-- > 0) {
+    *(Buffer++) = MmioRead8 (StartAddress++);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 16-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer.
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 32-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer.
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 64-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer.
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead64 (StartAddress);
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 8-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer.
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  VOID* ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ReturnBuffer = (UINT8 *) Buffer;
+
+  while (Length-- > 0) {
+     MmioWrite8 (StartAddress++, *(Buffer++));
+  }
+
+  return ReturnBuffer;
+
+}
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 16-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer.
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = (UINT16 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite16 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 32-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer.
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = (UINT32 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite32 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 64-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer.
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = (UINT64 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite64 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.inf b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.inf
new file mode 100644
index 000000000000..bf3ec7d7611a
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.inf
@@ -0,0 +1,49 @@
+## @file
+# I/O Library instance that layers on top of Itanium ESAL services.
+#
+# I/O Library implementation that uses Itanium ESAL services for I/O
+#  and MMIO operations.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeIoLibEsal
+  MODULE_UNI_FILE                = DxeIoLibEsal.uni
+  FILE_GUID                      = 0D8E6E4E-B029-475f-9122-60A3FEDBA8C0
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = IoLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  IoHighLevel.c
+  IoLib.c
+  IoLibMmioBuffer.c
+  DxeIoLibEsalInternal.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  ExtendedSalLib
+  BaseLib
+  DebugLib
+
+[Depex]
+  gEfiExtendedSalBaseIoServicesProtocolGuid
+
diff --git a/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.uni b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.uni
new file mode 100644
index 000000000000..1609fce94462
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.uni
@@ -0,0 +1,23 @@
+// /** @file
+// I/O Library instance that layers on top of Itanium ESAL services.
+//
+// I/O Library implementation that uses Itanium ESAL services for I/O
+// and MMIO operations.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "I/O Library instance that layers on top of Itanium ESAL services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "I/O Library implementation that uses Itanium ESAL services for I/O and MMIO operations."
+
diff --git a/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsalInternal.h b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsalInternal.h
new file mode 100644
index 000000000000..2cd9e7d5199f
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/DxeIoLibEsalInternal.h
@@ -0,0 +1,28 @@
+/** @file
+  Internal include file for the I/O Library using ESAL services.
+  
+  Copyright (c) 2006 - 2011, 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 __DXE_IO_LIB_ESAL_INTERNAL_H_
+#define __DXE_IO_LIB_ESAL_INTERNAL_H_
+
+#include <PiDxe.h>
+
+#include <Protocol/CpuIo2.h>
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/ExtendedSalLib.h>
+
+#endif
diff --git a/MdePkg/Library/DxeIoLibEsal/IoHighLevel.c b/MdePkg/Library/DxeIoLibEsal/IoHighLevel.c
new file mode 100644
index 000000000000..5e34bc98e1b4
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/IoHighLevel.c
@@ -0,0 +1,2303 @@
+/** @file
+  High-level Io/Mmio functions.
+
+  Copyright (c) 2006 - 2012, 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 "DxeIoLibEsalInternal.h"
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8)(IoRead8 (Port) | OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (Port, (UINT8)(IoRead8 (Port) & AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8)((IoRead8 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the value read from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16)(IoRead16 (Port) | OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (Port, (UINT16)(IoRead16 (Port) & AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16)((IoRead16 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the value read from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) | OrData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) & AndData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the value read from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) | OrData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) & AndData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the value read from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the value read from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the value read from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8)(MmioRead8 (Address) | OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (Address, (UINT8)(MmioRead8 (Address) & AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8)((MmioRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with value read from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16)(MmioRead16 (Address) | OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (Address, (UINT16)(MmioRead16 (Address) & AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16)((MmioRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with value read from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) | OrData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) & AndData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with value read from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) | OrData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) & AndData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the value read from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with value read from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with value read from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
diff --git a/MdePkg/Library/DxeIoLibEsal/IoLib.c b/MdePkg/Library/DxeIoLibEsal/IoLib.c
new file mode 100644
index 000000000000..a9c47bf36290
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/IoLib.c
@@ -0,0 +1,879 @@
+/** @file
+  I/O Library basic function implementation and worker functions.
+
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 "DxeIoLibEsalInternal.h"
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The read value is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI CPU I/O space.
+
+**/
+UINT64
+EFIAPI
+IoReadWorker (
+  IN      UINTN                     Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+  UINT64           Data;
+
+  Data = 0;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                IoReadFunctionId, 
+                (UINT64)Width, 
+                Port, 
+                1, 
+                (UINT64)&Data, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+  return Data;
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width and value specified by Width
+  and Data respectively. Data is returned.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+
+  @return The parameter of Data.
+
+**/
+UINT64
+EFIAPI
+IoWriteWorker (
+  IN      UINTN                     Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width,
+  IN      UINT64                    Data
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                IoWriteFunctionId, 
+                (UINT64)Width, 
+                Port, 
+                1, 
+                (UINT64)&Data, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+  return Data;
+}
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The port is read Count times, and the read data is stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to read I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                IoReadFunctionId, 
+                (UINT64)Width, 
+                Port, 
+                Count, 
+                (UINT64)Buffer, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width specified by Width.
+  The port is written Count times, and the write data is retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to write I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoWriteFifoWorker (
+  IN      UINTN                      Port,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
+  IN      UINTN                      Count,
+  IN      VOID                       *Buffer
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                IoWriteFunctionId, 
+                (UINT64)Width, 
+                Port, 
+                Count, 
+                (UINT64)Buffer, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+}
+
+/**
+  Reads memory-mapped registers in the EFI system memory space.
+
+  Reads the MMIO registers specified by Address with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioReadWorker (
+  IN      UINTN                     Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+  UINT64           Data;
+
+  Data = 0;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                MemReadFunctionId, 
+                (UINT64)Width, 
+                Address, 
+                1, 
+                (UINT64)&Data, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+  return Data;
+}
+
+/**
+  Writes memory-mapped registers in the EFI system memory space.
+
+  Writes the MMIO registers specified by Address with registers width and value specified by Width
+  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to memory-mapped registers
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioWriteWorker (
+  IN      UINTN                     Address,
+  IN      EFI_CPU_IO_PROTOCOL_WIDTH Width,
+  IN      UINT64                    Data
+  )
+{
+  SAL_RETURN_REGS  ReturnReg;
+
+  ReturnReg = EsalCall (
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_BASE_IO_SERVICES_PROTOCOL_GUID_HI,
+                MemWriteFunctionId, 
+                (UINT64)Width, 
+                Address, 
+                1, 
+                (UINT64)&Data, 
+                0, 
+                0, 
+                0
+                );
+  ASSERT (ReturnReg.Status == EFI_SAL_SUCCESS);
+  return Data;
+}
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  return (UINT8)IoReadWorker (Port, EfiCpuIoWidthUint8);
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)IoWriteWorker (Port, EfiCpuIoWidthUint8, Value);
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoReadWorker (Port, EfiCpuIoWidthUint16);
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoWriteWorker (Port, EfiCpuIoWidthUint16, Value);
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoReadWorker (Port, EfiCpuIoWidthUint32);
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoWriteWorker (Port, EfiCpuIoWidthUint32, Value);
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoReadWorker (Port, EfiCpuIoWidthUint64);
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoWriteWorker (Port, EfiCpuIoWidthUint64, Value);
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return (UINT8)MmioReadWorker (Address, EfiCpuIoWidthUint8);
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)MmioWriteWorker (Address, EfiCpuIoWidthUint8, Value);
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioReadWorker (Address, EfiCpuIoWidthUint16);
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioWriteWorker (Address, EfiCpuIoWidthUint16, Value);
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioReadWorker (Address, EfiCpuIoWidthUint32);
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioWriteWorker (Address, EfiCpuIoWidthUint32, Value);
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioReadWorker (Address, EfiCpuIoWidthUint64);
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioWriteWorker (Address, EfiCpuIoWidthUint64, Value);
+}
diff --git a/MdePkg/Library/DxeIoLibEsal/IoLibMmioBuffer.c b/MdePkg/Library/DxeIoLibEsal/IoLibMmioBuffer.c
new file mode 100644
index 000000000000..6f2d2c0c8bdb
--- /dev/null
+++ b/MdePkg/Library/DxeIoLibEsal/IoLibMmioBuffer.c
@@ -0,0 +1,411 @@
+/** @file
+  I/O Library MMIO Buffer Functions.
+
+  Copyright (c) 2006 - 2011, 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 "DxeIoLibEsalInternal.h"
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8   *ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length-- > 0) {
+    *(Buffer++) = MmioRead8 (StartAddress++);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length > 0) {
+    *(Buffer++) = MmioRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length > 0) {
+    *(Buffer++) = MmioRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied from.
+  @param  Length          Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length > 0) {
+    *(Buffer++) = MmioRead64 (StartAddress);
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  VOID* ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = (UINT8 *) Buffer;
+  
+  while (Length-- > 0) {
+     MmioWrite8 (StartAddress++, *(Buffer++));
+  }
+
+  return ReturnBuffer;
+ 
+}
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = (UINT16 *) Buffer;
+  
+  while (Length > 0) {
+    MmioWrite16 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = (UINT32 *) Buffer;
+  
+  while (Length > 0) {
+    MmioWrite32 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    Starting address for the MMIO region to be copied to.
+  @param  Length     Size in bytes of the copy.
+  @param  Buffer          Pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = (UINT64 *) Buffer;
+  
+  while (Length > 0) {
+    MmioWrite64 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.c b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.c
new file mode 100644
index 000000000000..c1f943724677
--- /dev/null
+++ b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.c
@@ -0,0 +1,73 @@
+/** @file
+  PAL Library Class implementation built upon Extended SAL Procedures.
+
+  Copyright (c) 2007 - 2011, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/PalLib.h>
+#include <Library/ExtendedSalLib.h>
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param Index - The PAL procedure Index number.
+  @param Arg2  - The 2nd parameter for PAL procedure calls.
+  @param Arg3  - The 3rd parameter for PAL procedure calls.
+  @param Arg4  - The 4th parameter for PAL procedure calls.
+
+  @return structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  )
+{
+  SAL_RETURN_REGS SalReturn;
+  PAL_CALL_RETURN *PalReturn;
+
+  SalReturn = EsalCall (
+                EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO,
+                EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+                PalProcFunctionId, 
+                Index, 
+                Arg2, 
+                Arg3, 
+                Arg4, 
+                0, 
+                0, 
+                0
+                );
+  PalReturn = (PAL_CALL_RETURN *) (UINTN) (&SalReturn);
+  return *PalReturn;
+}
diff --git a/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.inf b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.inf
new file mode 100644
index 000000000000..aed361a0ad67
--- /dev/null
+++ b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.inf
@@ -0,0 +1,41 @@
+## @file
+#  Instance of PAL Library Class using Extended SAL functions
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxePalLibEsal
+  MODULE_UNI_FILE                = DxePalLibEsal.uni
+  FILE_GUID                      = 8BA65DE3-39E1-4afd-A8FE-7DD0BAFEFCC0
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PalLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION 
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.IPF]
+  DxePalLibEsal.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  ExtendedSalLib
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiExtendedSalPalServicesProtocolGuid
+
diff --git a/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.uni b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.uni
new file mode 100644
index 000000000000..1ce15f586811
--- /dev/null
+++ b/MdePkg/Library/DxePalLibEsal/DxePalLibEsal.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of PAL Library Class using Extended SAL functions
+//
+// An instance of PAL Library Class using Extended SAL functions.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "An instance of PAL Library Class using Extended SAL functions."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "An instance of PAL Library Class using Extended SAL functions."
+
diff --git a/MdePkg/Library/DxePcdLib/DxePcdLib.c b/MdePkg/Library/DxePcdLib/DxePcdLib.c
new file mode 100644
index 000000000000..26e252170b3e
--- /dev/null
+++ b/MdePkg/Library/DxePcdLib/DxePcdLib.c
@@ -0,0 +1,1626 @@
+/** @file
+Implementation of PcdLib class library for DXE phase.
+
+Copyright (c) 2006 - 2016, 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 <PiDxe.h>
+
+#include <Protocol/Pcd.h>
+#include <Protocol/PiPcd.h>
+#include <Protocol/PcdInfo.h>
+#include <Protocol/PiPcdInfo.h>
+
+#include <Library/PcdLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseMemoryLib.h>
+
+PCD_PROTOCOL                *mPcd       = NULL;
+EFI_PCD_PROTOCOL            *mPiPcd     = NULL;
+GET_PCD_INFO_PROTOCOL       *mPcdInfo   = NULL;
+EFI_GET_PCD_INFO_PROTOCOL   *mPiPcdInfo = NULL;
+
+/**
+  Retrieves the PI PCD protocol from the handle database.
+
+  @retval EFI_PCD_PROTOCOL * The pointer to the EFI_PCD_PROTOCOL.
+**/
+EFI_PCD_PROTOCOL *
+EFIAPI
+GetPiPcdProtocol (
+  VOID
+  )
+{
+  EFI_STATUS  Status;
+
+  if (mPiPcd == NULL) {
+    //
+    // PI Pcd protocol defined in PI 1.2 vol3 should be installed before the module 
+    // access DynamicEx type PCD.
+    //
+    Status = gBS->LocateProtocol (&gEfiPcdProtocolGuid, NULL, (VOID **) &mPiPcd);
+    ASSERT_EFI_ERROR (Status);
+    ASSERT (mPiPcd != NULL);
+  }
+  return mPiPcd;
+}
+
+/**
+  Retrieves the PCD protocol from the handle database.
+
+  @retval PCD_PROTOCOL * The pointer to the PCD_PROTOCOL.
+**/
+PCD_PROTOCOL *
+EFIAPI
+GetPcdProtocol (
+  VOID
+  )
+{
+  EFI_STATUS  Status;
+
+  if (mPcd == NULL) {
+    //
+    // PCD protocol need to be installed before the module access Dynamic type PCD.
+    // But dynamic type PCD is not required in PI 1.2 specification.
+    // 
+    Status = gBS->LocateProtocol (&gPcdProtocolGuid, NULL, (VOID **)&mPcd);
+    ASSERT_EFI_ERROR (Status);
+    ASSERT (mPcd != NULL);
+  }
+  return mPcd;
+}
+
+/**
+  Retrieves the PI PCD info protocol from the handle database.
+
+  @retval EFI_GET_PCD_INFO_PROTOCOL * The pointer to the EFI_GET_PCD_INFO_PROTOCOL defined in PI 1.2.1 Vol 3.
+**/
+EFI_GET_PCD_INFO_PROTOCOL *
+GetPiPcdInfoProtocolPointer (
+  VOID
+  )
+{
+  EFI_STATUS  Status;
+
+  if (mPiPcdInfo == NULL) {
+    Status = gBS->LocateProtocol (&gEfiGetPcdInfoProtocolGuid, NULL, (VOID **)&mPiPcdInfo);
+    ASSERT_EFI_ERROR (Status);
+    ASSERT (mPiPcdInfo != NULL);
+  }
+  return mPiPcdInfo;
+}
+
+/**
+  Retrieves the PCD info protocol from the handle database.
+
+  @retval GET_PCD_INFO_PROTOCOL * The pointer to the GET_PCD_INFO_PROTOCOL.
+**/
+GET_PCD_INFO_PROTOCOL *
+GetPcdInfoProtocolPointer (
+  VOID
+  ) 
+{
+  EFI_STATUS  Status;
+
+  if (mPcdInfo == NULL) {
+    Status = gBS->LocateProtocol (&gGetPcdInfoProtocolGuid, NULL, (VOID **)&mPcdInfo);
+    ASSERT_EFI_ERROR (Status);
+    ASSERT (mPcdInfo != NULL);
+  }
+  return mPcdInfo;
+}
+
+/**
+  This function provides a means by which SKU support can be established in the PCD infrastructure.
+
+  Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
+
+  @param  SkuId   The SKU value that will be used when the PCD service retrieves and sets values
+                  associated with a PCD token.
+
+  @return  Return the SKU ID that just be set.
+
+**/
+UINTN
+EFIAPI
+LibPcdSetSku (
+  IN UINTN   SkuId
+  )
+{
+  GetPcdProtocol()->SetSku (SkuId);
+
+  return SkuId;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 8-bit value for the token specified by TokenNumber. 
+
+**/
+UINT8
+EFIAPI
+LibPcdGet8 (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->Get8 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 16-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 16-bit value for the token specified by TokenNumber. 
+
+**/
+UINT16
+EFIAPI
+LibPcdGet16 (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->Get16 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 32-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 32-bit value for the token specified by TokenNumber.
+
+**/
+UINT32
+EFIAPI
+LibPcdGet32 (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->Get32 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 64-bit value for the token specified by TokenNumber.
+
+**/
+UINT64
+EFIAPI
+LibPcdGet64 (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->Get64 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the pointer to the token specified by TokenNumber.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetPtr (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->GetPtr (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the Boolean value of the token specified by TokenNumber. 
+
+**/
+BOOLEAN 
+EFIAPI
+LibPcdGetBool (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->GetBool (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the size of the token specified by TokenNumber. 
+
+**/
+UINTN
+EFIAPI
+LibPcdGetSize (
+  IN UINTN             TokenNumber
+  )
+{
+  return GetPcdProtocol()->GetSize (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT8.
+
+**/
+UINT8
+EFIAPI
+LibPcdGetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+  
+  return GetPiPcdProtocol()->Get8 (Guid, TokenNumber);
+}
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+
+  Returns the 16-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT16.
+
+**/
+UINT16
+EFIAPI
+LibPcdGetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Get16 (Guid, TokenNumber);
+}
+
+
+/**
+  Returns the 32-bit value for the token specified by TokenNumber and Guid.
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT32.
+
+**/
+UINT32
+EFIAPI
+LibPcdGetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Get32 (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the UINT64.
+
+**/
+UINT64
+EFIAPI
+LibPcdGetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+  
+  return GetPiPcdProtocol()->Get64 (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the VOID* pointer.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetExPtr (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->GetPtr (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the BOOLEAN.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdGetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->GetBool (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+  
+  Returns the size of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the size.
+
+**/
+UINTN
+EFIAPI
+LibPcdGetExSize (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->GetSize (Guid, TokenNumber);
+}
+
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSet8 (
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  GetPcdProtocol()->Set8 (TokenNumber, Value);
+  
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSet16 (
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  GetPcdProtocol()->Set16 (TokenNumber, Value);
+  
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSet32 (
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  GetPcdProtocol()->Set32 (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+  
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSet64 (
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  GetPcdProtocol()->Set64 (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value 
+  specified by Buffer and SizeOfBuffer.  Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size support by TokenNumber, 
+  then set SizeOfBuffer to the maximum size supported by TokenNumber and 
+  return NULL to indicate that the set operation was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 
+  maximum size supported by TokenName and NULL must be returned.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return Return the pointer for the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetPtr (
+  IN        UINTN             TokenNumber,
+  IN OUT    UINTN             *SizeOfBuffer,
+  IN CONST  VOID              *Buffer
+  )
+{
+  EFI_STATUS Status;
+  UINTN      InputSizeOfBuffer;
+
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  InputSizeOfBuffer = *SizeOfBuffer;
+  Status = GetPcdProtocol()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
+  if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
+    return NULL;
+  }
+
+  return (VOID *)Buffer;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetBool (
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  GetPcdProtocol()->SetBool (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  GetPiPcdProtocol()->Set8 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  GetPiPcdProtocol()->Set16 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  GetPiPcdProtocol()->Set32 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  GetPiPcdProtocol()->Set64 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value specified by 
+  Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size 
+  supported by TokenNumber and return NULL to indicate that the set operation 
+  was not actually performed.
+  
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]  Guid              The pointer to a 128-bit unique value that 
+                                designates which namespace to set a value from.
+  @param[in]  TokenNumber       The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]  Buffer            A pointer to the buffer to set.
+
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetExPtr (
+  IN      CONST GUID        *Guid,
+  IN      UINTN             TokenNumber,
+  IN OUT  UINTN             *SizeOfBuffer,
+  IN      VOID              *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       InputSizeOfBuffer;
+
+  ASSERT (Guid != NULL);
+
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  InputSizeOfBuffer = *SizeOfBuffer;
+  Status = GetPiPcdProtocol()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
+  if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
+    return NULL;
+  }
+
+  return Buffer;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The Boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  GetPiPcdProtocol()->SetBool (Guid, TokenNumber, Value);
+
+  return Value;
+}
+#endif
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet8S (
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  return GetPcdProtocol()->Set8 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet16S (
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  return GetPcdProtocol()->Set16 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet32S (
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  return GetPcdProtocol()->Set32 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet64S (
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  return GetPcdProtocol()->Set64 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
+  maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned.
+
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetPtrS (
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  return GetPcdProtocol()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetBoolS (
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  return GetPcdProtocol()->SetBool (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx8S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Set8 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx16S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Set16 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx32S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Set32 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx64S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->Set64 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified by
+  Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      Guid          Pointer to a 128-bit unique value that
+                                designates which namespace to set a value from.
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExPtrS (
+  IN CONST GUID     *Guid,
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN       VOID     *Buffer
+  )
+{
+  ASSERT (Guid != NULL);
+
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  return GetPiPcdProtocol()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExBoolS (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return GetPiPcdProtocol()->SetBool (Guid, TokenNumber, Value);
+}
+
+/**
+  Set up a notification function that is called when a specified token is set.
+  
+  When the token specified by TokenNumber and Guid is set, 
+  then notification function specified by NotificationFunction is called.  
+  If Guid is NULL, then the default token space is used.
+  If NotificationFunction is NULL, then ASSERT().
+
+  @param[in]  Guid                  The pointer to a 128-bit unique value that designates which 
+                                    namespace to set a value from.  If NULL, then the default 
+                                    token space is used.
+  @param[in]  TokenNumber           The PCD token number to monitor.
+  @param[in]  NotificationFunction  The function to call when the token 
+                                    specified by Guid and TokenNumber is set.
+
+**/
+VOID
+EFIAPI
+LibPcdCallbackOnSet (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  EFI_STATUS Status;
+
+  ASSERT (NotificationFunction != NULL);
+
+  Status = GetPiPcdProtocol()->CallbackOnSet (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
+  ASSERT_EFI_ERROR (Status);
+
+  return;
+}
+
+
+
+/**
+  Disable a notification function that was established with LibPcdCallbackonSet().
+  
+  Disable a notification function that was previously established with LibPcdCallbackOnSet().
+  If NotificationFunction is NULL, then ASSERT().
+  If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber, 
+  and NotificationFunction, then ASSERT().
+  
+  @param[in]  Guid                 Specify the GUID token space.
+  @param[in]  TokenNumber          Specify the token number.
+  @param[in]  NotificationFunction The callback function to be unregistered.
+
+**/
+VOID
+EFIAPI
+LibPcdCancelCallback (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  EFI_STATUS Status;
+
+  ASSERT (NotificationFunction != NULL);
+    
+  Status = GetPiPcdProtocol()->CancelCallback (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
+  ASSERT_EFI_ERROR (Status);
+
+  return;
+}
+
+
+
+/**
+  Retrieves the next token in a token space.
+  
+  Retrieves the next PCD token number from the token space specified by Guid.  
+  If Guid is NULL, then the default token space is used.  If TokenNumber is 0, 
+  then the first token number is returned.  Otherwise, the token number that 
+  follows TokenNumber in the token space is returned.  If TokenNumber is the last 
+  token number in the token space, then 0 is returned.  
+  
+  If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]  Guid        The pointer to a 128-bit unique value that designates which namespace 
+                          to set a value from.  If NULL, then the default token space is used.
+  @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD 
+                          token number.
+
+  @return The next valid token number.
+
+**/
+UINTN           
+EFIAPI
+LibPcdGetNextToken (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber
+  )
+{
+  EFI_STATUS    Status;
+
+  Status = GetPiPcdProtocol()->GetNextToken (Guid, &TokenNumber);
+  ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
+
+  return TokenNumber;
+}
+
+
+
+/**
+  Used to retrieve the list of available PCD token space GUIDs.
+  
+  Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
+  in the platform.
+  If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
+  If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
+  
+  @param  TokenSpaceGuid  The pointer to the a PCD token space GUID.
+
+  @return The next valid token namespace.
+
+**/
+GUID *
+EFIAPI
+LibPcdGetNextTokenSpace (
+  IN CONST GUID  *TokenSpaceGuid
+  )
+{
+  GetPiPcdProtocol()->GetNextTokenSpace (&TokenSpaceGuid);
+
+  return (GUID *)TokenSpaceGuid;
+}
+
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtr (
+  OUT       VOID        *PatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrS (
+  OUT       VOID     *PatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+
+  return RETURN_SUCCESS;
+}
+
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtrAndSize (
+  OUT       VOID        *PatchVariable,
+  OUT       UINTN       *SizeOfPatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrAndSizeS (
+  OUT      VOID     *PatchVariable,
+  OUT      UINTN    *SizeOfPatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the default token space specified, then ASSERT().
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfo (
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  EFI_STATUS Status;
+
+  Status = GetPcdInfoProtocolPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfoEx (
+  IN CONST  GUID            *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  EFI_STATUS Status;
+
+  Status = GetPiPcdInfoProtocolPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+UINTN
+EFIAPI
+LibPcdGetSku (
+  VOID
+  )
+{
+  return GetPiPcdInfoProtocolPointer()->GetSku ();
+}
+
diff --git a/MdePkg/Library/DxePcdLib/DxePcdLib.inf b/MdePkg/Library/DxePcdLib/DxePcdLib.inf
new file mode 100644
index 000000000000..56e2006d41d9
--- /dev/null
+++ b/MdePkg/Library/DxePcdLib/DxePcdLib.inf
@@ -0,0 +1,68 @@
+## @file
+# Instance of PCD Library using PCD Protocol.
+#
+# There are two PCD protocols as follows:
+#   1) PCD_PROTOCOL
+#      It is EDKII implementation which support Dynamic/DynamicEx Pcds.
+#   2) EFI_PCD_PROTOCOL
+#      It is defined by PI specification 1.2, Vol 3 which only support dynamicEx 
+#      type Pcd.
+#
+# For dynamicEx type PCD, it is compatible between PCD_PROTOCOL and EFI_PCD_PROTOCOL.
+#
+# This library instance uses the PCD_PROTOCOL to handle dynamic PCD request and use
+# EFI_PCD_PROTOCOL to handle dynamicEx type PCD.
+#
+# Note: A driver of type DXE_RUNTIME_DRIVER and DXE_SMM_DRIVER can only use this DxePcdLib 
+#  in their initialization without any issues to access Dynamic and DynamicEx PCD. They can't 
+#  access Dynamic and DynamicEx PCD in the implementation of runtime services and SMI handlers.
+#  Because EFI_PCD_PROTOCOL is DXE protocol that is not aviable in OS runtime phase.  
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxePcdLib
+  MODULE_UNI_FILE                = DxePcdLib.uni
+  FILE_GUID                      = af97eb89-4cc6-45f8-a514-ca025b346480
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PcdLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER SMM_CORE UEFI_APPLICATION UEFI_DRIVER 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DxePcdLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  UefiBootServicesTableLib
+  DebugLib
+
+
+[Protocols]
+  gPcdProtocolGuid                              ## SOMETIMES_CONSUMES
+  gEfiPcdProtocolGuid                           ## CONSUMES
+  gGetPcdInfoProtocolGuid                       ## SOMETIMES_CONSUMES
+  gEfiGetPcdInfoProtocolGuid                    ## SOMETIMES_CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiPcdProtocolGuid
+
diff --git a/MdePkg/Library/DxePcdLib/DxePcdLib.uni b/MdePkg/Library/DxePcdLib/DxePcdLib.uni
new file mode 100644
index 000000000000..6d6c3a5cb3e3
--- /dev/null
+++ b/MdePkg/Library/DxePcdLib/DxePcdLib.uni
@@ -0,0 +1,31 @@
+// /** @file
+// Instance of PCD Library using PCD Protocol.
+//
+// There are two PCD protocols as follows:
+// 1) PCD_PROTOCOL
+// It is EDKII implementation which support Dynamic/DynamicEx Pcds.
+// 2) EFI_PCD_PROTOCOL
+// It is defined by PI specification 1.2, Vol 3 which only support dynamicEx
+// type Pcd.
+// 
+// For dynamicEx type PCD, it is compatible between PCD_PROTOCOL and EFI_PCD_PROTOCOL.
+// 
+// This library instance uses the PCD_PROTOCOL to handle dynamic PCD request and use
+// EFI_PCD_PROTOCOL to handle dynamicEx type PCD.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCD Library using PCD Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "There are two PCD protocols: 1) PCD_PROTOCOL It is an EDKII implementation that supporst Dynamic/DynamicEx PCDs. 2) EFI_PCD_PROTOCOL It is defined by PI Specification 1.2, Vol 3, which only support dynamicEx type PCD.  For dynamicEx type PCDs, it is compatible between PCD_PROTOCOL and EFI_PCD_PROTOCOL.  This library instance uses the PCD_PROTOCOL to handle dynamic PCD requests and uses EFI_PCD_PROTOCOL to handle DynamicEx type PCDs."
+
diff --git a/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.inf b/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.inf
new file mode 100644
index 000000000000..e5a1f212f7da
--- /dev/null
+++ b/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.inf
@@ -0,0 +1,40 @@
+## @file
+#  PCI Library that uses ESAL services to perform PCI Configuration cycles.
+#
+#  Copyright (c) 2006 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxePciLibEsal
+  MODULE_UNI_FILE                = DxePciLibEsal.uni
+  FILE_GUID                      = E3441740-3B41-4c90-9C9D-964056C7417D
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  PciLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  ExtendedSalLib
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.uni b/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.uni
new file mode 100644
index 000000000000..8550fc53e775
--- /dev/null
+++ b/MdePkg/Library/DxePciLibEsal/DxePciLibEsal.uni
@@ -0,0 +1,21 @@
+// /** @file
+// PCI Library that uses ESAL services to perform PCI Configuration cycles.
+//
+// The PCI Library that uses ESAL services to perform PCI Configuration cycles.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Uses ESAL services to perform PCI Configuration cycles"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The PCI Library that uses ESAL services to perform PCI Configuration cycles."
+
diff --git a/MdePkg/Library/DxePciLibEsal/PciLib.c b/MdePkg/Library/DxePciLibEsal/PciLib.c
new file mode 100644
index 000000000000..54212670823b
--- /dev/null
+++ b/MdePkg/Library/DxePciLibEsal/PciLib.c
@@ -0,0 +1,1464 @@
+/** @file
+  DXE PCI Library instance layered on top of ESAL services.
+
+  Copyright (c) 2006 - 2012, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/PciLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/ExtendedSalLib.h>
+
+/**
+  Assert the validity of a PCI address. A valid PCI address should contain 1's
+  only in the low 28 bits.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A,M) \
+  ASSERT (((A) & (~0xfffffff | (M))) == 0)
+
+/**
+  Converts a PCI Library Address to a ESAL PCI Service Address.
+  Based on SAL Spec 3.2, there are two SAL PCI Address:
+
+  If address type = 0
+  Bits 0..7 - Register address
+  Bits 8..10 - Function number
+  Bits 11..15 - Device number
+  Bits 16..23 - Bus number
+  Bits 24..31 - PCI segment group
+  Bits 32..63 - Reserved (0)
+
+  If address type = 1
+  Bits 0..7 - Register address
+  Bits 8..11 - Extended Register address
+  Bits 12..14 - Function number
+  Bits 15..19 - Device number
+  Bits 20..27 - Bus number
+  Bits 28..43 - PCI segment group
+  Bits 44..63 - Reserved (0)
+
+  @param  A The PCI Library Address to convert.
+
+**/
+#define CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0(Address)  ((((Address) >> 4) & 0x00ffff00) | ((Address) & 0xff))
+#define CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1(Address)  (Address)
+
+/**
+  Check a PCI Library Address is a PCI Compatible Address or not.
+**/
+#define IS_PCI_COMPATIBLE_ADDRESS(Address)  (((Address) & 0xf00) == 0)
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EsalPciConfigRead function of Extended SAL PCI
+  Services Class.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+DxePciLibEsalReadWorker (
+  IN    UINTN                       Address,
+  IN    UINTN                       Width
+  )
+{
+ SAL_RETURN_REGS Return;
+
+  if (IS_PCI_COMPATIBLE_ADDRESS(Address)) {
+    Return = EsalCall (
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+               SalPciConfigReadFunctionId,
+               CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0 (Address),
+               Width,
+               EFI_SAL_PCI_COMPATIBLE_ADDRESS,
+               0,
+               0,
+               0,
+               0
+               );
+  } else {
+    Return = EsalCall (
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+               SalPciConfigReadFunctionId,
+               CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1 (Address),
+               Width,
+               EFI_SAL_PCI_EXTENDED_REGISTER_ADDRESS,
+               0,
+               0,
+               0,
+               0
+               );
+  }
+
+  return (UINT32) Return.r9;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EsalPciConfigWrite function of Extended SAL PCI
+  Services Class.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specified by Width.
+  Data is returned.
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+DxePciLibEsalWriteWorker (
+  IN    UINTN                       Address,
+  IN    UINTN                       Width,
+  IN    UINT32                      Data
+  )
+{
+  if (IS_PCI_COMPATIBLE_ADDRESS(Address)) {
+    EsalCall (
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+      SalPciConfigWriteFunctionId,
+      CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0 (Address),
+      Width,
+      Data,
+      EFI_SAL_PCI_COMPATIBLE_ADDRESS,
+      0,
+      0,
+      0
+      );
+  } else {
+    EsalCall (
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+      SalPciConfigWriteFunctionId,
+      CONVERT_PCI_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1 (Address),
+      Width,
+      Data,
+      EFI_SAL_PCI_EXTENDED_REGISTER_ADDRESS,
+      0,
+      0,
+      0
+      );
+  }
+
+  return Data;
+}
+
+/**
+  Register a PCI device so PCI configuration registers may be accessed after
+  SetVirtualAddressMap().
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  return RETURN_SUCCESS;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciLibEsalReadWorker (Address, 1);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Data
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciLibEsalWriteWorker (Address, 1, Data);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8)(PciRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (Address, (UINT8)(PciRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8)((PciRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldWrite8 (PciRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldOr8 (PciRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAnd8 (PciRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciLibEsalReadWorker (Address, 2);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Data
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciLibEsalWriteWorker (Address, 2, Data);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16)(PciRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (Address, (UINT16)(PciRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16)((PciRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldWrite16 (PciRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldOr16 (PciRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAnd16 (PciRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return DxePciLibEsalReadWorker (Address, 4);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Data
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return DxePciLibEsalWriteWorker (Address, 4, Data);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, (PciRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldWrite32 (PciRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldOr32 (PciRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAnd32 (PciRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x100);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    *(volatile UINT16 *)Buffer = PciRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    *(volatile UINT32 *)Buffer = PciRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    *(volatile UINT16 *)Buffer = PciRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x100);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciWrite16 (StartAddress, *(UINT16*)Buffer);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciWrite32 (StartAddress, *(UINT32*)Buffer);
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciWrite16 (StartAddress, *(UINT16*)Buffer);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegementLibEsal.uni b/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegementLibEsal.uni
new file mode 100644
index 000000000000..b247798bd51d
--- /dev/null
+++ b/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegementLibEsal.uni
@@ -0,0 +1,21 @@
+// /** @file
+// PCI Segment Library that uses ESAL services to perform PCI Configuration cycles.
+//
+// The PCI Segment Library that uses ESAL services to perform PCI Configuration cycles.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Uses ESAL services to perform PCI Configuration cycles"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The PCI Segment Library that uses ESAL services to perform PCI Configuration cycles."
+
diff --git a/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegmentLibEsal.inf b/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegmentLibEsal.inf
new file mode 100644
index 000000000000..0d9110503da8
--- /dev/null
+++ b/MdePkg/Library/DxePciSegmentLibEsal/DxePciSegmentLibEsal.inf
@@ -0,0 +1,40 @@
+## @file
+#  PCI Segment Library that uses ESAL services to perform PCI Configuration cycles.
+#
+#  Copyright (c) 2006 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxePciSegementLibEsal
+  MODULE_UNI_FILE                = DxePciSegementLibEsal.uni
+  FILE_GUID                      = 6D497A7A-D7DA-467c-B485-B7FB3493C41F
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciSegmentLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  PciLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  ExtendedSalLib
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/DxePciSegmentLibEsal/PciLib.c b/MdePkg/Library/DxePciSegmentLibEsal/PciLib.c
new file mode 100644
index 000000000000..36a667647fa8
--- /dev/null
+++ b/MdePkg/Library/DxePciSegmentLibEsal/PciLib.c
@@ -0,0 +1,1416 @@
+/** @file
+  DXE PCI Segment Library instance layered on top of ESAL services.
+
+  Copyright (c) 2006 - 2012, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/PciSegmentLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/ExtendedSalLib.h>
+
+/**
+  Assert the validity of a PCI Segment address.
+  A valid PCI Segment address should not contain 1's in bits 31:28
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_SEGMENT_ADDRESS(A,M) \
+  ASSERT (((A) & (0xf0000000 | (M))) == 0)
+
+/**
+  Converts a PCI Library Address to a ESAL PCI Service Address.
+  Based on SAL Spec 3.2, there are two SAL PCI Address:
+
+  If address type = 0
+  Bits 0..7 - Register address
+  Bits 8..10 - Function number
+  Bits 11..15 - Device number
+  Bits 16..23 - Bus number
+  Bits 24..31 - PCI segment group
+  Bits 32..63 - Reserved (0)
+
+  If address type = 1
+  Bits 0..7 - Register address
+  Bits 8..11 - Extended Register address
+  Bits 12..14 - Function number
+  Bits 15..19 - Device number
+  Bits 20..27 - Bus number
+  Bits 28..43 - PCI segment group
+  Bits 44..63 - Reserved (0)
+
+  @param  A The PCI Library Address to convert.
+
+**/
+#define CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0(Address)  (((Address >> 8) & 0xff000000) | (((Address) >> 4) & 0x00ffff00) | ((Address) & 0xff))
+#define CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1(Address)  (((Address >> 4) & 0xffff0000000) | ((Address) & 0xfffffff))
+
+/**
+  Check a PCI Library Address is a PCI Compatible Address or not.
+**/
+#define IS_PCI_COMPATIBLE_ADDRESS(Address)  (((Address) & 0xf00) == 0)
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EsalPciConfigRead function of Extended SAL PCI
+  Services Class.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+DxePciSegmentLibEsalReadWorker (
+  IN  UINT64        Address,
+  IN  UINTN         Width
+  )
+{
+  SAL_RETURN_REGS Return;
+
+  if (IS_PCI_COMPATIBLE_ADDRESS(Address)) {
+    Return = EsalCall (
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+               SalPciConfigReadFunctionId,
+               CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0 (Address),
+               Width,
+               EFI_SAL_PCI_COMPATIBLE_ADDRESS,
+               0,
+               0,
+               0,
+               0
+               );
+  } else {
+    Return = EsalCall (
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+               EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+               SalPciConfigReadFunctionId,
+               CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1 (Address),
+               Width,
+               EFI_SAL_PCI_EXTENDED_REGISTER_ADDRESS,
+               0,
+               0,
+               0,
+               0
+               );
+  }
+
+  return (UINT32) Return.r9;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EsalPciConfigWrite function of Extended SAL PCI
+  Services Class.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specified by Width.
+  Data is returned.
+
+  @param  Address Address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+DxePciSegmentLibEsalWriteWorker (
+  IN  UINT64           Address,
+  IN  UINTN            Width,
+  IN  UINT32           Data
+  )
+{
+  if (IS_PCI_COMPATIBLE_ADDRESS(Address)) {
+    EsalCall (
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+      SalPciConfigWriteFunctionId,
+      CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS0 (Address),
+      Width,
+      Data,
+      EFI_SAL_PCI_COMPATIBLE_ADDRESS,
+      0,
+      0,
+      0
+      );
+  } else {
+    EsalCall (
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+      EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+      SalPciConfigWriteFunctionId,
+      CONVERT_PCI_SEGMENT_LIB_ADDRESS_TO_PCI_ESAL_ADDRESS1 (Address),
+      Width,
+      Data,
+      EFI_SAL_PCI_EXTENDED_REGISTER_ADDRESS,
+      0,
+      0,
+      0
+      );
+  }
+
+  return Data;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentRead8 (
+  IN      UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciSegmentLibEsalReadWorker (Address, 1);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentWrite8 (
+  IN      UINT64                    Address,
+  IN      UINT8                     Data
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciSegmentLibEsalWriteWorker (Address, 1, Data);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentOr8 (
+  IN      UINT64                    Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAnd8 (
+  IN      UINT64                    Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAndThenOr8 (
+  IN      UINT64                    Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) ((PciSegmentRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldRead8 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciSegmentRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldWrite8 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldWrite8 (PciSegmentRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldOr8 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldOr8 (PciSegmentRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAnd8 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAnd8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAndThenOr8 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentRead16 (
+  IN      UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciSegmentLibEsalReadWorker (Address, 2);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentWrite16 (
+  IN      UINT64                    Address,
+  IN      UINT16                    Data
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciSegmentLibEsalWriteWorker (Address, 2, Data);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentOr16 (
+  IN      UINT64                    Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAnd16 (
+  IN      UINT64                    Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAndThenOr16 (
+  IN      UINT64                    Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) ((PciSegmentRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldRead16 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciSegmentRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldWrite16 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldWrite16 (PciSegmentRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldOr16 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldOr16 (PciSegmentRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAnd16 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAnd16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAndThenOr16 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentRead32 (
+  IN      UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return DxePciSegmentLibEsalReadWorker (Address, 4);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentWrite32 (
+  IN      UINT64                    Address,
+  IN      UINT32                    Data
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return DxePciSegmentLibEsalWriteWorker (Address, 4, Data);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentOr32 (
+  IN      UINT64                    Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAnd32 (
+  IN      UINT64                    Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address Address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAndThenOr32 (
+  IN      UINT64                    Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, (PciSegmentRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldRead32 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciSegmentRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     New value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldWrite32 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldWrite32 (PciSegmentRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldOr32 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldOr32 (PciSegmentRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAnd32 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAnd32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAndThenOr32 (
+  IN      UINT64                    Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting Address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentReadBuffer (
+  IN      UINT64                    StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    *(volatile UINT16 *)Buffer = PciSegmentRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    *(volatile UINT32 *)Buffer = PciSegmentRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    *(volatile UINT16 *)Buffer = PciSegmentRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  Starting Address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          Size in bytes of the transfer.
+  @param  Buffer        Pointer to a buffer containing the data to write.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentWriteBuffer (
+  IN      UINT64                    StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciSegmentWrite16 (StartAddress, *(UINT16*)Buffer);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciSegmentWrite32 (StartAddress, *(UINT32*)Buffer);
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciSegmentWrite16 (StartAddress, *(UINT16*)Buffer);
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.inf b/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.inf
new file mode 100644
index 000000000000..aefdd23b5754
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.inf
@@ -0,0 +1,52 @@
+## @file
+#  This library implements the Extended SAL Library Class for use in boot services and runtime.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeRuntimeExtendedSalLib
+  MODULE_UNI_FILE                = DxeRuntimeExtendedSalLib.uni
+  FILE_GUID                      = AE66715B-75F5-4423-8FAD-A4AFB3C53ACF
+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ExtendedSalLib|DXE_RUNTIME_DRIVER DXE_SAL_DRIVER 
+  CONSTRUCTOR                    = DxeRuntimeExtendedSalLibConstruct
+  DESTRUCTOR                     = DxeRuntimeExtendedSalLibDeconstruct
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.IPF]
+  ExtendedSalLib.c
+  Ipf/AsmExtendedSalLib.s
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  UefiRuntimeServicesTableLib
+  DebugLib
+
+[Protocols]
+  gEfiExtendedSalBootServiceProtocolGuid        ## CONSUMES
+
+[Guids]
+  gEfiEventVirtualAddressChangeGuid   ## CONSUMES  ## Event
+
+[Depex]
+  gEfiExtendedSalBootServiceProtocolGuid
+
diff --git a/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.uni b/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.uni
new file mode 100644
index 000000000000..692b732618e8
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// This library implements the Extended SAL Library Class for use in boot services and runtime.
+//
+// This library implements the Extended SAL Library Class for use in boot services and runtime.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Implements the Extended SAL Library Class for use in boot services and runtime"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library implements the Extended SAL Library Class for use in boot services and runtime."
+
diff --git a/MdePkg/Library/DxeRuntimeExtendedSalLib/ExtendedSalLib.c b/MdePkg/Library/DxeRuntimeExtendedSalLib/ExtendedSalLib.c
new file mode 100644
index 000000000000..fdb9a95f484d
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimeExtendedSalLib/ExtendedSalLib.c
@@ -0,0 +1,1124 @@
+/** @file
+  This library implements the Extended SAL Library Class for use in boot services and runtime.
+
+  Copyright (c) 2006 - 2012, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalBootService.h>
+#include <Protocol/ExtendedSalServiceClasses.h>
+#include <Guid/EventGroup.h>
+
+#include <Library/ExtendedSalLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/UefiRuntimeLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Stores the virtual plabel of ESAL entrypoint.
+
+  This assembly function stores the virtual plabel of ESAL entrypoint
+  where GetEsalEntryPoint() can easily retrieve.
+
+  @param  EntryPoint  Virtual address of ESAL entrypoint
+  @param  Gp          Virtual GP of ESAL entrypoint
+
+  @return r8 = EFI_SAL_SUCCESS
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SetEsalVirtualEntryPoint (
+  IN  UINT64  EntryPoint,
+  IN  UINT64  Gp
+  );
+
+/**
+  Stores the physical plabel of ESAL entrypoint.
+
+  This assembly function stores the physical plabel of ESAL entrypoint
+  where GetEsalEntryPoint() can easily retrieve.
+
+  @param  EntryPoint  Physical address of ESAL entrypoint
+  @param  Gp          Physical GP of ESAL entrypoint
+
+  @return r8 = EFI_SAL_SUCCESS
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SetEsalPhysicalEntryPoint (
+  IN  UINT64  EntryPoint,
+  IN  UINT64  Gp
+  );
+
+/**
+  Retrieves plabel of ESAL entrypoint.
+
+  This function retrives plabel of ESAL entrypoint stored by
+  SetEsalPhysicalEntryPoint().
+
+  @return r8  = EFI_SAL_SUCCESS
+          r9  = Physical Plabel
+          r10 = Virtual Plabel
+          r11 = PSR
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+GetEsalEntryPoint (
+  VOID
+  );
+
+EXTENDED_SAL_BOOT_SERVICE_PROTOCOL  *mEsalBootService = NULL;
+EFI_PLABEL                          mPlabel;
+EFI_EVENT                           mEfiVirtualNotifyEvent;
+
+/**
+  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE to set virtual plabel of
+  ESAL entrypoint.
+
+  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
+  It converts physical plabel of ESAL entrypoint to virtual plabel and stores it where
+  GetEsalEntryPoint() can easily retrieve.
+
+  @param  Event        Event whose notification function is being invoked.
+  @param  Context      Pointer to the notification function's context
+
+**/
+VOID
+EFIAPI
+ExtendedSalVirtualNotifyEvent (
+  IN EFI_EVENT        Event,
+  IN VOID             *Context
+  )
+{
+  UINT64  PhysicalEntryPoint;
+
+  PhysicalEntryPoint = mPlabel.EntryPoint;
+
+  gRT->ConvertPointer (0x0, (VOID **) &mPlabel.EntryPoint);
+
+  mPlabel.GP += mPlabel.EntryPoint - PhysicalEntryPoint;
+
+  SetEsalVirtualEntryPoint (mPlabel.EntryPoint, mPlabel.GP);
+}
+
+/**
+  Gets Extended SAL Boot Service Protocol, and initializes physical plabel of
+  ESAL entrypoint.
+
+  This function first locates Extended SAL Boot Service Protocol and caches it in global variable.
+  Then it initializes the physical plable of ESAL entrypoint, and stores
+  it where GetEsalEntryPoint() can easily retrieve.
+
+  @retval  EFI_SUCCESS  Plable of ESAL entrypoint successfully stored.
+
+**/
+EFI_STATUS
+DxeSalLibInitialize (
+  VOID
+  )
+{
+  EFI_PLABEL  *Plabel;
+  EFI_STATUS  Status;
+
+  //
+  // The protocol contains a function pointer, which is an indirect procedure call.
+  // An indirect procedure call goes through a plabel, and pointer to a function is
+  // a pointer to a plabel. To implement indirect procedure calls that can work in
+  // both physical and virtual mode, two plabels are required (one physical and one
+  // virtual). So lets grap the physical PLABEL for the EsalEntryPoint and store it
+  // away. We cache it in a module global, so we can register the vitrual version.
+  //
+  Status = gBS->LocateProtocol (&gEfiExtendedSalBootServiceProtocolGuid, NULL, (VOID **) &mEsalBootService);
+  ASSERT_EFI_ERROR (Status);
+
+  Plabel              = (EFI_PLABEL *) (UINTN) mEsalBootService->ExtendedSalProc;
+  mPlabel.EntryPoint  = Plabel->EntryPoint;
+  mPlabel.GP          = Plabel->GP;
+  //
+  // Stores the physical plabel of ESAL entrypoint where GetEsalEntryPoint() can easily retrieve.
+  //
+  SetEsalPhysicalEntryPoint (mPlabel.EntryPoint, mPlabel.GP);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Constructor function to initializes physical plabel of ESAL entrypoint and register an event
+  for initialization of virtual plabel of ESAL entrypoint.
+  
+  This is the library constructor function to call a function to initialize physical plabel of ESAL entrypoint
+  and to register notification function for 
+  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE, which sets virtual plabel of ESAL entrypoint.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   Notification function successfully registered.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeRuntimeExtendedSalLibConstruct (
+  IN EFI_HANDLE           ImageHandle,
+  IN EFI_SYSTEM_TABLE     *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // Register notify function for EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
+  //
+  ASSERT (gBS != NULL);
+
+  DxeSalLibInitialize ();
+
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  ExtendedSalVirtualNotifyEvent,
+                  NULL,
+                  &gEfiEventVirtualAddressChangeGuid,
+                  &mEfiVirtualNotifyEvent
+                  );
+
+  ASSERT_EFI_ERROR (Status);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Destructor function to close the event created by the library constructor 
+  
+  This is the library destructor function to close the event with type of 
+  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE, which is created by the library constructor.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   Event successfully closed.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeRuntimeExtendedSalLibDeconstruct (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // Close SetVirtualAddressMap () notify function
+  //
+  ASSERT (gBS != NULL);
+  Status = gBS->CloseEvent (mEfiVirtualNotifyEvent);
+  ASSERT_EFI_ERROR (Status);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Registers function of ESAL class and it's associated global.
+  
+  This function registers function of ESAL class, together with its associated global.
+  It is worker function for RegisterEsalClass().
+  It is only for boot time.
+
+  @param  FunctionId     ID of function to register
+  @param  ClassGuidLo    GUID of ESAL class, lower 64-bits
+  @param  ClassGuidHi    GUID of ESAL class, upper 64-bits
+  @param  Function       Function to register with ClassGuid/FunctionId pair
+  @param  ModuleGlobal   Module global for the function.
+
+  @return Status returned by RegisterExtendedSalProc() of Extended SAL Boot Service Protocol
+
+**/
+EFI_STATUS
+RegisterEsalFunction (
+  IN  UINT64                                    FunctionId,
+  IN  UINT64                                    ClassGuidLo,
+  IN  UINT64                                    ClassGuidHi,
+  IN  SAL_INTERNAL_EXTENDED_SAL_PROC            Function,
+  IN  VOID                                      *ModuleGlobal
+  )
+{
+  return mEsalBootService->RegisterExtendedSalProc (
+                             mEsalBootService,
+                             ClassGuidLo,
+                             ClassGuidHi,
+                             FunctionId,
+                             Function,
+                             ModuleGlobal
+                             );
+}
+
+/**
+  Registers ESAL Class and it's associated global.
+  
+  This function registers one or more Extended SAL services in a given
+  class along with the associated global context.
+  This function is only available prior to ExitBootServices().
+
+  @param  ClassGuidLo          GUID of function class, lower 64-bits
+  @param  ClassGuidHi          GUID of function class, upper 64-bits
+  @param  ModuleGlobal         Module global for the class.
+  @param  ...                  List of Function/FunctionId pairs, ended by NULL
+
+  @retval EFI_SUCCESS          The Extended SAL services were registered.
+  @retval EFI_UNSUPPORTED      This function was called after ExitBootServices().
+  @retval EFI_OUT_OF_RESOURCES There are not enough resources available to register one or more of the specified services.
+  @retval Other                ClassGuid could not be installed onto a new handle.  
+
+**/
+EFI_STATUS
+EFIAPI
+RegisterEsalClass (
+  IN  CONST UINT64    ClassGuidLo,
+  IN  CONST UINT64    ClassGuidHi,
+  IN  VOID            *ModuleGlobal,  OPTIONAL
+  ...
+  )
+{
+  VA_LIST                         Args;
+  EFI_STATUS                      Status;
+  SAL_INTERNAL_EXTENDED_SAL_PROC  Function;
+  UINT64                          FunctionId;
+  EFI_HANDLE                      NewHandle;
+  EFI_GUID                        ClassGuid;
+
+  VA_START (Args, ModuleGlobal);
+
+  //
+  // Register all functions of the class to register.
+  //
+  Status = EFI_SUCCESS;
+  while (!EFI_ERROR (Status)) {
+    Function = (SAL_INTERNAL_EXTENDED_SAL_PROC) VA_ARG (Args, SAL_INTERNAL_EXTENDED_SAL_PROC);
+    //
+    // NULL serves as the end mark of function list
+    //
+    if (Function == NULL) {
+      break;
+    }
+
+    FunctionId  = VA_ARG (Args, UINT64);
+
+    Status      = RegisterEsalFunction (FunctionId, ClassGuidLo, ClassGuidHi, Function, ModuleGlobal);
+  }
+
+  VA_END (Args);
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  NewHandle = NULL;
+  *((UINT64 *)(&ClassGuid) + 0) = ClassGuidLo;
+  *((UINT64 *)(&ClassGuid) + 1) = ClassGuidHi;
+  return gBS->InstallProtocolInterface (
+                &NewHandle,
+                &ClassGuid,
+                EFI_NATIVE_INTERFACE,
+                NULL
+                );
+}
+
+/**
+  Calls an Extended SAL Class service that was previously registered with RegisterEsalClass().
+  
+  This function gets the entrypoint of Extended SAL, and calls an Extended SAL Class service
+  that was previously registered with RegisterEsalClass() through this entrypoint.
+
+  @param  ClassGuidLo     GUID of function, lower 64-bits
+  @param  ClassGuidHi     GUID of function, upper 64-bits
+  @param  FunctionId      Function in ClassGuid to call
+  @param  Arg2            Argument 2 ClassGuid/FunctionId defined
+  @param  Arg3            Argument 3 ClassGuid/FunctionId defined
+  @param  Arg4            Argument 4 ClassGuid/FunctionId defined
+  @param  Arg5            Argument 5 ClassGuid/FunctionId defined
+  @param  Arg6            Argument 6 ClassGuid/FunctionId defined
+  @param  Arg7            Argument 7 ClassGuid/FunctionId defined
+  @param  Arg8            Argument 8 ClassGuid/FunctionId defined
+  
+  @retval EFI_SAL_SUCCESS ESAL procedure successfully called.
+  @retval EFI_SAL_ERROR   The address of ExtendedSalProc() can not be correctly
+                          initialized.
+  @retval Other           Status returned from ExtendedSalProc() service of
+                          EXTENDED_SAL_BOOT_SERVICE_PROTOCOL.  
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalCall (
+  IN  UINT64    ClassGuidLo,
+  IN  UINT64    ClassGuidHi,
+  IN  UINT64    FunctionId,
+  IN  UINT64    Arg2,
+  IN  UINT64    Arg3,
+  IN  UINT64    Arg4,
+  IN  UINT64    Arg5,
+  IN  UINT64    Arg6,
+  IN  UINT64    Arg7,
+  IN  UINT64    Arg8
+  )
+{
+  SAL_RETURN_REGS       ReturnReg;
+  EXTENDED_SAL_PROC     EsalProc;
+
+  //
+  // Get the entrypoint of Extended SAL
+  //
+  ReturnReg = GetEsalEntryPoint ();
+  if (*(UINT64 *)ReturnReg.r9 == 0 && *(UINT64 *)(ReturnReg.r9 + 8) == 0) {
+    //
+    // The ESAL Entry Point could not be initialized
+    //
+    ReturnReg.Status = EFI_SAL_ERROR;
+    return ReturnReg;
+  }
+
+  //
+  // Test PSR.it which is BIT36
+  //
+  if ((ReturnReg.r11 & BIT36) != 0) {
+    //
+    // Virtual mode plabel to entry point
+    //
+    EsalProc = (EXTENDED_SAL_PROC) ReturnReg.r10;
+  } else {
+    //
+    // Physical mode plabel to entry point
+    //
+    EsalProc = (EXTENDED_SAL_PROC) ReturnReg.r9;
+  }
+
+  return EsalProc (
+           ClassGuidLo,
+           ClassGuidHi,
+           FunctionId,
+           Arg2,
+           Arg3,
+           Arg4,
+           Arg5,
+           Arg6,
+           Arg7,
+           Arg8
+           );
+}
+
+/**
+  Wrapper for the EsalStallFunctionId service of Extended SAL Stall Services Class.
+  
+  This function is a wrapper for the EsalStallFunctionId service of Extended SAL
+  Stall Services Class. See EsalStallFunctionId of Extended SAL Specification.
+
+  @param  Microseconds         The number of microseconds to delay.
+
+  @retval EFI_SAL_SUCCESS               Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT      Invalid argument.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR Virtual address not registered
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalStall (
+  IN UINTN  Microseconds
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_LO, 
+           EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_HI, 
+           StallFunctionId, 
+           Microseconds, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalSetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalSetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress        If TRUE, then PalEntryPoint is a physical address.
+                                 If FALSE, then PalEntryPoint is a virtual address.
+  @param  PalEntryPoint          The PAL Entry Point being set.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was set.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress,
+  IN UINT64   PalEntryPoint
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO, 
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+           SetNewPalEntryFunctionId, 
+           PhysicalAddress, 
+           PalEntryPoint, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL PAL Services Services Class.
+  
+  This function is a wrapper for the EsalGetNewPalEntryFunctionId service of Extended SAL
+  PAL Services Services Class. See EsalGetNewPalEntryFunctionId of Extended SAL Specification.
+
+  @param  PhysicalAddress        If TRUE, then PalEntryPoint is a physical address.
+                                 If FALSE, then PalEntryPoint is a virtual address.
+
+  @retval EFI_SAL_SUCCESS                The PAL Entry Point was retrieved and returned in
+                                         SAL_RETURN_REGS.r9.
+  @retval EFI_SAL_VIRTUAL_ADDRESS_ERROR  This function was called in virtual mode before
+                                         virtual mappings for the specified Extended SAL
+                                         Procedure are available.
+  @return r9                             PAL entry point retrieved.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetNewPalEntry (
+  IN BOOLEAN  PhysicalAddress
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+           GetNewPalEntryFunctionId, 
+           PhysicalAddress, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalGetStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalGetStateBufferFunctionId of Extended SAL Specification.
+
+  @param  McaType         See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+  @param  McaBuffer             A pointer to the base address of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r9.
+  @param  BufferSize            A pointer to the size, in bytes, of the returned buffer.
+                                Copied from SAL_RETURN_REGS.r10.
+
+  @retval EFI_SAL_SUCCESS       The memory buffer to store error records was returned in r9 and r10.
+  @retval EFI_OUT_OF_RESOURCES  A memory buffer for string error records in not available
+  @return r9                    Base address of the returned buffer
+  @return r10                   Size of the returned buffer in bytes
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetStateBuffer (
+  IN  UINT64  McaType,
+  OUT UINT8   **McaBuffer,
+  OUT UINTN   *BufferSize
+  )
+{
+  SAL_RETURN_REGS Regs;
+
+  Regs = EsalCall (
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetStateBufferFunctionId, 
+           McaType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+
+  *McaBuffer  = (UINT8 *) Regs.r9;
+  *BufferSize = Regs.r10;
+
+  return Regs;
+}
+
+/**
+  Wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL MCA Log Services Class.
+  
+  This function is a wrapper for the EsalSaveStateBufferFunctionId service of Extended SAL
+  MCA Log Services Class. See EsalSaveStateBufferFunctionId of Extended SAL Specification.
+  
+  @param  McaType         See type parameter of SAL Procedure SAL_GET_STATE_INFO.
+
+  @retval EFI_SUCCESS  The memory buffer containing the error record was written to nonvolatile storage.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSaveStateBuffer (
+  IN  UINT64  McaType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+           EsalSaveStateBufferFunctionId, 
+           McaType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetVectorsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetVectorsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetVectorsFunctionId of Extended SAL Specification.
+
+  @param  VectorType         The vector type to retrieve.
+                             0 - MCA, 1 - BSP INIT, 2 - BOOT_RENDEZ, 3 - AP INIT.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_SET_VECTORS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetVectors (
+  IN  UINT64  VectorType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetVectorsFunctionId, 
+           VectorType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+
+  @param  ParamInfoType         The parameter type to retrieve.
+                                1 - rendezvous interrupt
+                                2 - wake up
+                                3 - Corrected Platform Error Vector.
+
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_INVALID_ARGUMENT Invalid argument.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetParams (
+  IN  UINT64  ParamInfoType
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalMcGetParamsFunctionId, 
+           ParamInfoType, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcGetParamsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalMcGetParamsFunctionId service of Extended SAL
+  Base Services Class. See EsalMcGetParamsFunctionId of Extended SAL Specification.
+  
+  @retval EFI_SAL_SUCCESS          Call completed without error.
+  @retval EFI_SAL_NO_INFORMATION   The requested vector has not been registered
+                                   with the SAL Procedure SAL_MC_SET_PARAMS.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcGetMcParams (
+  VOID
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalMcGetMcParamsFunctionId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL Base Services Class.
+  
+  This function is a wrapper for the EsalGetMcCheckinFlagsFunctionId service of Extended SAL
+  Base Services Class. See EsalGetMcCheckinFlagsFunctionId of Extended SAL Specification.
+
+  @param  CpuIndex         The index of the CPU of set of enabled CPUs to check.
+
+  @retval EFI_SAL_SUCCESS  The checkin status of the requested CPU was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMcCheckinFlags (
+  IN  UINT64  CpuIndex
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+           EsalGetMcCheckinFlagsFunctionId, 
+           CpuIndex, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalAddCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalAddCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalAddCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId         The Global ID for the CPU being added.
+  @param  Enabled             The enable flag for the CPU being added.
+                              TRUE means the CPU is enabled.
+                              FALSE means the CPU is disabled.
+  @param  PalCompatibility    The PAL Compatibility value for the CPU being added.
+
+  @retval EFI_SAL_SUCCESS             The CPU was added to the database.
+  @retval EFI_SAL_NOT_ENOUGH_SCRATCH  There are not enough resource available to add the CPU.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalAddCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           AddCpuDataFunctionId, 
+           CpuGlobalId, 
+           Enabled, 
+           PalCompatibility, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalRemoveCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalRemoveCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId         The Global ID for the CPU being removed.
+
+  @retval EFI_SAL_SUCCESS         The CPU was removed from the database.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalRemoveCpuData (
+  IN UINT64  CpuGlobalId
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           RemoveCpuDataFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalModifyCpuDataFunctionId service of Extended SAL
+  MP Services Class. See EsalModifyCpuDataFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId         The Global ID for the CPU being modified.
+  @param  Enabled             The enable flag for the CPU being modified.
+                              TRUE means the CPU is enabled.
+                              FALSE means the CPU is disabled.
+  @param  PalCompatibility    The PAL Compatibility value for the CPU being modified.
+
+  @retval EFI_SAL_SUCCESS         The CPU database was updated.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalModifyCpuData (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  Enabled,
+  IN UINT64   PalCompatibility
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           ModifyCpuDataFunctionId, 
+           CpuGlobalId, 
+           Enabled, 
+           PalCompatibility, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIdFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIdFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId         The Global ID for the CPU being looked up.
+  @param  IndexByEnabledCpu   If TRUE, then the index of set of enabled CPUs of database is returned.
+                              If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataById (
+  IN UINT64   CpuGlobalId,
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetCpuDataByIDFunctionId, 
+           CpuGlobalId, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetCpuDataByIndexFunctionId service of Extended SAL
+  MP Services Class. See EsalGetCpuDataByIndexFunctionId of Extended SAL Specification.
+
+  @param  Index               The Global ID for the CPU being modified.
+  @param  IndexByEnabledCpu   If TRUE, then the index of set of enabled CPUs of database is returned.
+                              If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The information on the specified CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetCpuDataByIndex (
+  IN UINT64   Index,
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetCpuDataByIndexFunctionId, 
+           Index, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalWhoAmIFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalWhoAmIFunctionId service of Extended SAL
+  MP Services Class. See EsalWhoAmIFunctionId of Extended SAL Specification.
+
+  @param  IndexByEnabledCpu   If TRUE, then the index of set of enabled CPUs of database is returned.
+                              If FALSE, then the index of set of all CPUs of database is returned.
+
+  @retval EFI_SAL_SUCCESS         The Global ID for the calling CPU was returned.
+  @retval EFI_SAL_NO_INFORMATION  The calling CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalWhoAmI (
+  IN BOOLEAN  IndexByEnabledCpu
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           CurrentProcInfoFunctionId, 
+           IndexByEnabledCpu, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalNumProcessors service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalNumProcessors service of Extended SAL
+  MP Services Class. See EsalNumProcessors of Extended SAL Specification.
+
+  @retval EFI_SAL_SUCCESS    The information on the number of CPUs in the platform
+                             was returned.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalNumProcessors (
+  VOID
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           NumProcessorsFunctionId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalSetMinStateFnctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalSetMinStateFnctionId service of Extended SAL
+  MP Services Class. See EsalSetMinStateFnctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId       The Global ID for the CPU whose MINSTATE pointer is being set.
+  @param  MinStatePointer          The physical address of the MINSTATE buffer for the CPU
+                                   specified by CpuGlobalId.
+
+  @retval EFI_SAL_SUCCESS          The MINSTATE pointer was set for the specified CPU.
+  @retval EFI_SAL_NO_INFORMATION   The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalSetMinState (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  MinStatePointer
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           SetMinStateFunctionId, 
+           CpuGlobalId, 
+           MinStatePointer, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalGetMinStateFunctionId service of Extended SAL MP Services Class.
+  
+  This function is a wrapper for the EsalGetMinStateFunctionId service of Extended SAL
+  MP Services Class. See EsalGetMinStateFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId   The Global ID for the CPU whose MINSTATE pointer is being retrieved.
+
+  @retval EFI_SAL_SUCCESS        The MINSTATE pointer for the specified CPU was retrieved.
+  @retval EFI_SAL_NO_INFORMATION The specified CPU is not in the database.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalGetMinState (
+  IN UINT64  CpuGlobalId
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MP_SERVICES_PROTOCOL_GUID_HI,
+           GetMinStateFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
+
+/**
+  Wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcsGetStateInfoFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcsGetStateInfoFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId               The Global ID for the CPU whose MCA state buffer is being retrieved.
+  @param  StateBufferPointer        A pointer to the returned MCA state buffer.
+  @param  RequiredStateBufferSize   A pointer to the size, in bytes, of the returned MCA state buffer.
+
+  @retval EFI_SUCCESS               MINSTATE successfully got and size calculated.
+  @retval EFI_SAL_NO_INFORMATION    Fail to get MINSTATE.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaGetStateInfo (
+  IN  UINT64                CpuGlobalId,
+  OUT EFI_PHYSICAL_ADDRESS  *StateBufferPointer,
+  OUT UINT64                *RequiredStateBufferSize
+  )
+{
+  SAL_RETURN_REGS  Regs;
+
+  Regs = EsalCall (
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_HI,
+           McaGetStateInfoFunctionId, 
+           CpuGlobalId, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+
+  *StateBufferPointer      = (EFI_PHYSICAL_ADDRESS) Regs.r9;
+  *RequiredStateBufferSize = (UINT64) Regs.r10;
+
+  return Regs;
+}
+
+/**
+  Wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL MCA Services Class.
+  
+  This function is a wrapper for the EsalMcaRegisterCpuFunctionId service of Extended SAL
+  MCA Services Class. See EsalMcaRegisterCpuFunctionId of Extended SAL Specification.
+
+  @param  CpuGlobalId          The Global ID for the CPU whose MCA state buffer is being set.
+  @param  StateBufferPointer   A pointer to the MCA state buffer.
+
+  @retval EFI_SAL_NO_INFORMATION   Cannot get the processor info with the CpuId
+  @retval EFI_SUCCESS              Save the processor's state info successfully
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+EsalMcaRegisterCpu (
+  IN UINT64                CpuGlobalId,
+  IN EFI_PHYSICAL_ADDRESS  StateBufferPointer
+  )
+{
+  return EsalCall (
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_LO,
+           EFI_EXTENDED_SAL_MCA_SERVICES_PROTOCOL_GUID_HI,
+           McaRegisterCpuFunctionId, 
+           CpuGlobalId, 
+           StateBufferPointer, 
+           0, 
+           0, 
+           0, 
+           0, 
+           0
+           );
+}
diff --git a/MdePkg/Library/DxeRuntimeExtendedSalLib/Ipf/AsmExtendedSalLib.s b/MdePkg/Library/DxeRuntimeExtendedSalLib/Ipf/AsmExtendedSalLib.s
new file mode 100644
index 000000000000..131df9e25b63
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimeExtendedSalLib/Ipf/AsmExtendedSalLib.s
@@ -0,0 +1,131 @@
+/// @file
+///  Assembly procedures to get and set ESAL entry point.
+///
+/// Copyright (c) 2006 - 2011, 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.
+///
+
+.auto
+.text
+
+#include  "IpfMacro.i"
+
+//
+// Exports
+//
+ASM_GLOBAL GetEsalEntryPoint
+
+//-----------------------------------------------------------------------------
+//++
+// GetEsalEntryPoint
+//
+// Return Esal global and PSR register.
+//
+// On Entry :
+//
+//
+// Return Value:
+//        r8  = EFI_SAL_SUCCESS
+//        r9  = Physical Plabel
+//        r10 = Virtual Plabel
+//        r11 = psr
+// 
+// As per static calling conventions. 
+// 
+//--
+//---------------------------------------------------------------------------
+PROCEDURE_ENTRY (GetEsalEntryPoint)
+
+      NESTED_SETUP (0,8,0,0)
+
+EsalCalcStart:
+      mov   r8  = ip;;
+      add   r8  = (EsalEntryPoint - EsalCalcStart), r8;;
+      mov   r9  = r8;;
+      add   r10 = 0x10, r8;;
+      mov   r11 = psr;;
+      mov   r8  = r0;;
+
+      NESTED_RETURN
+
+PROCEDURE_EXIT (GetEsalEntryPoint)
+
+//-----------------------------------------------------------------------------
+//++
+// SetEsalPhysicalEntryPoint
+//
+// Set the dispatcher entry point
+//
+// On Entry:
+//  in0 = Physical address of Esal Dispatcher
+//  in1 = Physical GP
+//
+// Return Value: 
+//   r8 = EFI_SAL_SUCCESS
+// 
+// As per static calling conventions. 
+// 
+//--
+//---------------------------------------------------------------------------
+PROCEDURE_ENTRY (SetEsalPhysicalEntryPoint)
+
+      NESTED_SETUP (2,8,0,0)
+
+EsalCalcStart1:
+      mov   r8   = ip;;
+      add   r8   = (EsalEntryPoint - EsalCalcStart1), r8;;
+      st8   [r8] = in0;;
+      add   r8   = 0x08, r8;;
+      st8   [r8] = in1;;
+      mov   r8   = r0;;
+
+      NESTED_RETURN
+
+PROCEDURE_EXIT (SetEsalPhysicalEntryPoint)
+
+//-----------------------------------------------------------------------------
+//++
+// SetEsalVirtualEntryPoint
+//
+// Register physical address of Esal globals.
+//
+// On Entry :
+//  in0 = Virtual address of Esal Dispatcher
+//  in1 = Virtual GP
+//
+// Return Value: 
+//  r8 = EFI_SAL_ERROR
+// 
+// As per static calling conventions. 
+// 
+//--
+//---------------------------------------------------------------------------
+PROCEDURE_ENTRY (SetEsalVirtualEntryPoint)
+
+      NESTED_SETUP (2,8,0,0)
+
+EsalCalcStart2:
+      mov   r8   = ip;;
+      add   r8   = (EsalEntryPoint - EsalCalcStart2), r8;;
+      add   r8   = 0x10, r8;;
+      st8   [r8] = in0;;
+      add   r8   = 0x08, r8;;
+      st8   [r8] = in1;;
+      mov   r8   = r0;;
+
+      NESTED_RETURN
+
+PROCEDURE_EXIT (SetEsalVirtualEntryPoint)
+
+.align 32
+EsalEntryPoint: 
+    data8 0   // Physical Entry
+    data8 0   //         GP
+    data8 0   // Virtual Entry
+    data8 0   //         GP
diff --git a/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.inf b/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.inf
new file mode 100644
index 000000000000..3992fa9f75cd
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.inf
@@ -0,0 +1,58 @@
+## @file
+# Instance of PCI Express Library using the 256 MB PCI Express MMIO window that 
+# is safe for runtime use.
+#
+# PCI Express Library that uses the 256 MB PCI Express MMIO window to perform
+#  PCI Configuration cycles. Layers on top of an I/O Library instance.  A table of 
+#  PCI devices that are registered for for runtime access is maintained so the 
+#  proper virtual address is used to perform the PCI Express Configuration cycle.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeRuntimePciExpressLib
+  MODULE_UNI_FILE                = DxeRuntimePciExpressLib.uni
+  FILE_GUID                      = 54DCBCE5-92AD-41f5-AAAF-1170F16DA6A8
+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciExpressLib|DXE_RUNTIME_DRIVER 
+  CONSTRUCTOR                    = DxeRuntimePciExpressLibConstructor
+  DESTRUCTOR                     = DxeRuntimePciExpressLibDestructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciExpressLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  IoLib
+  DebugLib
+  PcdLib
+  MemoryAllocationLib
+  UefiBootServicesTableLib
+  DxeServicesTableLib
+  UefiRuntimeLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress  ## CONSUMES
+
+[Guids]
+  gEfiEventVirtualAddressChangeGuid         ## CONSUMES ## Event
+
diff --git a/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.uni b/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.uni
new file mode 100644
index 000000000000..51c2cea38002
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.uni
@@ -0,0 +1,26 @@
+// /** @file
+// Instance of PCI Express Library using the 256 MB PCI Express MMIO window that
+//
+// is safe for runtime use.
+// 
+// PCI Express Library that uses the 256 MB PCI Express MMIO window to perform
+// PCI Configuration cycles. Layers on top of an I/O Library instance.  A table of
+// PCI devices that are registered for for runtime access is maintained so the
+// proper virtual address is used to perform the PCI Express Configuration cycle.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCI Express Support Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The PCI Express Library uses a 256 MB PCI Express MMIO window to perform PCI Configuration cycles. This library layers on top of an I/O Library instance.  A table of PCI devices that are registered for runtime access is maintained so that the proper virtual address is used to perform the PCI Express Configuration cycle."
+
diff --git a/MdePkg/Library/DxeRuntimePciExpressLib/PciExpressLib.c b/MdePkg/Library/DxeRuntimePciExpressLib/PciExpressLib.c
new file mode 100644
index 000000000000..7547884b1a64
--- /dev/null
+++ b/MdePkg/Library/DxeRuntimePciExpressLib/PciExpressLib.c
@@ -0,0 +1,1660 @@
+/** @file
+  Functions in this library instance make use of MMIO functions in IoLib to
+  access memory mapped PCI configuration space.
+
+  All assertions for I/O operations are handled in MMIO functions in the IoLib
+  Library.
+
+  Copyright (c) 2006 - 2012, 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 <PiDxe.h>
+
+#include <Guid/EventGroup.h>
+
+#include <Library/BaseLib.h>
+#include <Library/PciExpressLib.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DxeServicesTableLib.h>
+#include <Library/UefiRuntimeLib.h>
+
+///
+/// Define table for mapping PCI Express MMIO physical addresses to virtual addresses at OS runtime
+///
+typedef struct {
+  UINTN  PhysicalAddress;
+  UINTN  VirtualAddress;
+} PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE;
+
+///
+/// Set Virtual Address Map Event
+///
+EFI_EVENT                               mDxeRuntimePciExpressLibVirtualNotifyEvent = NULL;
+
+///
+/// Module global that contains the base physical address of the PCI Express MMIO range.
+///
+UINTN                                   mDxeRuntimePciExpressLibPciExpressBaseAddress = 0;
+
+///
+/// The number of PCI devices that have been registered for runtime access.
+///
+UINTN                                   mDxeRuntimePciExpressLibNumberOfRuntimeRanges = 0;
+
+///
+/// The table of PCI devices that have been registered for runtime access.
+///
+PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE  *mDxeRuntimePciExpressLibRegistrationTable = NULL;
+
+///
+/// The table index of the most recent virtual address lookup.
+///
+UINTN                                   mDxeRuntimePciExpressLibLastRuntimeRange = 0;
+
+
+/**
+  Convert the physical PCI Express MMIO addresses for all registered PCI devices
+  to virtual addresses.
+
+  @param[in]    Event   The event that is being processed.
+  @param[in]    Context The Event Context.
+**/
+VOID
+EFIAPI
+DxeRuntimePciExpressLibVirtualNotify (
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
+  )
+{
+  UINTN  Index;
+
+  //
+  // If there have been no runtime registrations, then just return
+  //
+  if (mDxeRuntimePciExpressLibRegistrationTable == NULL) {
+    return;
+  }
+
+  //
+  // Convert physical addresses associated with the set of registered PCI devices to
+  // virtual addresses.
+  //
+  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
+    EfiConvertPointer (0, (VOID **) &(mDxeRuntimePciExpressLibRegistrationTable[Index].VirtualAddress));
+  }
+
+  //
+  // Convert table pointer that is allocated from EfiRuntimeServicesData to a virtual address.
+  //
+  EfiConvertPointer (0, (VOID **) &mDxeRuntimePciExpressLibRegistrationTable);
+}
+
+/**
+  The constructor function caches the PCI Express Base Address and creates a 
+  Set Virtual Address Map event to convert physical address to virtual addresses.
+  
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor completed successfully.
+  @retval Other value   The constructor did not complete successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeRuntimePciExpressLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // Cache the physical address of the PCI Express MMIO range into a module global variable
+  //
+  mDxeRuntimePciExpressLibPciExpressBaseAddress = (UINTN) PcdGet64 (PcdPciExpressBaseAddress);
+
+  //
+  // Register SetVirtualAddressMap () notify function
+  //
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  DxeRuntimePciExpressLibVirtualNotify,
+                  NULL,
+                  &gEfiEventVirtualAddressChangeGuid,
+                  &mDxeRuntimePciExpressLibVirtualNotifyEvent
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  The destructor function frees any allocated buffers and closes the Set Virtual 
+  Address Map event.
+  
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The destructor completed successfully.
+  @retval Other value   The destructor did not complete successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeRuntimePciExpressLibDestructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // If one or more PCI devices have been registered for runtime access, then 
+  // free the registration table.
+  //
+  if (mDxeRuntimePciExpressLibRegistrationTable != NULL) {
+    FreePool (mDxeRuntimePciExpressLibRegistrationTable);
+  }
+
+  //
+  // Close the Set Virtual Address Map event
+  //
+  Status = gBS->CloseEvent (mDxeRuntimePciExpressLibVirtualNotifyEvent);
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  Gets the base address of PCI Express.
+  
+  This internal functions retrieves PCI Express Base Address via a PCD entry
+  PcdPciExpressBaseAddress.
+  
+  @param  Address  The address that encodes the PCI Bus, Device, Function and Register.
+  @return          The base address of PCI Express.
+
+**/
+UINTN
+GetPciExpressAddress (
+  IN UINTN  Address
+  )
+{
+  UINTN  Index;
+
+  //
+  // Make sure Address is valid
+  //
+  ASSERT (((Address) & ~0xfffffff) == 0);
+
+  //
+  // Convert Address to a physical address in the MMIO PCI Express range
+  //
+  Address += mDxeRuntimePciExpressLibPciExpressBaseAddress;
+
+  //
+  // If SetVirtualAddressMap() has not been called, then just return the physical address
+  //
+  if (!EfiGoneVirtual ()) {
+    return Address;
+  }
+
+  //
+  // See if there is a physical address match at the exact same index as the last address match
+  //
+  if (mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibLastRuntimeRange].PhysicalAddress == (Address & (~0x00000fff))) {
+    //
+    // Convert the physical address to a virtual address and return the virtual address
+    //
+    return (Address & 0x00000fff) + mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibLastRuntimeRange].VirtualAddress;
+  }
+
+  //
+  // Search the entire table for a physical address match
+  //
+  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
+    if (mDxeRuntimePciExpressLibRegistrationTable[Index].PhysicalAddress == (Address & (~0x00000fff))) {
+      //
+      // Cache the matching index value
+      //
+      mDxeRuntimePciExpressLibLastRuntimeRange = Index;
+      //
+      // Convert the physical address to a virtual address and return the virtual address
+      //
+      return (Address & 0x00000fff) + mDxeRuntimePciExpressLibRegistrationTable[Index].VirtualAddress;
+    }
+  }
+
+  //
+  // No match was found.  This is a critical error at OS runtime, so ASSERT() and force a breakpoint.
+  //
+  ASSERT (FALSE);
+  CpuBreakpoint();
+
+  //
+  // Return the physical address 
+  //
+  return Address;
+}
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration 
+  registers associated with that PCI device may be accessed after SetVirtualAddressMap() 
+  is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciExpressRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  EFI_STATUS                       Status;
+  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  Descriptor;
+  UINTN                            Index;
+  VOID                             *NewTable;
+
+  //
+  // Return an error if this function is called after ExitBootServices().
+  //
+  if (EfiAtRuntime ()) {
+    return RETURN_UNSUPPORTED;
+  }
+
+  //
+  // Make sure Address is valid
+  //
+  ASSERT (((Address) & ~0xfffffff) == 0);
+
+  //
+  // Convert Address to a physical address in the MMIO PCI Express range
+  // at the beginning of the PCI Configuration header for the specified
+  // PCI Bus/Dev/Func
+  //
+  Address = GetPciExpressAddress (Address & 0x0ffff000);
+
+  //
+  // See if Address has already been registerd for runtime access
+  //
+  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
+    if (mDxeRuntimePciExpressLibRegistrationTable[Index].PhysicalAddress == Address) {
+      return RETURN_SUCCESS;
+    }
+  }
+
+  //
+  // Get the GCD Memory Descriptor for the PCI Express Bus/Dev/Func specified by Address
+  //
+  Status = gDS->GetMemorySpaceDescriptor (Address, &Descriptor);
+  if (EFI_ERROR (Status)) {
+    return RETURN_UNSUPPORTED;
+  }
+
+  //
+  // Mark the 4KB region for the PCI Express Bus/Dev/Func as EFI_RUNTIME_MEMORY so the OS
+  // will allocate a virtual address range for the 4KB PCI Configuration Header.
+  //
+  Status = gDS->SetMemorySpaceAttributes (Address, 0x1000, Descriptor.Attributes | EFI_MEMORY_RUNTIME);
+  if (EFI_ERROR (Status)) {
+    return RETURN_UNSUPPORTED;
+  }
+
+  //
+  // Grow the size of the registration table
+  //
+  NewTable = ReallocateRuntimePool (
+               (mDxeRuntimePciExpressLibNumberOfRuntimeRanges + 0) * sizeof (PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE), 
+               (mDxeRuntimePciExpressLibNumberOfRuntimeRanges + 1) * sizeof (PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE), 
+               mDxeRuntimePciExpressLibRegistrationTable
+               );
+  if (NewTable == NULL) {
+    return RETURN_OUT_OF_RESOURCES;
+  }
+  mDxeRuntimePciExpressLibRegistrationTable = NewTable;
+  mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibNumberOfRuntimeRanges].PhysicalAddress = Address;
+  mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibNumberOfRuntimeRanges].VirtualAddress  = Address;
+  mDxeRuntimePciExpressLibNumberOfRuntimeRanges++;
+
+  return RETURN_SUCCESS;
+}
+
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return MmioRead8 (GetPciExpressAddress (Address));
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioOr8 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioAnd8 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioAndThenOr8 (
+           GetPciExpressAddress (Address),
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return MmioBitFieldRead8 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioBitFieldWrite8 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioBitFieldOr8 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioBitFieldAnd8 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioBitFieldAndThenOr8 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressRead16 (
+  IN      UINTN                     Address
+  )
+{
+  return MmioRead16 (GetPciExpressAddress (Address));
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioOr16 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioAnd16 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioAndThenOr16 (
+           GetPciExpressAddress (Address),
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return MmioBitFieldRead16 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioBitFieldWrite16 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioBitFieldOr16 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioBitFieldAnd16 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioBitFieldAndThenOr16 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressRead32 (
+  IN      UINTN                     Address
+  )
+{
+  return MmioRead32 (GetPciExpressAddress (Address));
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioOr32 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioAnd32 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioAndThenOr32 (
+           GetPciExpressAddress (Address),
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return MmioBitFieldRead32 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit
+           );
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioBitFieldWrite32 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           Value
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioBitFieldOr32 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           OrData
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioBitFieldAnd32 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioBitFieldAndThenOr32 (
+           GetPciExpressAddress (Address),
+           StartBit,
+           EndBit,
+           AndData,
+           OrData
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size read data from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN   ReturnValue;
+
+  //
+  // Make sure Address is valid
+  //
+  ASSERT (((StartAddress) & ~0xfffffff) == 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 ((UINT32 *) Buffer, (UINT32) PciExpressRead32 (StartAddress));
+
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  //
+  // Make sure Address is valid
+  //
+  ASSERT (((StartAddress) & ~0xfffffff) == 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & 1) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciExpressWrite32 (StartAddress, ReadUnaligned32 ((UINT32*)Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.c b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.c
new file mode 100644
index 000000000000..3fde21d20998
--- /dev/null
+++ b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.c
@@ -0,0 +1,286 @@
+/** @file
+  This library implements the SAL Library Class using Extended SAL functions
+
+  Copyright (c) 2006 - 2011, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/SalLib.h>
+#include <Library/ExtendedSalLib.h>
+
+/**
+  Makes a SAL procedure call.
+  
+  This is a wrapper function to make a SAL procedure call.  
+  No parameter checking is performed on the 8 input parameters,
+  but there are some common rules that the caller should follow
+  when making a SAL call.  Any address passed to SAL as buffers
+  for return parameters must be 8-byte aligned.  Unaligned
+  addresses may cause undefined results.  For those parameters
+  defined as reserved or some fields defined as reserved must be
+  zero filled or the invalid argument return value may be returned
+  or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param  Index       The SAL procedure Index number
+  @param  Arg2        The 2nd parameter for SAL procedure calls
+  @param  Arg3        The 3rd parameter for SAL procedure calls
+  @param  Arg4        The 4th parameter for SAL procedure calls
+  @param  Arg5        The 5th parameter for SAL procedure calls
+  @param  Arg6        The 6th parameter for SAL procedure calls
+  @param  Arg7        The 7th parameter for SAL procedure calls
+  @param  Arg8        The 8th parameter for SAL procedure calls
+
+  @return SAL returned registers.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SalCall (
+  IN UINT64  Index,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  )
+{
+  SAL_RETURN_REGS Regs;
+  
+  //
+  // Initial all members in this structure.
+  //
+  Regs.r9     = 0;
+  Regs.r10    = 0;
+  Regs.r11    = 0;
+  Regs.Status = EFI_SAL_INVALID_ARGUMENT;
+
+  switch (Index) {
+  case EFI_SAL_SET_VECTORS:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             SalSetVectorsFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_GET_STATE_INFO:
+    return EsalCall (
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+             SalGetStateInfoFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_GET_STATE_INFO_SIZE:
+    return EsalCall (
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+             SalGetStateInfoSizeFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_CLEAR_STATE_INFO:
+    return EsalCall (
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_MCA_LOG_SERVICES_PROTOCOL_GUID_HI,
+             SalClearStateInfoFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_MC_RENDEZ:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             SalMcRendezFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+   break;
+
+  case EFI_SAL_MC_SET_PARAMS:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             SalMcSetParamsFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_REGISTER_PHYSICAL_ADDR:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             EsalRegisterPhysicalAddrFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_CACHE_FLUSH:
+    return EsalCall (
+             EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_HI,
+             SalCacheFlushFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_CACHE_INIT:
+    return EsalCall (
+             EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_CACHE_SERVICES_PROTOCOL_GUID_HI,
+             SalCacheInitFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_PCI_CONFIG_READ:
+    return EsalCall (
+             EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+             SalPciConfigReadFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_PCI_CONFIG_WRITE:
+    return EsalCall (
+             EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_PCI_SERVICES_PROTOCOL_GUID_HI,
+             SalPciConfigWriteFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_FREQ_BASE:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             EsalGetPlatformBaseFreqFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_PHYSICAL_ID_INFO:
+    return EsalCall (
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_BASE_SERVICES_PROTOCOL_GUID_HI,
+             EsalPhysicalIdInfoFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  case EFI_SAL_UPDATE_PAL:
+    return EsalCall (
+             EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_LO,
+             EFI_EXTENDED_SAL_PAL_SERVICES_PROTOCOL_GUID_HI,
+             EsalUpdatePalFunctionId, 
+             Arg2, 
+             Arg3, 
+             Arg4, 
+             Arg5, 
+             Arg6, 
+             Arg7, 
+             Arg8
+             );
+    break;
+
+  default:
+    return Regs;
+    break;
+  }
+}
diff --git a/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.inf b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.inf
new file mode 100644
index 000000000000..a9ad5ab6817e
--- /dev/null
+++ b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.inf
@@ -0,0 +1,38 @@
+## @file
+#  This library implements the SAL Library Class using Extended SAL functions
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeSalLibEsal
+  MODULE_UNI_FILE                = DxeSalLibEsal.uni
+  FILE_GUID                      = 2B73B074-2E67-498b-82AC-CE38FB770FFC
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SalLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION 
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.IPF]
+  DxeSalLibEsal.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  ExtendedSalLib
+
diff --git a/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.uni b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.uni
new file mode 100644
index 000000000000..ec47af9656f2
--- /dev/null
+++ b/MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.uni
@@ -0,0 +1,21 @@
+// /** @file
+// This library implements the SAL Library Class using Extended SAL functions
+//
+// This library implements the SAL Library Class using Extended SAL functions.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Implements the SAL Library Class using Extended SAL functions"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library implements the SAL Library Class using Extended SAL functions."
+
diff --git a/MdePkg/Library/DxeServicesLib/DxeServicesLib.c b/MdePkg/Library/DxeServicesLib/DxeServicesLib.c
new file mode 100644
index 000000000000..94c389cc5d61
--- /dev/null
+++ b/MdePkg/Library/DxeServicesLib/DxeServicesLib.c
@@ -0,0 +1,1085 @@
+/** @file
+  MDE DXE Services Library provides functions that simplify the development of DXE Drivers.  
+  These functions help access data from sections of FFS files or from file path.
+
+  Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2015 Hewlett Packard Enterprise Development LP<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 <PiDxe.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/UefiLib.h>
+#include <Library/DxeServicesLib.h>
+#include <Protocol/FirmwareVolume2.h>
+#include <Protocol/LoadedImage.h>
+#include <Protocol/LoadFile2.h>
+#include <Protocol/LoadFile.h>
+#include <Protocol/SimpleFileSystem.h>
+#include <Guid/FileInfo.h>
+
+/**
+  Identify the device handle from which the Image is loaded from. As this device handle is passed to
+  GetSectionFromFv as the identifier for a Firmware Volume, an EFI_FIRMWARE_VOLUME2_PROTOCOL 
+  protocol instance should be located succesfully by calling gBS->HandleProtocol ().
+
+  This function locates the EFI_LOADED_IMAGE_PROTOCOL instance installed
+  on ImageHandle. It then returns EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle.
+  
+  If ImageHandle is NULL, then ASSERT ();
+  If failed to locate a EFI_LOADED_IMAGE_PROTOCOL on ImageHandle, then ASSERT ();
+  
+  @param  ImageHandle         The firmware allocated handle for UEFI image.
+
+  @retval  EFI_HANDLE         The device handle from which the Image is loaded from.
+
+**/
+EFI_HANDLE
+InternalImageHandleToFvHandle (
+  EFI_HANDLE ImageHandle
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_LOADED_IMAGE_PROTOCOL     *LoadedImage;
+  
+  ASSERT (ImageHandle != NULL);
+
+  Status = gBS->HandleProtocol (
+             (EFI_HANDLE *) ImageHandle,
+             &gEfiLoadedImageProtocolGuid,
+             (VOID **) &LoadedImage
+             );
+
+  ASSERT_EFI_ERROR (Status);
+
+  return LoadedImage->DeviceHandle;
+
+}
+
+/**
+  Allocate and fill a buffer from a Firmware Section identified by a Firmware File GUID name, a Firmware 
+  Section type and instance number from the specified Firmware Volume.
+
+  This functions first locate the EFI_FIRMWARE_VOLUME2_PROTOCOL protocol instance on FvHandle in order to 
+  carry out the Firmware Volume read operation. The function then reads the Firmware Section found sepcifed 
+  by NameGuid, SectionType and SectionInstance. 
+  
+  The details of this search order is defined in description of EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection () 
+  found in PI Specification.
+  
+  If SectionType is EFI_SECTION_TE, EFI_SECTION_TE is used as section type to start the search. If EFI_SECTION_TE section 
+  is not found, EFI_SECTION_PE32 will be used to try the search again. If no EFI_SECTION_PE32 section is found, EFI_NOT_FOUND 
+  is returned.
+  
+  The data and size is returned by Buffer and Size. The caller is responsible to free the Buffer allocated 
+  by this function. This function can be only called at TPL_NOTIFY and below.
+  
+  If FvHandle is NULL, then ASSERT ();
+  If NameGuid is NULL, then ASSERT();
+  If Buffer is NULL, then ASSERT();
+  If Size is NULL, then ASSERT().
+
+  @param  FvHandle                The device handle that contains a instance of 
+                                  EFI_FIRMWARE_VOLUME2_PROTOCOL instance.
+  @param  NameGuid                The GUID name of a Firmware File.
+  @param  SectionType             The Firmware Section type.
+  @param  SectionInstance         The instance number of Firmware Section to  
+                                  read from starting from 0.
+  @param  Buffer                  On output, Buffer contains the the data read 
+                                  from the section in the Firmware File found.
+  @param  Size                    On output, the size of Buffer.
+
+  @retval  EFI_SUCCESS            The image is found and data and size is returned.
+  @retval  EFI_NOT_FOUND          The image specified by NameGuid and SectionType 
+                                  can't be found.
+  @retval  EFI_OUT_OF_RESOURCES   There were not enough resources to allocate the 
+                                  output data buffer or complete the operations.
+  @retval  EFI_DEVICE_ERROR       A hardware error occurs during reading from the 
+                                  Firmware Volume.
+  @retval  EFI_ACCESS_DENIED      The firmware volume containing the searched 
+                                  Firmware File is configured to disallow reads.
+  
+**/
+EFI_STATUS
+InternalGetSectionFromFv (
+  IN  EFI_HANDLE                    FvHandle,
+  IN  CONST EFI_GUID                *NameGuid,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
+  UINT32                        AuthenticationStatus;
+
+  ASSERT (NameGuid != NULL);
+  ASSERT (Buffer != NULL);
+  ASSERT (Size != NULL);
+  
+  ASSERT (FvHandle != NULL);
+
+  Status = gBS->HandleProtocol (
+                  FvHandle,
+                  &gEfiFirmwareVolume2ProtocolGuid,
+                  (VOID **) &Fv
+                  );
+  if (EFI_ERROR (Status)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // Read desired section content in NameGuid file
+  //
+  *Buffer     = NULL;
+  *Size       = 0;
+  Status      = Fv->ReadSection (
+                      Fv,
+                      NameGuid,
+                      SectionType,
+                      SectionInstance,
+                      Buffer,
+                      Size,
+                      &AuthenticationStatus
+                      );
+
+  if (EFI_ERROR (Status) && (SectionType == EFI_SECTION_TE)) {
+    //
+    // Try reading PE32 section, if the required section is TE type 
+    //
+    *Buffer = NULL;
+    *Size   = 0;
+    Status  = Fv->ReadSection (
+                    Fv,
+                    NameGuid,
+                    EFI_SECTION_PE32,
+                    SectionInstance,
+                    Buffer,
+                    Size,
+                    &AuthenticationStatus
+                    );
+  }
+
+  return Status;
+}
+
+/**
+  Searches all the available firmware volumes and returns the first matching FFS section. 
+
+  This function searches all the firmware volumes for FFS files with FV file type specified by FileType
+  The order that the firmware volumes is searched is not deterministic. For each available FV a search 
+  is made for FFS file of type FileType. If the FV contains more than one FFS file with the same FileType, 
+  the FileInstance instance will be the matched FFS file. For each FFS file found a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances 
+  of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. 
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer.  
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections 
+  are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+  @param  FileType             Indicates the FV file type to search for within all 
+                               available FVs.
+  @param  FileInstance         Indicates which file instance within all available 
+                               FVs specified by FileType.
+                               FileInstance starts from zero.
+  @param  SectionType          Indicates the FFS section type to search for 
+                               within the FFS file 
+                               specified by FileType with FileInstance.
+  @param  SectionInstance      Indicates which section instance within the FFS file 
+                               specified by FileType with FileInstance to retrieve. 
+                               SectionInstance starts from zero.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.
+                               Is it the caller's responsibility to free this 
+                               buffer using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because 
+                                the firmware volume that 
+                                contains the matching FFS section does not allow reads.
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromAnyFvByFileType  (
+  IN  EFI_FV_FILETYPE               FileType,
+  IN  UINTN                         FileInstance,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_HANDLE                    *HandleBuffer;
+  UINTN                         HandleCount;
+  UINTN                         IndexFv;
+  UINTN                         IndexFile;
+  UINTN                         Key;
+  EFI_GUID                      NameGuid;
+  EFI_FV_FILE_ATTRIBUTES        Attributes;
+  EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
+
+  //
+  // Locate all available FVs.
+  //
+  HandleBuffer = NULL;
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiFirmwareVolume2ProtocolGuid,
+                  NULL,
+                  &HandleCount,
+                  &HandleBuffer
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Go through FVs one by one to find the required section data.
+  //
+  for (IndexFv = 0; IndexFv < HandleCount; IndexFv++) {
+    Status = gBS->HandleProtocol (
+                    HandleBuffer[IndexFv],
+                    &gEfiFirmwareVolume2ProtocolGuid,
+                    (VOID **)&Fv
+                    );
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    //
+    // Use Firmware Volume 2 Protocol to search for a file of type FileType in all FVs.
+    //
+    IndexFile = FileInstance + 1;
+    Key = 0;
+    do {
+      Status = Fv->GetNextFile (Fv, &Key, &FileType, &NameGuid, &Attributes, Size);
+      if (EFI_ERROR (Status)) {
+        break;
+      }
+      IndexFile --;
+    } while (IndexFile > 0);
+
+    //
+    // Fv File with the required FV file type is found.
+    // Search the section file in the found FV file.
+    //
+    if (IndexFile == 0) {
+      Status = InternalGetSectionFromFv (
+                 HandleBuffer[IndexFv], 
+                 &NameGuid,
+                 SectionType,
+                 SectionInstance,
+                 Buffer,
+                 Size
+                 );
+
+      if (!EFI_ERROR (Status)) {
+        goto Done;
+      }
+    }
+  }
+
+  //
+  // The required FFS section file is not found. 
+  //
+  if (IndexFv == HandleCount) {
+    Status = EFI_NOT_FOUND;
+  }
+
+Done:
+  if (HandleBuffer != NULL) {  
+    FreePool(HandleBuffer);
+  }
+
+  return Status;
+}
+
+/**
+  Searches all the availables firmware volumes and returns the first matching FFS section. 
+
+  This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid.  
+  The order that the firmware volumes is searched is not deterministic. For each FFS file found a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances 
+  of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. 
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer.  
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections 
+  are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If NameGuid is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+
+  @param  NameGuid             A pointer to to the FFS filename GUID to search for  
+                               within any of the firmware volumes in the platform. 
+  @param  SectionType          Indicates the FFS section type to search for within 
+                               the FFS file specified by NameGuid.
+  @param  SectionInstance      Indicates which section instance within the FFS file 
+                               specified by NameGuid to retrieve.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.  
+                               Is it the caller's responsibility to free this buffer 
+                               using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to 
+                                retrieve the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that 
+                                contains the matching FFS section does not allow reads.
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromAnyFv  (
+  IN CONST  EFI_GUID           *NameGuid,
+  IN        EFI_SECTION_TYPE   SectionType,
+  IN        UINTN              SectionInstance,
+  OUT       VOID               **Buffer,
+  OUT       UINTN              *Size
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_HANDLE                    *HandleBuffer;
+  UINTN                         HandleCount;
+  UINTN                         Index;
+  EFI_HANDLE                    FvHandle;
+
+  //
+  // Search the FV that contain the caller's FFS first.
+  // FV builder can choose to build FFS into the this FV
+  // so that this implementation of GetSectionFromAnyFv
+  // will locate the FFS faster.
+  //
+  FvHandle = InternalImageHandleToFvHandle (gImageHandle);
+  Status = InternalGetSectionFromFv (
+             FvHandle,
+             NameGuid,
+             SectionType,
+             SectionInstance,
+             Buffer,
+             Size
+             );
+  if (!EFI_ERROR (Status)) {
+    return EFI_SUCCESS;
+  }
+
+  HandleBuffer = NULL;
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiFirmwareVolume2ProtocolGuid,
+                  NULL,
+                  &HandleCount,
+                  &HandleBuffer
+                  );
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  for (Index = 0; Index < HandleCount; Index++) {
+    //
+    // Skip the FV that contain the caller's FFS
+    //
+    if (HandleBuffer[Index] != FvHandle) {
+      Status = InternalGetSectionFromFv (
+                 HandleBuffer[Index], 
+                 NameGuid, 
+                 SectionType, 
+                 SectionInstance,
+                 Buffer, 
+                 Size
+                 );
+
+      if (!EFI_ERROR (Status)) {
+        goto Done;
+      }
+    }
+
+  }
+
+  if (Index == HandleCount) {
+    Status = EFI_NOT_FOUND;
+  }
+
+Done:
+  
+  if (HandleBuffer != NULL) {  
+    FreePool(HandleBuffer);
+  }
+  return Status;
+  
+}
+
+/**
+  Searches the firmware volume that the currently executing module was loaded from and returns the first matching FFS section. 
+
+  This function searches the firmware volume that the currently executing module was loaded 
+  from for an FFS file with an FFS filename specified by NameGuid. If the FFS file is found a search 
+  is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance 
+  instances of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer.
+  Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. 
+  It is the caller's responsibility to use FreePool() to free the allocated buffer. 
+  See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections are retrieved from 
+  an FFS file based on SectionType and SectionInstance.
+
+  If the currently executing module was not loaded from a firmware volume, then EFI_NOT_FOUND is returned.
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  
+  This function must be called with a TPL <= TPL_NOTIFY.
+  If NameGuid is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+  @param  NameGuid             A pointer to to the FFS filename GUID to search for 
+                               within the firmware volumes that the currently 
+                               executing module was loaded from.
+  @param  SectionType          Indicates the FFS section type to search for within 
+                               the FFS file specified by NameGuid.
+  @param  SectionInstance      Indicates which section instance within the FFS file 
+                               specified by NameGuid to retrieve.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.  
+                               Is it the caller's responsibility to free this buffer 
+                               using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that contains the matching FFS 
+                                section does not allow reads.  
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromFv (
+  IN  CONST EFI_GUID                *NameGuid,
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+    )
+{
+  return InternalGetSectionFromFv (
+           InternalImageHandleToFvHandle(gImageHandle),
+           NameGuid,
+           SectionType,
+           SectionInstance,
+           Buffer,
+           Size
+           );
+}
+
+
+/**
+  Searches the FFS file the the currently executing module was loaded from and returns the first matching FFS section.
+
+  This function searches the FFS file that the currently executing module was loaded from for a FFS sections of type SectionType.
+  If the FFS file contains at least SectionInstance instances of the FFS section specified by SectionType, 
+  then the SectionInstance instance is returned in Buffer. Buffer is allocated using AllocatePool(), 
+  and the size of the allocated buffer is returned in Size. It is the caller's responsibility 
+  to use FreePool() to free the allocated buffer. See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for 
+  details on how sections are retrieved from an FFS file based on SectionType and SectionInstance.
+
+  If the currently executing module was not loaded from an FFS file, then EFI_NOT_FOUND is returned.
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, 
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+  
+  If Buffer is NULL, then ASSERT().
+  If Size is NULL, then ASSERT().
+
+
+  @param  SectionType          Indicates the FFS section type to search for within 
+                               the FFS file that the currently executing module 
+                               was loaded from.
+  @param  SectionInstance      Indicates which section instance to retrieve within 
+                               the FFS file that the currently executing module 
+                               was loaded from.
+  @param  Buffer               On output, a pointer to a callee allocated buffer 
+                               containing the FFS file section that was found.  
+                               Is it the caller's responsibility to free this buffer 
+                               using FreePool().
+  @param  Size                 On output, a pointer to the size, in bytes, of Buffer.
+
+  @retval  EFI_SUCCESS          The specified FFS section was returned.
+  @retval  EFI_NOT_FOUND        The specified FFS section could not be found.
+  @retval  EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve 
+                                the matching FFS section.
+  @retval  EFI_DEVICE_ERROR     The FFS section could not be retrieves due to a 
+                                device error.
+  @retval  EFI_ACCESS_DENIED    The FFS section could not be retrieves because the 
+                                firmware volume that contains the matching FFS 
+                                section does not allow reads.  
+  
+**/
+EFI_STATUS
+EFIAPI
+GetSectionFromFfs (
+  IN  EFI_SECTION_TYPE              SectionType,
+  IN  UINTN                         SectionInstance,
+  OUT VOID                          **Buffer,
+  OUT UINTN                         *Size
+    )
+{
+  return InternalGetSectionFromFv(
+           InternalImageHandleToFvHandle(gImageHandle),
+           &gEfiCallerIdGuid,
+           SectionType,
+           SectionInstance,
+           Buffer,
+           Size
+           );
+}
+
+
+/**
+  Get the image file buffer data and buffer size by its device path. 
+  
+  Access the file either from a firmware volume, from a file system interface, 
+  or from the load file interface.
+  
+  Allocate memory to store the found image. The caller is responsible to free memory.
+
+  If FilePath is NULL, then NULL is returned.
+  If FileSize is NULL, then NULL is returned.
+  If AuthenticationStatus is NULL, then NULL is returned.
+
+  @param[in]       BootPolicy           Policy for Open Image File.If TRUE, indicates 
+                                        that the request originates from the boot 
+                                        manager, and that the boot manager is
+                                        attempting to load FilePath as a boot
+                                        selection. If FALSE, then FilePath must 
+                                        match an exact file to be loaded.
+  @param[in]       FilePath             The pointer to the device path of the file
+                                        that is absracted to the file buffer.
+  @param[out]      FileSize             The pointer to the size of the abstracted 
+                                        file buffer.
+  @param[out]      AuthenticationStatus Pointer to the authentication status.
+
+  @retval NULL   FilePath is NULL, or FileSize is NULL, or AuthenticationStatus is NULL, or the file can't be found.
+  @retval other  The abstracted file buffer. The caller is responsible to free memory.
+**/
+VOID *
+EFIAPI
+GetFileBufferByFilePath (
+  IN BOOLEAN                           BootPolicy,
+  IN CONST EFI_DEVICE_PATH_PROTOCOL    *FilePath,
+  OUT      UINTN                       *FileSize,
+  OUT UINT32                           *AuthenticationStatus
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL          *DevicePathNode;
+  EFI_DEVICE_PATH_PROTOCOL          *OrigDevicePathNode;
+  EFI_DEVICE_PATH_PROTOCOL          *TempDevicePathNode;
+  EFI_HANDLE                        Handle;
+  EFI_GUID                          *FvNameGuid;
+  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;
+  EFI_SECTION_TYPE                  SectionType;
+  UINT8                             *ImageBuffer;
+  UINTN                             ImageBufferSize;
+  EFI_FV_FILETYPE                   Type;
+  EFI_FV_FILE_ATTRIBUTES            Attrib;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
+  EFI_FILE_HANDLE                   FileHandle;
+  EFI_FILE_HANDLE                   LastHandle;
+  EFI_FILE_INFO                     *FileInfo;
+  UINTN                             FileInfoSize;
+  EFI_LOAD_FILE_PROTOCOL            *LoadFile;
+  EFI_LOAD_FILE2_PROTOCOL           *LoadFile2;
+  EFI_STATUS                        Status;
+
+  //
+  // Check input File device path.
+  //
+  if (FilePath == NULL || FileSize == NULL || AuthenticationStatus == NULL) {
+    return NULL;
+  }
+
+  //
+  // Init local variable
+  //
+  TempDevicePathNode  = NULL;
+  FvNameGuid          = NULL;
+  FileInfo            = NULL;
+  FileHandle          = NULL;
+  ImageBuffer         = NULL;
+  ImageBufferSize     = 0;
+  *AuthenticationStatus = 0;
+  
+  //
+  // Copy File Device Path
+  //
+  OrigDevicePathNode = DuplicateDevicePath (FilePath);
+  if (OrigDevicePathNode == NULL) {
+    return NULL;
+  }
+
+  //
+  // Check whether this device path support FV2 protocol.
+  // Is so, this device path may contain a Image.
+  //
+  DevicePathNode = OrigDevicePathNode;
+  Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &DevicePathNode, &Handle);
+  if (!EFI_ERROR (Status)) {
+    //
+    // For FwVol File system there is only a single file name that is a GUID.
+    //
+    FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePathNode);
+    if (FvNameGuid == NULL) {
+      Status = EFI_INVALID_PARAMETER;
+    } else {
+      //
+      // Read image from the firmware file
+      //
+      Status = gBS->HandleProtocol (Handle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**)&FwVol);
+      if (!EFI_ERROR (Status)) {
+        SectionType = EFI_SECTION_PE32;
+        ImageBuffer = NULL;
+        Status = FwVol->ReadSection (
+                          FwVol,
+                          FvNameGuid,
+                          SectionType,
+                          0,
+                          (VOID **)&ImageBuffer,
+                          &ImageBufferSize,
+                          AuthenticationStatus
+                          );
+        if (EFI_ERROR (Status)) {
+          //
+          // Try a raw file, since a PE32 SECTION does not exist
+          //
+          if (ImageBuffer != NULL) {
+            FreePool (ImageBuffer);
+            *AuthenticationStatus = 0;
+          }
+          ImageBuffer = NULL;
+          Status = FwVol->ReadFile (
+                            FwVol,
+                            FvNameGuid,
+                            (VOID **)&ImageBuffer,
+                            &ImageBufferSize,
+                            &Type,
+                            &Attrib,
+                            AuthenticationStatus
+                            );
+        }
+      }
+    }
+    if (!EFI_ERROR (Status)) {
+      goto Finish;
+    }
+  }
+
+  //
+  // Attempt to access the file via a file system interface
+  //
+  DevicePathNode = OrigDevicePathNode;
+  Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &DevicePathNode, &Handle);
+  if (!EFI_ERROR (Status)) {
+    Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID**)&Volume);
+    if (!EFI_ERROR (Status)) {
+      //
+      // Open the Volume to get the File System handle
+      //
+      Status = Volume->OpenVolume (Volume, &FileHandle);
+      if (!EFI_ERROR (Status)) {
+        //
+        // Duplicate the device path to avoid the access to unaligned device path node.
+        // Because the device path consists of one or more FILE PATH MEDIA DEVICE PATH
+        // nodes, It assures the fields in device path nodes are 2 byte aligned.
+        //
+        TempDevicePathNode = DuplicateDevicePath (DevicePathNode);
+        if (TempDevicePathNode == NULL) {
+          FileHandle->Close (FileHandle);
+          //
+          // Setting Status to an EFI_ERROR value will cause the rest of
+          // the file system support below to be skipped.
+          //
+          Status = EFI_OUT_OF_RESOURCES;
+        }
+        //
+        // Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the
+        // directory information and filename can be seperate. The goal is to inch
+        // our way down each device path node and close the previous node
+        //
+        DevicePathNode = TempDevicePathNode;
+        while (!EFI_ERROR (Status) && !IsDevicePathEnd (DevicePathNode)) {
+          if (DevicePathType (DevicePathNode) != MEDIA_DEVICE_PATH ||
+              DevicePathSubType (DevicePathNode) != MEDIA_FILEPATH_DP) {
+            Status = EFI_UNSUPPORTED;
+            break;
+          }
+  
+          LastHandle = FileHandle;
+          FileHandle = NULL;
+  
+          Status = LastHandle->Open (
+                                LastHandle,
+                                &FileHandle,
+                                ((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName,
+                                EFI_FILE_MODE_READ,
+                                0
+                                );
+  
+          //
+          // Close the previous node
+          //
+          LastHandle->Close (LastHandle);
+  
+          DevicePathNode = NextDevicePathNode (DevicePathNode);
+        }
+  
+        if (!EFI_ERROR (Status)) {
+          //
+          // We have found the file. Now we need to read it. Before we can read the file we need to
+          // figure out how big the file is.
+          //
+          FileInfo = NULL;
+          FileInfoSize = 0;
+          Status = FileHandle->GetInfo (
+                                FileHandle,
+                                &gEfiFileInfoGuid,
+                                &FileInfoSize,
+                                FileInfo
+                                );
+  
+          if (Status == EFI_BUFFER_TOO_SMALL) {
+            FileInfo = AllocatePool (FileInfoSize);
+            if (FileInfo == NULL) {
+              Status = EFI_OUT_OF_RESOURCES;
+            } else {
+              Status = FileHandle->GetInfo (
+                                    FileHandle,
+                                    &gEfiFileInfoGuid,
+                                    &FileInfoSize,
+                                    FileInfo
+                                    );
+            }
+          }
+          
+          if (!EFI_ERROR (Status) && (FileInfo != NULL)) {
+            if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
+              //
+              // Allocate space for the file
+              //
+              ImageBuffer = AllocatePool ((UINTN)FileInfo->FileSize);
+              if (ImageBuffer == NULL) {
+                Status = EFI_OUT_OF_RESOURCES;
+              } else {
+                //
+                // Read the file into the buffer we allocated
+                //
+                ImageBufferSize = (UINTN)FileInfo->FileSize;
+                Status          = FileHandle->Read (FileHandle, &ImageBufferSize, ImageBuffer);
+              }
+            }
+          }
+        }
+        //
+        // Close the file and Free FileInfo and TempDevicePathNode since we are done
+        // 
+        if (FileInfo != NULL) {
+          FreePool (FileInfo);
+        }
+        if (FileHandle != NULL) {
+          FileHandle->Close (FileHandle);
+        }
+        if (TempDevicePathNode != NULL) {
+          FreePool (TempDevicePathNode);
+        }
+      }
+    }
+    if (!EFI_ERROR (Status)) {
+      goto Finish;
+    }
+  }
+
+  //
+  // Attempt to access the file via LoadFile2 interface
+  //
+  if (!BootPolicy) {
+    DevicePathNode = OrigDevicePathNode;
+    Status = gBS->LocateDevicePath (&gEfiLoadFile2ProtocolGuid, &DevicePathNode, &Handle);
+    if (!EFI_ERROR (Status)) {
+      Status = gBS->HandleProtocol (Handle, &gEfiLoadFile2ProtocolGuid, (VOID**)&LoadFile2);
+      if (!EFI_ERROR (Status)) {
+        //
+        // Call LoadFile2 with the correct buffer size
+        //
+        ImageBufferSize = 0;
+        ImageBuffer     = NULL;
+        Status = LoadFile2->LoadFile (
+                             LoadFile2,
+                             DevicePathNode,
+                             FALSE,
+                             &ImageBufferSize,
+                             ImageBuffer
+                             );
+        if (Status == EFI_BUFFER_TOO_SMALL) {
+          ImageBuffer = AllocatePool (ImageBufferSize);
+          if (ImageBuffer == NULL) {
+            Status = EFI_OUT_OF_RESOURCES;
+          } else {
+            Status = LoadFile2->LoadFile (
+                                 LoadFile2,
+                                 DevicePathNode,
+                                 FALSE,
+                                 &ImageBufferSize,
+                                 ImageBuffer
+                                 );
+          }
+        }
+      }
+      if (!EFI_ERROR (Status)) {
+        goto Finish;
+      }
+    }
+  }
+
+  //
+  // Attempt to access the file via LoadFile interface
+  //
+  DevicePathNode = OrigDevicePathNode;
+  Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &DevicePathNode, &Handle);
+  if (!EFI_ERROR (Status)) {
+    Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID**)&LoadFile);
+    if (!EFI_ERROR (Status)) {
+      //
+      // Call LoadFile with the correct buffer size
+      //
+      ImageBufferSize = 0;
+      ImageBuffer     = NULL;
+      Status = LoadFile->LoadFile (
+                           LoadFile,
+                           DevicePathNode,
+                           BootPolicy,
+                           &ImageBufferSize,
+                           ImageBuffer
+                           );
+      if (Status == EFI_BUFFER_TOO_SMALL) {
+        ImageBuffer = AllocatePool (ImageBufferSize);
+        if (ImageBuffer == NULL) {
+          Status = EFI_OUT_OF_RESOURCES;
+        } else {
+          Status = LoadFile->LoadFile (
+                               LoadFile,
+                               DevicePathNode,
+                               BootPolicy,
+                               &ImageBufferSize,
+                               ImageBuffer
+                               );
+        }
+      }
+    }
+  }
+
+Finish:
+
+  if (EFI_ERROR (Status)) {
+    if (ImageBuffer != NULL) {
+      FreePool (ImageBuffer);
+      ImageBuffer = NULL;
+    }
+    *FileSize = 0;
+  } else {
+    *FileSize = ImageBufferSize;
+  }
+
+  FreePool (OrigDevicePathNode);
+
+  return ImageBuffer;
+}
+
+/**
+  Searches all the available firmware volumes and returns the file device path of first matching
+  FFS section.
+
+  This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid.
+  The order that the firmware volumes is searched is not deterministic. For each FFS file found a search
+  is made for FFS sections of type SectionType.
+
+  If SectionType is EFI_SECTION_TE, and the search with an FFS file fails,
+  the search will be retried with a section type of EFI_SECTION_PE32.
+  This function must be called with a TPL <= TPL_NOTIFY.
+
+  If NameGuid is NULL, then ASSERT().
+
+   @param  NameGuid             A pointer to to the FFS filename GUID to search for
+                                within any of the firmware volumes in the platform.
+   @param  SectionType          Indicates the FFS section type to search for within
+                                the FFS file specified by NameGuid.
+   @param  SectionInstance      Indicates which section instance within the FFS file
+                                specified by NameGuid to retrieve.
+   @param  FvFileDevicePath     Device path for the target FFS
+                                file.
+
+   @retval  EFI_SUCCESS           The specified file device path of FFS section was returned.
+   @retval  EFI_NOT_FOUND         The specified file device path of FFS section could not be found.
+   @retval  EFI_DEVICE_ERROR      The FFS section could not be retrieves due to a
+                                  device error.
+   @retval  EFI_ACCESS_DENIED     The FFS section could not be retrieves because the
+                                  firmware volume that contains the matching FFS section does not
+                                  allow reads.
+   @retval  EFI_INVALID_PARAMETER FvFileDevicePath is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+GetFileDevicePathFromAnyFv (
+  IN CONST  EFI_GUID                  *NameGuid,
+  IN        EFI_SECTION_TYPE          SectionType,
+  IN        UINTN                     SectionInstance,
+  OUT       EFI_DEVICE_PATH_PROTOCOL  **FvFileDevicePath
+  )
+{
+  EFI_STATUS                        Status;
+  EFI_HANDLE                        *HandleBuffer;
+  UINTN                             HandleCount;
+  UINTN                             Index;
+  EFI_HANDLE                        FvHandle;
+  EFI_DEVICE_PATH_PROTOCOL          *FvDevicePath;
+  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *TempFvFileDevicePath;
+  VOID                              *Buffer;
+  UINTN                             Size;
+
+  if (FvFileDevicePath == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  HandleBuffer         = NULL;
+  FvDevicePath         = NULL;
+  TempFvFileDevicePath = NULL;
+  Buffer               = NULL;
+  Size                 = 0;
+
+  //
+  // Search the FV that contain the caller's FFS first.
+  // FV builder can choose to build FFS into the this FV
+  // so that this implementation of GetSectionFromAnyFv
+  // will locate the FFS faster.
+  //
+  FvHandle = InternalImageHandleToFvHandle (gImageHandle);
+  Status = InternalGetSectionFromFv (
+             FvHandle,
+             NameGuid,
+             SectionType,
+             SectionInstance,
+             &Buffer,
+             &Size
+             );
+  if (!EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiFirmwareVolume2ProtocolGuid,
+                  NULL,
+                  &HandleCount,
+                  &HandleBuffer
+                  );
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  for (Index = 0; Index < HandleCount; Index++) {
+    //
+    // Skip the FV that contain the caller's FFS
+    //
+    if (HandleBuffer[Index] != FvHandle) {
+      Status = InternalGetSectionFromFv (
+                 HandleBuffer[Index],
+                 NameGuid,
+                 SectionType,
+                 SectionInstance,
+                 &Buffer,
+                 &Size
+                 );
+
+      if (!EFI_ERROR (Status)) {
+        //
+        // Update FvHandle to the current handle.
+        //
+        FvHandle = HandleBuffer[Index];
+        goto Done;
+      }
+    }
+  }
+
+  if (Index == HandleCount) {
+    Status = EFI_NOT_FOUND;
+  }
+
+Done:
+  if (Status == EFI_SUCCESS) {
+    //
+    // Build a device path to the file in the FV to pass into gBS->LoadImage
+    //
+    Status = gBS->HandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath);
+    if (EFI_ERROR (Status)) {
+      *FvFileDevicePath = NULL;
+    } else {
+      TempFvFileDevicePath = AllocateZeroPool (sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH) + END_DEVICE_PATH_LENGTH);
+      if (TempFvFileDevicePath == NULL) {
+        *FvFileDevicePath = NULL;
+        return EFI_OUT_OF_RESOURCES;
+      }
+      EfiInitializeFwVolDevicepathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH*)TempFvFileDevicePath, NameGuid);
+      SetDevicePathEndNode (NextDevicePathNode (TempFvFileDevicePath));
+      *FvFileDevicePath = AppendDevicePath (
+                            FvDevicePath,
+                            (EFI_DEVICE_PATH_PROTOCOL *)TempFvFileDevicePath
+                            );
+      FreePool (TempFvFileDevicePath);
+    }
+  }
+
+  if (Buffer != NULL) {
+    FreePool (Buffer);
+  }
+
+  if (HandleBuffer != NULL) {
+    FreePool (HandleBuffer);
+  }
+
+  return Status;
+}
diff --git a/MdePkg/Library/DxeServicesLib/DxeServicesLib.inf b/MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
new file mode 100644
index 000000000000..8f02a4225097
--- /dev/null
+++ b/MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
@@ -0,0 +1,56 @@
+## @file
+# DXE Services Library instance provides functions that simplify the development of DXE Drivers.
+#
+# DXE Services Library provides access data from sections of FFS files based on FV protocol.
+# It also provides access file based on file path from a firmware volume, 
+# from a file system interface, or from the load file interface.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeServicesLib
+  MODULE_UNI_FILE                = DxeServicesLib.uni
+  FILE_GUID                      = EE680C58-FFC0-4a5d-858F-66FF9C84BC9F
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DxeServicesLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER SMM_CORE UEFI_APPLICATION UEFI_DRIVER
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DxeServicesLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  MemoryAllocationLib
+  DebugLib
+  DevicePathLib
+  UefiLib
+  UefiBootServicesTableLib
+
+[Guids]
+  gEfiFileInfoGuid                              ## SOMETIMES_CONSUMES ## UNDEFINED
+
+[Protocols]
+  gEfiFirmwareVolume2ProtocolGuid               ## SOMETIMES_CONSUMES
+  gEfiLoadedImageProtocolGuid                   ## SOMETIMES_CONSUMES
+  gEfiLoadFileProtocolGuid                      ## SOMETIMES_CONSUMES
+  gEfiLoadFile2ProtocolGuid                     ## SOMETIMES_CONSUMES 
+  gEfiSimpleFileSystemProtocolGuid              ## SOMETIMES_CONSUMES 
+
diff --git a/MdePkg/Library/DxeServicesLib/DxeServicesLib.uni b/MdePkg/Library/DxeServicesLib/DxeServicesLib.uni
new file mode 100644
index 000000000000..57f31760f945
--- /dev/null
+++ b/MdePkg/Library/DxeServicesLib/DxeServicesLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// DXE Services Library instance provides functions that simplify the development of DXE Drivers.
+//
+// DXE Services Library provides access data from sections of FFS files based on FV protocol.
+// It also provides access file based on file path from a firmware volume,
+// from a file system interface, or from the load file interface.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Provides functions that simplify the development of DXE Drivers"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "A DXE Services Library provides access data from sections of FFS files based on FV protocol. It also provides access file based on file path from a firmware volume, from a file system interface, or from the load file interface."
+
diff --git a/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.c b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.c
new file mode 100644
index 000000000000..0f9bd20843df
--- /dev/null
+++ b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.c
@@ -0,0 +1,68 @@
+/** @file
+  This library implement library class DxeServiceTableLib.
+  It produce EFI_DXE_SERVICE pointer in global variable gDS in library's constructure.
+  
+  A DXE driver can use gDS pointer to access services in EFI_DXE_SERVICE, if this
+  DXE driver declare that use DxeServicesTableLib library class and link to this 
+  library instance.
+
+  Please attention this library instance can not be used util EFI_SYSTEM_TABLE was 
+  initialized.
+  
+  This library contains contruct function to retrieve EFI_DXE_SERIVCE, this construct
+  function will be invoked in DXE driver's autogen file.
+
+  Copyright (c) 2006 - 2008, 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 <PiDxe.h>
+#include <Guid/DxeServices.h>
+#include <Library/DxeServicesTableLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiLib.h>
+
+//
+// Cache copy of the DXE Services Table
+//
+EFI_DXE_SERVICES  *gDS      = NULL;
+
+/**
+  The constructor function caches the pointer of DXE Services Table.
+
+  The constructor function caches the pointer of DXE Services Table.
+  It will ASSERT() if that operation fails.
+  It will ASSERT() if the pointer of DXE Services Table is NULL.
+  It will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+DxeServicesTableLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // Cache copy of the DXE Services Table
+  //
+  Status = EfiGetSystemConfigurationTable (&gEfiDxeServicesTableGuid, (VOID **) &gDS);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (gDS != NULL);
+
+  return Status;
+}
diff --git a/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
new file mode 100644
index 000000000000..d7047673ef3c
--- /dev/null
+++ b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
@@ -0,0 +1,49 @@
+## @file
+# Instance of DXE Services Table Library using EFI Configuration Table.
+#
+# DXE Services Table Library that retrieves a pointer to the DXE Services
+# Table from the Configuration Table in the EFI System Table.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeServicesTableLib
+  MODULE_UNI_FILE                = DxeServicesTableLib.uni
+  FILE_GUID                      = baa1baa3-0a8d-402c-8042-985115fae953
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DxeServicesTableLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+  CONSTRUCTOR                    = DxeServicesTableLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DxeServicesTableLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  UefiLib
+  DebugLib
+
+
+[Guids]
+  gEfiDxeServicesTableGuid                      ## CONSUMES  ## SystemTable
+
diff --git a/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.uni b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.uni
new file mode 100644
index 000000000000..e437230702dd
--- /dev/null
+++ b/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of DXE Services Table Library using EFI Configuration Table.
+//
+// DXE Services Table Library that retrieves a pointer to the DXE Services
+// Table from the Configuration Table in the EFI System Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Uses EFI Configuration Table"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "DXE Services Table Library retrieves a pointer to the DXE Services Table from the Configuration Table in the EFI System Table."
+
diff --git a/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.c b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.c
new file mode 100644
index 000000000000..5c2c9dbf0d40
--- /dev/null
+++ b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.c
@@ -0,0 +1,104 @@
+/** @file
+Implementation of SmBusLib class library for DXE phase.
+
+Copyright (c) 2006 - 2010, 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 "InternalSmbusLib.h"
+
+
+//
+// Globle varible to cache pointer to Smbus protocol.
+//
+EFI_SMBUS_HC_PROTOCOL      *mSmbus = NULL;
+
+/**
+  The constructor function caches the pointer to Smbus protocol.
+
+  The constructor function locates Smbus protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmbusLibConstructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = gBS->LocateProtocol (&gEfiSmbusHcProtocolGuid, NULL, (VOID**) &mSmbus);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (mSmbus != NULL);
+
+  return Status;
+}
+
+/**
+  Executes an SMBus operation to an SMBus controller.
+
+  This function provides a standard way to execute Smbus script
+  as defined in the SmBus Specification. The data can either be of
+  the Length byte, word, or a block of data.
+
+  @param  SmbusOperation  Signifies which particular SMBus hardware protocol instance 
+                          that it will use to execute the SMBus transactions.
+  @param  SmBusAddress    The address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Length          Signifies the number of bytes that this operation will do. 
+                          The maximum number of bytes can be revision specific 
+                          and operation specific.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave 
+                          device. Not all operations require this argument. The 
+                          length of this buffer is identified by Length.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The actual number of bytes that are executed for this operation.
+
+**/
+UINTN
+InternalSmBusExec (
+  IN     EFI_SMBUS_OPERATION        SmbusOperation,
+  IN     UINTN                      SmBusAddress,
+  IN     UINTN                      Length,
+  IN OUT VOID                       *Buffer,
+     OUT RETURN_STATUS              *Status        OPTIONAL
+  )
+{
+  RETURN_STATUS             ReturnStatus;
+  EFI_SMBUS_DEVICE_ADDRESS  SmbusDeviceAddress;
+
+  SmbusDeviceAddress.SmbusDeviceAddress = SMBUS_LIB_SLAVE_ADDRESS (SmBusAddress);
+
+  ReturnStatus = mSmbus->Execute (
+                           mSmbus,
+                           SmbusDeviceAddress,
+                           SMBUS_LIB_COMMAND (SmBusAddress),
+                           SmbusOperation,
+                           SMBUS_LIB_PEC (SmBusAddress),
+                           &Length,
+                           Buffer
+                           );
+  if (Status != NULL) {
+    *Status = ReturnStatus;
+  }
+
+  return Length;
+}
diff --git a/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.inf b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.inf
new file mode 100644
index 000000000000..edbbc064a907
--- /dev/null
+++ b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.inf
@@ -0,0 +1,51 @@
+## @file
+# SMBUS Library that layers on top of the SMBUS Protocol.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeSmbusLib
+  MODULE_UNI_FILE                = DxeSmbusLib.uni
+  FILE_GUID                      = 4F369FB1-31A7-423c-960E-B3EFD337894F
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmbusLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+
+  CONSTRUCTOR                    = SmbusLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  SmbusLib.c
+  DxeSmbusLib.c
+  InternalSmbusLib.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  UefiBootServicesTableLib
+  DebugLib
+
+
+[Protocols]
+  gEfiSmbusHcProtocolGuid                        ## CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiSmbusHcProtocolGuid
+
diff --git a/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.uni b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.uni
new file mode 100644
index 000000000000..30adce80644d
--- /dev/null
+++ b/MdePkg/Library/DxeSmbusLib/DxeSmbusLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// SMBUS Library that layers on top of the SMBUS Protocol.
+//
+// SMBUS Library that layers on top of the SMBUS Protocol.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "SMBUS Library that layers on top of the SMBUS Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "SMBUS Library that layers on top of the SMBUS Protocol."
+
diff --git a/MdePkg/Library/DxeSmbusLib/InternalSmbusLib.h b/MdePkg/Library/DxeSmbusLib/InternalSmbusLib.h
new file mode 100644
index 000000000000..b9a190b98ec9
--- /dev/null
+++ b/MdePkg/Library/DxeSmbusLib/InternalSmbusLib.h
@@ -0,0 +1,85 @@
+/** @file
+Internal header file for Smbus library.
+
+Copyright (c) 2006 - 2010, 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 __INTERNAL_SMBUS_LIB_H_
+#define __INTERNAL_SMBUS_LIB_H_
+
+
+#include <PiDxe.h>
+
+#include <Protocol/SmbusHc.h>
+
+#include <Library/SmbusLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseMemoryLib.h>
+
+#include <IndustryStandard/SmBus.h>
+
+//
+// Declaration for internal functions
+//
+/**
+  Executes an SMBus operation to an SMBus controller.
+
+  This function provides a standard way to execute Smbus script
+  as defined in the SmBus Specification. The data can either be of
+  the Length byte, word, or a block of data.
+
+  @param  SmbusOperation  Signifies which particular SMBus hardware protocol instance 
+                          that it will use toexecute the SMBus transactions.
+  @param  SmBusAddress    The address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Length          Signifies the number of bytes that this operation will 
+                          do. The maximum number of bytes can be revision specific 
+                          and operation specific.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave
+                          device. Not all operations require this argument. The 
+                          length of this buffer is identified by Length.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The actual number of bytes that are executed for this operation.
+
+**/
+UINTN
+InternalSmBusExec (
+  IN     EFI_SMBUS_OPERATION        SmbusOperation,
+  IN     UINTN                      SmBusAddress,
+  IN     UINTN                      Length,
+  IN OUT VOID                       *Buffer,
+     OUT RETURN_STATUS              *Status        OPTIONAL
+  );
+
+/**
+  The constructor function caches the pointer to Smbus protocol.
+
+  The constructor function locates Smbus protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmbusLibConstructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  );
+
+#endif
diff --git a/MdePkg/Library/DxeSmbusLib/SmbusLib.c b/MdePkg/Library/DxeSmbusLib/SmbusLib.c
new file mode 100644
index 000000000000..f1c058d09168
--- /dev/null
+++ b/MdePkg/Library/DxeSmbusLib/SmbusLib.c
@@ -0,0 +1,592 @@
+/** @file
+Implementation of SmBusLib class library for DXE phase.
+
+Copyright (c) 2006 - 2010, 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 "InternalSmbusLib.h"
+
+/**
+  Executes an SMBUS quick read command.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS:  The SMBUS command was executed.
+                        RETURN_TIMEOUT:  A timeout occurred while executing the 
+                        SMBUS command. 
+                        RETURN_DEVICE_ERROR: The request was not 
+                        completed because a failure reflected in the Host Status 
+                        Register bit.  Device errors are a result of a transaction 
+                        collision, illegal command field, unclaimed cycle (host 
+                        initiated), or bus errors (collisions). 
+                        RETURN_UNSUPPORTED: The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickRead (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusQuickRead, SmBusAddress, 0, NULL, Status);
+}
+
+/**
+  Executes an SMBUS quick write command.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickWrite (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusQuickWrite, SmBusAddress, 0, NULL, Status);
+}
+
+/**
+  Executes an SMBUS receive byte command.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle(host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)  == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReceiveByte, SmBusAddress, 1, &Byte, Status);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS send byte command.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to send.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle(host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Byte   = Value;
+  InternalSmBusExec (EfiSmbusSendByte, SmBusAddress, 1, &Byte, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read data byte command.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failurereflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReadByte, SmBusAddress, 1, &Byte, Status);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS write data byte command.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Byte = Value;
+  InternalSmBusExec (EfiSmbusWriteByte, SmBusAddress, 1, &Byte, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read data word command.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+  
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is 
+                        incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReadWord, SmBusAddress, 2, &Word, Status);
+
+  return Word;
+}
+
+/**
+  Executes an SMBUS write data word command.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the SMBUS 
+                        command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. 
+                        (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Word = Value;
+  InternalSmBusExec (EfiSmbusWriteWord, SmBusAddress, 2, &Word, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS process call command.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is 
+                        incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusProcessCall, SmBusAddress, 2, &Value, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read block command.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        The pointer to the buffer to store the bytes read from 
+                        the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the SMBUS 
+                        command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is 
+                        incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  return InternalSmBusExec (EfiSmbusReadBlock, SmBusAddress, 0x20, Buffer, Status);
+}
+
+/**
+  Executes an SMBUS write block command.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.  
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        MBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        The pointer to the buffer to store the bytes read from 
+                        the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is 
+                        incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN  Length;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Length = SMBUS_LIB_LENGTH (SmBusAddress);
+  return InternalSmBusExec (EfiSmbusWriteBlock, SmBusAddress, Length, Buffer, Status);
+}
+
+/**
+  Executes an SMBUS block process call command.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  WriteBuffer   The pointer to the buffer of bytes to write to the SMBUS.
+  @param  ReadBuffer    The pointer to the buffer of bytes to read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR: The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is 
+                        incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN   Length;
+
+  ASSERT (WriteBuffer != NULL);
+  ASSERT (ReadBuffer  != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Length = SMBUS_LIB_LENGTH (SmBusAddress);
+  //
+  // Assuming that ReadBuffer is large enough to save another memory copy.
+  //
+  ReadBuffer = CopyMem (ReadBuffer, WriteBuffer, Length);
+  return InternalSmBusExec (EfiSmbusBWBRProcessCall, SmBusAddress, Length, ReadBuffer, Status);
+}
diff --git a/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.c b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.c
new file mode 100644
index 000000000000..ed87cb0ab920
--- /dev/null
+++ b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.c
@@ -0,0 +1,223 @@
+/** @file
+  This library implements the Timer Library using the Extended SAL Stall Services Class.
+
+  Copyright (c) 2007 - 2011, 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 <PiDxe.h>
+
+#include <Protocol/ExtendedSalServiceClasses.h>
+
+#include <Library/TimerLib.h>
+#include <Library/BaseLib.h>
+#include <Library/ExtendedSalLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PalLib.h>
+
+/**
+  Stalls the CPU for at least the given number of microseconds.
+
+  This function wraps EsalStall function of Extended SAL Stall Services Class.
+  It stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return MicroSeconds
+
+**/
+UINTN
+EFIAPI
+MicroSecondDelay (
+  IN      UINTN                     MicroSeconds
+  )
+{
+  EsalCall (
+    EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_LO,
+    EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_HI,
+    StallFunctionId, 
+    MicroSeconds, 
+    0, 
+    0, 
+    0, 
+    0, 
+    0, 
+    0
+    );
+  return MicroSeconds;
+}
+
+/**
+  Stalls the CPU for at least the given number of nanoseconds.
+
+  This function wraps EsalStall function of Extended SAL Stall Services Class.
+  It stalls the CPU for the number of nanoseconds specified by NanoSeconds.
+
+  @param  NanoSeconds The minimum number of nanoseconds to delay.
+
+  @return NanoSeconds
+
+**/
+UINTN
+EFIAPI
+NanoSecondDelay (
+  IN      UINTN                     NanoSeconds
+  )
+{
+  UINT64          MicroSeconds;
+
+  //
+  // The unit of ESAL Stall service is microsecond, so we turn the time interval
+  // from nanosecond to microsecond, using the ceiling value to ensure stalling
+  // at least the given number of nanoseconds.
+  //
+  MicroSeconds = DivU64x32 (NanoSeconds + 999, 1000);
+  EsalCall (
+    EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_LO,
+    EFI_EXTENDED_SAL_STALL_SERVICES_PROTOCOL_GUID_HI,
+    StallFunctionId, 
+    MicroSeconds, 
+    0, 
+    0, 
+    0, 
+    0, 
+    0, 
+    0
+    );
+  return NanoSeconds;
+}
+
+/**
+  Retrieves the current value of a 64-bit free running performance counter.
+
+  Retrieves the current value of a 64-bit free running performance counter. The
+  counter can either count up by 1 or count down by 1. If the physical
+  performance counter counts by a larger increment, then the counter values
+  must be translated. The properties of the counter can be retrieved from
+  GetPerformanceCounterProperties().
+
+  @return The current value of the free running performance counter.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounter (
+  VOID
+  )
+{
+  return AsmReadItc ();
+}
+
+/**
+  Retrieves the 64-bit frequency in Hz and the range of performance counter
+  values.
+
+  If StartValue is not NULL, then the value that the performance counter starts
+  with immediately after is it rolls over is returned in StartValue. If
+  EndValue is not NULL, then the value that the performance counter end with
+  immediately before it rolls over is returned in EndValue. The 64-bit
+  frequency of the performance counter in Hz is always returned. If StartValue
+  is less than EndValue, then the performance counter counts up. If StartValue
+  is greater than EndValue, then the performance counter counts down. For
+  example, a 64-bit free running counter that counts up would have a StartValue
+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
+
+  @param  StartValue  The value the performance counter starts with when it
+                      rolls over.
+  @param  EndValue    The value that the performance counter ends with before
+                      it rolls over.
+
+  @return The frequency in Hz.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  OUT      UINT64                    *StartValue,  OPTIONAL
+  OUT      UINT64                    *EndValue     OPTIONAL
+  )
+{
+  PAL_CALL_RETURN                   PalRet;
+  UINT64                            BaseFrequence;
+
+  //
+  // Get processor base frequency
+  //
+  PalRet = PalCall (PAL_FREQ_BASE, 0, 0, 0);
+  ASSERT (PalRet.Status == 0);
+  BaseFrequence = PalRet.r9;
+
+  //
+  // Get processor frequency ratio
+  //
+  PalRet = PalCall (PAL_FREQ_RATIOS, 0, 0, 0);
+  ASSERT (PalRet.Status == 0);
+
+  //
+  // Start value of counter is 0
+  //
+  if (StartValue != NULL) {
+    *StartValue = 0;
+  }
+
+  //
+  // End value of counter is 0xFFFFFFFFFFFFFFFF
+  //
+  if (EndValue != NULL) {
+    *EndValue = (UINT64)(-1);
+  }
+
+  return BaseFrequence * (PalRet.r11 >> 32) / (UINT32)PalRet.r11;
+}
+
+/**
+  Converts elapsed ticks of performance counter to time in nanoseconds.
+
+  This function converts the elapsed ticks of running performance counter to
+  time value in unit of nanoseconds.
+
+  @param  Ticks     The number of elapsed ticks of running performance counter.
+
+  @return The elapsed time in nanoseconds.
+
+**/
+UINT64
+EFIAPI
+GetTimeInNanoSecond (
+  IN      UINT64                     Ticks
+  )
+{
+  UINT64  Frequency;
+  UINT64  NanoSeconds;
+  UINT64  Remainder;
+  INTN    Shift;
+
+  Frequency = GetPerformanceCounterProperties (NULL, NULL);
+
+  //
+  //          Ticks
+  // Time = --------- x 1,000,000,000
+  //        Frequency
+  //
+  NanoSeconds = MultU64x32 (DivU64x64Remainder (Ticks, Frequency, &Remainder), 1000000000u);
+
+  //
+  // Ensure (Remainder * 1,000,000,000) will not overflow 64-bit.
+  // Since 2^29 < 1,000,000,000 = 0x3B9ACA00 < 2^30, Remainder should < 2^(64-30) = 2^34,
+  // i.e. highest bit set in Remainder should <= 33.
+  //
+  Shift = MAX (0, HighBitSet64 (Remainder) - 33);
+  Remainder = RShiftU64 (Remainder, (UINTN) Shift);
+  Frequency = RShiftU64 (Frequency, (UINTN) Shift);
+  NanoSeconds += DivU64x64Remainder (MultU64x32 (Remainder, 1000000000u), Frequency, NULL);
+
+  return NanoSeconds;
+}
diff --git a/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.inf b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.inf
new file mode 100644
index 000000000000..41b0a2f09eab
--- /dev/null
+++ b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.inf
@@ -0,0 +1,41 @@
+## @file
+#  This library implements the Timer Library using the Extended SAL Stall Services Class.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxeTimerLibEsal
+  MODULE_UNI_FILE                = DxeTimerLibEsal.uni
+  FILE_GUID                      = F672AE85-3769-4fb8-A5A0-70B38FB0A7C4
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = TimerLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION 
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  DxeTimerLibEsal.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  ExtendedSalLib
+  BaseLib
+  PalLib
+
diff --git a/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.uni b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.uni
new file mode 100644
index 000000000000..7ac0e0386bdd
--- /dev/null
+++ b/MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.uni
@@ -0,0 +1,21 @@
+// /** @file
+// This library implements the Timer Library using the Extended SAL Stall Services Class.
+//
+// This library implements the Timer Library using the Extended SAL Stall Services Class.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Implements the Timer Library using the Extended SAL Stall Services Class"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library implements the Timer Library using the Extended SAL Stall Services Class."
+
diff --git a/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.c b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.c
new file mode 100644
index 000000000000..0dc3f2821618
--- /dev/null
+++ b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.c
@@ -0,0 +1,101 @@
+/** @file
+  Entry point to a the PEI Core.
+
+Copyright (c) 2006 - 2010, 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 <PiPei.h>
+
+//
+// The Library classes this module produced
+//
+#include <Library/PeiCoreEntryPoint.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  The entry point of PE/COFF Image for the PEI Core.
+
+  This function is the entry point for the PEI Foundation, which allows the SEC phase
+  to pass information about the stack, temporary RAM and the Boot Firmware Volume.
+  In addition, it also allows the SEC phase to pass services and data forward for use
+  during the PEI phase in the form of one or more PPIs.
+  There is no limit to the number of additional PPIs that can be passed from SEC into
+  the PEI Foundation. As part of its initialization phase, the PEI Foundation will add
+  these SEC-hosted PPIs to its PPI database such that both the PEI Foundation and any
+  modules can leverage the associated service calls and/or code in these early PPIs.
+  This function is required to call ProcessModuleEntryPointList() with the Context
+  parameter set to NULL.  ProcessModuleEntryPoint() is never expected to return.
+  The PEI Core is responsible for calling ProcessLibraryConstructorList() as soon as
+  the PEI Services Table and the file handle for the PEI Core itself have been established.
+  If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system.
+
+  @param SecCoreData  Points to a data structure containing information about the 
+                      PEI core's operating environment, such as the size and 
+                      location of temporary RAM, the stack location and the BFV 
+                      location.
+                      
+  @param PpiList      Points to a list of one or more PPI descriptors to be 
+                      installed initially by the PEI core. An empty PPI list 
+                      consists of a single descriptor with the end-tag 
+                      EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                      As part of its initialization phase, the PEI Foundation will
+                      add these SEC-hosted PPIs to its PPI database, such that both 
+                      the PEI Foundation and any modules can leverage the associated 
+                      service calls and/or code in these early PPIs.
+
+**/
+VOID
+EFIAPI 
+_ModuleEntryPoint(
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList
+)
+{
+  ProcessModuleEntryPointList (SecCoreData, PpiList, NULL);
+  
+  //
+  // Should never return
+  //
+  ASSERT(FALSE);
+  CpuDeadLoop ();  
+}
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+
+  This function is required to call _ModuleEntryPoint() passing in SecCoreData and PpiList.
+
+  @param SecCoreData  Points to a data structure containing information about the PEI core's
+                      operating environment, such as the size and location of temporary RAM,
+                      the stack location and the BFV location. 
+
+  @param PpiList      Points to a list of one or more PPI descriptors to be installed
+                      initially by the PEI core.  An empty PPI list consists of 
+                      a single descriptor with the end-tag 
+                      EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
+                      As part of its initialization phase, the PEI Foundation will 
+                      add these SEC-hosted PPIs to its PPI database, such that both 
+                      the PEI Foundationand any modules can leverage the associated 
+                      service calls and/or code in these early PPIs.
+
+**/
+VOID
+EFIAPI
+EfiMain (
+  IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
+  IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList
+  )
+{
+  _ModuleEntryPoint (SecCoreData, PpiList);
+}
diff --git a/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf
new file mode 100644
index 000000000000..a1030db48e2d
--- /dev/null
+++ b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf
@@ -0,0 +1,39 @@
+## @file
+# Module entry point library for PEI core.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiCoreEntryPoint
+  MODULE_UNI_FILE                = PeiCoreEntryPoint.uni
+  FILE_GUID                      = b3b0654a-969d-4096-86cb-27e262a02083
+  MODULE_TYPE                    = PEI_CORE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeiCoreEntryPoint|PEI_CORE
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiCoreEntryPoint.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+
diff --git a/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.uni b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.uni
new file mode 100644
index 000000000000..e5ae4b7c8ff8
--- /dev/null
+++ b/MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Module entry point library for PEI core.
+//
+// Module entry point library for PEI core.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Module entry point library for PEI core"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Module entry point library for PEI core."
+
diff --git a/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.inf b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.inf
new file mode 100644
index 000000000000..a00e74e5a2e0
--- /dev/null
+++ b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.inf
@@ -0,0 +1,45 @@
+## @file
+# Instance of Post Code Library based on Report Status Code Library.
+#
+# Post Code Library that layers on top of a Report Status Code Library instance.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiDxePostCodeLibReportStatusCode
+  MODULE_UNI_FILE                = PeiDxePostCodeLibReportStatusCode.uni
+  FILE_GUID                      = e062c52d-78dc-4cc5-b246-b13497a8123c
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PostCodeLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER PEIM PEI_CORE UEFI_APPLICATION UEFI_DRIVER
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PostCode.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  PcdLib
+  ReportStatusCodeLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask     ## CONSUMES
+
diff --git a/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.uni b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.uni
new file mode 100644
index 000000000000..67b761af0250
--- /dev/null
+++ b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Post Code Library based on Report Status Code Library.
+//
+// Post Code Library that layers on top of a Report Status Code Library instance.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Post Code Library based on Report Status Code Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The Post Code Library that layers on top of a Report Status Code Library instance."
+
diff --git a/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PostCode.c b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PostCode.c
new file mode 100644
index 000000000000..d94ffb60368b
--- /dev/null
+++ b/MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PostCode.c
@@ -0,0 +1,159 @@
+/** @file
+  Post code library instace bases on report status code library
+  PostCode Library for PEIMs and DXE drivers that send PostCode to ReportStatusCode
+
+  Copyright (c) 2006 - 2010, 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 <PiPei.h>
+
+#include <Library/PostCodeLib.h>
+#include <Library/ReportStatusCodeLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseLib.h>
+
+/**
+  Converts POST code value to status code value.
+
+  This macro converts the post code to status code value. Bits 0..4 of PostCode
+  are mapped to bits 16..20 of status code value, and bits 5..7 of PostCode are mapped to bits
+  24..26 of status code value.
+
+  @param  PostCode  POST code value.
+
+  @return The converted status code value.
+
+**/
+#define POST_CODE_TO_STATUS_CODE_VALUE(PostCode)  \
+  ((EFI_STATUS_CODE_VALUE) (((PostCode & 0x1f) << 16) | ((PostCode & 0x3) << 19)))
+
+/**
+  Sends an 32-bit value to a POST card.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.  
+  Some implementations of this library function may perform I/O operations 
+  directly to a POST card device.  Other implementations may send Value to 
+  ReportStatusCode(), and the status code reporting mechanism will eventually 
+  display the 32-bit value on the status reporting device.
+  
+  PostCode() must actively prevent recursion.  If PostCode() is called while 
+  processing another any other Post Code Library function, then 
+  PostCode() must return Value immediately.
+
+  @param  Value  The 32-bit value to write to the POST card.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCode (
+  IN UINT32  Value
+  )
+{
+  REPORT_STATUS_CODE (EFI_PROGRESS_CODE, POST_CODE_TO_STATUS_CODE_VALUE (Value));
+  return Value;
+}
+
+
+/**
+  Sends an 32-bit value to a POST and associated ASCII string.
+
+  Sends the 32-bit value specified by Value to a POST card, and returns Value.
+  If Description is not NULL, then the ASCII string specified by Description is 
+  also passed to the handler that displays the POST card value.  Some 
+  implementations of this library function may perform I/O operations directly 
+  to a POST card device.  Other implementations may send Value to ReportStatusCode(), 
+  and the status code reporting mechanism will eventually display the 32-bit 
+  value on the status reporting device.  
+
+  PostCodeWithDescription()must actively prevent recursion.  If 
+  PostCodeWithDescription() is called while processing another any other Post 
+  Code Library function, then PostCodeWithDescription() must return Value 
+  immediately.
+
+  @param  Value        The 32-bit value to write to the POST card.
+  @param  Description  The pointer to an ASCII string that is a description of the 
+                       POST code value.  This is an optional parameter that may 
+                       be NULL.
+
+  @return The 32-bit value to write to the POST card.
+
+**/
+UINT32
+EFIAPI
+PostCodeWithDescription (
+  IN UINT32       Value,
+  IN CONST CHAR8  *Description  OPTIONAL
+  )
+{
+  if (Description == NULL) {
+    REPORT_STATUS_CODE (
+      EFI_PROGRESS_CODE,
+      POST_CODE_TO_STATUS_CODE_VALUE (Value)
+      );
+  } else {
+    REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
+      EFI_PROGRESS_CODE,
+      POST_CODE_TO_STATUS_CODE_VALUE (Value),
+      Description,
+      AsciiStrSize (Description)
+      );
+  }
+
+  return Value;
+}
+
+
+/**
+  Returns TRUE if POST Codes are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_ENABLED 
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_ENABLED bit of 
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_ENABLED) != 0);
+}
+
+
+/**
+  Returns TRUE if POST code descriptions are enabled.
+
+  This function returns TRUE if the POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED
+  bit of PcdPostCodePropertyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE   The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is set.
+  @retval  FALSE  The POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED bit of
+                  PcdPostCodeProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+PostCodeDescriptionEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdPostCodePropertyMask) & POST_CODE_PROPERTY_POST_CODE_DESCRIPTION_ENABLED) != 0);
+}
+
diff --git a/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.c b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.c
new file mode 100644
index 000000000000..2c3b312381a0
--- /dev/null
+++ b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.c
@@ -0,0 +1,519 @@
+/** @file
+  Provide generic extract guided section functions for PEI phase.
+
+  Copyright (c) 2007 - 2012, 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 <PiPei.h>
+
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/HobLib.h>
+#include <Library/ExtractGuidedSectionLib.h>
+
+#define PEI_EXTRACT_HANDLER_INFO_SIGNATURE SIGNATURE_32 ('P', 'E', 'H', 'I')
+
+typedef struct {
+  UINT32                                  Signature;
+  UINT32                                  NumberOfExtractHandler;
+  GUID                                    *ExtractHandlerGuidTable;
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER   *ExtractDecodeHandlerTable;
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *ExtractGetInfoHandlerTable;
+} PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO;
+
+/**
+  Build guid hob for the global memory to store the registered guid and Handler list.
+  If GuidHob exists, HandlerInfo will be directly got from Guid hob data.
+
+  @param[in, out]  InfoPointer   The pointer to pei handler information structure.
+
+  @retval  RETURN_SUCCESS            Build Guid hob for the global memory space to store guid and function tables.
+  @retval  RETURN_OUT_OF_RESOURCES   No enough memory to allocated.
+**/
+RETURN_STATUS
+PeiGetExtractGuidedSectionHandlerInfo (
+  IN OUT PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO **InfoPointer
+  )
+{
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  EFI_PEI_HOB_POINTERS                    Hob;
+  
+  //
+  // First try to get handler information from guid hob specified by CallerId.
+  //
+  Hob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GetHobList ());
+  while (Hob.Raw != NULL) {
+    if (CompareGuid (&(Hob.Guid->Name), &gEfiCallerIdGuid)) {
+      HandlerInfo = (PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *) GET_GUID_HOB_DATA (Hob.Guid);
+      if (HandlerInfo->Signature == PEI_EXTRACT_HANDLER_INFO_SIGNATURE) {
+        //
+        // Update Table Pointer when hob start address is changed.
+        //
+        if (HandlerInfo->ExtractHandlerGuidTable != (GUID *) (HandlerInfo + 1)) {
+          HandlerInfo->ExtractHandlerGuidTable    = (GUID *) (HandlerInfo + 1);
+          HandlerInfo->ExtractDecodeHandlerTable  = (EXTRACT_GUIDED_SECTION_DECODE_HANDLER *) (
+                                                      (UINT8 *)HandlerInfo->ExtractHandlerGuidTable + 
+                                                      PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (GUID)
+                                                     );
+          HandlerInfo->ExtractGetInfoHandlerTable = (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *) (
+                                                      (UINT8 *)HandlerInfo->ExtractDecodeHandlerTable + 
+                                                      PcdGet32 (PcdMaximumGuidedExtractHandler) * 
+                                                      sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER)
+                                                     );
+        }
+        //
+        // Return HandlerInfo pointer.
+        //
+        *InfoPointer = HandlerInfo;
+        return EFI_SUCCESS;
+      }
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, Hob.Raw);
+  }
+  
+  //
+  // If Guid Hob is not found, Build CallerId Guid hob to store Handler Info
+  //
+  HandlerInfo = BuildGuidHob (
+                 &gEfiCallerIdGuid, 
+                 sizeof (PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO) +
+                 PcdGet32 (PcdMaximumGuidedExtractHandler) * 
+                 (sizeof (GUID) + sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER) + sizeof (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER))
+                );
+  if (HandlerInfo == NULL) {
+    //
+    // No enough resource to build guid hob.
+    //
+    *InfoPointer = NULL;
+    return EFI_OUT_OF_RESOURCES;
+  }
+  //
+  // Init HandlerInfo structure
+  //
+  HandlerInfo->Signature = PEI_EXTRACT_HANDLER_INFO_SIGNATURE;
+  HandlerInfo->NumberOfExtractHandler     = 0;
+  HandlerInfo->ExtractHandlerGuidTable    = (GUID *) (HandlerInfo + 1);
+  HandlerInfo->ExtractDecodeHandlerTable  = (EXTRACT_GUIDED_SECTION_DECODE_HANDLER *) (
+                                              (UINT8 *)HandlerInfo->ExtractHandlerGuidTable + 
+                                              PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (GUID)
+                                             );
+  HandlerInfo->ExtractGetInfoHandlerTable = (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *) (
+                                              (UINT8 *)HandlerInfo->ExtractDecodeHandlerTable + 
+                                              PcdGet32 (PcdMaximumGuidedExtractHandler) * 
+                                              sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER)
+                                             );
+  //
+  // return the created HandlerInfo.
+  //
+  *InfoPointer = HandlerInfo;
+  return EFI_SUCCESS;
+}
+
+/**
+  Retrieve the list GUIDs that have been registered through ExtractGuidedSectionRegisterHandlers().
+
+  Sets ExtractHandlerGuidTable so it points at a callee allocated array of registered GUIDs.
+  The total number of GUIDs in the array are returned. Since the array of GUIDs is callee allocated
+  and caller must treat this array of GUIDs as read-only data. 
+  If ExtractHandlerGuidTable is NULL, then ASSERT().
+
+  @param[out]  ExtractHandlerGuidTable  A pointer to the array of GUIDs that have been registered through
+                                        ExtractGuidedSectionRegisterHandlers().
+
+  @return the number of the supported extract guided Handler.
+
+**/
+UINTN
+EFIAPI
+ExtractGuidedSectionGetGuidList (
+  OUT  GUID  **ExtractHandlerGuidTable
+  )
+{
+  EFI_STATUS Status;
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+
+  ASSERT (ExtractHandlerGuidTable != NULL);
+
+  //
+  // Get all registered handler information
+  //
+  Status = PeiGetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (EFI_ERROR (Status)) {
+    *ExtractHandlerGuidTable = NULL;
+    return 0;
+  }
+
+  //
+  // Get GuidTable and Table Number
+  //
+  ASSERT (HandlerInfo != NULL);
+  *ExtractHandlerGuidTable = HandlerInfo->ExtractHandlerGuidTable;
+  return HandlerInfo->NumberOfExtractHandler;
+}
+
+/**
+  Registers handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and EXTRACT_GUIDED_SECTION_DECODE_HANDLER
+  for a specific GUID section type.
+
+  Registers the handlers specified by GetInfoHandler and DecodeHandler with the GUID specified by SectionGuid.
+  If the GUID value specified by SectionGuid has already been registered, then return RETURN_ALREADY_STARTED.
+  If there are not enough resources available to register the handlers  then RETURN_OUT_OF_RESOURCES is returned.
+  
+  If SectionGuid is NULL, then ASSERT().
+  If GetInfoHandler is NULL, then ASSERT().
+  If DecodeHandler is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the the handlers
+                             of the GUIDed section type being registered.
+  @param[in]  GetInfoHandler The pointer to a function that examines a GUIDed section and returns the
+                             size of the decoded buffer and the size of an optional scratch buffer
+                             required to actually decode the data in a GUIDed section.
+  @param[in]  DecodeHandler  The pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. 
+
+  @retval  RETURN_SUCCESS           The handlers were registered.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to register the handlers.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionRegisterHandlers (
+  IN CONST  GUID                                     *SectionGuid,
+  IN        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  GetInfoHandler,
+  IN        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    DecodeHandler
+  )
+{
+  EFI_STATUS Status;
+  UINT32     Index;
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+
+  //
+  // Check input parameter
+  //
+  ASSERT (SectionGuid != NULL);
+  ASSERT (GetInfoHandler != NULL);
+  ASSERT (DecodeHandler != NULL);
+
+
+
+  //
+  // Get the registered handler information
+  //
+  Status = PeiGetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionGuid)) {
+      //
+      // If the guided handler has been registered before, only update its handler.
+      //
+      HandlerInfo->ExtractDecodeHandlerTable [Index] = DecodeHandler;
+      HandlerInfo->ExtractGetInfoHandlerTable [Index] = GetInfoHandler;
+      return RETURN_SUCCESS;
+    }
+  }
+
+  //
+  // Check the global table is enough to contain new Handler.
+  //
+  if (HandlerInfo->NumberOfExtractHandler >= PcdGet32 (PcdMaximumGuidedExtractHandler)) {
+    return RETURN_OUT_OF_RESOURCES;
+  }
+  
+  //
+  // Register new Handler and guid value.
+  //
+  CopyGuid (HandlerInfo->ExtractHandlerGuidTable + HandlerInfo->NumberOfExtractHandler, SectionGuid);
+  HandlerInfo->ExtractDecodeHandlerTable [HandlerInfo->NumberOfExtractHandler] = DecodeHandler;
+  HandlerInfo->ExtractGetInfoHandlerTable [HandlerInfo->NumberOfExtractHandler++] = GetInfoHandler;
+
+  //
+  // Build the Guided Section GUID HOB to record the GUID itself.
+  // Then the content of the GUIDed HOB will be the same as the GUID value itself.
+  //
+  BuildGuidDataHob (
+    (EFI_GUID *) SectionGuid,
+    (VOID *) SectionGuid,
+    sizeof (GUID)
+    );
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieves a GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to retrieve and return the size of the decoded buffer and the size of an
+  optional scratch buffer required to actually decode the data in a GUIDed section.
+
+  Examines a GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler 
+  of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to retrieve the OututBufferSize, ScratchSize, and Attributes values. The return status from the handler of
+  type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER is returned.
+  
+  If InputSection is NULL, then ASSERT().
+  If OutputBufferSize is NULL, then ASSERT().
+  If ScratchBufferSize is NULL, then ASSERT().
+  If SectionAttribute is NULL, then ASSERT().
+
+  @param[in]  InputSection       A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBufferSize   A pointer to the size, in bytes, of an output buffer required if the buffer
+                                 specified by InputSection were decoded.
+  @param[out] ScratchBufferSize  A pointer to the size, in bytes, required as scratch space if the buffer specified by
+                                 InputSection were decoded.
+  @param[out] SectionAttribute   A pointer to the attributes of the GUIDed section.  See the Attributes field of
+                                 EFI_GUID_DEFINED_SECTION in the PI Specification.
+
+  @retval  RETURN_SUCCESS      Get the required information successfully.
+  @retval  RETURN_UNSUPPORTED  The GUID from the section specified by InputSection does not match any of
+                               the GUIDs registered with ExtractGuidedSectionRegisterHandlers().
+  @retval  Others              The return status from the handler associated with the GUID retrieved from
+                               the section specified by InputSection.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetInfo (
+  IN  CONST VOID    *InputSection,
+  OUT       UINT32  *OutputBufferSize,
+  OUT       UINT32  *ScratchBufferSize,
+  OUT       UINT16  *SectionAttribute   
+  )
+{
+  UINT32 Index;
+  EFI_STATUS Status;
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  EFI_GUID *SectionDefinitionGuid;
+  
+  //
+  // Check input parameter
+  //
+  ASSERT (InputSection != NULL);
+  ASSERT (OutputBufferSize != NULL);
+  ASSERT (ScratchBufferSize != NULL);
+  ASSERT (SectionAttribute != NULL);
+
+  //
+  // Get all registered handler information.
+  //
+  Status = PeiGetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionDefinitionGuid)) {
+      //
+      // Call the match handler to get information for the input section data.
+      //
+      return HandlerInfo->ExtractGetInfoHandlerTable [Index] (
+                InputSection,
+                OutputBufferSize,
+                ScratchBufferSize,
+                SectionAttribute
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves the GUID from a GUIDed section and uses that GUID to select an associated handler of type
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers().
+  The selected handler is used to decode the data in a GUIDed section and return the result in a caller
+  allocated output buffer.
+
+  Decodes the GUIDed section specified by InputSection.  
+  If GUID for InputSection does not match any of the GUIDs registered through ExtractGuidedSectionRegisterHandlers(),
+  then RETURN_UNSUPPORTED is returned.  
+  If the GUID of InputSection does match the GUID that this handler supports, then the the associated handler
+  of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER that was registered with ExtractGuidedSectionRegisterHandlers()
+  is used to decode InputSection into the buffer specified by OutputBuffer and the authentication status of this
+  decode operation is returned in AuthenticationStatus.  If the decoded buffer is identical to the data in InputSection,
+  then OutputBuffer is set to point at the data in InputSection.  Otherwise, the decoded data will be placed in caller
+  allocated buffer specified by OutputBuffer.    This function is responsible for computing the  EFI_AUTH_STATUS_PLATFORM_OVERRIDE
+  bit of in AuthenticationStatus.  The return status from the handler of type EXTRACT_GUIDED_SECTION_DECODE_HANDLER is returned. 
+   
+  If InputSection is NULL, then ASSERT().
+  If OutputBuffer is NULL, then ASSERT().
+  If ScratchBuffer is NULL and this decode operation requires a scratch buffer, then ASSERT().
+  If AuthenticationStatus is NULL, then ASSERT().  
+
+  @param[in]  InputSection   A pointer to a GUIDed section of an FFS formatted file.
+  @param[out] OutputBuffer   A pointer to a buffer that contains the result of a decode operation. 
+  @param[in]  ScratchBuffer  A caller allocated buffer that may be required by this function as a scratch buffer to perform the decode operation. 
+  @param[out] AuthenticationStatus 
+                             A pointer to the authentication status of the decoded output buffer. See the definition
+                             of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI section of the PI
+                             Specification.
+
+  @retval  RETURN_SUCCESS           The buffer specified by InputSection was decoded.
+  @retval  RETURN_UNSUPPORTED       The section specified by InputSection does not match the GUID this handler supports.
+  @retval  RETURN_INVALID_PARAMETER The section specified by InputSection can not be decoded.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionDecode (
+  IN  CONST VOID    *InputSection,
+  OUT       VOID    **OutputBuffer,
+  IN        VOID    *ScratchBuffer,        OPTIONAL
+  OUT       UINT32  *AuthenticationStatus  
+  )
+{
+  UINT32     Index;
+  EFI_STATUS Status;
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO *HandlerInfo;
+  EFI_GUID *SectionDefinitionGuid;
+  
+  //
+  // Check input parameter
+  //
+  ASSERT (InputSection != NULL);
+  ASSERT (OutputBuffer != NULL);
+  ASSERT (AuthenticationStatus != NULL);
+
+  //
+  // Get all registered handler information.
+  //  
+  Status = PeiGetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_SECTION2 (InputSection)) {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
+  } else {
+    SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
+  }
+
+  //
+  // Search the match registered Extract handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionDefinitionGuid)) {
+      //
+      // Call the match handler to extract raw data for the input guided section.
+      //
+      return HandlerInfo->ExtractDecodeHandlerTable [Index] (
+                InputSection,
+                OutputBuffer,
+                ScratchBuffer,
+                AuthenticationStatus
+              );
+    }
+  }
+
+  //
+  // Not found, the input guided section is not supported. 
+  //
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Retrieves handlers of type EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER and 
+  EXTRACT_GUIDED_SECTION_DECODE_HANDLER for a specific GUID section type.
+  
+  Retrieves the handlers associated with SectionGuid and returns them in 
+  GetInfoHandler and DecodeHandler.
+
+  If the GUID value specified by SectionGuid has not been registered, then 
+  return RETURN_NOT_FOUND.
+  
+  If SectionGuid is NULL, then ASSERT().
+
+  @param[in]  SectionGuid    A pointer to the GUID associated with the handlersof the GUIDed 
+                             section type being retrieved.
+  @param[out] GetInfoHandler Pointer to a function that examines a GUIDed section and returns 
+                             the size of the decoded buffer and the size of an optional scratch 
+                             buffer required to actually decode the data in a GUIDed section.  
+                             This is an optional parameter that may be NULL. If it is NULL, then 
+                             the previously registered handler is not returned.
+  @param[out] DecodeHandler  Pointer to a function that decodes a GUIDed section into a caller
+                             allocated output buffer. This is an optional parameter that may be NULL.
+                             If it is NULL, then the previously registered handler is not returned.
+
+  @retval  RETURN_SUCCESS     The handlers were retrieved.
+  @retval  RETURN_NOT_FOUND   No handlers have been registered with the specified GUID.
+
+**/
+RETURN_STATUS
+EFIAPI
+ExtractGuidedSectionGetHandlers (
+  IN CONST   GUID                                     *SectionGuid,
+  OUT        EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER  *GetInfoHandler,  OPTIONAL
+  OUT        EXTRACT_GUIDED_SECTION_DECODE_HANDLER    *DecodeHandler    OPTIONAL
+  )
+{
+  EFI_STATUS                               Status;
+  UINT32                                   Index;
+  PEI_EXTRACT_GUIDED_SECTION_HANDLER_INFO  *HandlerInfo;
+
+  //
+  // Check input parameter
+  //
+  ASSERT (SectionGuid != NULL);
+
+  //
+  // Get the registered handler information
+  //
+  Status = PeiGetExtractGuidedSectionHandlerInfo (&HandlerInfo);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Search the match registered GetInfo handler for the input guided section.
+  //
+  ASSERT (HandlerInfo != NULL);
+  for (Index = 0; Index < HandlerInfo->NumberOfExtractHandler; Index ++) {
+    if (CompareGuid (HandlerInfo->ExtractHandlerGuidTable + Index, SectionGuid)) {
+
+      //
+      // If the guided handler has been registered before, then return the registered handlers.
+      //
+      if (GetInfoHandler != NULL) {
+        *GetInfoHandler = HandlerInfo->ExtractGetInfoHandlerTable[Index];
+      }
+      if (DecodeHandler != NULL) {
+        *DecodeHandler = HandlerInfo->ExtractDecodeHandlerTable[Index];
+      }
+      return RETURN_SUCCESS;
+    }
+  }
+  return RETURN_NOT_FOUND;
+}
diff --git a/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.inf b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.inf
new file mode 100644
index 000000000000..5fd0fe29bdc6
--- /dev/null
+++ b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.inf
@@ -0,0 +1,48 @@
+## @file
+# Instance of ExtractGuidedSection Library for PEI phase.
+#
+# This library provides generic extract guided section functions for PEIM and PEI_CORE module.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiExtractGuidedSectionLib
+  MODULE_UNI_FILE                = PeiExtractGuidedSectionLib.uni
+  FILE_GUID                      = 41ddf016-2a11-415f-8880-00d938e9541a
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ExtractGuidedSectionLib|PEIM PEI_CORE
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiExtractGuidedSectionLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  DebugLib
+  HobLib
+  PcdLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumGuidedExtractHandler     ## CONSUMES
+
diff --git a/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.uni b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.uni
new file mode 100644
index 000000000000..6842496e6ba4
--- /dev/null
+++ b/MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of ExtractGuidedSection Library for PEI phase.
+//
+// This library provides generic extract guided section functions for PEIM and PEI_CORE module.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Extract Guided Section Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library provides generic extract guided section functions for PEIM and PEI_CORE modules."
+
diff --git a/MdePkg/Library/PeiHobLib/HobLib.c b/MdePkg/Library/PeiHobLib/HobLib.c
new file mode 100644
index 000000000000..b5a438df59fe
--- /dev/null
+++ b/MdePkg/Library/PeiHobLib/HobLib.c
@@ -0,0 +1,804 @@
+/** @file
+  Provide Hob Library functions for Pei phase.
+
+Copyright (c) 2007 - 2016, 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 <PiPei.h>
+
+#include <Guid/MemoryAllocationHob.h>
+
+#include <Library/HobLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PeiServicesLib.h>
+#include <Library/BaseMemoryLib.h>
+
+/**
+  Returns the pointer to the HOB list.
+
+  This function returns the pointer to first HOB in the list.
+  For PEI phase, the PEI service GetHobList() can be used to retrieve the pointer 
+  to the HOB list.  For the DXE phase, the HOB list pointer can be retrieved through
+  the EFI System Table by looking up theHOB list GUID in the System Configuration Table.
+  Since the System Configuration Table does not exist that the time the DXE Core is 
+  launched, the DXE Core uses a global variable from the DXE Core Entry Point Library 
+  to manage the pointer to the HOB list.
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+  
+  @return The pointer to the HOB list.
+
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  )
+{
+  EFI_STATUS            Status;
+  VOID                  *HobList;
+
+  Status = PeiServicesGetHobList (&HobList);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (HobList != NULL);
+
+  return HobList;
+}
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+
+  This function searches the first instance of a HOB type from the starting HOB pointer. 
+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If HobStart is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+  @param  HobStart      The starting HOB pointer to search from.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  IN UINT16                 Type,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  Hob;
+
+  ASSERT (HobStart != NULL);
+   
+  Hob.Raw = (UINT8 *) HobStart;
+  //
+  // Parse the HOB list until end of list or matching type is found.
+  //
+  while (!END_OF_HOB_LIST (Hob)) {
+    if (Hob.Header->HobType == Type) {
+      return Hob.Raw;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+  }
+  return NULL;
+}
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+
+  This function searches the first instance of a HOB type among the whole HOB list. 
+  If there does not exist such HOB type in the HOB list, it will return NULL. 
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  IN UINT16                 Type
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextHob (Type, HobList);
+}
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+  
+  This function searches the first instance of a HOB from the starting HOB pointer. 
+  Such HOB should satisfy two conditions: 
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+  
+  If Guid is NULL, then ASSERT().
+  If HobStart is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+  @param  HobStart      A pointer to a Guid.
+
+  @return The next instance of the matched GUID HOB from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  IN CONST EFI_GUID         *Guid,
+  IN CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  GuidHob;
+
+  GuidHob.Raw = (UINT8 *) HobStart;
+  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
+    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
+      break;
+    }
+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
+  }
+  return GuidHob.Raw;
+}
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+  
+  This function searches the first instance of a HOB among the whole HOB list. 
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size information, respectively.
+  
+  If the pointer to the HOB list is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+
+  @return The first instance of the matched GUID HOB among the whole HOB list.
+
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  IN CONST EFI_GUID         *Guid
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextGuidHob (Guid, HobList);
+}
+
+/**
+  Get the system boot mode from the HOB list.
+
+  This function returns the system boot mode information from the 
+  PHIT HOB in HOB list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+  
+  @param  VOID.
+
+  @return The Boot Mode.
+
+**/
+EFI_BOOT_MODE
+EFIAPI
+GetBootModeHob (
+  VOID
+  )
+{
+  EFI_STATUS             Status;
+  EFI_BOOT_MODE          BootMode;
+
+  Status = PeiServicesGetBootMode (&BootMode);
+  ASSERT_EFI_ERROR (Status);
+
+  return BootMode;
+}
+
+/**
+  Adds a new HOB to the HOB List.
+
+  This internal function enables PEIMs to create various types of HOBs.
+
+  @param  Type          Type of the new HOB.
+  @param  Length        Length of the new HOB to allocate.
+
+  @retval  NULL         The HOB could not be allocated.
+  @retval  others       The address of new HOB.
+
+**/
+VOID *
+EFIAPI
+InternalPeiCreateHob (
+  IN UINT16                      Type,
+  IN UINT16                      Length
+  )
+{
+  EFI_STATUS        Status;
+  VOID              *Hob;
+
+  Status = PeiServicesCreateHob (Type, Length, &Hob);
+  if (EFI_ERROR (Status)) {
+    Hob = NULL;
+  }
+  //
+  // Assume the process of HOB building is always successful.
+  //
+  ASSERT (Hob != NULL);
+  return Hob;
+}
+
+/**
+  Builds a HOB for a loaded PE32 module.
+
+  This function builds a HOB for a loaded PE32 module.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If ModuleName is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ModuleName              The GUID File Name of the module.
+  @param  MemoryAllocationModule  The 64 bit physical address of the module.
+  @param  ModuleLength            The length of the module in bytes.
+  @param  EntryPoint              The 64 bit physical address of the module entry point.
+
+**/
+VOID
+EFIAPI
+BuildModuleHob (
+  IN CONST EFI_GUID         *ModuleName,
+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
+  IN UINT64                 ModuleLength,
+  IN EFI_PHYSICAL_ADDRESS   EntryPoint
+  )
+{
+  EFI_HOB_MEMORY_ALLOCATION_MODULE  *Hob;
+
+  ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
+          ((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));
+  if (Hob == NULL) {
+    return;
+  }
+
+  CopyGuid (&(Hob->MemoryAllocationHeader.Name), &gEfiHobMemoryAllocModuleGuid);
+  Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;
+  Hob->MemoryAllocationHeader.MemoryLength      = ModuleLength;
+  Hob->MemoryAllocationHeader.MemoryType        = EfiBootServicesCode;
+
+  //
+  // Zero the reserved space to match HOB spec
+  //
+  ZeroMem (Hob->MemoryAllocationHeader.Reserved, sizeof (Hob->MemoryAllocationHeader.Reserved));
+  
+  CopyGuid (&Hob->ModuleName, ModuleName);
+  Hob->EntryPoint = EntryPoint;
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory with Owner GUID.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+  @param  OwnerGUID           GUID for the owner of this resource.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorWithOwnerHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes,
+  IN EFI_GUID                     *OwnerGUID
+  )
+{
+  EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (UINT16) sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->ResourceType      = ResourceType;
+  Hob->ResourceAttribute = ResourceAttribute;
+  Hob->PhysicalStart     = PhysicalStart;
+  Hob->ResourceLength    = NumberOfBytes;
+
+  CopyGuid (&Hob->Owner, OwnerGUID);
+}
+
+/**
+  Builds a HOB that describes a chunk of system memory.
+
+  This function builds a HOB that describes a chunk of system memory.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  ResourceType        The type of resource described by this HOB.
+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
+
+**/
+VOID
+EFIAPI
+BuildResourceDescriptorHob (
+  IN EFI_RESOURCE_TYPE            ResourceType,
+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
+  IN UINT64                       NumberOfBytes
+  )
+{
+  EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (UINT16) sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->ResourceType      = ResourceType;
+  Hob->ResourceAttribute = ResourceAttribute;
+  Hob->PhysicalStart     = PhysicalStart;
+  Hob->ResourceLength    = NumberOfBytes;
+  ZeroMem (&(Hob->Owner), sizeof (EFI_GUID));
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification and returns 
+  the start address of GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification 
+  and returns the start address of GUID HOB data so that caller can fill the customized data. 
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidHob (
+  IN CONST EFI_GUID              *Guid,
+  IN UINTN                       DataLength
+  )
+{
+  EFI_HOB_GUID_TYPE *Hob;
+
+  //
+  // Make sure Guid is valid
+  //
+  ASSERT (Guid != NULL);
+  
+  //
+  // Make sure that data length is not too long.
+  //
+  ASSERT (DataLength <= (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)));
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
+  if (Hob == NULL) {
+    return Hob;
+  }
+  CopyGuid (&Hob->Name, Guid);
+  return Hob + 1;
+}
+
+/**
+  Builds a customized HOB tagged with a GUID for identification, copies the input data to the HOB 
+  data field, and returns the start address of the GUID HOB data.
+
+  This function builds a customized HOB tagged with a GUID for identification and copies the input
+  data to the HOB data field and returns the start address of the GUID HOB data.  It can only be 
+  invoked during PEI phase; for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.  
+  The HOB Header and Name field is already stripped.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If Guid is NULL, then ASSERT().
+  If Data is NULL and DataLength > 0, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+  If DataLength > (0xFFF8 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
+  HobLength is UINT16 and multiples of 8 bytes, so the max HobLength is 0xFFF8.
+
+  @param  Guid          The GUID to tag the customized HOB.
+  @param  Data          The data to be copied into the data field of the GUID HOB.
+  @param  DataLength    The size of the data payload for the GUID HOB.
+
+  @retval  NULL         The GUID HOB could not be allocated.
+  @retval  others       The start address of GUID HOB data.
+
+**/
+VOID *
+EFIAPI
+BuildGuidDataHob (
+  IN CONST EFI_GUID              *Guid,
+  IN VOID                        *Data,
+  IN UINTN                       DataLength
+  )
+{
+  VOID  *HobData;
+
+  ASSERT (Data != NULL || DataLength == 0);
+
+  HobData = BuildGuidHob (Guid, DataLength);
+  if (HobData == NULL) {
+    return HobData;
+  }
+
+  return CopyMem (HobData, Data, DataLength);
+}
+
+/**
+  Check FV alignment.
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+
+  @retval TRUE          FvImage buffer is at its required alignment.
+  @retval FALSE         FvImage buffer is not at its required alignment.
+
+**/
+BOOLEAN
+InternalCheckFvAlignment (
+  IN EFI_PHYSICAL_ADDRESS       BaseAddress,
+  IN UINT64                     Length
+  )
+{
+  EFI_FIRMWARE_VOLUME_HEADER    *FwVolHeader;
+  UINT32                        FvAlignment;
+
+  FvAlignment = 0;
+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) BaseAddress;
+
+  //
+  // If EFI_FVB2_WEAK_ALIGNMENT is set in the volume header then the first byte of the volume
+  // can be aligned on any power-of-two boundary. A weakly aligned volume can not be moved from
+  // its initial linked location and maintain its alignment.
+  //
+  if ((FwVolHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) {
+    //
+    // Get FvHeader alignment
+    //
+    FvAlignment = 1 << ((FwVolHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16);
+    //
+    // FvAlignment must be greater than or equal to 8 bytes of the minimum FFS alignment value.
+    //
+    if (FvAlignment < 8) {
+      FvAlignment = 8;
+    }
+    if ((UINTN)BaseAddress % FvAlignment != 0) {
+      //
+      // FvImage buffer is not at its required alignment.
+      //
+      DEBUG ((
+        DEBUG_ERROR,
+        "Unaligned FvImage found at 0x%lx:0x%lx, the required alignment is 0x%x\n",
+        BaseAddress,
+        Length,
+        FvAlignment
+        ));
+      return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+/**
+  Builds a Firmware Volume HOB.
+
+  This function builds a Firmware Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildFvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  EFI_HOB_FIRMWARE_VOLUME  *Hob;
+
+  if (!InternalCheckFvAlignment (BaseAddress, Length)) {
+    ASSERT (FALSE);
+    return;
+  }
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->BaseAddress = BaseAddress;
+  Hob->Length      = Length;
+}
+
+/**
+  Builds a EFI_HOB_TYPE_FV2 HOB.
+
+  This function builds a EFI_HOB_TYPE_FV2 HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+  If the FvImage buffer is not at its required alignment, then ASSERT().
+
+  @param  BaseAddress   The base address of the Firmware Volume.
+  @param  Length        The size of the Firmware Volume in bytes.
+  @param  FvName        The name of the Firmware Volume.
+  @param  FileName      The name of the file.
+  
+**/
+VOID
+EFIAPI
+BuildFv2Hob (
+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN          UINT64                      Length,
+  IN CONST    EFI_GUID                    *FvName,
+  IN CONST    EFI_GUID                    *FileName
+  )
+{
+  EFI_HOB_FIRMWARE_VOLUME2  *Hob;
+
+  if (!InternalCheckFvAlignment (BaseAddress, Length)) {
+    ASSERT (FALSE);
+    return;
+  }
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_FV2, (UINT16) sizeof (EFI_HOB_FIRMWARE_VOLUME2));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->BaseAddress = BaseAddress;
+  Hob->Length      = Length;
+  CopyGuid (&Hob->FvName, FvName);
+  CopyGuid (&Hob->FileName, FileName);
+}
+
+/**
+  Builds a Capsule Volume HOB.
+
+  This function builds a Capsule Volume HOB.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If the platform does not support Capsule Volume HOBs, then ASSERT().
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The base address of the Capsule Volume.
+  @param  Length        The size of the Capsule Volume in bytes.
+
+**/
+VOID
+EFIAPI
+BuildCvHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  EFI_HOB_UEFI_CAPSULE  *Hob;
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_UEFI_CAPSULE, (UINT16) sizeof (EFI_HOB_UEFI_CAPSULE));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->BaseAddress  = BaseAddress;
+  Hob->Length       = Length;
+}
+
+/**
+  Builds a HOB for the CPU.
+
+  This function builds a HOB for the CPU.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
+
+**/
+VOID
+EFIAPI
+BuildCpuHob (
+  IN UINT8                       SizeOfMemorySpace,
+  IN UINT8                       SizeOfIoSpace
+  )
+{
+  EFI_HOB_CPU  *Hob;
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_CPU, (UINT16) sizeof (EFI_HOB_CPU));
+  if (Hob == NULL) {
+    return;
+  }
+
+  Hob->SizeOfMemorySpace = SizeOfMemorySpace;
+  Hob->SizeOfIoSpace     = SizeOfIoSpace;
+
+  //
+  // Zero the reserved space to match HOB spec
+  //
+  ZeroMem (Hob->Reserved, sizeof (Hob->Reserved)); 
+}
+
+/**
+  Builds a HOB for the Stack.
+
+  This function builds a HOB for the stack.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the Stack.
+  @param  Length        The length of the stack in bytes.
+
+**/
+VOID
+EFIAPI
+BuildStackHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length
+  )
+{
+  EFI_HOB_MEMORY_ALLOCATION_STACK  *Hob;
+
+  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
+          ((Length & (EFI_PAGE_SIZE - 1)) == 0));
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));
+  if (Hob == NULL) {
+    return;
+  }
+
+  CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocStackGuid);
+  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
+  Hob->AllocDescriptor.MemoryLength      = Length;
+  Hob->AllocDescriptor.MemoryType        = EfiBootServicesData;
+
+  //
+  // Zero the reserved space to match HOB spec
+  //
+  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
+}
+
+/**
+  Builds a HOB for the BSP store.
+
+  This function builds a HOB for BSP store.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the BSP.
+  @param  Length        The length of the BSP store in bytes.
+  @param  MemoryType    The type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildBspStoreHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  EFI_HOB_MEMORY_ALLOCATION_BSP_STORE  *Hob;
+
+  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
+          ((Length & (EFI_PAGE_SIZE - 1)) == 0));
+
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION_BSP_STORE));
+  if (Hob == NULL) {
+    return;
+  }
+
+  CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocBspStoreGuid);
+  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
+  Hob->AllocDescriptor.MemoryLength      = Length;
+  Hob->AllocDescriptor.MemoryType        = MemoryType;
+
+  //
+  // Zero the reserved space to match HOB spec
+  //
+  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
+}
+
+/**
+  Builds a HOB for the memory allocation.
+
+  This function builds a HOB for the memory allocation.
+  It can only be invoked during PEI phase;
+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
+  
+  If there is no additional space for HOB creation, then ASSERT().
+
+  @param  BaseAddress   The 64 bit physical address of the memory.
+  @param  Length        The length of the memory allocation in bytes.
+  @param  MemoryType    The type of memory allocated by this HOB.
+
+**/
+VOID
+EFIAPI
+BuildMemoryAllocationHob (
+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
+  IN UINT64                      Length,
+  IN EFI_MEMORY_TYPE             MemoryType
+  )
+{
+  EFI_HOB_MEMORY_ALLOCATION  *Hob;
+
+  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
+          ((Length & (EFI_PAGE_SIZE - 1)) == 0));
+  
+  Hob = InternalPeiCreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, (UINT16) sizeof (EFI_HOB_MEMORY_ALLOCATION));
+  if (Hob == NULL) {
+    return;
+  }
+  
+  ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));
+  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
+  Hob->AllocDescriptor.MemoryLength      = Length;
+  Hob->AllocDescriptor.MemoryType        = MemoryType;
+  //
+  // Zero the reserved space to match HOB spec
+  //
+  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
+}
diff --git a/MdePkg/Library/PeiHobLib/PeiHobLib.inf b/MdePkg/Library/PeiHobLib/PeiHobLib.inf
new file mode 100644
index 000000000000..4cb9b8433399
--- /dev/null
+++ b/MdePkg/Library/PeiHobLib/PeiHobLib.inf
@@ -0,0 +1,56 @@
+## @file
+# Instance of HOB Library using PEI Services.
+#
+# HOB Library implementation that uses PEI Services to retrieve the HOB List.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiHobLib
+  MODULE_UNI_FILE                = PeiHobLib.uni
+  FILE_GUID                      = 9643128f-ac24-4b3e-b6be-d8849a306153
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = HobLib|PEIM PEI_CORE SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  HobLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  PeiServicesLib
+  DebugLib
+
+[Guids]
+  gEfiHobMemoryAllocStackGuid                   ## SOMETIMES_PRODUCES ## HOB # MemoryAllocation StackHob
+  gEfiHobMemoryAllocBspStoreGuid                ## SOMETIMES_PRODUCES ## HOB # MemoryAllocation BspStoreHob
+  gEfiHobMemoryAllocModuleGuid                  ## SOMETIMES_PRODUCES ## HOB # MemoryAllocation ModuleHob
+
+#
+# [Hob]
+#   MEMORY_ALLOCATION     ## SOMETIMES_PRODUCES
+#   RESOURCE_DESCRIPTOR   ## SOMETIMES_PRODUCES
+#   FIRMWARE_VOLUME       ## SOMETIMES_PRODUCES
+#   
+
diff --git a/MdePkg/Library/PeiHobLib/PeiHobLib.uni b/MdePkg/Library/PeiHobLib/PeiHobLib.uni
new file mode 100644
index 000000000000..38fc17cee341
--- /dev/null
+++ b/MdePkg/Library/PeiHobLib/PeiHobLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of HOB Library using PEI Services.
+//
+// HOB Library implementation that uses PEI Services to retrieve the HOB List.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of HOB Library using PEI Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "HOB Library implementation that uses PEI Services to retrieve the HOB List."
+
diff --git a/MdePkg/Library/PeiIoLibCpuIo/IoHighLevel.c b/MdePkg/Library/PeiIoLibCpuIo/IoHighLevel.c
new file mode 100644
index 000000000000..b2dc11e294b1
--- /dev/null
+++ b/MdePkg/Library/PeiIoLibCpuIo/IoHighLevel.c
@@ -0,0 +1,2356 @@
+/** @file
+  High-level Io/Mmio functions.
+
+  All assertions for bit field operations are handled bit field functions in the
+  Base Library.
+
+  Copyright (c) 2006 - 2012, 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 <PiPei.h>
+
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) | OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) & AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) ((IoRead8 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. 
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) | OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) & AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) ((IoRead16 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) | OrData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) & AndData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) | OrData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) & AndData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) | OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) & AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) ((MmioRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) | OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) & AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) ((MmioRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) | OrData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) & AndData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) | OrData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) & AndData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise 
+  OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise 
+  OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
diff --git a/MdePkg/Library/PeiIoLibCpuIo/IoLib.c b/MdePkg/Library/PeiIoLibCpuIo/IoLib.c
new file mode 100644
index 000000000000..5c253fb989be
--- /dev/null
+++ b/MdePkg/Library/PeiIoLibCpuIo/IoLib.c
@@ -0,0 +1,835 @@
+/** @file
+  I/O Library. The implementations are based on EFI_PEI_SERVICE->CpuIo interface.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 <PiPei.h>
+
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The port is read Count times, and the read data is stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to read I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifoWorker (
+  IN      UINTN                     Port,
+  IN      EFI_PEI_CPU_IO_PPI_WIDTH  Width,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+  EFI_STATUS                        Status;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  Status = CpuIo->Io.Read (PeiServices, CpuIo, Width, Port, Count, Buffer);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width specified by Width.
+  The port is written Count times, and the write data is retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are serialized.
+  If such operations are not supported, then ASSERT().
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Count         The number of times to write I/O port.
+  @param  Buffer        The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoWriteFifoWorker (
+  IN      UINTN                     Port,
+  IN      EFI_PEI_CPU_IO_PPI_WIDTH  Width,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+  EFI_STATUS                        Status;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  Status = CpuIo->Io.Write (PeiServices, CpuIo, Width, Port, Count, Buffer);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  return CpuIo->IoRead8 (PeiServices, CpuIo, (UINT64) Port);
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  CpuIo->IoWrite8 (PeiServices, CpuIo, (UINT64) Port, Value);
+  return Value;
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return CpuIo->IoRead16 (PeiServices, CpuIo, (UINT64) Port);
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  CpuIo->IoWrite16 (PeiServices, CpuIo, (UINT64) Port, Value);
+  return Value;
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return CpuIo->IoRead32 (PeiServices, CpuIo, (UINT64) Port);
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+  
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  CpuIo->IoWrite32 (PeiServices, CpuIo, (UINT64) Port, Value);
+  return Value;
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return CpuIo->IoRead64 (PeiServices, CpuIo, (UINT64) Port);
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  CpuIo->IoWrite64 (PeiServices, CpuIo, (UINT64) Port, Value);
+  return Value;;
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  IoReadFifoWorker (Port, EfiPeiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  IoWriteFifoWorker (Port, EfiPeiCpuIoWidthFifoUint8, Count, Buffer);
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoReadFifoWorker (Port, EfiPeiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  IoWriteFifoWorker (Port, EfiPeiCpuIoWidthFifoUint16, Count, Buffer);
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoReadFifoWorker (Port, EfiPeiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  IoWriteFifoWorker (Port, EfiPeiCpuIoWidthFifoUint32, Count, Buffer);
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  return CpuIo->MemRead8 (PeiServices, CpuIo, (UINT64) Address);
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+
+  CpuIo->MemWrite8 (PeiServices, CpuIo, (UINT64) Address, Value);
+  return Value;
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return CpuIo->MemRead16 (PeiServices, CpuIo, (UINT64) Address);
+
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  CpuIo->MemWrite16 (PeiServices, CpuIo, (UINT64) Address, Value);
+  return Value;
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return CpuIo->MemRead32 (PeiServices, CpuIo, (UINT64) Address);
+
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+  
+  @return Value.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  CpuIo->MemWrite32 (PeiServices, CpuIo, (UINT64) Address, Value);
+  return Value;
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & (sizeof (UINT64) - 1)) == 0);
+  return CpuIo->MemRead64 (PeiServices, CpuIo, (UINT64) Address);
+
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  CONST EFI_PEI_SERVICES            **PeiServices;
+  EFI_PEI_CPU_IO_PPI                *CpuIo;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  CpuIo       = (*PeiServices)->CpuIo;
+  ASSERT (CpuIo != NULL);
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  CpuIo->MemWrite64 (PeiServices, CpuIo, (UINT64) Address, Value);
+  return Value;
+}
diff --git a/MdePkg/Library/PeiIoLibCpuIo/IoLibMmioBuffer.c b/MdePkg/Library/PeiIoLibCpuIo/IoLibMmioBuffer.c
new file mode 100644
index 000000000000..5eaa6a812780
--- /dev/null
+++ b/MdePkg/Library/PeiIoLibCpuIo/IoLibMmioBuffer.c
@@ -0,0 +1,418 @@
+/** @file
+  I/O Library MMIO Buffer Functions.
+  The implementations are based on EFI_PEI_SERVICE->CpuIo interface.
+
+  Copyright (c) 2007 - 2009, 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 <PiPei.h>
+
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 8-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8   *ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length-- != 0) {
+    *(Buffer++) = MmioRead8 (StartAddress++);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 16-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 32-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress 
+  to system memory specified by Buffer by using 64-bit access. The total 
+  number of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+ 
+  ReturnBuffer = Buffer;
+  
+  while (Length != 0) {
+    *(Buffer++) = MmioRead64 (StartAddress);
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 8-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  VOID* ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+ 
+  ReturnBuffer = (UINT8 *) Buffer;
+  
+  while (Length-- != 0) {
+     MmioWrite8 (StartAddress++, *(Buffer++));
+  }
+
+  return ReturnBuffer;
+ 
+}
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 16-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = (UINT16 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite16 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 32-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = (UINT32 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite32 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified 
+  by starting address StartAddress by using 64-bit access. The total number 
+  of byte to be copied is specified by Length. Buffer is returned.
+  
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT(). 
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size, in bytes, of Buffer.
+  @param  Buffer          The pointer to a system memory buffer containing the data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+  
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = (UINT64 *) Buffer;
+  
+  while (Length != 0) {
+    MmioWrite64 (StartAddress, *(Buffer++));
+    
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.inf b/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.inf
new file mode 100644
index 000000000000..9eac8a24f341
--- /dev/null
+++ b/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.inf
@@ -0,0 +1,48 @@
+## @file
+# Instance of I/O Library using CPU I/O PPI.
+#
+# I/O Library implementation that uses the CPU I/O PPI for I/O
+#  and MMIO operations.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiIoLibCpuIo
+  MODULE_UNI_FILE                = PeiIoLibCpuIo.uni
+  FILE_GUID                      = b2585b69-fb63-4220-844a-8fbea8bf01af
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = IoLib|PEIM PEI_CORE SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  IoHighLevel.c
+  IoLib.c
+  IoLibMmioBuffer.c
+ 
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PeiServicesTablePointerLib
+  BaseLib
+  DebugLib
+
+[Depex.common.PEIM]
+  gEfiPeiCpuIoPpiInstalledGuid
+
diff --git a/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.uni b/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.uni
new file mode 100644
index 000000000000..4931d693fe9b
--- /dev/null
+++ b/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of I/O Library using CPU I/O PPI.
+//
+// I/O Library implementation that uses the CPU I/O PPI for I/O
+// and MMIO operations.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of I/O Library using CPU I/O PPI"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "I/O Library implementation that uses the CPU I/O PPI for I/O and MMIO operations."
+
diff --git a/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
new file mode 100644
index 000000000000..bb67805f2e05
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
@@ -0,0 +1,938 @@
+/** @file
+  Support routines for memory allocation routines 
+  based on PeiService for PEI phase drivers.
+
+  Copyright (c) 2006 - 2015, 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 <PiPei.h>
+
+
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PeiServicesLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/HobLib.h>
+
+
+/**
+  Allocates one or more 4KB pages of a certain memory type.
+
+  Allocates the number of 4KB pages of a certain memory type and returns a pointer to the allocated
+  buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL is returned.
+  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory; 
+
+  if (Pages == 0) {
+    return NULL;
+  }
+
+  Status = PeiServicesAllocatePages (MemoryType, Pages, &Memory);
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+
+  return (VOID *) (UINTN) Memory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData.
+
+  Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiBootServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
+
+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiRuntimeServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType.
+
+  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiReservedMemoryType, Pages);
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the page allocation
+  functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will
+  perform no actions.
+  
+  If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
+  then ASSERT().
+  If Pages is zero, then ASSERT().
+ 
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreePages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  ASSERT (Pages != 0);
+  //
+  // PEI phase does not support to free pages, so leave it as NOP.
+  //
+}
+
+/**
+  Allocates one or more 4KB pages of a certain memory type at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of a certain memory type with an alignment
+  specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is returned.
+  If there is not enough memory at the specified alignment remaining to satisfy the request, then
+  NULL is returned.
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateAlignedPages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages,
+  IN UINTN            Alignment
+  )
+{
+  EFI_PHYSICAL_ADDRESS   Memory;
+  EFI_PHYSICAL_ADDRESS   AlignedMemory;
+  EFI_PEI_HOB_POINTERS   Hob;
+  BOOLEAN                SkipBeforeMemHob;
+  BOOLEAN                SkipAfterMemHob;
+  EFI_PHYSICAL_ADDRESS   HobBaseAddress;
+  UINT64                 HobLength;
+  EFI_MEMORY_TYPE        HobMemoryType;
+  UINTN                  TotalPages;
+
+  //
+  // Alignment must be a power of two or zero.
+  //
+  ASSERT ((Alignment & (Alignment - 1)) == 0);
+
+  if (Pages == 0) {
+    return NULL;
+  }
+  //
+  // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
+  //
+  ASSERT (Pages <= (MAX_ADDRESS - EFI_SIZE_TO_PAGES (Alignment))); 
+
+  //
+  // We would rather waste some memory to save PEI code size.
+  // meaning in addition to the requested size for the aligned mem,
+  // we simply reserve an overhead memory equal to Alignmemt(page-aligned), no matter what.
+  // The overhead mem size could be reduced later with more involved malloc mechanisms
+  // (e.g., somthing that can detect the alignment boundary before allocating memory or 
+  //  can request that memory be allocated at a certain address that is aleady aligned).
+  //
+  TotalPages = Pages + (Alignment <= EFI_PAGE_SIZE ? 0 : EFI_SIZE_TO_PAGES(Alignment));
+  Memory = (EFI_PHYSICAL_ADDRESS) (UINTN) InternalAllocatePages (MemoryType, TotalPages);
+  if (Memory == 0) {
+    DEBUG((DEBUG_INFO, "Out of memory resource! \n"));
+    return NULL;
+  }
+  DEBUG ((DEBUG_INFO, "Allocated Memory unaligned: Address = 0x%LX, Pages = 0x%X, Type = %d \n", Memory, TotalPages, (UINTN) MemoryType));
+
+  //
+  // Alignment calculation
+  //
+  AlignedMemory = Memory;
+  if (Alignment > EFI_PAGE_SIZE) {
+    AlignedMemory = ALIGN_VALUE (Memory, Alignment);
+  }
+  DEBUG ((DEBUG_INFO, "After aligning to 0x%X bytes: Address = 0x%LX, Pages = 0x%X \n", Alignment, AlignedMemory, Pages));
+
+  //
+  // In general three HOBs cover the total allocated space.
+  // The aligned portion is covered by the aligned mem HOB and
+  // the unaligned(to be freed) portions before and after the aligned portion are covered by newly created HOBs.
+  //
+  // Before mem HOB covers the region between "Memory" and "AlignedMemory"
+  // Aligned mem HOB covers the region between "AlignedMemory" and "AlignedMemory + EFI_PAGES_TO_SIZE(Pages)"
+  // After mem HOB covers the region between "AlignedMemory + EFI_PAGES_TO_SIZE(Pages)" and "Memory + EFI_PAGES_TO_SIZE(TotalPages)"
+  //
+  // The before or after mem HOBs need to be skipped under special cases where the aligned portion
+  // touches either the top or bottom of the original allocated space.
+  //
+  SkipBeforeMemHob = FALSE;
+  SkipAfterMemHob  = FALSE;
+  if (Memory == AlignedMemory) {
+    SkipBeforeMemHob = TRUE;
+  }
+  if ((Memory + EFI_PAGES_TO_SIZE(TotalPages)) == (AlignedMemory + EFI_PAGES_TO_SIZE(Pages))) {
+    //
+    // This condition is never met in the current implementation.
+    // There is always some after-mem since the overhead mem(used in TotalPages)
+    // is no less than Alignment.
+    //
+    SkipAfterMemHob = TRUE;
+  }
+
+  //  
+  // Search for the mem HOB referring to the original(unaligned) allocation 
+  // and update the size and type if needed.
+  //
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+  while (Hob.Raw != NULL) {
+    if (Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress == Memory) {
+      break;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+  }
+  ASSERT (Hob.Raw != NULL);
+  if (SkipBeforeMemHob) {
+    //
+    // Use this HOB as aligned mem HOB as there is no portion before it.
+    //
+    HobLength = EFI_PAGES_TO_SIZE(Pages);
+    Hob.MemoryAllocation->AllocDescriptor.MemoryLength = HobLength;
+  } else {
+    //
+    // Use this HOB as before mem HOB and create a new HOB for the aligned portion 
+    //
+    HobLength = (AlignedMemory - Memory); 
+    Hob.MemoryAllocation->AllocDescriptor.MemoryLength = HobLength;
+    Hob.MemoryAllocation->AllocDescriptor.MemoryType = EfiConventionalMemory;
+  }
+
+  HobBaseAddress = Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress;
+  HobMemoryType = Hob.MemoryAllocation->AllocDescriptor.MemoryType;
+
+  //
+  // Build the aligned mem HOB if needed
+  //
+  if (!SkipBeforeMemHob) {
+    DEBUG((DEBUG_INFO, "Updated before-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
+      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
+
+    HobBaseAddress = AlignedMemory;
+    HobLength = EFI_PAGES_TO_SIZE(Pages);
+    HobMemoryType = MemoryType;
+
+    BuildMemoryAllocationHob (
+      HobBaseAddress,
+      HobLength,
+      HobMemoryType
+      );
+
+    DEBUG((DEBUG_INFO, "Created aligned-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
+      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
+  } else {
+    if (HobBaseAddress != 0) {
+      DEBUG((DEBUG_INFO, "Updated aligned-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
+        HobBaseAddress, HobLength, (UINTN) HobMemoryType));
+    }
+  }
+
+
+  //
+  // Build the after mem HOB if needed
+  //
+  if (!SkipAfterMemHob) {
+    HobBaseAddress = AlignedMemory + EFI_PAGES_TO_SIZE(Pages);
+    HobLength = (Memory + EFI_PAGES_TO_SIZE(TotalPages)) - (AlignedMemory + EFI_PAGES_TO_SIZE(Pages));
+    HobMemoryType = EfiConventionalMemory;
+
+    BuildMemoryAllocationHob (
+      HobBaseAddress,
+      HobLength,
+      HobMemoryType
+      );
+
+    DEBUG((DEBUG_INFO, "Created after-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
+      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
+  }
+
+  return (VOID *) (UINTN) AlignedMemory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiBootServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedRuntimePages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiRuntimeServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedReservedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiReservedMemoryType, Pages, Alignment);
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the aligned page
+  allocation functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the aligned page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will 
+  perform no actions.
+  
+  If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
+  Library, then ASSERT().
+  If Pages is zero, then ASSERT().
+  
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreeAlignedPages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  ASSERT (Pages != 0);
+  //
+  // PEI phase does not support to free pages, so leave it as NOP.
+  //
+}
+
+/**
+  Allocates a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type and returns a
+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePool (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            AllocationSize
+  )
+{
+  //
+  // If we need lots of small runtime/reserved memory type from PEI in the future, 
+  // we can consider providing a more complex algorithm that allocates runtime pages and 
+  // provide pool allocations from those pages. 
+  //
+  return InternalAllocatePages (MemoryType, EFI_SIZE_TO_PAGES (AllocationSize));
+}
+
+/**
+  Allocates a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePool (
+  IN UINTN  AllocationSize
+  )
+{
+  EFI_STATUS        Status;
+  VOID              *Buffer;
+  
+  Status = PeiServicesAllocatePool (AllocationSize, &Buffer);
+  if (EFI_ERROR (Status)) {
+    Buffer = NULL;
+  }
+  return Buffer;
+}
+
+/**
+  Allocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiReservedMemoryType, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, clears the buffer
+  with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a valid
+  buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the request,
+  then NULL is returned.
+
+  @param  PoolType              The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateZeroPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize
+  ) 
+{
+  VOID  *Memory;
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+    Memory = ZeroMem (Memory, AllocationSize);
+  }
+  return Memory;
+}
+
+/**
+  Allocates and zeros a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  VOID  *Memory;
+
+  Memory = AllocatePool (AllocationSize);
+  if (Memory != NULL) {
+    Memory = ZeroMem (Memory, AllocationSize);
+  }
+  return Memory;
+}
+
+/**
+  Allocates and zeros a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiReservedMemoryType, AllocationSize);
+}
+
+/**
+  Copies a buffer to an allocated buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  PoolType              The type of pool to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateCopyPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize,
+  IN CONST VOID       *Buffer
+  ) 
+{
+  VOID  *Memory;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+     Memory = CopyMem (Memory, Buffer, AllocationSize);
+  }
+  return Memory;
+} 
+
+/**
+  Copies a buffer to an allocated buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  VOID  *Memory;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
+
+  Memory = AllocatePool (AllocationSize);
+  if (Memory != NULL) {
+     Memory = CopyMem (Memory, Buffer, AllocationSize);
+  }
+  return Memory;
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer);
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiReservedMemoryType, AllocationSize, Buffer);
+}
+
+/**
+  Reallocates a buffer of a specified memory type.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of the type
+  specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  PoolType       The type of pool to allocate.
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalReallocatePool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            OldSize,
+  IN UINTN            NewSize,
+  IN VOID             *OldBuffer  OPTIONAL
+  )
+{
+  VOID  *NewBuffer;
+
+  NewBuffer = InternalAllocateZeroPool (PoolType, NewSize);
+  if (NewBuffer != NULL && OldBuffer != NULL) {
+    CopyMem (NewBuffer, OldBuffer, MIN (OldSize, NewSize));
+    FreePool (OldBuffer);
+  }
+  return NewBuffer;
+}
+
+/**
+  Reallocates a buffer of type EfiBootServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocatePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiBootServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateRuntimePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiRuntimeServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiReservedMemoryType.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateReservedPool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiReservedMemoryType, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Frees a buffer that was previously allocated with one of the pool allocation functions in the
+  Memory Allocation Library.
+
+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
+  pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
+  resources, then this function will perform no actions.
+  
+  If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
+  then ASSERT().
+
+  @param  Buffer                The pointer to the buffer to free.
+
+**/
+VOID
+EFIAPI
+FreePool (
+  IN VOID   *Buffer
+  )
+{
+  //
+  // PEI phase does not support to free pool, so leave it as NOP.
+  //
+}
+
+
diff --git a/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf b/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
new file mode 100644
index 000000000000..9f0ae450c13d
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
@@ -0,0 +1,45 @@
+## @file
+# Instance of Memory Allocation Library using PEI Services.
+#
+# Memory Allocation Library that uses PEI Services to allocate memory.
+#  Free operations are ignored.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiMemoryAllocationLib
+  MODULE_UNI_FILE                = PeiMemoryAllocationLib.uni
+  FILE_GUID                      = b694e0dc-cd4e-4b30-885b-9c164ed3e74a
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = MemoryAllocationLib|PEIM PEI_CORE SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  MemoryAllocationLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+  BaseMemoryLib
+  PeiServicesLib
+  HobLib
+
diff --git a/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.uni b/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.uni
new file mode 100644
index 000000000000..6f84d69cec2b
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Memory Allocation Library using PEI Services.
+//
+// Memory Allocation Library that uses PEI Services to allocate memory.
+// Free operations are ignored.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Memory Allocation Library using PEI Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Memory Allocation Library that uses PEI Services to allocate memory. Free operations are ignored."
+
diff --git a/MdePkg/Library/PeiMemoryLib/CompareMemWrapper.c b/MdePkg/Library/PeiMemoryLib/CompareMemWrapper.c
new file mode 100644
index 000000000000..8f3d7f8daffa
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/CopyMemWrapper.c b/MdePkg/Library/PeiMemoryLib/CopyMemWrapper.c
new file mode 100644
index 000000000000..f1a97699445d
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/IsZeroBufferWrapper.c b/MdePkg/Library/PeiMemoryLib/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/MemLib.c b/MdePkg/Library/PeiMemoryLib/MemLib.c
new file mode 100644
index 000000000000..42efeb4c6e69
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/MemLib.c
@@ -0,0 +1,71 @@
+/** @file
+  Base Memory Library functions implementation bases on PeiServcie.
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function wraps the gPS->CopyMem ().
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *Destination,
+  IN      CONST VOID                *Source,
+  IN      UINTN                     Length
+  )
+{
+  (*GetPeiServicesTablePointer ())->CopyMem (
+                                      Destination,
+                                      (VOID*)Source,
+                                      Length
+                                      );
+  return Destination;
+}
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function wraps the gPS->SetMem ().
+  
+  @param  Buffer    Memory to set.
+  @param  Size      The number of bytes to set.
+  @param  Value     Value of the set operation.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Size,
+  IN      UINT8                     Value
+  )
+{
+  (*GetPeiServicesTablePointer ())->SetMem (
+                                      Buffer,
+                                      Size,
+                                      Value
+                                      );
+  return Buffer;
+}
diff --git a/MdePkg/Library/PeiMemoryLib/MemLibGeneric.c b/MdePkg/Library/PeiMemoryLib/MemLibGeneric.c
new file mode 100644
index 000000000000..42e2e7dbdf42
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/MemLibGeneric.c
@@ -0,0 +1,289 @@
+/** @file
+  Architecture Independent Base Memory Library Implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT16*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT32*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT64*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  return InternalMemSetMem (Buffer, Length, 0);
+}
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer
+  @param  SourceBuffer      The second memory buffer
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  )
+{
+  while ((--Length != 0) &&
+         (*(INT8*)DestinationBuffer == *(INT8*)SourceBuffer)) {
+    DestinationBuffer = (INT8*)DestinationBuffer + 1;
+    SourceBuffer = (INT8*)SourceBuffer + 1;
+  }
+  return (INTN)*(UINT8*)DestinationBuffer - (INTN)*(UINT8*)SourceBuffer;
+}
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  )
+{
+  CONST UINT8                       *Pointer;
+
+  Pointer = (CONST UINT8*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  CONST UINT16                      *Pointer;
+
+  Pointer = (CONST UINT16*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  CONST UINT32                      *Pointer;
+
+  Pointer = (CONST UINT32*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  CONST UINT64                      *Pointer;
+
+  Pointer = (CONST UINT64*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  CONST UINT8 *BufferData;
+  UINTN       Index;
+
+  BufferData = Buffer;
+  for (Index = 0; Index < Length; Index++) {
+    if (BufferData[Index] != 0) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
diff --git a/MdePkg/Library/PeiMemoryLib/MemLibGuid.c b/MdePkg/Library/PeiMemoryLib/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/MemLibInternals.h b/MdePkg/Library/PeiMemoryLib/MemLibInternals.h
new file mode 100644
index 000000000000..87d256ca502b
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/MemLibInternals.h
@@ -0,0 +1,249 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <PiPei.h>
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function wraps the (*PeiServices)->CopyMem ().
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *Destination,
+  IN      CONST VOID                *Source,
+  IN      UINTN                     Length
+  );
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function wraps the (*PeiServices)->SetMem ().
+  
+  @param  Buffer    The memory to set.
+  @param  Size      The number of bytes to set.
+  @param  Value     Value of the set operation.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Size,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer
+  @param  SourceBuffer      The second memory buffer
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence, or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.inf b/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.inf
new file mode 100644
index 000000000000..2728a1340284
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.inf
@@ -0,0 +1,60 @@
+## @file
+# Instance of Base Memory Library using PEI Services.
+#
+# Base Memory Library implementation that uses PEI Services
+#  where possible for size reduction.
+#
+# Copyright (c) 2006 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiMemoryLib
+  MODULE_UNI_FILE                = PeiMemoryLib.uni
+  FILE_GUID                      = 3a9759d2-53bc-4eb2-abcd-c93099419063
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib|PEIM
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGeneric.c
+  MemLibGuid.c
+  MemLib.c
+  MemLibInternals.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+  PeiServicesTablePointerLib
+
diff --git a/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.uni b/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.uni
new file mode 100644
index 000000000000..f4ac7bb9a6ae
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/PeiMemoryLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library using PEI Services.
+//
+// Base Memory Library implementation that uses PEI Services
+// where possible for size reduction.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library using PEI Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library implementation that uses PEI Services where possible, for size reduction."
+
diff --git a/MdePkg/Library/PeiMemoryLib/ScanMem16Wrapper.c b/MdePkg/Library/PeiMemoryLib/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..606338675fe9
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/ScanMem32Wrapper.c b/MdePkg/Library/PeiMemoryLib/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..e82fc5878761
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/ScanMem64Wrapper.c b/MdePkg/Library/PeiMemoryLib/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..80af31a43cbc
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/ScanMem8Wrapper.c b/MdePkg/Library/PeiMemoryLib/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..f296da2e7a48
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/PeiMemoryLib/SetMem16Wrapper.c b/MdePkg/Library/PeiMemoryLib/SetMem16Wrapper.c
new file mode 100644
index 000000000000..7001f29ae8e9
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/SetMem32Wrapper.c b/MdePkg/Library/PeiMemoryLib/SetMem32Wrapper.c
new file mode 100644
index 000000000000..c51b846acf8a
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/SetMem64Wrapper.c b/MdePkg/Library/PeiMemoryLib/SetMem64Wrapper.c
new file mode 100644
index 000000000000..f4128970d48a
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/PeiMemoryLib/SetMemWrapper.c b/MdePkg/Library/PeiMemoryLib/SetMemWrapper.c
new file mode 100644
index 000000000000..b6646d81fc32
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2010, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/PeiMemoryLib/ZeroMemWrapper.c b/MdePkg/Library/PeiMemoryLib/ZeroMemWrapper.c
new file mode 100644
index 000000000000..c6902cd2f055
--- /dev/null
+++ b/MdePkg/Library/PeiMemoryLib/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/PeiPalLib/PeiPalLib.c b/MdePkg/Library/PeiPalLib/PeiPalLib.c
new file mode 100644
index 000000000000..fdcb77d7e4d3
--- /dev/null
+++ b/MdePkg/Library/PeiPalLib/PeiPalLib.c
@@ -0,0 +1,99 @@
+/** @file
+  PAL Call Services Function.
+
+  Copyright (c) 2006 - 2010, 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 <PiPei.h>
+
+#include <Ppi/SecPlatformInformation.h>
+
+#include <Library/PalLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/PeiServicesLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param Index  The PAL procedure Index number.
+  @param Arg2   The 2nd parameter for PAL procedure calls.
+  @param Arg3   The 3rd parameter for PAL procedure calls.
+  @param Arg4   The 4th parameter for PAL procedure calls.
+
+  @return Structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  )
+{
+  UINT64                              PalCallAddress;
+  PAL_CALL_RETURN                     ReturnVal;
+  CONST EFI_PEI_SERVICES              **PeiServices;
+  EFI_STATUS                          Status;
+  EFI_SEC_PLATFORM_INFORMATION_PPI    *SecPlatformPpi;
+  EFI_SEC_PLATFORM_INFORMATION_RECORD SecPlatformInfoRecord;
+  UINT64                              RecordSize;
+
+  //
+  // Get PEI Service Table Pointer
+  //
+  PeiServices = GetPeiServicesTablePointer ();
+
+  //
+  // Locate SEC Platform Information PPI
+  //
+  Status = PeiServicesLocatePpi (
+             &gEfiSecPlatformInformationPpiGuid,
+             0,
+             NULL,
+             (VOID **)&SecPlatformPpi
+             );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Retrieve PAL call address from platform information reported by the PPI
+  //
+  RecordSize = sizeof (SecPlatformInfoRecord);
+  SecPlatformPpi->PlatformInformation (
+                    PeiServices,
+                    &RecordSize,
+                    &SecPlatformInfoRecord
+                    );
+  PalCallAddress = SecPlatformInfoRecord.ItaniumHealthFlags.PalCallAddress;
+
+  ReturnVal = AsmPalCall (PalCallAddress, Index, Arg2, Arg3, Arg4);
+
+  return ReturnVal;
+}
+
diff --git a/MdePkg/Library/PeiPalLib/PeiPalLib.inf b/MdePkg/Library/PeiPalLib/PeiPalLib.inf
new file mode 100644
index 000000000000..4938b8b4d450
--- /dev/null
+++ b/MdePkg/Library/PeiPalLib/PeiPalLib.inf
@@ -0,0 +1,51 @@
+## @file
+# Instance of PAL Library using a PPI for PAL entrypoint.
+#
+# Instance of PAL Library that uses a PPI to retrieve the PAL
+# Entry Point and layers on top of AsmPalCall() in the Base Library
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiPalLib
+  MODULE_UNI_FILE                = PeiPalLib.uni
+  FILE_GUID                      = B53DC524-6B98-4584-940B-8F1363DEF09E
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PalLib|PEIM SEC PEI_CORE
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  PeiPalLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  PeiServicesLib
+  PeiServicesTablePointerLib
+
+
+[Ppis]
+  gEfiSecPlatformInformationPpiGuid             ## CONSUMES
+
diff --git a/MdePkg/Library/PeiPalLib/PeiPalLib.uni b/MdePkg/Library/PeiPalLib/PeiPalLib.uni
new file mode 100644
index 000000000000..870ea84a9cba
--- /dev/null
+++ b/MdePkg/Library/PeiPalLib/PeiPalLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PAL Library using a PPI for PAL entrypoint.
+//
+// Instance of PAL Library that uses a PPI to retrieve the PAL
+// Entry Point and layers on top of AsmPalCall() in the Base Library
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PAL Library using a PPI for PAL entry point"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Instance of PAL Library that uses a PPI to retrieve the PAL Entry Point and layers on top of AsmPalCall() in the Base Library."
+
diff --git a/MdePkg/Library/PeiPcdLib/PeiPcdLib.c b/MdePkg/Library/PeiPcdLib/PeiPcdLib.c
new file mode 100644
index 000000000000..3104977a06c7
--- /dev/null
+++ b/MdePkg/Library/PeiPcdLib/PeiPcdLib.c
@@ -0,0 +1,1625 @@
+/** @file
+Implementation of PcdLib class library for PEI phase.
+
+Copyright (c) 2006 - 2016, 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 <PiPei.h>
+
+#include <Ppi/Pcd.h>
+#include <Ppi/PiPcd.h>
+#include <Ppi/PcdInfo.h>
+#include <Ppi/PiPcdInfo.h>
+
+#include <Library/PeiServicesLib.h>
+#include <Library/PcdLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+
+/**
+  Retrieve the PCD_PPI pointer.
+
+  This function is to locate PCD_PPI PPI via PeiService. 
+  If fail to locate PCD_PPI, then ASSERT_EFI_ERROR().
+  
+  @retval PCD_PPI * The pointer to the PCD_PPI.
+
+**/
+PCD_PPI  *
+GetPcdPpiPointer (
+  VOID
+  ) 
+{
+  EFI_STATUS        Status;
+  PCD_PPI           *PcdPpi;
+  
+  Status = PeiServicesLocatePpi (&gPcdPpiGuid, 0, NULL, (VOID **)&PcdPpi);
+  ASSERT_EFI_ERROR (Status);
+
+  return PcdPpi;
+}
+
+/**
+  Retrieve the pointer of EFI_PEI_PCD_PPI defined in PI 1.2 Vol 3.
+
+  This function is to locate EFI_PEI_PCD_PPI PPI via PeiService. 
+  If fail to locate EFI_PEI_PCD_PPI, then ASSERT_EFI_ERROR().
+  
+  @retval EFI_PEI_PCD_PPI * The pointer to the EFI_PEI_PCD_PPI.
+
+**/
+EFI_PEI_PCD_PPI *
+GetPiPcdPpiPointer (
+  VOID
+  )
+{
+  EFI_STATUS        Status;
+  EFI_PEI_PCD_PPI   *PiPcdPpi;
+  
+  Status = PeiServicesLocatePpi (&gEfiPeiPcdPpiGuid, 0, NULL, (VOID **)&PiPcdPpi);
+  ASSERT_EFI_ERROR (Status);
+  
+  return PiPcdPpi;
+}  
+
+/**
+  Retrieve the GET_PCD_INFO_PPI pointer.
+
+  This function is to locate GET_PCD_INFO_PPI PPI via PeiService. 
+  If fail to locate GET_PCD_INFO_PPI, then ASSERT_EFI_ERROR().
+
+  @retval GET_PCD_INFO_PPI * The pointer to the GET_PCD_INFO_PPI.
+
+**/
+GET_PCD_INFO_PPI *
+GetPcdInfoPpiPointer (
+  VOID
+  ) 
+{
+  EFI_STATUS            Status;
+  GET_PCD_INFO_PPI      *PcdInfoPpi;
+  
+  Status = PeiServicesLocatePpi (&gGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PcdInfoPpi);
+  ASSERT_EFI_ERROR (Status);
+
+  return PcdInfoPpi;
+}
+
+/**
+  Retrieve the pointer of EFI_GET_PCD_INFO_PPI defined in PI 1.2.1 Vol 3.
+
+  This function is to locate EFI_GET_PCD_INFO_PPI PPI via PeiService. 
+  If fail to locate EFI_GET_PCD_INFO_PPI, then ASSERT_EFI_ERROR().
+
+  @retval EFI_GET_PCD_INFO_PPI * The pointer to the EFI_GET_PCD_INFO_PPI.
+
+**/
+EFI_GET_PCD_INFO_PPI *
+GetPiPcdInfoPpiPointer (
+  VOID
+  )
+{
+  EFI_STATUS            Status;
+  EFI_GET_PCD_INFO_PPI  *PiPcdInfoPpi;
+  
+  Status = PeiServicesLocatePpi (&gEfiGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PiPcdInfoPpi);
+  ASSERT_EFI_ERROR (Status);
+  
+  return PiPcdInfoPpi;
+}  
+
+/**
+  This function provides a means by which SKU support can be established in the PCD infrastructure.
+
+  Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
+
+  @param  SkuId   The SKU value that will be used when the PCD service retrieves 
+                  and sets values associated with a PCD token.
+
+  @return  Return the SKU ID that just be set.
+
+**/
+UINTN
+EFIAPI
+LibPcdSetSku (
+  IN UINTN   SkuId
+  )
+{
+  GetPiPcdPpiPointer()->SetSku (SkuId);
+  
+  return SkuId;
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 8-bit value for the token specified by TokenNumber. 
+
+**/
+UINT8
+EFIAPI
+LibPcdGet8 (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->Get8 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 16-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 16-bit value for the token specified by TokenNumber. 
+
+**/
+UINT16
+EFIAPI
+LibPcdGet16 (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->Get16 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 32-bit value for the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 32-bit value for the token specified by TokenNumber.
+
+**/
+UINT32
+EFIAPI
+LibPcdGet32 (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->Get32 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the 64-bit value for the token specified by TokenNumber.
+
+**/
+UINT64
+EFIAPI
+LibPcdGet64 (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->Get64 (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of the token specified by TokenNumber.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the pointer to the token specified by TokenNumber.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetPtr (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->GetPtr (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber. 
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the Boolean value of the token specified by TokenNumber. 
+
+**/
+BOOLEAN 
+EFIAPI
+LibPcdGetBool (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->GetBool (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+
+  @param[in]  TokenNumber The PCD token number to retrieve a current value for.
+
+  @return Returns the size of the token specified by TokenNumber. 
+
+**/
+UINTN
+EFIAPI
+LibPcdGetSize (
+  IN UINTN             TokenNumber
+  )
+{
+  return (GetPcdPpiPointer ())->GetSize (TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 8-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT8.
+
+**/
+UINT8
+EFIAPI
+LibPcdGetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Get8 (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+
+  Returns the 16-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT16.
+
+**/
+UINT16
+EFIAPI
+LibPcdGetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Get16 (Guid, TokenNumber);
+}
+
+
+
+/**
+  Returns the 32-bit value for the token specified by TokenNumber and Guid.
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid         The pointer to a 128-bit unique value that designates 
+                           which namespace to retrieve a value from.
+  @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
+
+  @return Return the UINT32.
+
+**/
+UINT32
+EFIAPI
+LibPcdGetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Get32 (Guid, TokenNumber);
+}
+
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the 64-bit value for the token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the UINT64.
+
+**/
+UINT64
+EFIAPI
+LibPcdGetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+  return (GetPiPcdPpiPointer ())->Get64 (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the pointer to the buffer of token specified by TokenNumber and Guid.
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the VOID* pointer.
+
+**/
+VOID *
+EFIAPI
+LibPcdGetExPtr (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->GetPtr (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve a value for a given PCD token.
+  
+  Returns the Boolean value of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the BOOLEAN.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdGetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+  return (GetPiPcdPpiPointer ())->GetBool (Guid, TokenNumber);
+}
+
+
+
+/**
+  This function provides a means by which to retrieve the size of a given PCD token.
+  
+  Returns the size of the token specified by TokenNumber and Guid. 
+  
+  If Guid is NULL, then ASSERT(). 
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that designates 
+                            which namespace to retrieve a value from.
+  @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
+
+  @return Return the size.
+
+**/
+UINTN
+EFIAPI
+LibPcdGetExSize (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber
+  )
+{
+  ASSERT (Guid != NULL);
+  return (GetPiPcdPpiPointer ())->GetSize (Guid, TokenNumber);
+}
+
+
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSet8 (
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  (GetPcdPpiPointer ())->Set8 (TokenNumber, Value);
+  
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSet16 (
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  (GetPcdPpiPointer ())->Set16 (TokenNumber, Value);
+  
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSet32 (
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  (GetPcdPpiPointer ())->Set32 (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSet64 (
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  (GetPcdPpiPointer ())->Set64 (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value 
+  specified by Buffer and SizeOfBuffer.  Buffer is returned.  
+  If SizeOfBuffer is greater than the maximum size support by TokenNumber, 
+  then set SizeOfBuffer to the maximum size supported by TokenNumber and 
+  return NULL to indicate that the set operation was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 
+  maximum size supported by TokenName and NULL must be returned.
+  
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return Return the pointer for the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetPtr (
+  IN        UINTN             TokenNumber,
+  IN OUT    UINTN             *SizeOfBuffer,
+  IN CONST  VOID              *Buffer
+  )
+{
+  EFI_STATUS Status;
+  UINTN      InputSizeOfBuffer;
+
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  InputSizeOfBuffer = *SizeOfBuffer;
+  Status = (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
+  if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
+    return NULL;
+  }
+
+  return (VOID *) Buffer;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber 
+  to the value specified by Value.  Value is returned.
+
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetBool (
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  (GetPcdPpiPointer ())->SetBool (TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 8-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 8-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT8
+EFIAPI
+LibPcdSetEx8 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT8             Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 16-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 16-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT16
+EFIAPI
+LibPcdSetEx16 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT16            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 32-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 32-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT32
+EFIAPI
+LibPcdSetEx32 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT32            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the 64-bit value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The 64-bit value to set.
+
+  @return Return the value that was set.
+
+**/
+UINT64
+EFIAPI
+LibPcdSetEx64 (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN UINT64            Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value);
+
+  return Value;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets a buffer for the token specified by TokenNumber to the value specified by 
+  Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size 
+  supported by TokenNumber and return NULL to indicate that the set operation 
+  was not actually performed.
+  
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+  
+  @param[in]  Guid              The pointer to a 128-bit unique value that 
+                                designates which namespace to set a value from.
+  @param[in]  TokenNumber       The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]  Buffer            A pointer to the buffer to set.
+
+  @return Return the pinter to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPcdSetExPtr (
+  IN      CONST GUID        *Guid,
+  IN      UINTN             TokenNumber,
+  IN OUT  UINTN             *SizeOfBuffer,
+  IN      VOID              *Buffer
+  )
+{
+  EFI_STATUS      Status;
+  UINTN           InputSizeOfBuffer;
+
+  ASSERT (SizeOfBuffer != NULL);
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+  ASSERT (Guid != NULL);
+
+  InputSizeOfBuffer = *SizeOfBuffer;
+  Status = (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
+  if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
+    return NULL;
+  }
+
+  return Buffer;
+}
+
+
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+  
+  Sets the Boolean value for the token specified by TokenNumber and 
+  Guid to the value specified by Value. Value is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Guid          The pointer to a 128-bit unique value that 
+                            designates which namespace to set a value from.
+  @param[in]  TokenNumber   The PCD token number to set a current value for.
+  @param[in]  Value         The Boolean value to set.
+
+  @return Return the value that was set.
+
+**/
+BOOLEAN
+EFIAPI
+LibPcdSetExBool (
+  IN CONST GUID        *Guid,
+  IN UINTN             TokenNumber,
+  IN BOOLEAN           Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value);
+
+  return Value;
+}
+#endif
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet8S (
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  return (GetPcdPpiPointer ())->Set8 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet16S (
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  return (GetPcdPpiPointer ())->Set16 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet32S (
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  return (GetPcdPpiPointer ())->Set32 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSet64S (
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  return (GetPcdPpiPointer ())->Set64 (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
+  maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned.
+
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetPtrS (
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  return (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetBoolS (
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  return (GetPcdPpiPointer ())->SetBool (TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 8-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 8-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx8S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT8          Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 16-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 16-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx16S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT16         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 32-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 32-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx32S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT32         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the 64-bit value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The 64-bit value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetEx64S (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN UINT64         Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets a buffer for the token specified by TokenNumber to the value specified by
+  Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
+  support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
+  TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
+  was not actually performed.
+
+  If Guid is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[in]      Guid          Pointer to a 128-bit unique value that
+                                designates which namespace to set a value from.
+  @param[in]      TokenNumber   The PCD token number to set a current value for.
+  @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
+  @param[in]      Buffer        A pointer to the buffer to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExPtrS (
+  IN CONST GUID     *Guid,
+  IN       UINTN    TokenNumber,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN       VOID     *Buffer
+  )
+{
+  ASSERT (Guid != NULL);
+
+  ASSERT (SizeOfBuffer != NULL);
+
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  return (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
+}
+
+/**
+  This function provides a means by which to set a value for a given PCD token.
+
+  Sets the boolean value for the token specified by TokenNumber
+  to the value specified by Value.
+
+  If Guid is NULL, then ASSERT().
+
+  @param[in] Guid           The pointer to a 128-bit unique value that
+                            designates which namespace to set a value from.
+  @param[in] TokenNumber    The PCD token number to set a current value for.
+  @param[in] Value          The boolean value to set.
+
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPcdSetExBoolS (
+  IN CONST GUID     *Guid,
+  IN UINTN          TokenNumber,
+  IN BOOLEAN        Value
+  )
+{
+  ASSERT (Guid != NULL);
+
+  return (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value);
+}
+
+/**
+  Set up a notification function that is called when a specified token is set.
+  
+  When the token specified by TokenNumber and Guid is set, 
+  then notification function specified by NotificationFunction is called.  
+  If Guid is NULL, then the default token space is used.
+  If NotificationFunction is NULL, then ASSERT().
+
+  @param[in]  Guid                  The pointer to a 128-bit unique value that 
+                                    designates which namespace to set a value from.  
+                                    If NULL, then the default token space is used.
+  @param[in]  TokenNumber           The PCD token number to monitor.
+  @param[in]  NotificationFunction  The function to call when the token 
+                                    specified by Guid and TokenNumber is set.
+
+**/
+VOID
+EFIAPI
+LibPcdCallbackOnSet (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  EFI_STATUS Status;
+
+  ASSERT (NotificationFunction != NULL);
+
+  Status = (GetPiPcdPpiPointer ())->CallbackOnSet (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction);
+
+  ASSERT_EFI_ERROR (Status);
+
+  return;
+}
+
+
+
+/**
+  Disable a notification function that was established with LibPcdCallbackonSet().
+  
+  Disable a notification function that was previously established with LibPcdCallbackOnSet().
+  If NotificationFunction is NULL, then ASSERT().
+  If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber, 
+  and NotificationFunction, then ASSERT().
+  
+  @param[in]  Guid                 Specify the GUID token space.
+  @param[in]  TokenNumber          Specify the token number.
+  @param[in]  NotificationFunction The callback function to be unregistered.
+
+**/
+VOID
+EFIAPI
+LibPcdCancelCallback (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber,
+  IN PCD_CALLBACK             NotificationFunction
+  )
+{
+  EFI_STATUS Status;
+
+  ASSERT (NotificationFunction != NULL);
+
+  Status = (GetPiPcdPpiPointer ())->CancelCallback (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction);
+
+  ASSERT_EFI_ERROR (Status);
+
+  return;
+}
+
+
+
+/**
+  Retrieves the next token in a token space.
+  
+  Retrieves the next PCD token number from the token space specified by Guid.  
+  If Guid is NULL, then the default token space is used.  If TokenNumber is 0, 
+  then the first token number is returned.  Otherwise, the token number that 
+  follows TokenNumber in the token space is returned.  If TokenNumber is the last 
+  token number in the token space, then 0 is returned.  
+  
+  If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]  Guid        The pointer to a 128-bit unique value that designates which namespace 
+                          to set a value from.  If NULL, then the default token space is used.
+  @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD 
+                          token number.
+
+  @return The next valid token number.
+
+**/
+UINTN           
+EFIAPI
+LibPcdGetNextToken (
+  IN CONST GUID               *Guid,       OPTIONAL
+  IN UINTN                    TokenNumber
+  )
+{
+  EFI_STATUS    Status;
+
+  Status = (GetPiPcdPpiPointer ())->GetNextToken (Guid, &TokenNumber);
+  ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
+
+  return TokenNumber;
+}
+
+
+/**
+  Used to retrieve the list of available PCD token space GUIDs.
+  
+  Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
+  in the platform.
+  If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
+  If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
+  
+  @param  TokenSpaceGuid  The pointer to the a PCD token space GUID
+
+  @return The next valid token namespace.
+
+**/
+GUID *
+EFIAPI
+LibPcdGetNextTokenSpace (
+  IN CONST GUID  *TokenSpaceGuid
+  )
+{
+  (GetPiPcdPpiPointer ())->GetNextTokenSpace (&TokenSpaceGuid);
+
+  return (GUID *) TokenSpaceGuid;
+}
+
+
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtr (
+  OUT       VOID        *PatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrS (
+  OUT      VOID     *PatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+
+  return RETURN_SUCCESS;
+}
+
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+  
+  Sets the PCD entry specified by PatchVariable to the value specified by Buffer 
+  and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than 
+  MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 
+  NULL to indicate that the set operation was not actually performed.  
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 
+  MaximumDatumSize and NULL must be returned.
+  
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is 
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return Return the pointer to the buffer been set.
+
+**/
+VOID *
+EFIAPI
+LibPatchPcdSetPtrAndSize (
+  OUT       VOID        *PatchVariable,
+  OUT       UINTN       *SizeOfPatchVariable,
+  IN        UINTN       MaximumDatumSize,
+  IN OUT    UINTN       *SizeOfBuffer,
+  IN CONST  VOID        *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return NULL;
+  }
+    
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+  
+  return (VOID *) Buffer;
+}
+
+/**
+  Sets a value and size of a patchable PCD entry that is type pointer.
+
+  Sets the PCD entry specified by PatchVariable to the value specified
+  by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
+  then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
+  to indicate that the set operation was not actually performed.
+  If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
+  MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
+
+  If PatchVariable is NULL, then ASSERT().
+  If SizeOfPatchVariable is NULL, then ASSERT().
+  If SizeOfBuffer is NULL, then ASSERT().
+  If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
+
+  @param[out] PatchVariable     A pointer to the global variable in a module that is
+                                the target of the set operation.
+  @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
+  @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
+  @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
+  @param[in] Buffer             A pointer to the buffer to used to set the target variable.
+  
+  @return The status of the set operation.
+
+**/
+RETURN_STATUS
+EFIAPI
+LibPatchPcdSetPtrAndSizeS (
+  OUT      VOID     *PatchVariable,
+  OUT      UINTN    *SizeOfPatchVariable,
+  IN       UINTN    MaximumDatumSize,
+  IN OUT   UINTN    *SizeOfBuffer,
+  IN CONST VOID     *Buffer
+  )
+{
+  ASSERT (PatchVariable != NULL);
+  ASSERT (SizeOfPatchVariable != NULL);
+  ASSERT (SizeOfBuffer  != NULL);
+  
+  if (*SizeOfBuffer > 0) {
+    ASSERT (Buffer != NULL);
+  }
+
+  if ((*SizeOfBuffer > MaximumDatumSize) ||
+      (*SizeOfBuffer == MAX_ADDRESS)) {
+    *SizeOfBuffer = MaximumDatumSize;
+    return RETURN_INVALID_PARAMETER;
+  }
+
+  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
+  *SizeOfPatchVariable = *SizeOfBuffer;
+
+  return RETURN_SUCCESS;
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the default token space specified, then ASSERT().
+
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfo (
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  EFI_STATUS Status;
+
+  Status = GetPcdInfoPpiPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Retrieve additional information associated with a PCD token.
+
+  This includes information such as the type of value the TokenNumber is associated with as well as possible
+  human readable name that is associated with the token.
+
+  If TokenNumber is not in the token space specified by Guid, then ASSERT().
+
+  @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
+  @param[in]    TokenNumber The PCD token number.
+  @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
+                            The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
+**/
+VOID
+EFIAPI
+LibPcdGetInfoEx (
+  IN CONST  GUID            *Guid,
+  IN        UINTN           TokenNumber,
+  OUT       PCD_INFO        *PcdInfo
+  )
+{
+  EFI_STATUS Status;
+
+  Status = GetPiPcdInfoPpiPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Retrieve the currently set SKU Id.
+
+  @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
+            default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
+            Id is returned.
+**/
+UINTN
+EFIAPI
+LibPcdGetSku (
+  VOID
+  )
+{
+  return GetPiPcdInfoPpiPointer()->GetSku ();
+}
diff --git a/MdePkg/Library/PeiPcdLib/PeiPcdLib.inf b/MdePkg/Library/PeiPcdLib/PeiPcdLib.inf
new file mode 100644
index 000000000000..93edb0b4ea37
--- /dev/null
+++ b/MdePkg/Library/PeiPcdLib/PeiPcdLib.inf
@@ -0,0 +1,66 @@
+## @file
+# Instance of PCD Library using PCD PPI.
+#
+# There are two PCD PPIs as follows:
+#   1) PCD_PPI 
+#      It is EDKII implementation which support Dynamic/DynamicEx Pcds.
+#   2) EFI_PEI_PCD_PPI
+#      It is defined by PI specification 1.2, Vol 3 which only support dynamicEx 
+#      type Pcd.
+# For dynamicEx type PCD, it is compatible between PCD_PPI and EFI_PEI_PCD_PPI.
+# This library instance uses the PCD_PPI to handle dynamic PCD request and use
+# EFI_PEI_PCD_PPI to handle dynamicEx type PCD.
+#
+# This library instance assume the PCD_PPI and EFI_PEI_PCD_PPI are both installed early.
+#
+# PCD Library that uses the PCD PPI to access Dynamic and DynamicEx PCD entries
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiPcdLib
+  MODULE_UNI_FILE                = PeiPcdLib.uni
+  FILE_GUID                      = 9dbf6f25-0da2-4a1d-8e12-e78de6ab4d0e
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PcdLib|PEIM PEI_CORE SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiPcdLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  PeiServicesLib
+  DebugLib
+
+
+[Ppis]
+  gPcdPpiGuid                                   ## SOMETIMES_CONSUMES
+  gEfiPeiPcdPpiGuid                             ## CONSUMES
+  gGetPcdInfoPpiGuid                            ## SOMETIMES_CONSUMES
+  gEfiGetPcdInfoPpiGuid                         ## SOMETIMES_CONSUMES
+
+[Depex.common.PEIM]
+  gEfiPeiPcdPpiGuid
+
diff --git a/MdePkg/Library/PeiPcdLib/PeiPcdLib.uni b/MdePkg/Library/PeiPcdLib/PeiPcdLib.uni
new file mode 100644
index 000000000000..c150057ad765
--- /dev/null
+++ b/MdePkg/Library/PeiPcdLib/PeiPcdLib.uni
@@ -0,0 +1,33 @@
+// /** @file
+// Instance of PCD Library using PCD PPI.
+//
+// There are two PCD PPIs as follows:
+// 1) PCD_PPI
+// It is EDKII implementation which support Dynamic/DynamicEx Pcds.
+// 2) EFI_PEI_PCD_PPI
+// It is defined by PI specification 1.2, Vol 3 which only support dynamicEx
+// type Pcd.
+// For dynamicEx type PCD, it is compatible between PCD_PPI and EFI_PEI_PCD_PPI.
+// This library instance uses the PCD_PPI to handle dynamic PCD request and use
+// EFI_PEI_PCD_PPI to handle dynamicEx type PCD.
+// 
+// This library instance assume the PCD_PPI and EFI_PEI_PCD_PPI are both installed early.
+// 
+// PCD Library that uses the PCD PPI to access Dynamic and DynamicEx PCD entries
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCD Library for PEI"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "There are two PCD PPIs as follows: 1) PCD_PPI: It is EDKII implementation which support Dynamic/DynamicEx Pcds. 2) EFI_PEI_PCD_PPI: It is defined by PI Specification 1.2, Vol 3, which only support dynamicEx type Pcd. For dynamicEx type PCD, it is compatible between PCD_PPI and EFI_PEI_PCD_PPI. This library instance uses the PCD_PPI to handle dynamic PCD request and use EFI_PEI_PCD_PPI to handle dynamicEx type PCD. This library instance assumes that PCD_PPI and EFI_PEI_PCD_PPI are both installed early. The PCD Library that uses the PCD PPI to access Dynamic and DynamicEx PCD entries."
+
diff --git a/MdePkg/Library/PeiPciLibPciCfg2/PciLib.c b/MdePkg/Library/PeiPciLibPciCfg2/PciLib.c
new file mode 100644
index 000000000000..edca469c7bff
--- /dev/null
+++ b/MdePkg/Library/PeiPciLibPciCfg2/PciLib.c
@@ -0,0 +1,1422 @@
+/** @file
+  PCI Library using PCI CFG2 PPI.
+
+  Copyright (c) 2007 - 2012, 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 <PiPei.h>
+
+#include <Ppi/PciCfg2.h>
+
+#include <Library/PciLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PeiServicesLib.h>
+
+/**
+  Assert the validity of a PCI address. A valid PCI address should contain 1's
+  only in the low 28 bits.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A,M) \
+  ASSERT (((A) & (~0xfffffff | (M))) == 0)
+
+/**
+  Translate PCI Lib address into format of PCI CFG2 PPI.
+
+  @param  A  The address that encodes the PCI Bus, Device, Function and
+             Register.
+
+**/
+#define PCI_TO_PCICFG2_ADDRESS(A) \
+  ((((A) << 4) & 0xff000000) | (((A) >> 4) & 0x00000700) | (((A) << 1) & 0x001f0000) | (LShiftU64((A) & 0xfff, 32)))
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EFI_PEI_PCI_CFG2_PPI.Read() service.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+PeiPciLibPciCfg2ReadWorker (
+  IN    UINTN                       Address,
+  IN    EFI_PEI_PCI_CFG_PPI_WIDTH   Width
+  )
+{
+  EFI_STATUS                   Status;
+  UINT32                       Data;
+  CONST EFI_PEI_PCI_CFG2_PPI   *PciCfg2Ppi;
+  UINT64                       PciCfg2Address;
+
+  Status = PeiServicesLocatePpi (&gEfiPciCfg2PpiGuid, 0, NULL, (VOID **) &PciCfg2Ppi);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (PciCfg2Ppi != NULL);
+
+  PciCfg2Address = PCI_TO_PCICFG2_ADDRESS (Address);
+  PciCfg2Ppi->Read (
+                GetPeiServicesTablePointer (),
+                PciCfg2Ppi,
+                Width,
+                PciCfg2Address,
+                &Data
+                );
+
+  return Data;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EFI_PEI_PCI_CFG2_PPI.Write() service.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specified by Width.
+  Data is returned.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+PeiPciLibPciCfg2WriteWorker (
+  IN    UINTN                       Address,
+  IN    EFI_PEI_PCI_CFG_PPI_WIDTH   Width,
+  IN    UINT32                      Data
+  )
+{
+  EFI_STATUS                      Status;
+  CONST EFI_PEI_PCI_CFG2_PPI      *PciCfg2Ppi;
+  UINT64                          PciCfg2Address;
+
+  Status = PeiServicesLocatePpi (&gEfiPciCfg2PpiGuid, 0, NULL, (VOID **) &PciCfg2Ppi);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (PciCfg2Ppi != NULL);
+
+  PciCfg2Address = PCI_TO_PCICFG2_ADDRESS (Address);
+  PciCfg2Ppi->Write (
+                GetPeiServicesTablePointer (),
+                PciCfg2Ppi,
+                Width,
+                PciCfg2Address,
+                &Data
+                );
+
+  return Data;
+}
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) PeiPciLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint8);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) PeiPciLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint8, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) ((PciRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldWrite8 (PciRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldOr8 (PciRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAnd8 (PciRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) PeiPciLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint16);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) PeiPciLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint16, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) ((PciRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldWrite16 (PciRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldOr16 (PciRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAnd16 (PciRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return PeiPciLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint32);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return PeiPciLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint32, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, (PciRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldWrite32 (PciRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldOr32 (PciRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAnd32 (PciRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.inf b/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.inf
new file mode 100644
index 000000000000..acbbd1852bf8
--- /dev/null
+++ b/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.inf
@@ -0,0 +1,56 @@
+## @file
+# PCI Library that layers on top of the PCI CFG2 PPI.
+#
+# This library produces the APIs from the PCI Library and implements
+#  these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more EFI_PEI_PCI CFG2
+#  PPIs are typically produced by a chipset specific PEIM. This library only uses
+#  the first PPI found, so this library instance should only be used platforms
+#  with a single PCI segment.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiPciLibPciCfg2
+  MODULE_UNI_FILE                = PeiPciLibPciCfg2.uni
+  FILE_GUID                      = FA3AD693-D58A-4619-960B-8EE85C914870
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib|PEIM SEC PEI_CORE
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PciLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  PeiServicesTablePointerLib
+  BaseLib
+  DebugLib
+  PeiServicesLib
+
+[Ppis]
+  gEfiPciCfg2PpiGuid                            ## CONSUMES
+
+[Depex.common.PEIM]
+  gEfiPciCfg2PpiGuid
+
diff --git a/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.uni b/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.uni
new file mode 100644
index 000000000000..3bba2e830f3b
--- /dev/null
+++ b/MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.uni
@@ -0,0 +1,25 @@
+// /** @file
+// PCI Library that layers on top of the PCI CFG2 PPI.
+//
+// This library produces the APIs from the PCI Library and implements
+// these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more EFI_PEI_PCI CFG2
+// PPIs are typically produced by a chipset specific PEIM. This library only uses
+// the first PPI found, so this library instance should only be used platforms
+// with a single PCI segment.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCI Library that layers on top of the PCI CFG2 PPI"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library produces the APIs from the PCI Library, and implements these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more EFI_PEI_PCI CFG2 PPIs are typically produced by a chipset-specific PEIM. This library only uses the first PPI found, so this library instance should only be used on platforms with a single PCI segment."
+
diff --git a/MdePkg/Library/PeiPciSegmentLibPciCfg2/PciSegmentLib.c b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PciSegmentLib.c
new file mode 100644
index 000000000000..738e0b09b371
--- /dev/null
+++ b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PciSegmentLib.c
@@ -0,0 +1,1415 @@
+/** @file
+  PCI Segment Library implementation using PCI CFG2 PPI.
+
+  Copyright (c) 2007 - 2012, 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 <PiPei.h>
+
+#include <Ppi/PciCfg2.h>
+
+#include <Library/PciSegmentLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PeiServicesLib.h>
+
+/**
+  Assert the validity of a PCI Segment address.
+  A valid PCI Segment address should not contain 1's in bits 28..31 and 48..63
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_SEGMENT_ADDRESS(A,M) \
+  ASSERT (((A) & (0xffff0000f0000000ULL | (M))) == 0)
+
+/**
+  Translate PCI Lib address into format of PCI CFG2 PPI.
+
+  @param  A  The address that encodes the PCI Bus, Device, Function and
+             Register.
+
+**/
+#define PCI_TO_PCICFG2_ADDRESS(A) \
+  ((((UINT32)(A) << 4) & 0xff000000) | (((UINT32)(A) >> 4) & 0x00000700) | (((UINT32)(A) << 1) & 0x001f0000) | (LShiftU64((A) & 0xfff, 32)))
+
+/**
+  Gets PCI CFG2 PPI.
+
+  This internal function retrieves PCI CFG2 PPI from PPI database.
+
+  @param  Address       The address that encodes the PCI Segment, Bus, Device, 
+                        Function and Register.
+
+  @return The pointer to PCI CFG2 PPI.
+
+**/
+EFI_PEI_PCI_CFG2_PPI *
+InternalGetPciCfg2Ppi (
+  IN  UINT64                Address
+  )
+{
+  EFI_STATUS                 Status;
+  UINTN                      Instance;
+  EFI_PEI_PCI_CFG2_PPI       *PciCfg2Ppi;
+  UINT64                     SegmentNumber;
+
+  Instance      = 0;
+  PciCfg2Ppi    = NULL;
+  SegmentNumber = BitFieldRead64 (Address, 32, 63);
+
+  //
+  // Loop through all instances of the PPI and match segment number
+  //
+  do {
+    Status = PeiServicesLocatePpi(
+               &gEfiPciCfg2PpiGuid,
+               Instance,
+               NULL,
+               (VOID**) &PciCfg2Ppi
+               );
+    ASSERT_EFI_ERROR (Status);
+    Instance++;
+  } while (PciCfg2Ppi->Segment != SegmentNumber);
+
+  return PciCfg2Ppi;
+}
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EFI_PEI_PCI_CFG2_PPI.Read() service.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+PeiPciSegmentLibPciCfg2ReadWorker (
+  IN  UINT64                      Address,
+  IN  EFI_PEI_PCI_CFG_PPI_WIDTH   Width
+  )
+{
+  UINT32                       Data;
+  CONST EFI_PEI_PCI_CFG2_PPI   *PciCfg2Ppi;
+  UINT64                       PciCfg2Address;
+
+  PciCfg2Ppi = InternalGetPciCfg2Ppi (Address);
+  PciCfg2Address = PCI_TO_PCICFG2_ADDRESS (Address);
+  PciCfg2Ppi->Read (
+                GetPeiServicesTablePointer (),
+                PciCfg2Ppi,
+                Width,
+                PciCfg2Address,
+                &Data
+                );
+
+  return Data;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EFI_PEI_PCI_CFG2_PPI.Write() service.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specifed by Width.
+  Data is returned.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+PeiPciSegmentLibPciCfg2WriteWorker (
+  IN  UINT64                      Address,
+  IN  EFI_PEI_PCI_CFG_PPI_WIDTH   Width,
+  IN  UINT32                      Data
+  )
+{
+  CONST EFI_PEI_PCI_CFG2_PPI   *PciCfg2Ppi;
+  UINT64                       PciCfg2Address;
+
+  PciCfg2Ppi = InternalGetPciCfg2Ppi (Address);
+  PciCfg2Address = PCI_TO_PCICFG2_ADDRESS (Address);
+  PciCfg2Ppi->Write (
+                GetPeiServicesTablePointer (),
+                PciCfg2Ppi,
+                Width,
+                PciCfg2Address,
+                &Data
+                );
+
+  return Data;
+}
+
+/**
+  Register a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciSegmentRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, 
+                    and Register.
+
+  @return The 8-bit PCI configuration register specified by Address.
+
+**/
+UINT8
+EFIAPI
+PciSegmentRead8 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) PeiPciSegmentLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint8);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentWrite8 (
+  IN UINT64                    Address,
+  IN UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) PeiPciSegmentLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint8, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAnd8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value,
+  followed a  bitwise OR with another 8-bit value.
+  
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) ((PciSegmentRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldRead8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciSegmentRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldWrite8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     Value
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldWrite8 (PciSegmentRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldOr8 (PciSegmentRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAnd8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAnd8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 16-bit PCI configuration register specified by Address.
+
+**/
+UINT16
+EFIAPI
+PciSegmentRead16 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) PeiPciSegmentLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint16);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+PciSegmentWrite16 (
+  IN UINT64                    Address,
+  IN UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) PeiPciSegmentLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint16, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAnd16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value,
+  followed a  bitwise OR with another 16-bit value.
+  
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) ((PciSegmentRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldRead16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciSegmentRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldWrite16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    Value
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldWrite16 (PciSegmentRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address. 
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldOr16 (PciSegmentRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR,
+  and writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  Extra left bits in OrData are stripped.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    The ordinal of the least significant bit in a byte is bit 0.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    The ordinal of the most significant bit in a byte is bit 7.
+  @param  AndData   The value to AND with the read value from the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAnd16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAnd16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, 
+                    and Register.
+
+  @return The 32-bit PCI configuration register specified by Address.
+
+**/
+UINT32
+EFIAPI
+PciSegmentRead32 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return PeiPciSegmentLibPciCfg2ReadWorker (Address, EfiPeiPciCfgWidthUint32);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, 
+                      Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT32
+EFIAPI
+PciSegmentWrite32 (
+  IN UINT64                    Address,
+  IN UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return PeiPciSegmentLibPciCfg2WriteWorker (Address, EfiPeiPciCfgWidthUint32, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, 
+                    and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAnd32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value,
+  followed a  bitwise OR with another 32-bit value.
+  
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function,
+                    and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, (PciSegmentRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldRead32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciSegmentRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldWrite32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    Value
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldWrite32 (PciSegmentRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldOr32 (PciSegmentRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  
+  Reads the 32-bit PCI configuration register specified by Address, performs a bitwise
+  AND between the read result and the value specified by AndData, and writes the result
+  to the 32-bit PCI configuration register specified by Address. The value written to
+  the PCI configuration register is returned.  This function must guarantee that all PCI
+  read and write operations are serialized.  Extra left bits in AndData are stripped.
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAnd32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAnd32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, 
+                        Device, Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentReadBuffer (
+  IN  UINT64                   StartAddress,
+  IN  UINTN                    Size,
+  OUT VOID                     *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciSegmentRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, 
+                        Device, Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return The parameter of Size.
+
+**/
+UINTN
+EFIAPI
+PciSegmentWriteBuffer (
+  IN UINT64                    StartAddress,
+  IN UINTN                     Size,
+  IN VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciSegmentWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.inf b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.inf
new file mode 100644
index 000000000000..1c0d22ee94b7
--- /dev/null
+++ b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.inf
@@ -0,0 +1,53 @@
+## @file
+# PCI Segment Library that layers on top of the PCI CFG2 PPI.
+#
+# This library produces the APIs from the PCI Segment Library and
+#  implements these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more
+#  EFI_PEI_PCI CFG2 PPIs are typically produced by a chipset specific PEIM.
+#  This library instance should only be used platforms with multiple PCI segments.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiPciSegmentLibPciCfg2
+  MODULE_UNI_FILE                = PeiPciSegmentLibPciCfg2.uni
+  FILE_GUID                      = 254901AD-7DB7-45f8-93C8-93D579398D9F
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciSegmentLib|PEIM SEC PEI_CORE
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PciSegmentLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PeiServicesTablePointerLib
+  BaseLib
+  DebugLib
+  PeiServicesLib
+
+[Ppis]
+  gEfiPciCfg2PpiGuid                            ##  CONSUMES
+
+[Depex.common.PEIM]
+  gEfiPciCfg2PpiGuid
+
diff --git a/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.uni b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.uni
new file mode 100644
index 000000000000..82d1cca5176b
--- /dev/null
+++ b/MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.uni
@@ -0,0 +1,24 @@
+// /** @file
+// PCI Segment Library that layers on top of the PCI CFG2 PPI.
+//
+// This library produces the APIs from the PCI Segment Library and
+// implements these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more
+// EFI_PEI_PCI CFG2 PPIs are typically produced by a chipset specific PEIM.
+// This library instance should only be used platforms with multiple PCI segments.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCI Segment Library that layers on top of the PCI CFG2 PPI"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library produces the APIs from the PCI Segment Library and implements these APIs by calling into the EFI_PEI_PCI CFG2 PPI. One or more EFI_PEI_PCI CFG2 PPIs are typically produced by a chipset-specific PEIM. This library instance should only be used on platforms with multiple PCI segments."
+
diff --git a/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.c b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.c
new file mode 100644
index 000000000000..3d7f52ee4c67
--- /dev/null
+++ b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.c
@@ -0,0 +1,58 @@
+/** @file
+  Resource Publication Library that uses PEI Core Services to publish system memory.
+
+  Copyright (c) 2006 - 2008, 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 <PiPei.h>
+
+
+#include <Library/ResourcePublicationLib.h>
+#include <Library/PeiServicesLib.h>
+#include <Library/DebugLib.h>
+
+
+/**
+  Declares the presence of permanent system memory in the platform.
+
+  Declares that the system memory buffer specified by MemoryBegin and MemoryLength
+  as permanent memory that may be used for general purpose use by software.
+  The amount of memory available to software may be less than MemoryLength
+  if published memory has alignment restrictions. 
+  If MemoryLength is 0, then ASSERT().
+  If MemoryLength is greater than (MAX_ADDRESS - MemoryBegin + 1), then ASSERT(). 
+
+  @param  MemoryBegin               The start address of the memory being declared.
+  @param  MemoryLength              The number of bytes of memory being declared.
+
+  @retval  RETURN_SUCCESS           The memory buffer was published.
+  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources to publish the memory buffer
+
+**/
+RETURN_STATUS
+EFIAPI
+PublishSystemMemory (
+  IN PHYSICAL_ADDRESS       MemoryBegin,
+  IN UINT64                 MemoryLength
+  )
+{
+  EFI_STATUS        Status;
+
+  ASSERT (MemoryLength > 0);
+  ASSERT (MemoryLength <= (MAX_ADDRESS - MemoryBegin + 1));
+
+  Status      = PeiServicesInstallPeiMemory (MemoryBegin, MemoryLength);
+     
+  return (RETURN_STATUS) Status;
+}
+
diff --git a/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.inf b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.inf
new file mode 100644
index 000000000000..c96e7ef60d14
--- /dev/null
+++ b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.inf
@@ -0,0 +1,42 @@
+## @file
+# Instance of Resource Publication Library using PEI Services.
+#
+# Resource Publication Library that uses PEI Services to publish system memory.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiResourcePublicationLib
+  MODULE_UNI_FILE                = PeiResourcePublicationLib.uni
+  FILE_GUID                      = e8d6390d-e190-4957-9ab6-d47d51b01336
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = ResourcePublicationLib|PEIM SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiResourcePublicationLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  PeiServicesLib
+
diff --git a/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.uni b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.uni
new file mode 100644
index 000000000000..593f877f1760
--- /dev/null
+++ b/MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Resource Publication Library using PEI Services.
+//
+// Resource Publication Library that uses PEI Services to publish system memory.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Resource Publication Library using PEI Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Resource Publication Library uses PEI Services to publish system memory."
+
diff --git a/MdePkg/Library/PeiServicesLib/PeiServicesLib.c b/MdePkg/Library/PeiServicesLib/PeiServicesLib.c
new file mode 100644
index 000000000000..e2932ea52bd1
--- /dev/null
+++ b/MdePkg/Library/PeiServicesLib/PeiServicesLib.c
@@ -0,0 +1,766 @@
+/** @file
+  Implementation for PEI Services Library.
+
+  Copyright (c) 2006 - 2016, 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 <PiPei.h>
+
+#include <Ppi/FirmwareVolumeInfo.h>
+#include <Ppi/FirmwareVolumeInfo2.h>
+#include <Guid/FirmwareFileSystem2.h>
+
+#include <Library/PeiServicesLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/BaseMemoryLib.h>
+
+/**
+  This service enables a given PEIM to register an interface into the PEI Foundation.
+
+  @param  PpiList               A pointer to the list of interfaces that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The PpiList pointer is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI PPI descriptors in the list do not have the
+                                EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesInstallPpi (
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *PpiList
+  )
+{
+  CONST EFI_PEI_SERVICES  **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->InstallPpi (PeiServices, PpiList);
+}
+
+/**
+  This service enables PEIMs to replace an entry in the PPI database with an alternate entry.
+
+  @param  OldPpi                The pointer to the old PEI PPI Descriptors.
+  @param  NewPpi                The pointer to the new PEI PPI Descriptors.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The OldPpi or NewPpi is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI PPI descriptors in the list do not have the
+                                EFI_PEI_PPI_DESCRIPTOR_PPI bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+  @retval EFI_NOT_FOUND         The PPI for which the reinstallation was requested has not been
+                                installed.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesReInstallPpi (
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *OldPpi,
+  IN CONST EFI_PEI_PPI_DESCRIPTOR     *NewPpi
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->ReInstallPpi (PeiServices, OldPpi, NewPpi);
+}
+
+/**
+  This service enables PEIMs to discover a given instance of an interface.
+
+  @param  Guid                  A pointer to the GUID whose corresponding interface needs to be
+                                found.
+  @param  Instance              The N-th instance of the interface that is required.
+  @param  PpiDescriptor         A pointer to instance of the EFI_PEI_PPI_DESCRIPTOR.
+  @param  Ppi                   A pointer to the instance of the interface.
+
+  @retval EFI_SUCCESS           The interface was successfully returned.
+  @retval EFI_NOT_FOUND         The PPI descriptor is not found in the database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesLocatePpi (
+  IN CONST EFI_GUID                   *Guid,
+  IN UINTN                      Instance,
+  IN OUT EFI_PEI_PPI_DESCRIPTOR **PpiDescriptor,
+  IN OUT VOID                   **Ppi
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->LocatePpi (PeiServices, Guid, Instance, PpiDescriptor, Ppi);
+}
+
+/**
+  This service enables PEIMs to register a given service to be invoked when another service is
+  installed or reinstalled.
+
+  @param  NotifyList            A pointer to the list of notification interfaces 
+                                that the caller shall install.
+
+  @retval EFI_SUCCESS           The interface was successfully installed.
+  @retval EFI_INVALID_PARAMETER The NotifyList pointer is NULL.
+  @retval EFI_INVALID_PARAMETER Any of the PEI notify descriptors in the list do
+                                 not have the EFI_PEI_PPI_DESCRIPTOR_NOTIFY_TYPES
+                                 bit set in the Flags field.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space in the PPI database.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesNotifyPpi (
+  IN CONST EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyList
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->NotifyPpi (PeiServices, NotifyList);
+}
+
+/**
+  This service enables PEIMs to ascertain the present value of the boot mode.
+
+  @param  BootMode              A pointer to contain the value of the boot mode.
+
+  @retval EFI_SUCCESS           The boot mode was returned successfully.
+  @retval EFI_INVALID_PARAMETER BootMode is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesGetBootMode (
+  OUT EFI_BOOT_MODE          *BootMode
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->GetBootMode (PeiServices, BootMode);
+}
+
+/**
+  This service enables PEIMs to update the boot mode variable.
+
+  @param  BootMode              The value of the boot mode to set.
+
+  @retval EFI_SUCCESS           The value was successfully updated
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesSetBootMode (
+  IN EFI_BOOT_MODE              BootMode
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->SetBootMode (PeiServices, BootMode);
+}
+
+/**
+  This service enables a PEIM to ascertain the address of the list of HOBs in memory.
+
+  @param  HobList               A pointer to the list of HOBs that the PEI Foundation 
+                                will initialize.
+  
+  @retval EFI_SUCCESS           The list was successfully returned.
+  @retval EFI_NOT_AVAILABLE_YET The HOB list is not yet published.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesGetHobList (
+  OUT VOID                      **HobList
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->GetHobList (PeiServices, HobList);
+}
+
+/**
+  This service enables PEIMs to create various types of HOBs.
+
+  @param  Type                  The type of HOB to be installed.
+  @param  Length                The length of the HOB to be added.
+  @param  Hob                   The address of a pointer that will contain the 
+                                HOB header.
+
+  @retval EFI_SUCCESS           The HOB was successfully created.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesCreateHob (
+  IN UINT16                     Type,
+  IN UINT16                     Length,
+  OUT VOID                      **Hob
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->CreateHob (PeiServices, Type, Length, Hob);
+}
+
+/**
+  This service enables PEIMs to discover additional firmware volumes.
+
+  @param  Instance              This instance of the firmware volume to find.  The 
+                                value 0 is the Boot Firmware Volume (BFV).
+  @param  VolumeHandle          Handle of the firmware volume header of the volume
+                                to return.
+
+  @retval EFI_SUCCESS           The volume was found.
+  @retval EFI_NOT_FOUND         The volume was not found.
+  @retval EFI_INVALID_PARAMETER FwVolHeader is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindNextVolume (
+  IN UINTN                          Instance,
+  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->FfsFindNextVolume (PeiServices, Instance, VolumeHandle);
+}
+
+/**
+  This service enables PEIMs to discover additional firmware files.
+
+  @param  SearchType            A filter to find files only of this type.
+  @param  VolumeHandle          The pointer to the firmware volume header of the 
+                                volume to search. This parameter must point to a 
+                                valid FFS volume. 
+  @param  FileHandle            Handle of the current file from which to begin searching.
+
+  @retval EFI_SUCCESS           The file was found.
+  @retval EFI_NOT_FOUND         The file was not found.
+  @retval EFI_NOT_FOUND         The header checksum was not zero.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindNextFile (
+  IN EFI_FV_FILETYPE            SearchType,
+  IN EFI_PEI_FV_HANDLE          VolumeHandle,
+  IN OUT EFI_PEI_FILE_HANDLE    *FileHandle
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->FfsFindNextFile (PeiServices, SearchType, VolumeHandle, FileHandle);
+}
+
+/**
+  This service enables PEIMs to discover sections of a given type within a valid FFS file.
+
+  @param  SectionType           The value of the section type to find.
+  @param  FileHandle            A pointer to the file header that contains the set 
+                                of sections to be searched.
+  @param  SectionData           A pointer to the discovered section, if successful.
+
+  @retval EFI_SUCCESS           The section was found.
+  @retval EFI_NOT_FOUND         The section was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindSectionData (
+  IN EFI_SECTION_TYPE           SectionType,
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  OUT VOID                      **SectionData
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->FfsFindSectionData (PeiServices, SectionType, FileHandle, SectionData);
+}
+
+/**
+  This service enables PEIMs to discover sections of a given instance and type within a valid FFS file.
+
+  @param  SectionType           The value of the section type to find.
+  @param  SectionInstance       Section instance to find.
+  @param  FileHandle            A pointer to the file header that contains the set 
+                                of sections to be searched.
+  @param  SectionData           A pointer to the discovered section, if successful.
+  @param  AuthenticationStatus  A pointer to the authentication status for this section.
+
+  @retval EFI_SUCCESS           The section was found.
+  @retval EFI_NOT_FOUND         The section was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindSectionData3 (
+  IN EFI_SECTION_TYPE           SectionType,
+  IN UINTN                      SectionInstance,
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  OUT VOID                      **SectionData,
+  OUT UINT32                    *AuthenticationStatus
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->FindSectionData3 (PeiServices, SectionType, SectionInstance, FileHandle, SectionData, AuthenticationStatus);
+}
+
+/**
+  This service enables PEIMs to register the permanent memory configuration
+  that has been initialized with the PEI Foundation.
+
+  @param  MemoryBegin           The value of a region of installed memory.
+  @param  MemoryLength          The corresponding length of a region of installed memory.
+
+  @retval EFI_SUCCESS           The region was successfully installed in a HOB.
+  @retval EFI_INVALID_PARAMETER MemoryBegin and MemoryLength are illegal for this system.
+  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesInstallPeiMemory (
+  IN EFI_PHYSICAL_ADDRESS       MemoryBegin,
+  IN UINT64                     MemoryLength
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->InstallPeiMemory (PeiServices, MemoryBegin, MemoryLength);
+}
+
+/**
+  This service enables PEIMs to allocate memory after the permanent memory has been
+   installed by a PEIM.
+
+  @param  MemoryType            Type of memory to allocate.
+  @param  Pages                 The number of pages to allocate.
+  @param  Memory                Pointer of memory allocated.
+
+  @retval EFI_SUCCESS           The memory range was successfully allocated.
+  @retval EFI_INVALID_PARAMETER Type is not equal to AllocateAnyPages.
+  @retval EFI_NOT_AVAILABLE_YET Called with permanent memory not available.
+  @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesAllocatePages (
+  IN EFI_MEMORY_TYPE            MemoryType,
+  IN UINTN                      Pages,
+  OUT EFI_PHYSICAL_ADDRESS      *Memory
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->AllocatePages (PeiServices, MemoryType, Pages, Memory);
+}
+
+/**
+  This service allocates memory from the Hand-Off Block (HOB) heap.
+
+  @param  Size                  The number of bytes to allocate from the pool.
+  @param  Buffer                If the call succeeds, a pointer to a pointer to 
+                                the allocate buffer; otherwise, undefined.
+
+  @retval EFI_SUCCESS           The allocation was successful
+  @retval EFI_OUT_OF_RESOURCES  There is not enough heap to allocate the requested size.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesAllocatePool (
+  IN UINTN                      Size,
+  OUT VOID                      **Buffer
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->AllocatePool (PeiServices, Size, Buffer);
+}
+
+/**
+  Resets the entire platform.
+
+  @retval EFI_SUCCESS           The function completed successfully.
+  @retval EFI_NOT_AVAILABLE_YET The service has not been installed yet.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesResetSystem (
+  VOID
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->ResetSystem (PeiServices);
+}
+
+/**
+  This service is a wrapper for the PEI Service RegisterForShadow(), except the 
+  pointer to the PEI Services Table has been removed.  See the Platform 
+  Initialization Pre-EFI Initialization Core Interface Specification for details. 
+
+  @param FileHandle             PEIM's file handle. Must be the currently
+                                executing PEIM.
+  
+  @retval EFI_SUCCESS           The PEIM was successfully registered for
+                                shadowing.
+
+  @retval EFI_ALREADY_STARTED   The PEIM was previously
+                                registered for shadowing.
+
+  @retval EFI_NOT_FOUND         The FileHandle does not refer to a
+                                valid file handle.
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesRegisterForShadow (
+  IN  EFI_PEI_FILE_HANDLE FileHandle
+  )
+{
+  return (*GetPeiServicesTablePointer())->RegisterForShadow (FileHandle);
+}
+
+/**
+  This service is a wrapper for the PEI Service FfsGetFileInfo(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param FileHandle              The handle of the file.
+
+  @param FileInfo                 Upon exit, points to the file's
+                                  information.
+
+  @retval EFI_SUCCESS             File information returned.
+  
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  
+  @retval EFI_INVALID_PARAMETER   FileInfo is NULL.
+  
+**/
+EFI_STATUS
+EFIAPI 
+PeiServicesFfsGetFileInfo (
+  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,
+  OUT EFI_FV_FILE_INFO            *FileInfo
+  )
+{
+  return (*GetPeiServicesTablePointer())->FfsGetFileInfo (FileHandle, FileInfo);
+}
+
+/**
+  This service is a wrapper for the PEI Service FfsGetFileInfo2(), except the pointer to the PEI Services
+  Table has been removed. See the Platform Initialization Pre-EFI Initialization Core Interface
+  Specification for details.
+
+  @param FileHandle               The handle of the file.
+  @param FileInfo                 Upon exit, points to the file's
+                                  information.
+
+  @retval EFI_SUCCESS             File information returned.
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  @retval EFI_INVALID_PARAMETER   FileInfo is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsGetFileInfo2 (
+  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,
+  OUT EFI_FV_FILE_INFO2           *FileInfo
+  )
+{
+  return (*GetPeiServicesTablePointer())->FfsGetFileInfo2 (FileHandle, FileInfo);
+}
+
+/**
+  This service is a wrapper for the PEI Service FfsFindByName(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param FileName                 A pointer to the name of the file to
+                                  find within the firmware volume.
+
+  @param VolumeHandle             The firmware volume to search FileHandle
+                                  Upon exit, points to the found file's
+                                  handle or NULL if it could not be found.
+  @param FileHandle               The pointer to found file handle 
+
+  @retval EFI_SUCCESS             File was found.
+
+  @retval EFI_NOT_FOUND           File was not found.
+
+  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or
+                                  FileName was NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsFindFileByName (
+  IN CONST  EFI_GUID            *FileName,
+  IN CONST  EFI_PEI_FV_HANDLE   VolumeHandle,
+  OUT       EFI_PEI_FILE_HANDLE *FileHandle
+  )
+{
+  return (*GetPeiServicesTablePointer())->FfsFindFileByName (FileName, VolumeHandle, FileHandle);
+}
+
+
+/**
+  This service is a wrapper for the PEI Service FfsGetVolumeInfo(), except the pointer to the PEI Services 
+  Table has been removed.  See the Platform Initialization Pre-EFI Initialization Core Interface 
+  Specification for details. 
+
+  @param VolumeHandle             Handle of the volume.
+
+  @param VolumeInfo               Upon exit, points to the volume's
+                                  information.
+
+  @retval EFI_SUCCESS             File information returned.
+  
+  @retval EFI_INVALID_PARAMETER   If FileHandle does not
+                                  represent a valid file.
+  
+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFfsGetVolumeInfo (
+  IN  EFI_PEI_FV_HANDLE       VolumeHandle,
+  OUT EFI_FV_INFO             *VolumeInfo
+  )
+{
+  return (*GetPeiServicesTablePointer())->FfsGetVolumeInfo (VolumeHandle, VolumeInfo);
+}
+
+/**
+  Install a EFI_PEI_FIRMWARE_VOLUME_INFO(2)_PPI instance so the PEI Core will be notified about a new firmware volume.
+
+  This function allocates, initializes, and installs a new EFI_PEI_FIRMWARE_VOLUME_INFO(2)_PPI using
+  the parameters passed in to initialize the fields of the EFI_PEI_FIRMWARE_VOLUME_INFO(2)_PPI instance.
+  If the resources can not be allocated for EFI_PEI_FIRMWARE_VOLUME_INFO(2)_PPI, then ASSERT().
+  If the EFI_PEI_FIRMWARE_VOLUME_INFO(2)_PPI can not be installed, then ASSERT().
+  If NULL is specified for FvFormat, but FvInfo does not have the firmware file system 2 format, then ASSERT.
+
+  @param  InstallFvInfoPpi     Install FvInfo Ppi if it is TRUE. Otherwise, install FvInfo2 Ppi.
+  @param  FvFormat             Unique identifier of the format of the memory-mapped
+                               firmware volume.  This parameter is optional and
+                               may be NULL.  If NULL is specified, the
+                               EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed.
+  @param  FvInfo               Points to a buffer which allows the
+                               EFI_PEI_FIRMWARE_VOLUME_PPI to process the volume.
+                               The format of this buffer is specific to the FvFormat.
+                               For memory-mapped firmware volumes, this typically
+                               points to the first byte of the firmware volume.
+  @param  FvInfoSize           The size, in bytes, of FvInfo. For memory-mapped
+                               firmware volumes, this is typically the size of
+                               the firmware volume.
+  @param  ParentFvName         If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID name of the originating firmware
+                               volume. Otherwise, this parameter must be NULL.
+  @param  ParentFileName       If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID file name of the originating
+                               firmware file. Otherwise, this parameter must be NULL.
+  @param  AuthenticationStatus Authentication Status, it will be ignored if InstallFvInfoPpi is TRUE.
+**/
+VOID
+EFIAPI
+InternalPeiServicesInstallFvInfoPpi (
+  IN       BOOLEAN                 InstallFvInfoPpi,
+  IN CONST EFI_GUID                *FvFormat, OPTIONAL
+  IN CONST VOID                    *FvInfo,
+  IN       UINT32                  FvInfoSize,
+  IN CONST EFI_GUID                *ParentFvName, OPTIONAL
+  IN CONST EFI_GUID                *ParentFileName, OPTIONAL
+  IN       UINT32                  AuthenticationStatus
+  )
+{
+  EFI_STATUS                       Status;   
+  EFI_PEI_FIRMWARE_VOLUME_INFO_PPI *FvInfoPpi;
+  EFI_PEI_PPI_DESCRIPTOR           *FvInfoPpiDescriptor;
+  EFI_GUID                         *ParentFvNameValue;
+  EFI_GUID                         *ParentFileNameValue;
+  EFI_GUID                         *PpiGuid;
+
+  ParentFvNameValue   = NULL;
+  ParentFileNameValue = NULL;
+  if (InstallFvInfoPpi) {
+    //
+    // To install FvInfo Ppi.
+    //
+    FvInfoPpi = AllocateZeroPool (sizeof (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI));
+    ASSERT (FvInfoPpi != NULL);
+    PpiGuid = &gEfiPeiFirmwareVolumeInfoPpiGuid;
+  } else {
+    //
+    // To install FvInfo2 Ppi.
+    //
+    FvInfoPpi = AllocateZeroPool (sizeof (EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI));
+    ASSERT (FvInfoPpi != NULL);
+    ((EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI *) FvInfoPpi)->AuthenticationStatus = AuthenticationStatus;
+    PpiGuid = &gEfiPeiFirmwareVolumeInfo2PpiGuid;
+  }
+
+  if (FvFormat != NULL) {
+    CopyGuid (&FvInfoPpi->FvFormat, FvFormat);
+  } else {
+    CopyGuid (&FvInfoPpi->FvFormat, &gEfiFirmwareFileSystem2Guid);
+    //
+    // Since the EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed if NULL is specified for FvFormat,
+    // check the FileSystemGuid pointed by FvInfo against EFI_FIRMWARE_FILE_SYSTEM2_GUID to make sure
+    // FvInfo has the firmware file system 2 format.
+    // If the ASSERT really appears, FvFormat needs to be specified correctly, for example,
+    // EFI_FIRMWARE_FILE_SYSTEM3_GUID can be used for firmware file system 3 format, or
+    // ((EFI_FIRMWARE_VOLUME_HEADER *) FvInfo)->FileSystemGuid can be just used for both
+    // firmware file system 2 and 3 format.
+    //
+    ASSERT (CompareGuid (&(((EFI_FIRMWARE_VOLUME_HEADER *) FvInfo)->FileSystemGuid), &gEfiFirmwareFileSystem2Guid));
+  }
+  FvInfoPpi->FvInfo = (VOID *) FvInfo;
+  FvInfoPpi->FvInfoSize = FvInfoSize;
+  if (ParentFvName != NULL) {
+    ParentFvNameValue = AllocateCopyPool (sizeof (EFI_GUID), ParentFvName);
+    ASSERT (ParentFvNameValue != NULL);
+    FvInfoPpi->ParentFvName = ParentFvNameValue;
+  }
+  if (ParentFileName != NULL) {
+    ParentFileNameValue = AllocateCopyPool (sizeof (EFI_GUID), ParentFileName);
+    ASSERT (ParentFileNameValue != NULL);
+    FvInfoPpi->ParentFileName = ParentFileNameValue;
+  }
+
+  FvInfoPpiDescriptor = AllocatePool (sizeof (EFI_PEI_PPI_DESCRIPTOR));
+  ASSERT (FvInfoPpiDescriptor != NULL);
+
+  FvInfoPpiDescriptor->Guid  = PpiGuid;
+  FvInfoPpiDescriptor->Flags = EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST;
+  FvInfoPpiDescriptor->Ppi   = (VOID *) FvInfoPpi;
+  Status = PeiServicesInstallPpi (FvInfoPpiDescriptor);
+  ASSERT_EFI_ERROR (Status);
+
+}
+
+/**
+  Install a EFI_PEI_FIRMWARE_VOLUME_INFO_PPI instance so the PEI Core will be notified about a new firmware volume.
+
+  This function allocates, initializes, and installs a new EFI_PEI_FIRMWARE_VOLUME_INFO_PPI using
+  the parameters passed in to initialize the fields of the EFI_PEI_FIRMWARE_VOLUME_INFO_PPI instance.
+  If the resources can not be allocated for EFI_PEI_FIRMWARE_VOLUME_INFO_PPI, then ASSERT().
+  If the EFI_PEI_FIRMWARE_VOLUME_INFO_PPI can not be installed, then ASSERT().
+  If NULL is specified for FvFormat, but FvInfo does not have the firmware file system 2 format, then ASSERT.
+
+  @param  FvFormat             Unique identifier of the format of the memory-mapped
+                               firmware volume.  This parameter is optional and
+                               may be NULL.  If NULL is specified, the
+                               EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed.
+  @param  FvInfo               Points to a buffer which allows the
+                               EFI_PEI_FIRMWARE_VOLUME_PPI to process the volume.
+                               The format of this buffer is specific to the FvFormat.
+                               For memory-mapped firmware volumes, this typically
+                               points to the first byte of the firmware volume.
+  @param  FvInfoSize           The size, in bytes, of FvInfo. For memory-mapped
+                               firmware volumes, this is typically the size of
+                               the firmware volume.
+  @param  ParentFvName         If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID name of the originating firmware
+                               volume. Otherwise, this parameter must be NULL.
+  @param  ParentFileName       If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID file name of the originating
+                               firmware file. Otherwise, this parameter must be NULL.
+**/
+VOID
+EFIAPI
+PeiServicesInstallFvInfoPpi (
+  IN CONST EFI_GUID                *FvFormat, OPTIONAL
+  IN CONST VOID                    *FvInfo,
+  IN       UINT32                  FvInfoSize,
+  IN CONST EFI_GUID                *ParentFvName, OPTIONAL
+  IN CONST EFI_GUID                *ParentFileName OPTIONAL
+  )
+{
+  InternalPeiServicesInstallFvInfoPpi (TRUE, FvFormat, FvInfo, FvInfoSize, ParentFvName, ParentFileName, 0);
+}
+
+/**
+  Install a EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI instance so the PEI Core will be notified about a new firmware volume.
+
+  This function allocates, initializes, and installs a new EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI using
+  the parameters passed in to initialize the fields of the EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI instance.
+  If the resources can not be allocated for EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI, then ASSERT().
+  If the EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI can not be installed, then ASSERT().
+  If NULL is specified for FvFormat, but FvInfo does not have the firmware file system 2 format, then ASSERT.
+
+  @param  FvFormat             Unique identifier of the format of the memory-mapped
+                               firmware volume.  This parameter is optional and
+                               may be NULL.  If NULL is specified, the
+                               EFI_FIRMWARE_FILE_SYSTEM2_GUID format is assumed.
+  @param  FvInfo               Points to a buffer which allows the
+                               EFI_PEI_FIRMWARE_VOLUME_PPI to process the volume.
+                               The format of this buffer is specific to the FvFormat.
+                               For memory-mapped firmware volumes, this typically
+                               points to the first byte of the firmware volume.
+  @param  FvInfoSize           The size, in bytes, of FvInfo. For memory-mapped
+                               firmware volumes, this is typically the size of
+                               the firmware volume.
+  @param  ParentFvName         If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID name of the originating firmware
+                               volume. Otherwise, this parameter must be NULL.
+  @param  ParentFileName       If the new firmware volume originated from a file
+                               in a different firmware volume, then this parameter
+                               specifies the GUID file name of the originating
+                               firmware file. Otherwise, this parameter must be NULL.
+  @param  AuthenticationStatus Authentication Status
+**/
+VOID
+EFIAPI
+PeiServicesInstallFvInfo2Ppi (
+  IN CONST EFI_GUID                *FvFormat, OPTIONAL
+  IN CONST VOID                    *FvInfo,
+  IN       UINT32                  FvInfoSize,
+  IN CONST EFI_GUID                *ParentFvName, OPTIONAL
+  IN CONST EFI_GUID                *ParentFileName, OPTIONAL
+  IN       UINT32                  AuthenticationStatus
+  )
+{
+  InternalPeiServicesInstallFvInfoPpi (FALSE, FvFormat, FvInfo, FvInfoSize, ParentFvName, ParentFileName, AuthenticationStatus);
+}
+
diff --git a/MdePkg/Library/PeiServicesLib/PeiServicesLib.inf b/MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
new file mode 100644
index 000000000000..376f3b90c405
--- /dev/null
+++ b/MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
@@ -0,0 +1,48 @@
+## @file
+# PEI Services Library implementation.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiServicesLib
+  MODULE_UNI_FILE                = PeiServicesLib.uni
+  FILE_GUID                      = a804239b-4155-446f-acc8-f0825d74908c
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeiServicesLib|SEC PEIM PEI_CORE 
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiServicesLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  PeiServicesTablePointerLib
+  MemoryAllocationLib
+  DebugLib
+
+[Guids]
+  gEfiFirmwareFileSystem2Guid        ## SOMETIMES_PRODUCES ## GUID # FV File System Guid.
+
+[Ppis]
+  gEfiPeiFirmwareVolumeInfoPpiGuid   ## SOMETIMES_PRODUCES
+  gEfiPeiFirmwareVolumeInfo2PpiGuid  ## SOMETIMES_PRODUCES
+
diff --git a/MdePkg/Library/PeiServicesLib/PeiServicesLib.uni b/MdePkg/Library/PeiServicesLib/PeiServicesLib.uni
new file mode 100644
index 000000000000..ce1028eba999
--- /dev/null
+++ b/MdePkg/Library/PeiServicesLib/PeiServicesLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// PEI Services Library implementation.
+//
+// PEI Services Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PEI Services Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PEI Services Library implementation."
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointer.c b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointer.c
new file mode 100644
index 000000000000..a22ad136941b
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointer.c
@@ -0,0 +1,116 @@
+/** @file
+  PEI Services Table Pointer Library.
+  
+  This library is used for PEIM which does executed from flash device directly but
+  executed in memory.
+
+  Copyright (c) 2006 - 2014, 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 <PiPei.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+
+CONST EFI_PEI_SERVICES  **gPeiServices;
+
+/**
+  Caches a pointer PEI Services Table. 
+ 
+  Caches the pointer to the PEI Services Table specified by PeiServicesTablePointer 
+  in a CPU specific manner as specified in the CPU binding section of the Platform Initialization 
+  Pre-EFI Initialization Core Interface Specification. 
+  
+  If PeiServicesTablePointer is NULL, then ASSERT().
+  
+  @param    PeiServicesTablePointer   The address of PeiServices pointer.
+**/
+VOID
+EFIAPI
+SetPeiServicesTablePointer (
+  IN CONST EFI_PEI_SERVICES ** PeiServicesTablePointer
+  )
+{
+  ASSERT (PeiServicesTablePointer != NULL);
+  gPeiServices = PeiServicesTablePointer;
+}
+
+/**
+  Retrieves the cached value of the PEI Services Table pointer.
+
+  Returns the cached value of the PEI Services Table pointer in a CPU specific manner 
+  as specified in the CPU binding section of the Platform Initialization Pre-EFI 
+  Initialization Core Interface Specification.
+  
+  If the cached PEI Services Table pointer is NULL, then ASSERT().
+
+  @return  The pointer to PeiServices.
+
+**/
+CONST EFI_PEI_SERVICES **
+EFIAPI
+GetPeiServicesTablePointer (
+  VOID
+  )
+{
+  ASSERT (gPeiServices != NULL);
+  return gPeiServices;
+}
+
+
+/**
+  The constructor function caches the pointer to PEI services.
+  
+  The constructor function caches the pointer to PEI services.
+  It will always return EFI_SUCCESS.
+
+  @param  FileHandle   The handle of FFS header the loaded driver.
+  @param  PeiServices  The pointer to the PEI services.
+
+  @retval EFI_SUCCESS  The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesTablePointerLibConstructor (
+  IN EFI_PEI_FILE_HANDLE        FileHandle,
+  IN CONST EFI_PEI_SERVICES     **PeiServices
+  )
+{
+  gPeiServices = PeiServices;
+  return EFI_SUCCESS;
+}
+
+/**
+  Perform CPU specific actions required to migrate the PEI Services Table 
+  pointer from temporary RAM to permanent RAM.
+
+  For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
+  a dedicated CPU register.  This means that there is no memory storage 
+  associated with storing the PEI Services Table pointer, so no additional 
+  migration actions are required for Itanium or ARM CPUs.
+
+**/
+VOID
+EFIAPI
+MigratePeiServicesTablePointer (
+  VOID
+  )
+{
+  //
+  //  PEI Services Table pointer is cached in the global variable. No additional 
+  //  migration actions are required.
+  //
+  return;
+}
diff --git a/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
new file mode 100644
index 000000000000..b397ab5e8490
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
@@ -0,0 +1,44 @@
+## @file
+# Instance of PEI Services Table Pointer Library using global variable for the table pointer.
+#
+# PEI Services Table Pointer Library implementation that retrieves a pointer to the
+#  PEI Services Table from a global variable. Not available to modules that execute from
+#  read-only memory.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiServicesTablePointerLib
+  MODULE_UNI_FILE                = PeiServicesTablePointerLib.uni
+  FILE_GUID                      = 1c747f6b-0a58-49ae-8ea3-0327a4fa10e3
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeiServicesTablePointerLib|PEIM PEI_CORE SEC
+
+  CONSTRUCTOR                    = PeiServicesTablePointerLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeiServicesTablePointer.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.uni b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.uni
new file mode 100644
index 000000000000..96fd42d4ec17
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of PEI Services Table Pointer Library using global variable for the table pointer.
+//
+// PEI Services Table Pointer Library implementation that retrieves a pointer to the
+// PEI Services Table from a global variable. Not available to modules that execute from
+// read-only memory.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PEI Services Table Pointer Library using global variable for the table pointer"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI Services Table from a global variable. Not available to modules that execute from read-only memory."
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointer.c b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointer.c
new file mode 100644
index 000000000000..593f837d9668
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointer.c
@@ -0,0 +1,131 @@
+/** @file
+  PEI Services Table Pointer Library for IA-32 and x64.
+
+  According to PI specification, the peiservice pointer is stored prior at IDT
+  table in IA32 and x64 architecture.
+  
+  Copyright (c) 2006 - 2014, 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 <PiPei.h>
+
+#include <Library/BaseLib.h>
+#include <Library/PeiServicesTablePointerLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+
+/**
+  Retrieves the cached value of the PEI Services Table pointer.
+
+  Returns the cached value of the PEI Services Table pointer in a CPU specific manner 
+  as specified in the CPU binding section of the Platform Initialization Pre-EFI 
+  Initialization Core Interface Specification.
+  
+  If the cached PEI Services Table pointer is NULL, then ASSERT().
+
+  @return  The pointer to PeiServices.
+
+**/
+CONST EFI_PEI_SERVICES **
+EFIAPI
+GetPeiServicesTablePointer (
+  VOID
+  )
+{
+  CONST EFI_PEI_SERVICES  **PeiServices;
+  IA32_DESCRIPTOR   Idtr;
+  
+  AsmReadIdtr (&Idtr);
+  PeiServices = (CONST EFI_PEI_SERVICES **) (*(UINTN*)(Idtr.Base - sizeof (UINTN)));
+  ASSERT (PeiServices != NULL);
+  return PeiServices;
+}
+
+/**
+  Caches a pointer PEI Services Table. 
+ 
+  Caches the pointer to the PEI Services Table specified by PeiServicesTablePointer 
+  in a CPU specific manner as specified in the CPU binding section of the Platform Initialization 
+  Pre-EFI Initialization Core Interface Specification. 
+  The function set the pointer of PEI services immediately preceding the IDT table
+  according to PI specification.
+  
+  If PeiServicesTablePointer is NULL, then ASSERT().
+  
+  @param    PeiServicesTablePointer   The address of PeiServices pointer.
+**/
+VOID
+EFIAPI
+SetPeiServicesTablePointer (
+  IN CONST EFI_PEI_SERVICES ** PeiServicesTablePointer
+  )
+{
+  IA32_DESCRIPTOR        Idtr;
+  
+  ASSERT (PeiServicesTablePointer != NULL);
+  AsmReadIdtr (&Idtr);
+  (*(UINTN*)(Idtr.Base - sizeof (UINTN))) = (UINTN)PeiServicesTablePointer;
+}
+
+/**
+  Perform CPU specific actions required to migrate the PEI Services Table 
+  pointer from temporary RAM to permanent RAM.
+
+  For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
+  a dedicated CPU register.  This means that there is no memory storage 
+  associated with storing the PEI Services Table pointer, so no additional 
+  migration actions are required for Itanium or ARM CPUs.
+
+  If The cached PEI Services Table pointer is NULL, then ASSERT().
+  If the permanent memory is allocated failed, then ASSERT().
+**/
+VOID
+EFIAPI
+MigratePeiServicesTablePointer (
+  VOID
+  )
+{
+  EFI_STATUS             Status;
+  IA32_DESCRIPTOR        Idtr;
+  EFI_PHYSICAL_ADDRESS   IdtBase;
+  CONST EFI_PEI_SERVICES  **PeiServices;
+
+  //
+  // Get PEI Services Table pointer
+  //
+  AsmReadIdtr (&Idtr);
+  PeiServices = (CONST EFI_PEI_SERVICES **) (*(UINTN*)(Idtr.Base - sizeof (UINTN)));
+  ASSERT (PeiServices != NULL);
+  //
+  // Allocate the permanent memory.
+  //
+  Status = (*PeiServices)->AllocatePages (
+                            PeiServices, 
+                            EfiBootServicesCode,
+                            EFI_SIZE_TO_PAGES(Idtr.Limit + 1 + sizeof (UINTN)),
+                            &IdtBase
+                            );
+  ASSERT_EFI_ERROR (Status);
+  //
+  // Idt table needs to be migrated into memory.
+  //
+  CopyMem ((VOID *) (UINTN) IdtBase, (VOID *) (Idtr.Base - sizeof (UINTN)), Idtr.Limit + 1 + sizeof (UINTN));
+  Idtr.Base = (UINTN) IdtBase + sizeof (UINTN);
+  AsmWriteIdtr (&Idtr);
+  
+  return;
+}
+
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.inf b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.inf
new file mode 100644
index 000000000000..93dc134b820a
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.inf
@@ -0,0 +1,43 @@
+## @file
+# Instance of PEI Services Table Pointer Library using IDT for the table pointer.
+#
+# PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI
+# Services Table from the IDT on IA-32 and x64.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiServicesTablePointerLibIdt
+  MODULE_UNI_FILE                = PeiServicesTablePointerLibIdt.uni
+  FILE_GUID                      = DED3F743-CE2C-4ba6-92A2-FFCE2A6D72D9
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeiServicesTablePointerLib|PEIM PEI_CORE SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[Sources]
+  PeiServicesTablePointer.c
+
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+  BaseMemoryLib
diff --git a/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.uni b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.uni
new file mode 100644
index 000000000000..e290665642f5
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PEI Services Table Pointer Library using IDT for the table pointer.
+//
+// PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI
+// Services Table from the IDT on IA-32 and x64.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PEI Services Table Pointer Library using IDT for the table pointer"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI Services Table from the IDT on IA-32 and x64."
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointer.c b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointer.c
new file mode 100644
index 000000000000..016dacf34682
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointer.c
@@ -0,0 +1,91 @@
+/** @file
+  PEI Services Table Pointer Library implementation for IPF that uses Kernel
+  Register 7 to store the pointer.
+
+  Copyright (c) 2006 - 2014, 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 <PiPei.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Retrieves the cached value of the PEI Services Table pointer.
+
+  Returns the cached value of the PEI Services Table pointer in a CPU specific manner 
+  as specified in the CPU binding section of the Platform Initialization Pre-EFI 
+  Initialization Core Interface Specification.
+  
+  If the cached PEI Services Table pointer is NULL, then ASSERT().
+
+  @return  The pointer to PeiServices.
+
+**/
+CONST EFI_PEI_SERVICES **
+EFIAPI
+GetPeiServicesTablePointer (
+  VOID
+  )
+{
+  CONST EFI_PEI_SERVICES  **PeiServices;
+
+  PeiServices = (CONST EFI_PEI_SERVICES **)(UINTN)AsmReadKr7 ();
+  ASSERT (PeiServices != NULL);
+  return PeiServices;
+}
+
+
+/**
+  Caches a pointer PEI Services Table. 
+ 
+  Caches the pointer to the PEI Services Table specified by PeiServicesTablePointer 
+  in a CPU specific manner as specified in the CPU binding section of the Platform Initialization 
+  Pre-EFI Initialization Core Interface Specification. 
+  The function set the pointer of PEI services in KR7 register 
+  according to PI specification.
+  
+  If PeiServicesTablePointer is NULL, then ASSERT().
+  
+  @param    PeiServicesTablePointer   The address of PeiServices pointer.
+**/
+VOID
+EFIAPI
+SetPeiServicesTablePointer (
+  IN CONST EFI_PEI_SERVICES ** PeiServicesTablePointer
+  )
+{
+  ASSERT (PeiServicesTablePointer != NULL);
+  AsmWriteKr7 ((UINT64)(UINTN)PeiServicesTablePointer);
+}
+  
+/**
+  Perform CPU specific actions required to migrate the PEI Services Table 
+  pointer from temporary RAM to permanent RAM.
+
+  For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes 
+  immediately preceding the Interrupt Descriptor Table (IDT) in memory.
+  For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
+  a dedicated CPU register.  This means that there is no memory storage 
+  associated with storing the PEI Services Table pointer, so no additional 
+  migration actions are required for Itanium or ARM CPUs.
+
+**/
+VOID
+EFIAPI
+MigratePeiServicesTablePointer (
+  VOID
+  )
+{
+  return;
+}
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.inf b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.inf
new file mode 100644
index 000000000000..9447ed9568bb
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.inf
@@ -0,0 +1,42 @@
+## @file
+# Instance of PEI Services Table Pointer Library using KR7 for the table pointer.
+#
+# PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI
+# Services Table from KR7 on IPF.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiServicesTablePointerLibKr7
+  MODULE_UNI_FILE                = PeiServicesTablePointerLibKr7.uni
+  FILE_GUID                      = E0E7D776-E7EB-4e5f-9AA8-54CF3AA64A43
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeiServicesTablePointerLib|SEC PEIM PEI_CORE
+
+
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.Ipf]
+  PeiServicesTablePointer.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.uni b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.uni
new file mode 100644
index 000000000000..eb00d8626f50
--- /dev/null
+++ b/MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of PEI Services Table Pointer Library using KR7 for the table pointer.
+//
+// PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI
+// Services Table from KR7 on IPF.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of PEI Services Table Pointer Library using KR7 for the table pointer"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "PEI Services Table Pointer Library implementation that retrieves a pointer to the PEI Services Table from KR7 on IPF."
+
diff --git a/MdePkg/Library/PeiSmbusLibSmbus2Ppi/InternalSmbusLib.h b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/InternalSmbusLib.h
new file mode 100644
index 000000000000..afdcae7aac68
--- /dev/null
+++ b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/InternalSmbusLib.h
@@ -0,0 +1,80 @@
+/** @file
+Internal header file for Smbus library.
+
+Copyright (c) 2006 - 2010, 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 __INTERNAL_SMBUS_LIB_H_
+#define __INTERNAL_SMBUS_LIB_H_
+
+
+#include <PiPei.h>
+
+#include <Ppi/Smbus2.h>
+
+#include <Library/SmbusLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PeiServicesLib.h>
+#include <Library/BaseMemoryLib.h>
+
+//
+// Declaration for internal functions
+//
+
+/**
+  Gets Smbus PPIs.
+
+  This internal function retrieves Smbus PPI from PPI database.
+
+  @param  VOID
+
+  @return The pointer to Smbus PPI.
+
+**/
+EFI_PEI_SMBUS2_PPI *
+InternalGetSmbusPpi (
+  VOID
+  );
+
+/**
+  Executes an SMBus operation to an SMBus controller.
+
+  This function provides a standard way to execute Smbus script
+  as defined in the SmBus Specification. The data can either be of
+  the Length byte, word, or a block of data.
+
+  @param  SmbusOperation  Signifies which particular SMBus hardware protocol 
+                          instance that it will use to execute the SMBus transactions.
+  @param  SmBusAddress    The address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Length          Signifies the number of bytes that this operation will 
+                          do. The maximum number of bytes can be revision specific 
+                          and operation specific.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave 
+                          device. Not all operations require this argument. The 
+                          length of this buffer is identified by Length.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The actual number of bytes that are executed for this operation.
+
+**/
+UINTN
+InternalSmBusExec (
+  IN     EFI_SMBUS_OPERATION        SmbusOperation,
+  IN     UINTN                      SmBusAddress,
+  IN     UINTN                      Length,
+  IN OUT VOID                       *Buffer,
+     OUT RETURN_STATUS              *Status        OPTIONAL
+  );
+
+#endif
diff --git a/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLib.c b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLib.c
new file mode 100644
index 000000000000..035c3eb88427
--- /dev/null
+++ b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLib.c
@@ -0,0 +1,95 @@
+/** @file
+Implementation of SmBusLib class library for PEI phase.
+
+Copyright (c) 2006 - 2010, 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 "InternalSmbusLib.h"
+
+/**
+  Gets Smbus PPIs.
+
+  This internal function retrieves Smbus PPI from PPI database.
+
+  @param  VOID
+
+  @return The pointer to Smbus PPI.
+
+**/
+EFI_PEI_SMBUS2_PPI *
+InternalGetSmbusPpi (
+  VOID
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PEI_SMBUS2_PPI     *SmbusPpi;
+
+  Status = PeiServicesLocatePpi (&gEfiPeiSmbus2PpiGuid, 0, NULL, (VOID **) &SmbusPpi);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (SmbusPpi != NULL);
+
+  return SmbusPpi;
+}
+
+/**
+  Executes an SMBus operation to an SMBus controller.
+
+  This function provides a standard way to execute Smbus script
+  as defined in the SmBus Specification. The data can either be of
+  the Length byte, word, or a block of data.
+
+  @param  SmbusOperation  Signifies which particular SMBus hardware protocol instance 
+                          that it will use to execute the SMBus transactions.
+  @param  SmBusAddress    The address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Length          Signifies the number of bytes that this operation will 
+                          do. The maximum number of bytes can be revision specific 
+                          and operation specific.
+  @param  Buffer          Contains the value of data to execute to the SMBus slave 
+                          device. Not all operations require this argument. The 
+                          length of this buffer is identified by Length.
+  @param  Status          Return status for the executed command.
+                          This is an optional parameter and may be NULL.
+
+  @return The actual number of bytes that are executed for this operation.
+
+**/
+UINTN
+InternalSmBusExec (
+  IN     EFI_SMBUS_OPERATION        SmbusOperation,
+  IN     UINTN                      SmBusAddress,
+  IN     UINTN                      Length,
+  IN OUT VOID                       *Buffer,
+     OUT RETURN_STATUS              *Status        OPTIONAL
+  )
+{
+  EFI_PEI_SMBUS2_PPI        *SmbusPpi;
+  RETURN_STATUS             ReturnStatus;
+  EFI_SMBUS_DEVICE_ADDRESS  SmbusDeviceAddress;
+
+  SmbusPpi    = InternalGetSmbusPpi ();
+  SmbusDeviceAddress.SmbusDeviceAddress = SMBUS_LIB_SLAVE_ADDRESS (SmBusAddress);
+
+  ReturnStatus = SmbusPpi->Execute (
+                             SmbusPpi,
+                             SmbusDeviceAddress,
+                             SMBUS_LIB_COMMAND (SmBusAddress),
+                             SmbusOperation,
+                             SMBUS_LIB_PEC (SmBusAddress),
+                             &Length,
+                             Buffer
+                             );
+  if (Status != NULL) {
+    *Status = ReturnStatus;
+  }
+
+  return Length;
+}
diff --git a/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.inf b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.inf
new file mode 100644
index 000000000000..8618e76e6f65
--- /dev/null
+++ b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.inf
@@ -0,0 +1,50 @@
+## @file
+# SMBUS library that layers on top of the SMBUS2 PPI.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeiSmbusLibSmbus2Ppi
+  MODULE_UNI_FILE                = PeiSmbusLibSmbus2Ppi.uni
+  FILE_GUID                      = 2A1E1C92-AABA-4d62-AC40-F3A4C3387356
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmbusLib|PEIM SEC
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  SmbusLib.c
+  PeiSmbusLib.c
+  InternalSmbusLib.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  PeiServicesLib
+  DebugLib
+
+[Ppis]
+  gEfiPeiSmbus2PpiGuid                           ## CONSUMES
+
+[Depex.common.PEIM]
+  gEfiPeiSmbus2PpiGuid 
+
diff --git a/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.uni b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.uni
new file mode 100644
index 000000000000..e783ddc5791c
--- /dev/null
+++ b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.uni
@@ -0,0 +1,21 @@
+// /** @file
+// SMBUS library that layers on top of the SMBUS2 PPI.
+//
+// SMBUS library that layers on top of the SMBUS2 PPI.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "SMBUS library that layers on top of the SMBUS2 PPI"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "SMBUS library that layers on top of the SMBUS2 PPI."
+
diff --git a/MdePkg/Library/PeiSmbusLibSmbus2Ppi/SmbusLib.c b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/SmbusLib.c
new file mode 100644
index 000000000000..739d3cbd874b
--- /dev/null
+++ b/MdePkg/Library/PeiSmbusLibSmbus2Ppi/SmbusLib.c
@@ -0,0 +1,584 @@
+/** @file
+Implementation of SmBusLib class library for PEI phase.
+
+Copyright (c) 2006 - 2008, 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 "InternalSmbusLib.h"
+
+/**
+  Executes an SMBUS quick read command.
+
+  Executes an SMBUS quick read command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS:  The SMBUS command was executed.
+                        RETURN_TIMEOUT:  A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR: The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle
+                        (host initiated), or bus errors (collisions).
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickRead (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusQuickRead, SmBusAddress, 0, NULL, Status);
+}
+
+/**
+  Executes an SMBUS quick write command.
+
+  Executes an SMBUS quick write command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If PEC is set in SmBusAddress, then ASSERT().
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_UNSUPPORTED::  The SMBus operation is not supported.
+
+**/
+VOID
+EFIAPI
+SmBusQuickWrite (
+  IN  UINTN                     SmBusAddress,
+  OUT RETURN_STATUS             *Status       OPTIONAL
+  )
+{
+  ASSERT (!SMBUS_LIB_PEC (SmBusAddress));
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusQuickWrite, SmBusAddress, 0, NULL, Status);
+}
+
+/**
+  Executes an SMBUS receive byte command.
+
+  Executes an SMBUS receive byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address field of SmBusAddress is required.
+  The byte received from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte received from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReceiveByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress) == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)  == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReceiveByte, SmBusAddress, 1, &Byte, Status);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS send byte command.
+
+  Executes an SMBUS send byte command on the SMBUS device specified by SmBusAddress.
+  The byte specified by Value is sent.
+  Only the SMBUS slave address field of SmBusAddress is required.  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Command in SmBusAddress is not zero, then ASSERT().
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to send.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  Device 
+                        errors are a result of a transaction collision, illegal 
+                        command field, unclaimed cycle (host initiated), or bus 
+                        errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusSendByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_COMMAND (SmBusAddress)   == 0);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Byte   = Value;
+  InternalSmBusExec (EfiSmbusSendByte, SmBusAddress, 1, &Byte, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read data byte command.
+
+  Executes an SMBUS read data byte command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 8-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress    The address that encodes the SMBUS Slave Address,
+                          SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                       or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT8
+EFIAPI
+SmBusReadDataByte (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReadByte, SmBusAddress, 1, &Byte, Status);
+
+  return Byte;
+}
+
+/**
+  Executes an SMBUS write data byte command.
+
+  Executes an SMBUS write data byte command on the SMBUS device specified by SmBusAddress.
+  The 8-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 8-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT8
+EFIAPI
+SmBusWriteDataByte (
+  IN  UINTN          SmBusAddress,
+  IN  UINT8          Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT8   Byte;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Byte = Value;
+  InternalSmBusExec (EfiSmbusWriteByte, SmBusAddress, 1, &Byte, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read data word command.
+
+  Executes an SMBUS read data word command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value read from the SMBUS is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+  
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The byte read from the SMBUS.
+
+**/
+UINT16
+EFIAPI
+SmBusReadDataWord (
+  IN  UINTN          SmBusAddress,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusReadWord, SmBusAddress, 2, &Word, Status);
+
+  return Word;
+}
+
+/**
+  Executes an SMBUS write data word command.
+
+  Executes an SMBUS write data word command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Value is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+SmBusWriteDataWord (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINT16  Word;
+
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Word = Value;
+  InternalSmBusExec (EfiSmbusWriteWord, SmBusAddress, 2, &Word, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS process call command.
+
+  Executes an SMBUS process call command on the SMBUS device specified by SmBusAddress.
+  The 16-bit value specified by Value is written.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  The 16-bit value returned by the process call command is returned.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Value         The 16-bit value to write.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated),
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The 16-bit value returned by the process call command.
+
+**/
+UINT16
+EFIAPI
+SmBusProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  UINT16         Value,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  InternalSmBusExec (EfiSmbusProcessCall, SmBusAddress, 2, &Value, Status);
+
+  return Value;
+}
+
+/**
+  Executes an SMBUS read block command.
+
+  Executes an SMBUS read block command on the SMBUS device specified by SmBusAddress.
+  Only the SMBUS slave address and SMBUS command fields of SmBusAddress are required.
+  Bytes are read from the SMBUS and stored in Buffer.
+  The number of bytes read is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure Buffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is not zero, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        The pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_SUCCESS: The SMBUS command was executed.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes read.
+
+**/
+UINTN
+EFIAPI
+SmBusReadBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress)    == 0);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  return InternalSmBusExec (EfiSmbusReadBlock, SmBusAddress, 0x20, Buffer, Status);
+}
+
+/**
+  Executes an SMBUS write block command.
+
+  Executes an SMBUS write block command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from Buffer.
+  The number of bytes written is returned, and will never return a value larger than 32-bytes.
+  If Status is not NULL, then the status of the executed command is returned in Status.  
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If Buffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        MBUS Command, SMBUS Data Length, and PEC.
+  @param  Buffer        The pointer to the buffer to store the bytes read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR:  The checksum is not correct (PEC is incorrect)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusWriteBlock (
+  IN  UINTN          SmBusAddress,
+  OUT VOID           *Buffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN  Length;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Length = SMBUS_LIB_LENGTH (SmBusAddress);
+  return InternalSmBusExec (EfiSmbusWriteBlock, SmBusAddress, Length, Buffer, Status);
+}
+
+/**
+  Executes an SMBUS block process call command.
+
+  Executes an SMBUS block process call command on the SMBUS device specified by SmBusAddress.
+  The SMBUS slave address, SMBUS command, and SMBUS length fields of SmBusAddress are required.
+  Bytes are written to the SMBUS from WriteBuffer.  Bytes are then read from the SMBUS into ReadBuffer.
+  If Status is not NULL, then the status of the executed command is returned in Status.
+  It is the caller's responsibility to make sure ReadBuffer is large enough for the total number of bytes read.
+  SMBUS supports a maximum transfer size of 32 bytes, so Buffer does not need to be any larger than 32 bytes.
+  If Length in SmBusAddress is zero or greater than 32, then ASSERT().
+  If WriteBuffer is NULL, then ASSERT().
+  If ReadBuffer is NULL, then ASSERT().
+  If any reserved bits of SmBusAddress are set, then ASSERT().
+
+  @param  SmBusAddress  The address that encodes the SMBUS Slave Address,
+                        SMBUS Command, SMBUS Data Length, and PEC.
+  @param  WriteBuffer   The pointer to the buffer of bytes to write to the SMBUS.
+  @param  ReadBuffer    The pointer to the buffer of bytes to read from the SMBUS.
+  @param  Status        Return status for the executed command.
+                        This is an optional parameter and may be NULL.
+                        RETURN_TIMEOUT: A timeout occurred while executing the 
+                        SMBUS command.
+                        RETURN_DEVICE_ERROR:  The request was not completed because 
+                        a failure reflected in the Host Status Register bit.  
+                        Device errors are a result of a transaction collision, 
+                        illegal command field, unclaimed cycle (host initiated), 
+                        or bus errors (collisions).
+                        RETURN_CRC_ERROR  The checksum is not correct. (PEC is incorrect.)
+                        RETURN_UNSUPPORTED:  The SMBus operation is not supported.
+
+  @return The number of bytes written.
+
+**/
+UINTN
+EFIAPI
+SmBusBlockProcessCall (
+  IN  UINTN          SmBusAddress,
+  IN  VOID           *WriteBuffer,
+  OUT VOID           *ReadBuffer,
+  OUT RETURN_STATUS  *Status        OPTIONAL
+  )
+{
+  UINTN   Length;
+
+  ASSERT (WriteBuffer != NULL);
+  ASSERT (ReadBuffer  != NULL);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) >= 1);
+  ASSERT (SMBUS_LIB_LENGTH (SmBusAddress) <= 32);
+  ASSERT (SMBUS_LIB_RESERVED (SmBusAddress) == 0);
+
+  Length = SMBUS_LIB_LENGTH (SmBusAddress);
+  //
+  // Assuming that ReadBuffer is large enough to save another memory copy.
+  //
+  ReadBuffer = CopyMem (ReadBuffer, WriteBuffer, Length);
+  return InternalSmBusExec (EfiSmbusBWBRProcessCall, SmBusAddress, Length, ReadBuffer, Status);
+}
diff --git a/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.c b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.c
new file mode 100644
index 000000000000..91797d85ad86
--- /dev/null
+++ b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.c
@@ -0,0 +1,81 @@
+/** @file
+  Entry point to a PEIM.
+
+Copyright (c) 2006 - 2008, 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 <PiPei.h>
+
+
+#include <Library/PeimEntryPoint.h>
+#include <Library/DebugLib.h>
+
+/**
+  The entry point of PE/COFF Image for a PEIM.
+
+  This function is the entry point for a PEIM.  This function must call ProcessLibraryConstructorList() 
+  and ProcessModuleEntryPointList().  The return value from ProcessModuleEntryPointList() is returned.
+  If _gPeimRevision is not zero and PeiServices->Hdr.Revision is less than _gPeimRevison, then ASSERT().
+
+  @param  FileHandle  Handle of the file being invoked. 
+  @param  PeiServices Describes the list of possible PEI Services.
+
+  @retval  EFI_SUCCESS   The PEIM executed normally.
+  @retval  !EFI_SUCCESS  The PEIM failed to execute normally.
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  )
+{
+  if (_gPeimRevision != 0) {
+    //
+    // Make sure that the PEI spec revision of the platform is >= PEI spec revision of the driver
+    //
+    ASSERT ((*PeiServices)->Hdr.Revision >= _gPeimRevision);
+  }
+
+  //
+  // Call constructor for all libraries
+  //
+  ProcessLibraryConstructorList (FileHandle, PeiServices);
+
+  //
+  // Call the driver entry point
+  //
+  return ProcessModuleEntryPointList (FileHandle, PeiServices);
+}
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint().
+  
+  This function is required to call _ModuleEntryPoint() passing in FileHandle and PeiServices.
+
+  @param  FileHandle  Handle of the file being invoked. 
+  @param  PeiServices Describes the list of possible PEI Services.
+
+  @retval EFI_SUCCESS  The PEIM executed normally.
+  @retval !EFI_SUCCESS The PEIM failed to execute normally.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_PEI_FILE_HANDLE       FileHandle,
+  IN CONST EFI_PEI_SERVICES    **PeiServices
+  )
+{
+  return _ModuleEntryPoint (FileHandle, PeiServices);
+}
diff --git a/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
new file mode 100644
index 000000000000..e70456603a8f
--- /dev/null
+++ b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
@@ -0,0 +1,39 @@
+## @file
+# Module entry point library for PEIM.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = PeimEntryPoint
+  MODULE_UNI_FILE                = PeimEntryPoint.uni
+  FILE_GUID                      = fa177ff7-1fc7-458d-a358-d9d62ae61cec
+  MODULE_TYPE                    = PEIM
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PeimEntryPoint|PEIM 
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC (EBC is for build only)
+#
+
+[Sources]
+  PeimEntryPoint.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.uni b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.uni
new file mode 100644
index 000000000000..a1894f5da4a5
--- /dev/null
+++ b/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Module entry point library for PEIM.
+//
+// Module entry point library for PEIM.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Module entry point library for PEIM"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Module entry point library for PEIM."
+
diff --git a/MdePkg/Library/SecPeiDxeTimerLibCpu/IpfTimerLib.c b/MdePkg/Library/SecPeiDxeTimerLibCpu/IpfTimerLib.c
new file mode 100644
index 000000000000..f5a8f7d2717f
--- /dev/null
+++ b/MdePkg/Library/SecPeiDxeTimerLibCpu/IpfTimerLib.c
@@ -0,0 +1,216 @@
+/** @file
+  Timer Library functions built upon ITC on IPF.
+
+  Copyright (c) 2006 - 2011, 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 <Base.h>
+#include <Library/TimerLib.h>
+#include <Library/BaseLib.h>
+#include <Library/PalLib.h>
+
+
+/**
+  Performs a delay measured as number of ticks.
+
+  An internal function to perform a delay measured as number of ticks. It's
+  invoked by MicroSecondDelay() and NanoSecondDelay().
+
+  @param  Delay The number of ticks to delay.
+
+**/
+VOID
+EFIAPI
+InternalIpfDelay (
+  IN      INT64                     Delay
+  )
+{
+  INT64                             Ticks;
+
+  //
+  // The target timer count is calculated here
+  //
+  Ticks = (INT64)AsmReadItc () + Delay;
+
+  //
+  // Wait until time out
+  // Delay > 2^63 could not be handled by this function
+  // Timer wrap-arounds are handled correctly by this function
+  //
+  while (Ticks - (INT64)AsmReadItc() >= 0);
+}
+
+/**
+  Stalls the CPU for at least the given number of microseconds.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return The value of MicroSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+MicroSecondDelay (
+  IN      UINTN                     MicroSeconds
+  )
+{
+  InternalIpfDelay (
+    GetPerformanceCounterProperties (NULL, NULL) *
+    MicroSeconds /
+    1000000
+    );
+  return MicroSeconds;
+}
+
+/**
+  Stalls the CPU for at least the given number of nanoseconds.
+
+  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
+
+  @param  NanoSeconds The minimum number of nanoseconds to delay.
+
+  @return The value of NanoSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+NanoSecondDelay (
+  IN      UINTN                     NanoSeconds
+  )
+{
+  InternalIpfDelay (
+    GetPerformanceCounterProperties (NULL, NULL) *
+    NanoSeconds /
+    1000000000
+    );
+  return NanoSeconds;
+}
+
+/**
+  Retrieves the current value of a 64-bit free running performance counter.
+
+  The counter can either count up by 1 or count down by 1. If the physical
+  performance counter counts by a larger increment, then the counter values
+  must be translated. The properties of the counter can be retrieved from
+  GetPerformanceCounterProperties().
+
+  @return The current value of the free running performance counter.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounter (
+  VOID
+  )
+{
+  return AsmReadItc ();
+}
+
+/**
+  Retrieves the 64-bit frequency in Hz and the range of performance counter
+  values.
+
+  If StartValue is not NULL, then the value that the performance counter starts
+  with immediately after is it rolls over is returned in StartValue. If
+  EndValue is not NULL, then the value that the performance counter end with
+  immediately before it rolls over is returned in EndValue. The 64-bit
+  frequency of the performance counter in Hz is always returned. If StartValue
+  is less than EndValue, then the performance counter counts up. If StartValue
+  is greater than EndValue, then the performance counter counts down. For
+  example, a 64-bit free running counter that counts up would have a StartValue
+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
+
+  @param  StartValue  The value the performance counter starts with when it
+                      rolls over.
+  @param  EndValue    The value that the performance counter ends with before
+                      it rolls over.
+
+  @return The frequency in Hz.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  OUT      UINT64                    *StartValue,  OPTIONAL
+  OUT      UINT64                    *EndValue     OPTIONAL
+  )
+{
+  PAL_CALL_RETURN                   PalRet;
+  UINT64                            BaseFrequence;
+
+  if (StartValue != NULL) {
+    *StartValue = 0;
+  }
+
+  if (EndValue != NULL) {
+    *EndValue = (UINT64)(-1);
+  }
+
+  PalRet = PalCall (PAL_FREQ_BASE, 0, 0, 0);
+  if (PalRet.Status != 0) {
+    return 1000000;
+  }
+  BaseFrequence = PalRet.r9;
+
+  PalRet = PalCall (PAL_FREQ_RATIOS, 0, 0, 0);
+  if (PalRet.Status != 0) {
+    return 1000000;
+  }
+
+  return BaseFrequence * (PalRet.r11 >> 32) / (UINT32)PalRet.r11;
+}
+
+/**
+  Converts elapsed ticks of performance counter to time in nanoseconds.
+
+  This function converts the elapsed ticks of running performance counter to
+  time value in unit of nanoseconds.
+
+  @param  Ticks     The number of elapsed ticks of running performance counter.
+
+  @return The elapsed time in nanoseconds.
+
+**/
+UINT64
+EFIAPI
+GetTimeInNanoSecond (
+  IN      UINT64                     Ticks
+  )
+{
+  UINT64  Frequency;
+  UINT64  NanoSeconds;
+  UINT64  Remainder;
+  INTN    Shift;
+
+  Frequency = GetPerformanceCounterProperties (NULL, NULL);
+
+  //
+  //          Ticks
+  // Time = --------- x 1,000,000,000
+  //        Frequency
+  //
+  NanoSeconds = MultU64x32 (DivU64x64Remainder (Ticks, Frequency, &Remainder), 1000000000u);
+
+  //
+  // Ensure (Remainder * 1,000,000,000) will not overflow 64-bit.
+  // Since 2^29 < 1,000,000,000 = 0x3B9ACA00 < 2^30, Remainder should < 2^(64-30) = 2^34,
+  // i.e. highest bit set in Remainder should <= 33.
+  //
+  Shift = MAX (0, HighBitSet64 (Remainder) - 33);
+  Remainder = RShiftU64 (Remainder, (UINTN) Shift);
+  Frequency = RShiftU64 (Frequency, (UINTN) Shift);
+  NanoSeconds += DivU64x64Remainder (MultU64x32 (Remainder, 1000000000u), Frequency, NULL);
+
+  return NanoSeconds;
+}
diff --git a/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf b/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf
new file mode 100644
index 000000000000..4a7501bfb193
--- /dev/null
+++ b/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf
@@ -0,0 +1,67 @@
+## @file
+# Instance of Timer Library only using CPU resources.
+#
+# Timer Library that only uses CPU resources to provide calibrated delays
+#  on IA-32, x64, and IPF.
+# Note: A driver of type DXE_RUNTIME_DRIVER and DXE_SMM_DRIVER can use this TimerLib 
+#  in their initialization without any issues. They only have to be careful in 
+#  the implementation of runtime services and SMI handlers.  
+#  Because CPU Local APIC and ITC could be programmed by OS, it cannot be
+#  used by SMM drivers and runtime drivers, ACPI timer is recommended for SMM
+#  drivers and runtime drivers.
+#
+# Note that for IA-32 and x64, this library only supports xAPIC mode. If x2APIC
+# support is desired, the SecPeiDxeTimerLibUefiCpu library can be used.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SecPeiDxeTimerLibCpu
+  MODULE_UNI_FILE                = SecPeiDxeTimerLibCpu.uni
+  FILE_GUID                      = b5a05743-9b71-489b-a0ed-a0eb3950d23b
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = TimerLib
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF
+#
+
+[Sources.Ia32, Sources.X64]
+  X86TimerLib.c
+
+[Sources.IPF]
+  IpfTimerLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+
+[LibraryClasses.IA32, LibraryClasses.X64]
+  PcdLib
+  IoLib
+  DebugLib
+
+[LibraryClasses.IPF]
+  PalLib
+
+
+[Pcd.IA32, Pcd.X64]
+  gEfiMdePkgTokenSpaceGuid.PcdFSBClock  ## CONSUMES
+
diff --git a/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.uni b/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.uni
new file mode 100644
index 000000000000..7591700d181e
--- /dev/null
+++ b/MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.uni
@@ -0,0 +1,31 @@
+// /** @file
+// Instance of Timer Library only using CPU resources.
+//
+// Timer Library that only uses CPU resources to provide calibrated delays
+// on IA-32, x64, and IPF.
+// Note: A driver of type DXE_RUNTIME_DRIVER and DXE_SMM_DRIVER can use this TimerLib
+// in their initialization without any issues. They only have to be careful in
+// the implementation of runtime services and SMI handlers.
+// Because CPU Local APIC and ITC could be programmed by OS, it cannot be
+// used by SMM drivers and runtime drivers, ACPI timer is recommended for SMM
+// drivers and runtime drivers.
+// 
+// Note that for IA-32 and x64, this library only supports xAPIC mode. If x2APIC
+// support is desired, the SecPeiDxeTimerLibUefiCpu library can be used.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Timer Library only using CPU resources"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Timer Library only uses CPU resources to provide calibrated delays on IA-32, x64, and IPF. Note: A driver of types DXE_RUNTIME_DRIVER and DXE_SMM_DRIVER can use this TimerLib in their initialization without any issues. They only have to be careful in the implementation of runtime services and SMI handlers. Because CPU Local APIC and ITC could be programmed by the OS, it cannot be used by SMM drivers and runtime drivers, and ACPI timer is recommended for SMM drivers and runtime drivers.  Note that for IA-32 and x64, this library only supports xAPIC mode. If x2APIC support is desired, the SecPeiDxeTimerLibUefiCpu library can be used."
+
diff --git a/MdePkg/Library/SecPeiDxeTimerLibCpu/X86TimerLib.c b/MdePkg/Library/SecPeiDxeTimerLibCpu/X86TimerLib.c
new file mode 100644
index 000000000000..4b99a70b94c1
--- /dev/null
+++ b/MdePkg/Library/SecPeiDxeTimerLibCpu/X86TimerLib.c
@@ -0,0 +1,375 @@
+/** @file
+  Timer Library functions built upon local APIC on IA32/x64.
+
+  Copyright (c) 2006 - 2015, 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 <Base.h>
+#include <Library/TimerLib.h>
+#include <Library/BaseLib.h>
+#include <Library/IoLib.h>
+#include <Library/PcdLib.h>
+#include <Library/DebugLib.h>
+
+#define APIC_SVR        0x0f0
+#define APIC_LVTERR     0x370
+#define APIC_TMICT      0x380
+#define APIC_TMCCT      0x390
+#define APIC_TDCR       0x3e0
+
+//
+// The following array is used in calculating the frequency of local APIC
+// timer. Refer to IA-32 developers' manual for more details.
+//
+GLOBAL_REMOVE_IF_UNREFERENCED
+CONST UINT8                           mTimerLibLocalApicDivisor[] = {
+  0x02, 0x04, 0x08, 0x10,
+  0x02, 0x04, 0x08, 0x10,
+  0x20, 0x40, 0x80, 0x01,
+  0x20, 0x40, 0x80, 0x01
+};
+
+/**
+  Internal function to retrieve the base address of local APIC.
+
+  This function will ASSERT if:
+  The local APIC is not globally enabled.
+  The local APIC is not working under XAPIC mode.
+  The local APIC is not software enabled.
+
+  @return The base address of local APIC
+
+**/
+UINTN
+EFIAPI
+InternalX86GetApicBase (
+  VOID
+  )
+{
+  UINTN                             MsrValue;
+  UINTN                             ApicBase;
+
+  MsrValue = (UINTN) AsmReadMsr64 (27);
+  ApicBase = MsrValue & 0xffffff000ULL;
+
+  //
+  // Check the APIC Global Enable bit (bit 11) in IA32_APIC_BASE MSR.
+  // This bit will be 1, if local APIC is globally enabled.
+  //
+  ASSERT ((MsrValue & BIT11) != 0);
+
+  //
+  // Check the APIC Extended Mode bit (bit 10) in IA32_APIC_BASE MSR.
+  // This bit will be 0, if local APIC is under XAPIC mode.
+  //
+  ASSERT ((MsrValue & BIT10) == 0);
+
+  //
+  // Check the APIC Software Enable/Disable bit (bit 8) in Spurious-Interrupt
+  // Vector Register.
+  // This bit will be 1, if local APIC is software enabled.
+  //
+  ASSERT ((MmioRead32 (ApicBase + APIC_SVR) & BIT8) != 0);
+
+  return ApicBase;
+}
+
+/**
+  Internal function to return the frequency of the local APIC timer.
+
+  @param  ApicBase  The base address of memory mapped registers of local APIC.
+
+  @return The frequency of the timer in Hz.
+
+**/
+UINT32
+EFIAPI
+InternalX86GetTimerFrequency (
+  IN      UINTN                     ApicBase
+  )
+{
+  return
+    PcdGet32(PcdFSBClock) /
+    mTimerLibLocalApicDivisor[MmioBitFieldRead32 (ApicBase + APIC_TDCR, 0, 3)];
+}
+
+/**
+  Internal function to read the current tick counter of local APIC.
+
+  @param  ApicBase  The base address of memory mapped registers of local APIC.
+
+  @return The tick counter read.
+
+**/
+INT32
+EFIAPI
+InternalX86GetTimerTick (
+  IN      UINTN                     ApicBase
+  )
+{
+  return MmioRead32 (ApicBase + APIC_TMCCT);
+}
+
+/**
+  Internal function to read the initial timer count of local APIC.
+
+  @param  ApicBase  The base address of memory mapped registers of local APIC.
+
+  @return The initial timer count read.
+
+**/
+UINT32
+InternalX86GetInitTimerCount (
+  IN      UINTN                     ApicBase
+  )
+{
+  return MmioRead32 (ApicBase + APIC_TMICT);
+}
+
+/**
+  Stalls the CPU for at least the given number of ticks.
+
+  Stalls the CPU for at least the given number of ticks. It's invoked by
+  MicroSecondDelay() and NanoSecondDelay().
+
+  This function will ASSERT if the APIC timer intial count returned from
+  InternalX86GetInitTimerCount() is zero.
+
+  @param  ApicBase  The base address of memory mapped registers of local APIC.
+  @param  Delay     A period of time to delay in ticks.
+
+**/
+VOID
+EFIAPI
+InternalX86Delay (
+  IN      UINTN                     ApicBase,
+  IN      UINT32                    Delay
+  )
+{
+  INT32                             Ticks;
+  UINT32                            Times;
+  UINT32                            InitCount;
+  UINT32                            StartTick;
+
+  //
+  // In case Delay is too larger, separate it into several small delay slot.
+  // Devided Delay by half value of Init Count is to avoid Delay close to
+  // the Init Count, timeout maybe missing if the time consuming between 2
+  // GetApicTimerCurrentCount() invoking is larger than the time gap between
+  // Delay and the Init Count.
+  //
+  InitCount = InternalX86GetInitTimerCount (ApicBase);
+  ASSERT (InitCount != 0);
+  Times     = Delay / (InitCount / 2);
+  Delay     = Delay % (InitCount / 2);
+
+  //
+  // Get Start Tick and do delay
+  //
+  StartTick  = InternalX86GetTimerTick (ApicBase);
+  do {
+    //
+    // Wait until time out by Delay value
+    //
+    do {
+      CpuPause ();
+      //
+      // Get Ticks from Start to Current.
+      //
+      Ticks = StartTick - InternalX86GetTimerTick (ApicBase);
+      //
+      // Ticks < 0 means Timer wrap-arounds happens.
+      //
+      if (Ticks < 0) {
+        Ticks += InitCount;
+      }
+    } while ((UINT32)Ticks < Delay);
+
+    //
+    // Update StartTick and Delay for next delay slot
+    //
+    StartTick -= (StartTick > Delay) ?  Delay : (Delay - InitCount);
+    Delay      = InitCount / 2;
+  } while (Times-- > 0);
+}
+
+/**
+  Stalls the CPU for at least the given number of microseconds.
+
+  Stalls the CPU for the number of microseconds specified by MicroSeconds.
+
+  @param  MicroSeconds  The minimum number of microseconds to delay.
+
+  @return The value of MicroSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+MicroSecondDelay (
+  IN      UINTN                     MicroSeconds
+  )
+{
+  UINTN                             ApicBase;
+
+  ApicBase = InternalX86GetApicBase ();
+  InternalX86Delay (
+    ApicBase,
+    (UINT32)DivU64x32 (
+              MultU64x64 (
+                InternalX86GetTimerFrequency (ApicBase),
+                MicroSeconds
+                ),
+              1000000u
+              )
+    );
+  return MicroSeconds;
+}
+
+/**
+  Stalls the CPU for at least the given number of nanoseconds.
+
+  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
+
+  @param  NanoSeconds The minimum number of nanoseconds to delay.
+
+  @return The value of NanoSeconds inputted.
+
+**/
+UINTN
+EFIAPI
+NanoSecondDelay (
+  IN      UINTN                     NanoSeconds
+  )
+{
+  UINTN                             ApicBase;
+
+  ApicBase = InternalX86GetApicBase ();
+  InternalX86Delay (
+    ApicBase,
+    (UINT32)DivU64x32 (
+              MultU64x64 (
+                InternalX86GetTimerFrequency (ApicBase),
+                NanoSeconds
+                ),
+              1000000000u
+              )
+    );
+  return NanoSeconds;
+}
+
+/**
+  Retrieves the current value of a 64-bit free running performance counter.
+
+  The counter can either count up by 1 or count down by 1. If the physical
+  performance counter counts by a larger increment, then the counter values
+  must be translated. The properties of the counter can be retrieved from
+  GetPerformanceCounterProperties().
+
+  @return The current value of the free running performance counter.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounter (
+  VOID
+  )
+{
+  return (UINT64)(UINT32)InternalX86GetTimerTick (InternalX86GetApicBase ());
+}
+
+/**
+  Retrieves the 64-bit frequency in Hz and the range of performance counter
+  values.
+
+  If StartValue is not NULL, then the value that the performance counter starts
+  with immediately after is it rolls over is returned in StartValue. If
+  EndValue is not NULL, then the value that the performance counter end with
+  immediately before it rolls over is returned in EndValue. The 64-bit
+  frequency of the performance counter in Hz is always returned. If StartValue
+  is less than EndValue, then the performance counter counts up. If StartValue
+  is greater than EndValue, then the performance counter counts down. For
+  example, a 64-bit free running counter that counts up would have a StartValue
+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
+
+  @param  StartValue  The value the performance counter starts with when it
+                      rolls over.
+  @param  EndValue    The value that the performance counter ends with before
+                      it rolls over.
+
+  @return The frequency in Hz.
+
+**/
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  OUT      UINT64                    *StartValue,  OPTIONAL
+  OUT      UINT64                    *EndValue     OPTIONAL
+  )
+{
+  UINTN                             ApicBase;
+
+  ApicBase = InternalX86GetApicBase ();
+
+  if (StartValue != NULL) {
+    *StartValue = (UINT64)InternalX86GetInitTimerCount (ApicBase);
+  }
+
+  if (EndValue != NULL) {
+    *EndValue = 0;
+  }
+
+  return (UINT64) InternalX86GetTimerFrequency (ApicBase);
+}
+
+/**
+  Converts elapsed ticks of performance counter to time in nanoseconds.
+
+  This function converts the elapsed ticks of running performance counter to
+  time value in unit of nanoseconds.
+
+  @param  Ticks     The number of elapsed ticks of running performance counter.
+
+  @return The elapsed time in nanoseconds.
+
+**/
+UINT64
+EFIAPI
+GetTimeInNanoSecond (
+  IN      UINT64                     Ticks
+  )
+{
+  UINT64  Frequency;
+  UINT64  NanoSeconds;
+  UINT64  Remainder;
+  INTN    Shift;
+
+  Frequency = GetPerformanceCounterProperties (NULL, NULL);
+
+  //
+  //          Ticks
+  // Time = --------- x 1,000,000,000
+  //        Frequency
+  //
+  NanoSeconds = MultU64x32 (DivU64x64Remainder (Ticks, Frequency, &Remainder), 1000000000u);
+
+  //
+  // Ensure (Remainder * 1,000,000,000) will not overflow 64-bit.
+  // Since 2^29 < 1,000,000,000 = 0x3B9ACA00 < 2^30, Remainder should < 2^(64-30) = 2^34,
+  // i.e. highest bit set in Remainder should <= 33.
+  //
+  Shift = MAX (0, HighBitSet64 (Remainder) - 33);
+  Remainder = RShiftU64 (Remainder, (UINTN) Shift);
+  Frequency = RShiftU64 (Frequency, (UINTN) Shift);
+  NanoSeconds += DivU64x64Remainder (MultU64x32 (Remainder, 1000000000u), Frequency, NULL);
+
+  return NanoSeconds;
+}
diff --git a/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.c b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.c
new file mode 100644
index 000000000000..813d33b7778a
--- /dev/null
+++ b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.c
@@ -0,0 +1,72 @@
+/** @file
+  NULL instance of SmiHandlerProfile 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.
+
+**/
+
+#include <PiSmm.h>
+#include <Library/SmiHandlerProfileLib.h>
+
+/**
+  This function is called by SmmChildDispatcher module to report
+  a new SMI handler is registered, to SmmCore.
+
+  @param HandlerGuid     The GUID to identify the type of the handler.
+                         For the SmmChildDispatch protocol, the HandlerGuid
+                         must be the GUID of SmmChildDispatch protocol.
+  @param Handler         The SMI handler.
+  @param CallerAddress   The address of the module who registers the SMI handler.
+  @param Context         The context of the SMI handler.
+                         For the SmmChildDispatch protocol, the Context
+                         must match the one defined for SmmChildDispatch protocol.
+  @param ContextSize     The size of the context in bytes.
+                         For the SmmChildDispatch protocol, the Context
+                         must match the one defined for SmmChildDispatch protocol.
+
+  @retval EFI_SUCCESS           The information is recorded.
+  @retval EFI_UNSUPPORTED       The feature is unsupported.
+  @retval EFI_OUT_OF_RESOURCES  There is no enough resource to record the information.
+**/
+EFI_STATUS
+EFIAPI
+SmiHandlerProfileRegisterHandler (
+  IN EFI_GUID                       *HandlerGuid,
+  IN EFI_SMM_HANDLER_ENTRY_POINT2   Handler,
+  IN PHYSICAL_ADDRESS               CallerAddress,
+  IN VOID                           *Context, OPTIONAL
+  IN UINTN                          ContextSize OPTIONAL
+  )
+{
+  return EFI_UNSUPPORTED;
+}
+
+/**
+  This function is called by SmmChildDispatcher module to report
+  an existing SMI handler is unregistered, to SmmCore.
+
+  @param HandlerGuid     The GUID to identify the type of the handler.
+                         For the SmmChildDispatch protocol, the HandlerGuid
+                         must be the GUID of SmmChildDispatch protocol.
+  @param Handler         The SMI handler.
+
+  @retval EFI_SUCCESS           The original record is removed.
+  @retval EFI_UNSUPPORTED       The feature is unsupported.
+  @retval EFI_NOT_FOUND         There is no record for the HandlerGuid and handler.
+**/
+EFI_STATUS
+EFIAPI
+SmiHandlerProfileUnregisterHandler (
+  IN EFI_GUID                       *HandlerGuid,
+  IN EFI_SMM_HANDLER_ENTRY_POINT2   Handler
+  )
+{
+  return EFI_UNSUPPORTED;
+}
diff --git a/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.inf b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.inf
new file mode 100644
index 000000000000..e0b9d9386755
--- /dev/null
+++ b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.inf
@@ -0,0 +1,36 @@
+## @file
+# NULL instance of SmiHandlerProfile 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmiHandlerProfileLibNull
+  MODULE_UNI_FILE                = SmiHandlerProfileLibNull.uni
+  FILE_GUID                      = B43D1B52-6251-4E6F-82EC-A599A5EE94C1
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmiHandlerProfileLib|DXE_SMM_DRIVER SMM_CORE
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  SmiHandlerProfileLibNull.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.uni b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.uni
new file mode 100644
index 000000000000..5d7e75be6fd5
--- /dev/null
+++ b/MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// NULL instance of SmiHandlerProfile Library.
+//
+// NULL instance of SmiHandlerProfile 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "NULL instance of SmiHandlerProfile Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "NULL instance of SmiHandlerProfile Library."
+
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/IoHighLevel.c b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoHighLevel.c
new file mode 100644
index 000000000000..e8f007f74728
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoHighLevel.c
@@ -0,0 +1,2312 @@
+/** @file
+  High-level Io/Mmio functions.
+
+  All assertions for bit field operations are handled bit field functions in the
+  Base Library.
+
+  Copyright (c) 2009 - 2012, 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.
+
+  The following IoLib instances share the same version of this file:
+
+    BaseIoLibIntrinsic
+    DxeIoLibCpuIo
+    PeiIoLibCpuIo
+    SmmIoLibCpuIo
+**/
+
+#include "SmmCpuIoLibInternal.h"
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) | OrData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAnd8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (Port, (UINT8) (IoRead8 (Port) & AndData));
+}
+
+/**
+  Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (Port, (UINT8) ((IoRead8 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in an 8-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldRead8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldWrite8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 8-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 8-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAnd8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 8-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoBitFieldAndThenOr8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return IoWrite8 (
+           Port,
+           BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) | OrData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAnd16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (Port, (UINT16) (IoRead16 (Port) & AndData));
+}
+
+/**
+  Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (Port, (UINT16) ((IoRead16 (Port) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 16-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldRead16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldWrite16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 16-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 16-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAnd16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 16-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoBitFieldAndThenOr16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return IoWrite16 (
+           Port,
+           BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) | OrData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAnd32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (Port, IoRead32 (Port) & AndData);
+}
+
+/**
+  Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 32-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldRead32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldWrite32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 32-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 32-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAnd32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 32-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoBitFieldAndThenOr32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return IoWrite32 (
+           Port,
+           BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise OR, and writes the
+  result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  OrData  The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) | OrData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back
+  to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAnd64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (Port, IoRead64 (Port) & AndData);
+}
+
+/**
+  Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, performs a bitwise OR
+  between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 64-bit I/O port specified by Port. The value
+  written to the I/O port is returned. This function must guarantee that all
+  I/O read and write operations are serialized.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  AndData The value to AND with the read value from the I/O port.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of an I/O register.
+
+  Reads the bit field in a 64-bit I/O register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Port      The I/O port to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldRead64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to an I/O register.
+
+  Writes Value to the bit field of the I/O register. The bit field is specified
+  by the StartBit and the EndBit. All other bits in the destination I/O
+  register are preserved. The value written to the I/O port is returned. Extra
+  left bits in Value are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldWrite64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise OR
+  between the read result and the value specified by OrData, and writes the
+  result to the 64-bit I/O port specified by Port. The value written to the I/O
+  port is returned. This function must guarantee that all I/O read and write
+  operations are serialized. Extra left bits in OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the
+  result back to the bit field in the 64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND between
+  the read result and the value specified by AndData, and writes the result to
+  the 64-bit I/O port specified by Port. The value written to the I/O port is
+  returned. This function must guarantee that all I/O read and write operations
+  are serialized. Extra left bits in AndData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAnd64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  64-bit port.
+
+  Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed
+  by a bitwise OR between the read result and the value specified by
+  AndData, and writes the result to the 64-bit I/O port specified by Port. The
+  value written to the I/O port is returned. This function must guarantee that
+  all I/O read and write operations are serialized. Extra left bits in both
+  AndData and OrData are stripped.
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Port      The I/O port to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with the read value from the I/O port.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoBitFieldAndThenOr64 (
+  IN      UINTN                     Port,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return IoWrite64 (
+           Port,
+           BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) | OrData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) & AndData));
+}
+
+/**
+  Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 8-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (Address, (UINT8) ((MmioRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in an 8-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 8-bit register is returned.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 8-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 8-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 8-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return MmioWrite8 (
+           Address,
+           BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) | OrData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) & AndData));
+}
+
+/**
+  Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 16-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (Address, (UINT16) ((MmioRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 16-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 16-bit register is returned.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 16-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 16-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 16-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return MmioWrite16 (
+           Address,
+           BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) | OrData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (Address, MmioRead32 (Address) & AndData);
+}
+
+/**
+  Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 32-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 32-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 32-bit register is returned.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 32-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 32-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 32-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return MmioWrite32 (
+           Address,
+           BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise OR, and writes the
+  result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  OrData  The value to OR with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) | OrData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result
+  back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAnd64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (Address, MmioRead64 (Address) & AndData);
+}
+
+/**
+  Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise
+  inclusive OR, and writes the result back to the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, performs a
+  bitwise OR between the result of the AND operation and the value specified by
+  OrData, and writes the result to the 64-bit MMIO register specified by
+  Address. The value written to the MMIO register is returned. This function
+  must guarantee that all MMIO read and write operations are serialized.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+
+  @param  Address The MMIO register to write.
+  @param  AndData The value to AND with the read value from the MMIO register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a MMIO register.
+
+  Reads the bit field in a 64-bit MMIO register. The bit field is specified by
+  the StartBit and the EndBit. The value of the bit field is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The MMIO register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldRead64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a MMIO register.
+
+  Writes Value to the bit field of the MMIO register. The bit field is
+  specified by the StartBit and the EndBit. All other bits in the destination
+  MMIO register are preserved. The new value of the 64-bit register is returned.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldWrite64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    Value
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise
+  inclusive OR between the read result and the value specified by OrData, and
+  writes the result to the 64-bit MMIO register specified by Address. The value
+  written to the MMIO register is returned. This function must guarantee that
+  all MMIO read and write operations are serialized. Extra left bits in OrData
+  are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  OrData    The value to OR with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and
+  writes the result back to the bit field in the 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  between the read result and the value specified by AndData, and writes the
+  result to the 64-bit MMIO register specified by Address. The value written to
+  the MMIO register is returned. This function must guarantee that all MMIO
+  read and write operations are serialized. Extra left bits in AndData are
+  stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAnd64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed
+  by a bitwise OR, and writes the result back to the bit field in the
+  64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address, performs a bitwise AND
+  followed by a bitwise OR between the read result and the value
+  specified by AndData, and writes the result to the 64-bit MMIO register
+  specified by Address. The value written to the MMIO register is returned.
+  This function must guarantee that all MMIO read and write operations are
+  serialized. Extra left bits in both AndData and OrData are stripped.
+
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+  If StartBit is greater than 63, then ASSERT().
+  If EndBit is greater than 63, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The MMIO register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..63.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..63.
+  @param  AndData   The value to AND with read value from the MMIO register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioBitFieldAndThenOr64 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT64                    AndData,
+  IN      UINT64                    OrData
+  )
+{
+  return MmioWrite64 (
+           Address,
+           BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLib.c b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLib.c
new file mode 100644
index 000000000000..8264886d2400
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLib.c
@@ -0,0 +1,803 @@
+/** @file
+  I/O Library.
+  The implementation of I/O operation for this library instance 
+  are based on EFI_CPU_IO_PROTOCOL.
+  
+  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2017, AMD Incorporated. 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 "SmmCpuIoLibInternal.h"
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all I/O read and write operations are serialized.
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI CPU I/O space.
+
+**/
+UINT64
+EFIAPI
+IoReadWorker (
+  IN      UINTN                     Port,
+  IN      EFI_SMM_IO_WIDTH          Width
+  )
+{
+  EFI_STATUS                        Status;
+  UINT64                            Data;
+
+  Status = gSmst->SmmIo.Io.Read (&gSmst->SmmIo, Width, Port, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width and value specified by Width
+  and Data respectively.  Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all I/O read and write operations are serialized.
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+
+  @return The parameter of Data.
+
+**/
+UINT64
+EFIAPI
+IoWriteWorker (
+  IN      UINTN                     Port,
+  IN      EFI_SMM_IO_WIDTH          Width,
+  IN      UINT64                    Data
+  )
+{
+  EFI_STATUS                        Status;
+
+  Status = gSmst->SmmIo.Io.Write (&gSmst->SmmIo, Width, Port, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Reads memory-mapped registers in the EFI system memory space.
+
+  Reads the MMIO registers specified by Address with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioReadWorker (
+  IN      UINTN                     Address,
+  IN      EFI_SMM_IO_WIDTH          Width
+  )
+{
+  EFI_STATUS                        Status;
+  UINT64                            Data;
+
+  Status = gSmst->SmmIo.Mem.Read (&gSmst->SmmIo, Width, Address, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Writes memory-mapped registers in the EFI system memory space.
+
+  Writes the MMIO registers specified by Address with registers width and value specified by Width
+  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+  
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioWriteWorker (
+  IN      UINTN                     Address,
+  IN      EFI_SMM_IO_WIDTH          Width,
+  IN      UINT64                    Data
+  )
+{
+  EFI_STATUS                        Status;
+
+  Status = gSmst->SmmIo.Mem.Write (&gSmst->SmmIo, Width, Address, 1, &Data);
+  ASSERT_EFI_ERROR (Status);
+
+  return Data;
+}
+
+/**
+  Reads an 8-bit I/O port.
+
+  Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+IoRead8 (
+  IN      UINTN                     Port
+  )
+{
+  return (UINT8)IoReadWorker (Port, SMM_IO_UINT8);
+}
+
+/**
+  Writes an 8-bit I/O port.
+
+  Writes the 8-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT8
+EFIAPI
+IoWrite8 (
+  IN      UINTN                     Port,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)IoWriteWorker (Port, SMM_IO_UINT8, Value);
+}
+
+/**
+  Reads a 16-bit I/O port.
+
+  Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+IoRead16 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoReadWorker (Port, SMM_IO_UINT16);
+}
+
+/**
+  Writes a 16-bit I/O port.
+
+  Writes the 16-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 16-bit boundary, then ASSERT().
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT16
+EFIAPI
+IoWrite16 (
+  IN      UINTN                     Port,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  return (UINT16)IoWriteWorker (Port, SMM_IO_UINT16, Value);
+}
+
+/**
+  Reads a 32-bit I/O port.
+
+  Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+ 
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+IoRead32 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoReadWorker (Port, SMM_IO_UINT32);
+}
+
+/**
+  Writes a 32-bit I/O port.
+
+  Writes the 32-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 32-bit boundary, then ASSERT().
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT32
+EFIAPI
+IoWrite32 (
+  IN      UINTN                     Port,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  return (UINT32)IoWriteWorker (Port, SMM_IO_UINT32, Value);
+}
+
+/**
+  Reads a 64-bit I/O port.
+
+  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+IoRead64 (
+  IN      UINTN                     Port
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoReadWorker (Port, SMM_IO_UINT64);
+}
+
+/**
+  Writes a 64-bit I/O port.
+
+  Writes the 64-bit I/O port specified by Port with the value specified by Value
+  and returns Value. This function must guarantee that all I/O read and write
+  operations are serialized.
+
+  If Port is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port  The I/O port to write.
+  @param  Value The value to write to the I/O port.
+
+  @return The value written the I/O port.
+
+**/
+UINT64
+EFIAPI
+IoWrite64 (
+  IN      UINTN                     Port,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Port is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Port & 7) == 0);
+  return IoWriteWorker (Port, SMM_IO_UINT64, Value);
+}
+
+/**
+  Reads an 8-bit I/O port fifo into a block of memory.
+
+  Reads the 8-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT8 *Buffer8;
+
+  Buffer8 = (UINT8 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer8++ = IoRead8 (Port);
+  }
+}
+
+/**
+  Writes a block of memory into an 8-bit I/O port fifo.
+
+  Writes the 8-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 8-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo8 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT8 *Buffer8;
+
+  Buffer8 = (UINT8 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite8 (Port, *Buffer8++);
+  }
+}
+
+/**
+  Reads a 16-bit I/O port fifo into a block of memory.
+
+  Reads the 16-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT16 *Buffer16;
+
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  Buffer16 = (UINT16 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer16++ = IoRead16 (Port);
+  }
+}
+
+/**
+  Writes a block of memory into a 16-bit I/O port fifo.
+
+  Writes the 16-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 16-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo16 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT16 *Buffer16;
+
+  //
+  // Make sure Port is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Port & 1) == 0);
+  Buffer16 = (UINT16 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite16 (Port, *Buffer16++);
+  }
+}
+
+/**
+  Reads a 32-bit I/O port fifo into a block of memory.
+
+  Reads the 32-bit I/O fifo port specified by Port.
+  The port is read Count times, and the read data is
+  stored in the provided Buffer.
+
+  This function must guarantee that all I/O read and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to read.
+  @param  Count   The number of times to read I/O port.
+  @param  Buffer  The buffer to store the read data into.
+
+**/
+VOID
+EFIAPI
+IoReadFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINT32 *Buffer32;
+
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  Buffer32 = (UINT32 *)Buffer;
+  while (Count-- > 0) {
+    *Buffer32++ = IoRead32 (Port);
+  }
+}
+
+/**
+  Writes a block of memory into a 32-bit I/O port fifo.
+
+  Writes the 32-bit I/O fifo port specified by Port.
+  The port is written Count times, and the write data is
+  retrieved from the provided Buffer.
+
+  This function must guarantee that all I/O write and write operations are
+  serialized.
+
+  If 32-bit I/O port operations are not supported, then ASSERT().
+
+  @param  Port    The I/O port to write.
+  @param  Count   The number of times to write I/O port.
+  @param  Buffer  The buffer to retrieve the write data from.
+
+**/
+VOID
+EFIAPI
+IoWriteFifo32 (
+  IN      UINTN                     Port,
+  IN      UINTN                     Count,
+  IN      VOID                      *Buffer
+  )
+{
+  UINT32 *Buffer32;
+
+  //
+  // Make sure Port is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Port & 3) == 0);
+  Buffer32 = (UINT32 *)Buffer;
+  while (Count-- > 0) {
+    IoWrite32 (Port, *Buffer32++);
+  }
+}
+
+/**
+  Reads an 8-bit MMIO register.
+
+  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT8
+EFIAPI
+MmioRead8 (
+  IN      UINTN                     Address
+  )
+{
+  return (UINT8)MmioReadWorker (Address, SMM_IO_UINT8);
+}
+
+/**
+  Writes an 8-bit MMIO register.
+
+  Writes the 8-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If 8-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT8
+EFIAPI
+MmioWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  return (UINT8)MmioWriteWorker (Address, SMM_IO_UINT8, Value);
+}
+
+/**
+  Reads a 16-bit MMIO register.
+
+  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT16
+EFIAPI
+MmioRead16 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioReadWorker (Address, SMM_IO_UINT16);
+}
+
+/**
+  Writes a 16-bit MMIO register.
+
+  Writes the 16-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  If 16-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT16
+EFIAPI
+MmioWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 16-bit boundary.
+  //
+  ASSERT ((Address & 1) == 0);
+  return (UINT16)MmioWriteWorker (Address, SMM_IO_UINT16, Value);
+}
+
+/**
+  Reads a 32-bit MMIO register.
+
+  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT32
+EFIAPI
+MmioRead32 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioReadWorker (Address, SMM_IO_UINT32);
+}
+
+/**
+  Writes a 32-bit MMIO register.
+
+  Writes the 32-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+ 
+  If 32-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT32
+EFIAPI
+MmioWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 32-bit boundary.
+  //
+  ASSERT ((Address & 3) == 0);
+  return (UINT32)MmioWriteWorker (Address, SMM_IO_UINT32, Value);
+}
+
+/**
+  Reads a 64-bit MMIO register.
+
+  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
+  returned. This function must guarantee that all MMIO read and write
+  operations are serialized.
+
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to read.
+
+  @return The value read.
+
+**/
+UINT64
+EFIAPI
+MmioRead64 (
+  IN      UINTN                     Address
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioReadWorker (Address, SMM_IO_UINT64);
+}
+
+/**
+  Writes a 64-bit MMIO register.
+
+  Writes the 64-bit MMIO register specified by Address with the value specified
+  by Value and returns Value. This function must guarantee that all MMIO read
+  and write operations are serialized.
+
+  If Address is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If 64-bit MMIO register operations are not supported, then ASSERT().
+
+  @param  Address The MMIO register to write.
+  @param  Value   The value to write to the MMIO register.
+
+**/
+UINT64
+EFIAPI
+MmioWrite64 (
+  IN      UINTN                     Address,
+  IN      UINT64                    Value
+  )
+{
+  //
+  // Make sure Address is aligned on a 64-bit boundary.
+  //
+  ASSERT ((Address & 7) == 0);
+  return (UINT64)MmioWriteWorker (Address, SMM_IO_UINT64, Value);
+}
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLibMmioBuffer.c b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLibMmioBuffer.c
new file mode 100644
index 000000000000..e853b158c563
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/IoLibMmioBuffer.c
@@ -0,0 +1,417 @@
+/** @file
+  I/O Library MMIO Buffer Functions.
+
+  Copyright (c) 2009 - 2010, 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 "SmmCpuIoLibInternal.h"
+
+/**
+  Copy data from MMIO region to system memory by using 8-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 8-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioReadBuffer8 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT8       *Buffer
+  )
+{
+  UINT8   *ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ReturnBuffer = Buffer;
+
+  while (Length-- > 0) {
+    *(Buffer++) = MmioRead8 (StartAddress++);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 16-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 16-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioReadBuffer16 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT16      *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead16 (StartAddress);
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 32-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 32-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioReadBuffer32 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT32      *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead32 (StartAddress);
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from MMIO region to system memory by using 64-bit access.
+
+  Copy data from MMIO region specified by starting address StartAddress
+  to system memory specified by Buffer by using 64-bit access. The total
+  number of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+ 
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied from.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer receiving the data read.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioReadBuffer64 (
+  IN  UINTN       StartAddress,
+  IN  UINTN       Length,
+  OUT UINT64      *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = Buffer;
+
+  while (Length > 0) {
+    *(Buffer++) = MmioRead64 (StartAddress);
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 8-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 8-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the 
+                          data to write.
+
+  @return Buffer
+
+**/
+UINT8 *
+EFIAPI
+MmioWriteBuffer8 (
+  IN  UINTN         StartAddress,
+  IN  UINTN         Length,
+  IN  CONST UINT8   *Buffer
+  )
+{
+  VOID* ReturnBuffer;
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ReturnBuffer = (UINT8 *) Buffer;
+
+  while (Length-- > 0) {
+     MmioWrite8 (StartAddress++, *(Buffer++));
+  }
+
+  return ReturnBuffer;
+
+}
+
+/**
+  Copy data from system memory to MMIO region by using 16-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 16-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the 
+                          data to write.
+
+  @return Buffer
+
+**/
+UINT16 *
+EFIAPI
+MmioWriteBuffer16 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT16 *Buffer
+  )
+{
+  UINT16    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT16) - 1)) == 0);
+
+  ReturnBuffer = (UINT16 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite16 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT16);
+    Length -= sizeof (UINT16);
+  }
+
+  return ReturnBuffer;
+}
+
+
+/**
+  Copy data from system memory to MMIO region by using 32-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 32-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the 
+                          data to write.
+
+  @return Buffer
+
+**/
+UINT32 *
+EFIAPI
+MmioWriteBuffer32 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT32 *Buffer
+  )
+{
+  UINT32    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT32) - 1)) == 0);
+
+  ReturnBuffer = (UINT32 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite32 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT32);
+    Length -= sizeof (UINT32);
+  }
+
+  return ReturnBuffer;
+}
+
+/**
+  Copy data from system memory to MMIO region by using 64-bit access.
+
+  Copy data from system memory specified by Buffer to MMIO region specified
+  by starting address StartAddress by using 64-bit access. The total number
+  of byte to be copied is specified by Length. Buffer is returned.
+
+  If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
+
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  StartAddress    The starting address for the MMIO region to be copied to.
+  @param  Length          The size in bytes of the copy.
+  @param  Buffer          The pointer to a system memory buffer containing the 
+                          data to write.
+
+  @return Buffer
+
+**/
+UINT64 *
+EFIAPI
+MmioWriteBuffer64 (
+  IN  UINTN        StartAddress,
+  IN  UINTN        Length,
+  IN  CONST UINT64 *Buffer
+  )
+{
+  UINT64    *ReturnBuffer;
+
+  ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
+
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - StartAddress));
+  ASSERT ((Length - 1) <=  (MAX_ADDRESS - (UINTN) Buffer));
+
+  ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
+  ASSERT (((UINTN) Buffer & (sizeof (UINT64) - 1)) == 0);
+
+  ReturnBuffer = (UINT64 *) Buffer;
+
+  while (Length > 0) {
+    MmioWrite64 (StartAddress, *(Buffer++));
+
+    StartAddress += sizeof (UINT64);
+    Length -= sizeof (UINT64);
+  }
+
+  return ReturnBuffer;
+}
+
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmCpuIoLibInternal.h b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmCpuIoLibInternal.h
new file mode 100644
index 000000000000..d1943ae72d68
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmCpuIoLibInternal.h
@@ -0,0 +1,118 @@
+/** @file
+  Internal include file of SMM CPU IO Library.
+  It includes all necessary protocol/library class's header file
+  for implementation of IoLib library instance. It is included 
+  all source code of this library instance.
+  
+  Copyright (c) 2009 - 2010, 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 _SMM_CPUIO_LIB_INTERNAL_H_
+#define _SMM_CPUIO_LIB_INTERNAL_H_
+
+#include <PiSmm.h>
+#include <Protocol/SmmCpuIo2.h>
+#include <Protocol/SmmPciRootBridgeIo.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/SmmServicesTableLib.h>
+
+
+/**
+  Reads registers in the EFI CPU I/O space.
+
+  Reads the I/O port specified by Port with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all I/O read and write operations are serialized.
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI CPU I/O space.
+
+**/
+UINT64
+EFIAPI
+IoReadWorker (
+  IN      UINTN                     Port,
+  IN      EFI_SMM_IO_WIDTH          Width
+  );
+
+/**
+  Writes registers in the EFI CPU I/O space.
+
+  Writes the I/O port specified by Port with registers width and value specified by Width
+  and Data respectively.  Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all I/O read and write operations are serialized.
+
+  @param  Port          The base address of the I/O operation.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+
+  @return The parameter of Data.
+
+**/
+UINT64
+EFIAPI
+IoWriteWorker (
+  IN      UINTN                     Port,
+  IN      EFI_SMM_IO_WIDTH          Width,
+  IN      UINT64                    Data
+  );
+
+/**
+  Reads memory-mapped registers in the EFI system memory space.
+
+  Reads the MMIO registers specified by Address with registers width specified by Width.
+  The read value is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioReadWorker (
+  IN      UINTN                     Address,
+  IN      EFI_SMM_IO_WIDTH          Width
+  );
+
+/**
+  Writes memory-mapped registers in the EFI system memory space.
+
+  Writes the MMIO registers specified by Address with registers width and value specified by Width
+  and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
+  This function must guarantee that all MMIO read and write operations are serialized.
+
+  @param  Address       The MMIO register to read.
+                        The caller is responsible for aligning the Address if required.
+  @param  Width         The width of the I/O operation.
+  @param  Data          The value to write to the I/O port.
+  
+  @return Data read from registers in the EFI system memory space.
+
+**/
+UINT64
+EFIAPI
+MmioWriteWorker (
+  IN      UINTN                     Address,
+  IN      EFI_SMM_IO_WIDTH          Width,
+  IN      UINT64                    Data
+  );
+
+#endif
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.inf b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.inf
new file mode 100644
index 000000000000..5cfd4e5466fe
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.inf
@@ -0,0 +1,49 @@
+## @file
+# SMM Instance of I/O Library using SMM CPU I/O 2 Protocol.
+#
+# I/O Library SMM implementation that uses SMM CPU I/O 2 Protocol for I/O
+#  and MMIO operations.
+# Copyright (c) 2009 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmIoLibSmmCpuIo2
+  MODULE_UNI_FILE                = SmmIoLibSmmCpuIo2.uni
+  FILE_GUID                      = DEEEA15E-4A77-4513-BA75-71D26FEF78A1
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = IoLib|DXE_SMM_DRIVER SMM_CORE
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  IoLibMmioBuffer.c
+  SmmCpuIoLibInternal.h
+  IoHighLevel.c
+  IoLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  DebugLib
+  SmmServicesTableLib
+
+[Depex.common.DXE_SMM_DRIVER]
+  gEfiSmmCpuIo2ProtocolGuid
+
diff --git a/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.uni b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.uni
new file mode 100644
index 000000000000..bc800c985d58
--- /dev/null
+++ b/MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.uni
@@ -0,0 +1,22 @@
+// /** @file
+// SMM Instance of I/O Library using SMM CPU I/O 2 Protocol.
+//
+// I/O Library SMM implementation that uses SMM CPU I/O 2 Protocol for I/O
+// and MMIO operations.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "The SMM Instance of I/O Library using SMM CPU I/O 2 Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This I/O Library SMM implementation uses the SMM CPU I/O 2 Protocol for I/O and MMIO operations."
+
diff --git a/MdePkg/Library/SmmLibNull/SmmLibNull.c b/MdePkg/Library/SmmLibNull/SmmLibNull.c
new file mode 100644
index 000000000000..dcedb478538d
--- /dev/null
+++ b/MdePkg/Library/SmmLibNull/SmmLibNull.c
@@ -0,0 +1,103 @@
+/** @file
+  NULL instance of SMM Library.
+
+  Copyright (c) 2009 - 2010, 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 <Base.h>
+#include <Library/SmmLib.h>
+
+/**
+  Triggers an SMI at boot time.  
+
+  This function triggers a software SMM interrupt at boot time.
+
+**/
+VOID
+EFIAPI
+TriggerBootServiceSoftwareSmi (
+  VOID
+  )
+{
+  return;
+}
+
+
+/**
+  Triggers an SMI at run time.  
+
+  This function triggers a software SMM interrupt at run time.
+
+**/
+VOID
+EFIAPI
+TriggerRuntimeSoftwareSmi (
+  VOID
+  )
+{
+  return;
+}
+
+
+
+/**
+  Test if a boot time software SMI happened.  
+
+  This function tests if a software SMM interrupt happened. If a software SMM 
+  interrupt happened and it was triggered at boot time, it returns TRUE. Otherwise, 
+  it returns FALSE.
+
+  @retval TRUE   A software SMI triggered at boot time happened.
+  @retval FALSE  No software SMI happened or the software SMI was triggered at run time.
+
+**/
+BOOLEAN
+EFIAPI
+IsBootServiceSoftwareSmi (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+
+/**
+  Test if a run time software SMI happened.  
+
+  This function tests if a software SMM interrupt happened. If a software SMM 
+  interrupt happened and it was triggered at run time, it returns TRUE. Otherwise, 
+  it returns FALSE.
+
+  @retval TRUE   A software SMI triggered at run time happened.
+  @retval FALSE  No software SMI happened or the software SMI was triggered at boot time.
+
+**/
+BOOLEAN
+EFIAPI
+IsRuntimeSoftwareSmi (
+  VOID
+  )
+{
+  return FALSE;
+}
+
+/**
+  Clear APM SMI Status Bit; Set the EOS bit. 
+  
+**/
+VOID
+EFIAPI
+ClearSmi (
+  VOID
+  )
+{
+  return;
+}
diff --git a/MdePkg/Library/SmmLibNull/SmmLibNull.inf b/MdePkg/Library/SmmLibNull/SmmLibNull.inf
new file mode 100644
index 000000000000..36bdb321f312
--- /dev/null
+++ b/MdePkg/Library/SmmLibNull/SmmLibNull.inf
@@ -0,0 +1,37 @@
+## @file
+# NULL instance of SMM Library.
+#
+#  Copyright (c) 2009 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmLibNull
+  MODULE_UNI_FILE                = SmmLibNull.uni
+  FILE_GUID                      = DDADFC93-FBC5-4389-B20F-EC99E4A6AE52
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmmLib
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  SmmLibNull.c
+  
+
+[Packages]
+  MdePkg/MdePkg.dec
+
diff --git a/MdePkg/Library/SmmLibNull/SmmLibNull.uni b/MdePkg/Library/SmmLibNull/SmmLibNull.uni
new file mode 100644
index 000000000000..578342c90191
--- /dev/null
+++ b/MdePkg/Library/SmmLibNull/SmmLibNull.uni
@@ -0,0 +1,21 @@
+// /** @file
+// NULL instance of SMM Library.
+//
+// NULL instance of SMM Library.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "NULL instance of SMM Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "NULL instance of SMM Library."
+
diff --git a/MdePkg/Library/SmmMemLib/SmmMemLib.c b/MdePkg/Library/SmmMemLib/SmmMemLib.c
new file mode 100644
index 000000000000..9a4f3bfaa4d8
--- /dev/null
+++ b/MdePkg/Library/SmmMemLib/SmmMemLib.c
@@ -0,0 +1,521 @@
+/** @file
+  Instance of SMM memory check library.
+
+  SMM memory check library library implementation. This library consumes SMM_ACCESS2_PROTOCOL
+  to get SMRAM information. In order to use this library instance, the platform should produce
+  all SMRAM range via SMM_ACCESS2_PROTOCOL, including the range for firmware (like SMM Core
+  and SMM driver) and/or specific dedicated hardware.
+
+  Copyright (c) 2015 - 2016, 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 <PiSmm.h>
+
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/SmmServicesTableLib.h>
+#include <Library/HobLib.h>
+#include <Protocol/SmmAccess2.h>
+#include <Protocol/SmmReadyToLock.h>
+#include <Protocol/SmmEndOfDxe.h>
+
+#define NEXT_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \
+  ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) + (Size)))
+
+EFI_SMRAM_DESCRIPTOR *mSmmMemLibInternalSmramRanges;
+UINTN                mSmmMemLibInternalSmramCount;
+
+//
+// Maximum support address used to check input buffer
+//
+EFI_PHYSICAL_ADDRESS  mSmmMemLibInternalMaximumSupportAddress = 0;
+
+UINTN                 mMemoryMapEntryCount;
+EFI_MEMORY_DESCRIPTOR *mMemoryMap;
+UINTN                 mDescriptorSize;
+
+VOID                  *mRegistrationEndOfDxe;
+VOID                  *mRegistrationReadyToLock;
+
+BOOLEAN               mSmmReadyToLock = FALSE;
+
+/**
+  Calculate and save the maximum support address.
+
+**/
+VOID
+SmmMemLibInternalCalculateMaximumSupportAddress (
+  VOID
+  )
+{
+  VOID         *Hob;
+  UINT32       RegEax;
+  UINT8        PhysicalAddressBits;
+
+  //
+  // Get physical address bits supported.
+  //
+  Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
+  if (Hob != NULL) {
+    PhysicalAddressBits = ((EFI_HOB_CPU *) Hob)->SizeOfMemorySpace;
+  } else {
+    AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
+    if (RegEax >= 0x80000008) {
+      AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
+      PhysicalAddressBits = (UINT8) RegEax;
+    } else {
+      PhysicalAddressBits = 36;
+    }
+  }
+  //
+  // IA-32e paging translates 48-bit linear addresses to 52-bit physical addresses.
+  //
+  ASSERT (PhysicalAddressBits <= 52);
+  if (PhysicalAddressBits > 48) {
+    PhysicalAddressBits = 48;
+  }
+  
+  //
+  // Save the maximum support address in one global variable  
+  //
+  mSmmMemLibInternalMaximumSupportAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)(LShiftU64 (1, PhysicalAddressBits) - 1);
+  DEBUG ((EFI_D_INFO, "mSmmMemLibInternalMaximumSupportAddress = 0x%lx\n", mSmmMemLibInternalMaximumSupportAddress));
+}
+
+/**
+  This function check if the buffer is valid per processor architecture and not overlap with SMRAM.
+
+  @param Buffer  The buffer start address to be checked.
+  @param Length  The buffer length to be checked.
+
+  @retval TRUE  This buffer is valid per processor architecture and not overlap with SMRAM.
+  @retval FALSE This buffer is not valid per processor architecture or overlap with SMRAM.
+**/
+BOOLEAN
+EFIAPI
+SmmIsBufferOutsideSmmValid (
+  IN EFI_PHYSICAL_ADDRESS  Buffer,
+  IN UINT64                Length
+  )
+{
+  UINTN  Index;
+  
+  //
+  // Check override.
+  // NOTE: (B:0->L:4G) is invalid for IA32, but (B:1->L:4G-1)/(B:4G-1->L:1) is valid.
+  //
+  if ((Length > mSmmMemLibInternalMaximumSupportAddress) ||
+      (Buffer > mSmmMemLibInternalMaximumSupportAddress) ||
+      ((Length != 0) && (Buffer > (mSmmMemLibInternalMaximumSupportAddress - (Length - 1)))) ) {
+    //
+    // Overflow happen
+    //
+    DEBUG ((
+      EFI_D_ERROR,
+      "SmmIsBufferOutsideSmmValid: Overflow: Buffer (0x%lx) - Length (0x%lx), MaximumSupportAddress (0x%lx)\n",
+      Buffer,
+      Length,
+      mSmmMemLibInternalMaximumSupportAddress
+      ));
+    return FALSE;
+  }
+  
+  for (Index = 0; Index < mSmmMemLibInternalSmramCount; Index ++) {
+    if (((Buffer >= mSmmMemLibInternalSmramRanges[Index].CpuStart) && (Buffer < mSmmMemLibInternalSmramRanges[Index].CpuStart + mSmmMemLibInternalSmramRanges[Index].PhysicalSize)) ||
+        ((mSmmMemLibInternalSmramRanges[Index].CpuStart >= Buffer) && (mSmmMemLibInternalSmramRanges[Index].CpuStart < Buffer + Length))) {
+      DEBUG ((
+        EFI_D_ERROR,
+        "SmmIsBufferOutsideSmmValid: Overlap: Buffer (0x%lx) - Length (0x%lx), ",
+        Buffer,
+        Length
+        ));
+      DEBUG ((
+        EFI_D_ERROR,
+        "CpuStart (0x%lx) - PhysicalSize (0x%lx)\n",
+        mSmmMemLibInternalSmramRanges[Index].CpuStart,
+        mSmmMemLibInternalSmramRanges[Index].PhysicalSize
+        ));
+      return FALSE;
+    }
+  }
+
+  //
+  // Check override for Valid Communication Region
+  //
+  if (mSmmReadyToLock) {
+    EFI_MEMORY_DESCRIPTOR          *MemoryMap;
+    BOOLEAN                        InValidCommunicationRegion;
+    
+    InValidCommunicationRegion = FALSE;
+    MemoryMap = mMemoryMap;
+    for (Index = 0; Index < mMemoryMapEntryCount; Index++) {
+      if ((Buffer >= MemoryMap->PhysicalStart) &&
+          (Buffer + Length <= MemoryMap->PhysicalStart + LShiftU64 (MemoryMap->NumberOfPages, EFI_PAGE_SHIFT))) {
+        InValidCommunicationRegion = TRUE;
+      }
+      MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, mDescriptorSize);
+    }
+
+    if (!InValidCommunicationRegion) {
+      DEBUG ((
+        EFI_D_ERROR,
+        "SmmIsBufferOutsideSmmValid: Not in ValidCommunicationRegion: Buffer (0x%lx) - Length (0x%lx), ",
+        Buffer,
+        Length
+        ));
+      ASSERT (FALSE);
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+
+/**
+  Copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if source buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it return EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant.
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMemToSmram (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)SourceBuffer, Length)) {
+    DEBUG ((EFI_D_ERROR, "SmmCopyMemToSmram: Security Violation: Source (0x%x), Length (0x%x)\n", SourceBuffer, Length));
+    return EFI_SECURITY_VIOLATION;
+  }
+  CopyMem (DestinationBuffer, SourceBuffer, Length);
+  return EFI_SUCCESS;
+}
+
+/**
+  Copies a source buffer (SMRAM) to a destination buffer (NON-SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if destination buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant.
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMemFromSmram (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)DestinationBuffer, Length)) {
+    DEBUG ((EFI_D_ERROR, "SmmCopyMemFromSmram: Security Violation: Destination (0x%x), Length (0x%x)\n", DestinationBuffer, Length));
+    return EFI_SECURITY_VIOLATION;
+  }
+  CopyMem (DestinationBuffer, SourceBuffer, Length);
+  return EFI_SUCCESS;
+}
+
+/**
+  Copies a source buffer (NON-SMRAM) to a destination buffer (NON-SMRAM).
+
+  This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
+  It checks if source buffer and destination buffer are valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it copies memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  The implementation must be reentrant, and it must handle the case where source buffer overlaps destination buffer.
+  
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is copied.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmCopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)DestinationBuffer, Length)) {
+    DEBUG ((EFI_D_ERROR, "SmmCopyMem: Security Violation: Destination (0x%x), Length (0x%x)\n", DestinationBuffer, Length));
+    return EFI_SECURITY_VIOLATION;
+  }
+  if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)SourceBuffer, Length)) {
+    DEBUG ((EFI_D_ERROR, "SmmCopyMem: Security Violation: Source (0x%x), Length (0x%x)\n", SourceBuffer, Length));
+    return EFI_SECURITY_VIOLATION;
+  }
+  CopyMem (DestinationBuffer, SourceBuffer, Length);
+  return EFI_SUCCESS;
+}
+
+/**
+  Fills a target buffer (NON-SMRAM) with a byte value.
+
+  This function fills a target buffer (non-SMRAM) with a byte value.
+  It checks if target buffer is valid per processor architecture and not overlap with SMRAM.
+  If the check passes, it fills memory and returns EFI_SUCCESS.
+  If the check fails, it returns EFI_SECURITY_VIOLATION.
+  
+  @param  Buffer    The memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+  
+  @retval EFI_SECURITY_VIOLATION The Buffer is invalid per processor architecture or overlap with SMRAM.
+  @retval EFI_SUCCESS            Memory is set.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmSetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, Length)) {
+    DEBUG ((EFI_D_ERROR, "SmmSetMem: Security Violation: Source (0x%x), Length (0x%x)\n", Buffer, Length));
+    return EFI_SECURITY_VIOLATION;
+  }
+  SetMem (Buffer, Length, Value);
+  return EFI_SUCCESS;
+}
+
+/**
+  Notification for SMM EndOfDxe protocol.
+
+  @param[in] Protocol   Points to the protocol's unique identifier.
+  @param[in] Interface  Points to the interface instance.
+  @param[in] Handle     The handle on which the interface was installed.
+
+  @retval EFI_SUCCESS   Notification runs successfully.
+**/
+EFI_STATUS
+EFIAPI
+SmmLibInternalEndOfDxeNotify (
+  IN CONST EFI_GUID  *Protocol,
+  IN VOID            *Interface,
+  IN EFI_HANDLE      Handle
+  )
+{
+  EFI_STATUS            Status;
+  UINTN                 MapKey;
+  UINTN                 MemoryMapSize;
+  EFI_MEMORY_DESCRIPTOR *MemoryMap;
+  EFI_MEMORY_DESCRIPTOR *MemoryMapStart;
+  EFI_MEMORY_DESCRIPTOR *SmmMemoryMapStart;
+  UINTN                 MemoryMapEntryCount;
+  UINTN                 DescriptorSize;
+  UINT32                DescriptorVersion;
+  UINTN                 Index;
+
+  MemoryMapSize = 0;
+  MemoryMap = NULL;
+  Status = gBS->GetMemoryMap (
+             &MemoryMapSize,
+             MemoryMap,
+             &MapKey,
+             &DescriptorSize,
+             &DescriptorVersion
+             );
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);
+
+  do {
+    Status = gBS->AllocatePool (EfiBootServicesData, MemoryMapSize, (VOID **)&MemoryMap);
+    ASSERT (MemoryMap != NULL);
+  
+    Status = gBS->GetMemoryMap (
+               &MemoryMapSize,
+               MemoryMap,
+               &MapKey,
+               &DescriptorSize,
+               &DescriptorVersion
+               );
+    if (EFI_ERROR (Status)) {
+      gBS->FreePool (MemoryMap);
+    }
+  } while (Status == EFI_BUFFER_TOO_SMALL);
+
+  //
+  // Get Count
+  //
+  mDescriptorSize = DescriptorSize;
+  MemoryMapEntryCount = MemoryMapSize/DescriptorSize;
+  MemoryMapStart = MemoryMap;
+  mMemoryMapEntryCount = 0;
+  for (Index = 0; Index < MemoryMapEntryCount; Index++) {
+    switch (MemoryMap->Type) {
+    case EfiReservedMemoryType:
+    case EfiRuntimeServicesCode:
+    case EfiRuntimeServicesData:
+    case EfiACPIMemoryNVS:
+      mMemoryMapEntryCount++;
+      break;
+    }
+    MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize);
+  }
+  MemoryMap = MemoryMapStart;
+  
+  //
+  // Get Data
+  //
+  mMemoryMap = AllocatePool (mMemoryMapEntryCount*DescriptorSize);
+  ASSERT (mMemoryMap != NULL);
+  SmmMemoryMapStart = mMemoryMap;
+  for (Index = 0; Index < MemoryMapEntryCount; Index++) {
+    switch (MemoryMap->Type) {
+    case EfiReservedMemoryType:
+    case EfiRuntimeServicesCode:
+    case EfiRuntimeServicesData:
+    case EfiACPIMemoryNVS:
+      CopyMem (mMemoryMap, MemoryMap, DescriptorSize);
+      mMemoryMap = NEXT_MEMORY_DESCRIPTOR(mMemoryMap, DescriptorSize);
+      break;
+    }
+    MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize);
+  }
+  mMemoryMap = SmmMemoryMapStart;
+  MemoryMap = MemoryMapStart;
+  
+  gBS->FreePool (MemoryMap);
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Notification for SMM ReadyToLock protocol.
+
+  @param[in] Protocol   Points to the protocol's unique identifier.
+  @param[in] Interface  Points to the interface instance.
+  @param[in] Handle     The handle on which the interface was installed.
+
+  @retval EFI_SUCCESS   Notification runs successfully.
+**/
+EFI_STATUS
+EFIAPI
+SmmLibInternalReadyToLockNotify (
+  IN CONST EFI_GUID  *Protocol,
+  IN VOID            *Interface,
+  IN EFI_HANDLE      Handle
+  )
+{
+  mSmmReadyToLock = TRUE;
+  return EFI_SUCCESS;
+}
+/**
+  The constructor function initializes the Smm Mem library
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmMemLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_SMM_ACCESS2_PROTOCOL      *SmmAccess;
+  UINTN                         Size;
+  
+  //
+  // Get SMRAM information
+  //
+  Status = gBS->LocateProtocol (&gEfiSmmAccess2ProtocolGuid, NULL, (VOID **)&SmmAccess);
+  ASSERT_EFI_ERROR (Status);
+
+  Size = 0;
+  Status = SmmAccess->GetCapabilities (SmmAccess, &Size, NULL);
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);
+
+  mSmmMemLibInternalSmramRanges = AllocatePool (Size);
+  ASSERT (mSmmMemLibInternalSmramRanges != NULL);
+
+  Status = SmmAccess->GetCapabilities (SmmAccess, &Size, mSmmMemLibInternalSmramRanges);
+  ASSERT_EFI_ERROR (Status);
+
+  mSmmMemLibInternalSmramCount = Size / sizeof (EFI_SMRAM_DESCRIPTOR);
+
+  //
+  // Calculate and save maximum support address
+  //
+  SmmMemLibInternalCalculateMaximumSupportAddress ();
+
+  //
+  // Register EndOfDxe to get UEFI memory map
+  //
+  Status = gSmst->SmmRegisterProtocolNotify (&gEfiSmmEndOfDxeProtocolGuid, SmmLibInternalEndOfDxeNotify, &mRegistrationEndOfDxe);
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Register ready to lock so that we can know when to check valid SMRAM region
+  //
+  Status = gSmst->SmmRegisterProtocolNotify (&gEfiSmmReadyToLockProtocolGuid, SmmLibInternalReadyToLockNotify, &mRegistrationReadyToLock);
+  ASSERT_EFI_ERROR (Status);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  The destructor function frees resource used in the Smm Mem library
+
+  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.
+  @param[in]  SystemTable   A pointer to the EFI System Table.
+
+  @retval     EFI_SUCCESS   The deconstructor always returns EFI_SUCCESS.
+**/
+EFI_STATUS
+EFIAPI
+SmmMemLibDestructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  FreePool (mSmmMemLibInternalSmramRanges);
+
+  gSmst->SmmRegisterProtocolNotify (&gEfiSmmEndOfDxeProtocolGuid, NULL, &mRegistrationEndOfDxe);
+  gSmst->SmmRegisterProtocolNotify (&gEfiSmmReadyToLockProtocolGuid, NULL, &mRegistrationReadyToLock);
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/SmmMemLib/SmmMemLib.inf b/MdePkg/Library/SmmMemLib/SmmMemLib.inf
new file mode 100644
index 000000000000..f857cd8e77f6
--- /dev/null
+++ b/MdePkg/Library/SmmMemLib/SmmMemLib.inf
@@ -0,0 +1,57 @@
+## @file
+#  Instance of SMM memory check library.
+#
+#  SMM memory check library library implementation. This library consumes SMM_ACCESS2_PROTOCOL
+#  to get SMRAM information. In order to use this library instance, the platform should produce
+#  all SMRAM range via SMM_ACCESS2_PROTOCOL, including the range for firmware (like SMM Core
+#  and SMM driver) and/or specific dedicated hardware.
+#  
+#  Copyright (c) 2015 - 2016, 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.
+#  
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmMemLib
+  MODULE_UNI_FILE                = SmmMemLib.uni
+  FILE_GUID                      = 7F23F839-C81C-4B89-8132-69746FCBCE52
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmmMemLib|DXE_SMM_DRIVER SMM_CORE
+  CONSTRUCTOR                    = SmmMemLibConstructor
+  DESTRUCTOR                     = SmmMemLibDestructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  SmmMemLib.c
+  
+[Packages]
+  MdePkg/MdePkg.dec
+  
+[LibraryClasses]
+  SmmServicesTableLib
+  UefiBootServicesTableLib
+  DebugLib
+  BaseMemoryLib
+  HobLib
+  MemoryAllocationLib
+
+[Protocols]
+  gEfiSmmAccess2ProtocolGuid     ## CONSUMES
+  gEfiSmmReadyToLockProtocolGuid ## CONSUMES
+  gEfiSmmEndOfDxeProtocolGuid    ## CONSUMES
+  
+[Depex]
+  gEfiSmmAccess2ProtocolGuid
diff --git a/MdePkg/Library/SmmMemLib/SmmMemLib.uni b/MdePkg/Library/SmmMemLib/SmmMemLib.uni
new file mode 100644
index 000000000000..9a5e2577e35a
--- /dev/null
+++ b/MdePkg/Library/SmmMemLib/SmmMemLib.uni
@@ -0,0 +1,24 @@
+// /** @file
+// SMM memory check library.
+//
+// SMM memory check library library implementation. This library consumes SMM_ACCESS2_PROTOCOL
+// to get SMRAM information. In order to use this library instance, the platform should produce
+// all SMRAM range via SMM_ACCESS2_PROTOCOL, including the range for firmware (like SMM Core
+// and SMM driver) and/or specific dedicated hardware.
+//
+// Copyright (c) 2015, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "SMM memory check library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "SMM memory check library library implementation. This library consumes SMM_ACCESS2_PROTOCOL to get SMRAM information. In order to use this library instance, the platform should produce all SMRAM range via SMM_ACCESS2_PROTOCOL, including the range for firmware (like SMM Core and SMM driver) and/or specific dedicated hardware."
+
diff --git a/MdePkg/Library/SmmMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/SmmMemoryAllocationLib/MemoryAllocationLib.c
new file mode 100644
index 000000000000..b57aff5d64f5
--- /dev/null
+++ b/MdePkg/Library/SmmMemoryAllocationLib/MemoryAllocationLib.c
@@ -0,0 +1,982 @@
+/** @file
+  Support routines for memory allocation routines based 
+  on SMM Services Table services for SMM phase drivers.
+  
+  The PI System Management Mode Core Interface Specification only allows the use
+  of EfiRuntimeServicesCode and EfiRuntimeServicesData memory types for memory 
+  allocations through the SMM Services Table as the SMRAM space should be 
+  reserved after BDS phase.  The functions in the Memory Allocation Library use
+  EfiBootServicesData as the default memory allocation type.  For this SMM 
+  specific instance of the Memory Allocation Library, EfiRuntimeServicesData 
+  is used as the default memory type for all allocations. In addition, 
+  allocation for the Reserved memory types are not supported and will always 
+  return NULL.
+
+  Copyright (c) 2006 - 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 <PiSmm.h>
+
+#include <Protocol/SmmAccess2.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/SmmServicesTableLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+
+EFI_SMRAM_DESCRIPTOR  *mSmramRanges;
+UINTN                 mSmramRangeCount;
+
+/**
+  The constructor function caches SMRAM ranges that are present in the system.
+    
+  It will ASSERT() if SMM Access2 Protocol doesn't exist.
+  It will ASSERT() if SMRAM ranges can't be got.
+  It will ASSERT() if Resource can't be allocated for cache SMRAM range. 
+  It will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmMemoryAllocationLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                Status;
+  EFI_SMM_ACCESS2_PROTOCOL  *SmmAccess;
+  UINTN                     Size;
+
+  //
+  // Locate SMM Access2 Protocol
+  //
+  Status = gBS->LocateProtocol (
+                  &gEfiSmmAccess2ProtocolGuid, 
+                  NULL, 
+                  (VOID **)&SmmAccess
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Get SMRAM range information
+  //
+  Size = 0;
+  Status = SmmAccess->GetCapabilities (SmmAccess, &Size, NULL);
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);
+
+  mSmramRanges = (EFI_SMRAM_DESCRIPTOR *) AllocatePool (Size);
+  ASSERT (mSmramRanges != NULL);
+
+  Status = SmmAccess->GetCapabilities (SmmAccess, &Size, mSmramRanges);
+  ASSERT_EFI_ERROR (Status);
+
+  mSmramRangeCount = Size / sizeof (EFI_SMRAM_DESCRIPTOR);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  If SMM driver exits with an error, it must call this routine 
+  to free the allocated resource before the exiting.
+
+  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.
+  @param[in]  SystemTable   A pointer to the EFI System Table.
+
+  @retval     EFI_SUCCESS   The deconstructor always returns EFI_SUCCESS.
+**/
+EFI_STATUS
+EFIAPI
+SmmMemoryAllocationLibDestructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  FreePool (mSmramRanges);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Check whether the start address of buffer is within any of the SMRAM ranges.
+
+  @param[in]  Buffer   The pointer to the buffer to be checked.
+
+  @retval     TRUE     The buffer is in SMRAM ranges.
+  @retval     FALSE    The buffer is out of SMRAM ranges.
+**/
+BOOLEAN
+EFIAPI
+BufferInSmram (
+  IN VOID *Buffer
+  )
+{
+  UINTN  Index;
+
+  for (Index = 0; Index < mSmramRangeCount; Index ++) {
+    if (((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer >= mSmramRanges[Index].CpuStart) && 
+        ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer < (mSmramRanges[Index].CpuStart + mSmramRanges[Index].PhysicalSize))) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+/**
+  Allocates one or more 4KB pages of a certain memory type.
+
+  Allocates the number of 4KB pages of a certain memory type and returns a pointer 
+  to the allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If 
+  Pages is 0, then NULL is returned.   If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory; 
+
+  if (Pages == 0) {
+    return NULL;
+  }
+
+  Status = gSmst->SmmAllocatePages (AllocateAnyPages, MemoryType, Pages, &Memory);
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+  return (VOID *) (UINTN) Memory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
+
+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer 
+  to the allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If 
+  Pages is 0, then NULL is returned.  If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiRuntimeServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
+
+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a 
+  pointer to the allocated buffer.  The buffer returned is aligned on a 4KB boundary.  
+  If Pages is 0, then NULL is returned.  If there is not enough memory remaining 
+  to satisfy the request, then NULL is returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiRuntimeServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType.
+
+  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a 
+  pointer to the allocated buffer.  The buffer returned is aligned on a 4KB boundary.  
+  If Pages is 0, then NULL is returned.  If there is not enough memory remaining 
+  to satisfy the request, then NULL is returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPages (
+  IN UINTN  Pages
+  )
+{
+  return NULL;
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the page allocation
+  functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  
+  Buffer must have been allocated on a previous call to the page allocation services 
+  of the Memory Allocation Library.  If it is not possible to free allocated pages, 
+  then this function will perform no actions.
+  
+  If Buffer was not allocated with a page allocation function in the Memory Allocation 
+  Library, then ASSERT().
+  If Pages is zero, then ASSERT().
+ 
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreePages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (Pages != 0);
+  if (BufferInSmram (Buffer)) {
+    //
+    // When Buffer is in SMRAM range, it should be allocated by gSmst->SmmAllocatePages() service.
+    // So, gSmst->SmmFreePages() service is used to free it.
+    //
+    Status = gSmst->SmmFreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  } else {
+    //
+    // When Buffer is out of SMRAM range, it should be allocated by gBS->AllocatePages() service.
+    // So, gBS->FreePages() service is used to free it.
+    //
+    Status = gBS->FreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  }
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Allocates one or more 4KB pages of a certain memory type at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of a certain memory type 
+  with an alignment specified by Alignment.  The allocated buffer is returned.  
+  If Pages is 0, then NULL is returned. If there is not enough memory at the 
+  specified alignment remaining to satisfy the request, then NULL is returned.
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateAlignedPages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages,
+  IN UINTN            Alignment
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory;
+  UINTN                 AlignedMemory;
+  UINTN                 AlignmentMask;
+  UINTN                 UnalignedPages;
+  UINTN                 RealPages;
+
+  //
+  // Alignment must be a power of two or zero.
+  //
+  ASSERT ((Alignment & (Alignment - 1)) == 0);
+ 
+  if (Pages == 0) {
+    return NULL;
+  }
+  if (Alignment > EFI_PAGE_SIZE) {
+    //
+    // Calculate the total number of pages since alignment is larger than page size.
+    //
+    AlignmentMask  = Alignment - 1;
+    RealPages      = Pages + EFI_SIZE_TO_PAGES (Alignment);
+    //
+    // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
+    //
+    ASSERT (RealPages > Pages);
+ 
+    Status         = gSmst->SmmAllocatePages (AllocateAnyPages, MemoryType, RealPages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
+    }
+    AlignedMemory  = ((UINTN) Memory + AlignmentMask) & ~AlignmentMask;
+    UnalignedPages = EFI_SIZE_TO_PAGES (AlignedMemory - (UINTN) Memory);
+    if (UnalignedPages > 0) {
+      //
+      // Free first unaligned page(s).
+      //
+      Status = gSmst->SmmFreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
+    Memory         = AlignedMemory + EFI_PAGES_TO_SIZE (Pages);
+    UnalignedPages = RealPages - Pages - UnalignedPages;
+    if (UnalignedPages > 0) {
+      //
+      // Free last unaligned page(s).
+      //
+      Status = gSmst->SmmFreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
+  } else {
+    //
+    // Do not over-allocate pages in this case.
+    //
+    Status = gSmst->SmmAllocatePages (AllocateAnyPages, MemoryType, Pages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
+    }
+    AlignedMemory  = (UINTN) Memory;
+  }
+  return (VOID *) AlignedMemory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData 
+  with an alignment specified by Alignment.  The allocated buffer is returned.  
+  If Pages is 0, then NULL is returned.  If there is not enough memory at the 
+  specified alignment remaining to satisfy the request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiRuntimeServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData 
+  with an alignment specified by Alignment.  The allocated buffer is returned.  
+  If Pages is 0, then NULL is returned.  If there is not enough memory at the 
+  specified alignment remaining to satisfy the request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedRuntimePages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiRuntimeServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType 
+  with an alignment specified by Alignment.  The allocated buffer is returned.  
+  If Pages is 0, then NULL is returned.  If there is not enough memory at the 
+  specified alignment remaining to satisfy the request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  
+                                Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedReservedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return NULL;
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the aligned page
+  allocation functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by 
+  Buffer.  Buffer must have been allocated on a previous call to the aligned page 
+  allocation services of the Memory Allocation Library.  If it is not possible to 
+  free allocated pages, then this function will perform no actions.
+  
+  If Buffer was not allocated with an aligned page allocation function in the 
+  Memory Allocation Library, then ASSERT().
+  If Pages is zero, then ASSERT().
+  
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreeAlignedPages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (Pages != 0);
+  if (BufferInSmram (Buffer)) {
+    //
+    // When Buffer is in SMRAM range, it should be allocated by gSmst->SmmAllocatePages() service.
+    // So, gSmst->SmmFreePages() service is used to free it.
+    //
+    Status = gSmst->SmmFreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  } else {
+    //
+    // When Buffer is out of SMRAM range, it should be allocated by gBS->AllocatePages() service.
+    // So, gBS->FreePages() service is used to free it.
+    //
+    Status = gBS->FreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  }
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Allocates a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type 
+  and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a 
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePool (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            AllocationSize
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *Memory;
+
+  Status = gSmst->SmmAllocatePool (MemoryType, AllocationSize, &Memory);
+  if (EFI_ERROR (Status)) {
+    Memory = NULL;
+  }
+  return Memory;
+}
+
+/**
+  Allocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData 
+  and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a 
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData 
+  and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a 
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType 
+  and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a 
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to 
+  satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return NULL;
+}
+
+/**
+  Allocates and zeros a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, 
+  clears the buffer with zeros, and returns a pointer to the allocated buffer.  
+  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there is 
+  not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  PoolType              The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateZeroPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize
+  ) 
+{
+  VOID  *Memory;
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+    Memory = ZeroMem (Memory, AllocationSize);
+  }
+  return Memory;
+}
+
+/**
+  Allocates and zeros a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, 
+  clears the buffer with zeros, and returns a pointer to the allocated buffer.  
+  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there is 
+  not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, 
+  clears the buffer with zeros, and returns a pointer to the allocated buffer.  
+  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there is 
+  not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, 
+  clears the   buffer with zeros, and returns a pointer to the allocated buffer.  
+  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there is 
+  not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return NULL;
+}
+
+/**
+  Copies a buffer to an allocated buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, 
+  copies AllocationSize bytes from Buffer to the newly allocated buffer, and returns 
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer 
+  of 0 size is returned.  If there is not enough memory remaining to satisfy the 
+  request, then NULL is returned. If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  PoolType              The type of pool to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateCopyPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize,
+  IN CONST VOID       *Buffer
+  ) 
+{
+  VOID  *Memory;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+     Memory = CopyMem (Memory, Buffer, AllocationSize);
+  }
+  return Memory;
+} 
+
+/**
+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, 
+  copies AllocationSize bytes from Buffer to the newly allocated buffer, and returns 
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer 
+  of 0 size is returned.  If there is not enough memory remaining to satisfy the 
+  request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer);
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, 
+  copies AllocationSize bytes from Buffer to the newly allocated buffer, and returns 
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer 
+  of 0 size is returned.  If there is not enough memory remaining to satisfy the 
+  request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer);
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, 
+  copies AllocationSize bytes from Buffer to the newly allocated buffer, and returns 
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer 
+  of 0 size is returned.  If there is not enough memory remaining to satisfy the 
+  request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return NULL;
+}
+
+/**
+  Reallocates a buffer of a specified memory type.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of the type
+  specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize 
+  and OldSize is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  PoolType       The type of pool to allocate.
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalReallocatePool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            OldSize,
+  IN UINTN            NewSize,
+  IN VOID             *OldBuffer  OPTIONAL
+  )
+{
+  VOID  *NewBuffer;
+
+  NewBuffer = InternalAllocateZeroPool (PoolType, NewSize);
+  if (NewBuffer != NULL && OldBuffer != NULL) {
+    CopyMem (NewBuffer, OldBuffer, MIN (OldSize, NewSize));
+    FreePool (OldBuffer);
+  }
+  return NewBuffer;
+}
+
+/**
+  Reallocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize 
+  and OldSize is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocatePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiRuntimeServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize 
+  and NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize 
+  and OldSize is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateRuntimePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiRuntimeServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiReservedMemoryType.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize 
+  and NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize 
+  and OldSize is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an 
+                         optional parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateReservedPool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return NULL;
+}
+
+/**
+  Frees a buffer that was previously allocated with one of the pool allocation 
+  functions in the Memory Allocation Library.
+
+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a 
+  previous call to the pool allocation services of the Memory Allocation Library.  
+  If it is not possible to free pool resources, then this function will perform 
+  no actions.
+  
+  If Buffer was not allocated with a pool allocation function in the Memory 
+  Allocation Library, then ASSERT().
+
+  @param  Buffer                The pointer to the buffer to free.
+
+**/
+VOID
+EFIAPI
+FreePool (
+  IN VOID   *Buffer
+  )
+{
+  EFI_STATUS    Status;
+
+  if (BufferInSmram (Buffer)) {
+    //
+    // When Buffer is in SMRAM range, it should be allocated by gSmst->SmmAllocatePool() service.
+    // So, gSmst->SmmFreePool() service is used to free it.
+    //
+    Status = gSmst->SmmFreePool (Buffer);
+  } else {
+    //
+    // When Buffer is out of SMRAM range, it should be allocated by gBS->AllocatePool() service.
+    // So, gBS->FreePool() service is used to free it.
+    //
+    Status = gBS->FreePool (Buffer);
+  }
+  ASSERT_EFI_ERROR (Status);
+}
diff --git a/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.inf b/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.inf
new file mode 100644
index 000000000000..bcad40e10493
--- /dev/null
+++ b/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.inf
@@ -0,0 +1,50 @@
+## @file
+# Instance of Memory Allocation Library using SMM Services Table.
+#
+# Memory Allocation Library that uses services from the SMM Services Table to 
+# allocate and free memory.
+#
+# Copyright (c) 2010 - 2014, 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.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmMemoryAllocationLib
+  MODULE_UNI_FILE                = SmmMemoryAllocationLib.uni
+  FILE_GUID                      = 4DF30A5D-D5B0-4f85-80ED-6B16CD343C8E
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+  LIBRARY_CLASS                  = MemoryAllocationLib|DXE_SMM_DRIVER 
+  CONSTRUCTOR                    = SmmMemoryAllocationLibConstructor
+  DESTRUCTOR                     = SmmMemoryAllocationLibDestructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  MemoryAllocationLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseMemoryLib
+  SmmServicesTableLib
+  UefiBootServicesTableLib
+
+[Protocols]
+  gEfiSmmAccess2ProtocolGuid    ## CONSUMES  
+
+[Depex]
+  gEfiSmmAccess2ProtocolGuid
+
diff --git a/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.uni b/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.uni
new file mode 100644
index 000000000000..75b26ed181c6
--- /dev/null
+++ b/MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Memory Allocation Library using SMM Services Table.
+//
+// Memory Allocation Library that uses services from the SMM Services Table to
+// allocate and free memory.
+//
+// Copyright (c) 2010 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Memory Allocation Library using SMM Services Table"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Memory Allocation Library uses services from the SMM Services Table to allocate and free memory."
+
diff --git a/MdePkg/Library/SmmPciExpressLib/PciExpressLib.c b/MdePkg/Library/SmmPciExpressLib/PciExpressLib.c
new file mode 100644
index 000000000000..befb6a4f4780
--- /dev/null
+++ b/MdePkg/Library/SmmPciExpressLib/PciExpressLib.c
@@ -0,0 +1,1430 @@
+/** @file
+ Functions in this library instance make use of MMIO functions in IoLib to
+ access memory mapped PCI configuration space.
+
+ All assertions for I/O operations are handled in MMIO functions in the IoLib
+ Library.
+
+ Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.
+ Portions copyright (c) 2016, American Megatrends, Inc. All rights reserved.
+ 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 <PiDxe.h>
+
+#include <Library/BaseLib.h>
+#include <Library/PciExpressLib.h>
+#include <Library/IoLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+///
+/// Module global that contains the base physical address of the PCI Express MMIO range.
+///
+UINTN mSmmPciExpressLibPciExpressBaseAddress = 0;
+
+/**
+ The constructor function caches the PCI Express Base Address
+
+ @param ImageHandle The firmware allocated handle for the EFI image.
+ @param SystemTable A pointer to the EFI System Table.
+
+ @retval EFI_SUCCESS The constructor completed successfully.
+**/
+EFI_STATUS
+EFIAPI
+SmmPciExpressLibConstructor (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ //
+ // Cache the physical address of the PCI Express MMIO range into a module global variable
+ //
+ mSmmPciExpressLibPciExpressBaseAddress = (UINTN) PcdGet64 (PcdPciExpressBaseAddress);
+
+ return EFI_SUCCESS;
+}
+
+/**
+ Assert the validity of a PCI address. A valid PCI address should contain 1's
+ only in the low 28 bits.
+
+ @param A The address to validate.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A) \
+ ASSERT (((A) & ~0xfffffff) == 0)
+
+/**
+ Registers a PCI device so PCI configuration registers may be accessed after
+ SetVirtualAddressMap().
+
+ Registers the PCI device specified by Address so all the PCI configuration
+ registers associated with that PCI device may be accessed after SetVirtualAddressMap()
+ is called.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+
+ @retval RETURN_SUCCESS The PCI device was registered for runtime access.
+ @retval RETURN_UNSUPPORTED An attempt was made to call this function
+ after ExitBootServices().
+ @retval RETURN_UNSUPPORTED The resources required to access the PCI device
+ at runtime could not be mapped.
+ @retval RETURN_OUT_OF_RESOURCES There are not enough resources available to
+ complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciExpressRegisterForRuntimeAccess (
+ IN UINTN Address
+ )
+{
+ ASSERT_INVALID_PCI_ADDRESS (Address);
+ return RETURN_UNSUPPORTED;
+}
+
+/**
+ Gets MMIO address that can be used to access PCI Express location defined by Address.
+
+ This internal functions converts PCI Express address to a CPU MMIO address by adding
+ PCI Express Base Address stored in a global variable mSmmPciExpressLibPciExpressBaseAddress.
+ mSmmPciExpressLibPciExpressBaseAddress is initialized in the library constructor from PCD entry
+ PcdPciExpressBaseAddress.
+
+ @param Address The address that encodes the PCI Bus, Device, Function and Register.
+ @return MMIO address corresponding to Address.
+
+**/
+UINTN
+GetPciExpressAddress (
+ IN UINTN Address
+ )
+{
+ //
+ // Make sure Address is valid
+ //
+ ASSERT_INVALID_PCI_ADDRESS (Address);
+ return mSmmPciExpressLibPciExpressBaseAddress + Address;
+}
+
+/**
+ Reads an 8-bit PCI configuration register.
+
+ Reads and returns the 8-bit PCI configuration register specified by Address.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+
+ @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressRead8 (
+ IN UINTN Address
+ )
+{
+ return MmioRead8 (GetPciExpressAddress (Address));
+}
+
+/**
+ Writes an 8-bit PCI configuration register.
+
+ Writes the 8-bit PCI configuration register specified by Address with the
+ value specified by Value. Value is returned. This function must guarantee
+ that all PCI read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param Value The value to write.
+
+ @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressWrite8 (
+ IN UINTN Address,
+ IN UINT8 Value
+ )
+{
+ return MmioWrite8 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+ Performs a bitwise OR of an 8-bit PCI configuration register with
+ an 8-bit value.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 8-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressOr8 (
+ IN UINTN Address,
+ IN UINT8 OrData
+ )
+{
+ return MmioOr8 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+ Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+ value.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 8-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAnd8 (
+ IN UINTN Address,
+ IN UINT8 AndData
+ )
+{
+ return MmioAnd8 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+ Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+ value, followed a bitwise OR with another 8-bit value.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData,
+ performs a bitwise OR between the result of the AND operation and
+ the value specified by OrData, and writes the result to the 8-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressAndThenOr8 (
+ IN UINTN Address,
+ IN UINT8 AndData,
+ IN UINT8 OrData
+ )
+{
+ return MmioAndThenOr8 (
+ GetPciExpressAddress (Address),
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field of a PCI configuration register.
+
+ Reads the bit field in an 8-bit PCI configuration register. The bit field is
+ specified by the StartBit and the EndBit. The value of the bit field is
+ returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If StartBit is greater than 7, then ASSERT().
+ If EndBit is greater than 7, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+
+ @param Address The PCI configuration register to read.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..7.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..7.
+
+ @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldRead8 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit
+ )
+{
+ return MmioBitFieldRead8 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit
+ );
+}
+
+/**
+ Writes a bit field to a PCI configuration register.
+
+ Writes Value to the bit field of the PCI configuration register. The bit
+ field is specified by the StartBit and the EndBit. All other bits in the
+ destination PCI configuration register are preserved. The new value of the
+ 8-bit register is returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If StartBit is greater than 7, then ASSERT().
+ If EndBit is greater than 7, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..7.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..7.
+ @param Value The new value of the bit field.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldWrite8 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT8 Value
+ )
+{
+ return MmioBitFieldWrite8 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ Value
+ );
+}
+
+/**
+ Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+ writes the result back to the bit field in the 8-bit port.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 8-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized. Extra left bits in OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If StartBit is greater than 7, then ASSERT().
+ If EndBit is greater than 7, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..7.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..7.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldOr8 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT8 OrData
+ )
+{
+ return MmioBitFieldOr8 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+ AND, and writes the result back to the bit field in the 8-bit register.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 8-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized. Extra left bits in AndData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If StartBit is greater than 7, then ASSERT().
+ If EndBit is greater than 7, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..7.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..7.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAnd8 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT8 AndData
+ )
+{
+ return MmioBitFieldAnd8 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData
+ );
+}
+
+/**
+ Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+ bitwise OR, and writes the result back to the bit field in the
+ 8-bit port.
+
+ Reads the 8-bit PCI configuration register specified by Address, performs a
+ bitwise AND followed by a bitwise OR between the read result and
+ the value specified by AndData, and writes the result to the 8-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized. Extra left bits in both AndData and
+ OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If StartBit is greater than 7, then ASSERT().
+ If EndBit is greater than 7, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..7.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..7.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciExpressBitFieldAndThenOr8 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT8 AndData,
+ IN UINT8 OrData
+ )
+{
+ return MmioBitFieldAndThenOr8 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a 16-bit PCI configuration register.
+
+ Reads and returns the 16-bit PCI configuration register specified by Address.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+
+ @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressRead16 (
+ IN UINTN Address
+ )
+{
+ return MmioRead16 (GetPciExpressAddress (Address));
+}
+
+/**
+ Writes a 16-bit PCI configuration register.
+
+ Writes the 16-bit PCI configuration register specified by Address with the
+ value specified by Value. Value is returned. This function must guarantee
+ that all PCI read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param Value The value to write.
+
+ @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressWrite16 (
+ IN UINTN Address,
+ IN UINT16 Value
+ )
+{
+ return MmioWrite16 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+ Performs a bitwise OR of a 16-bit PCI configuration register with
+ a 16-bit value.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 16-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressOr16 (
+ IN UINTN Address,
+ IN UINT16 OrData
+ )
+{
+ return MmioOr16 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+ Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+ value.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 16-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAnd16 (
+ IN UINTN Address,
+ IN UINT16 AndData
+ )
+{
+ return MmioAnd16 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+ Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+ value, followed a bitwise OR with another 16-bit value.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData,
+ performs a bitwise OR between the result of the AND operation and
+ the value specified by OrData, and writes the result to the 16-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressAndThenOr16 (
+ IN UINTN Address,
+ IN UINT16 AndData,
+ IN UINT16 OrData
+ )
+{
+ return MmioAndThenOr16 (
+ GetPciExpressAddress (Address),
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field of a PCI configuration register.
+
+ Reads the bit field in a 16-bit PCI configuration register. The bit field is
+ specified by the StartBit and the EndBit. The value of the bit field is
+ returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+ If StartBit is greater than 15, then ASSERT().
+ If EndBit is greater than 15, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+
+ @param Address The PCI configuration register to read.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..15.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..15.
+
+ @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldRead16 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit
+ )
+{
+ return MmioBitFieldRead16 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit
+ );
+}
+
+/**
+ Writes a bit field to a PCI configuration register.
+
+ Writes Value to the bit field of the PCI configuration register. The bit
+ field is specified by the StartBit and the EndBit. All other bits in the
+ destination PCI configuration register are preserved. The new value of the
+ 16-bit register is returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+ If StartBit is greater than 15, then ASSERT().
+ If EndBit is greater than 15, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..15.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..15.
+ @param Value The new value of the bit field.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldWrite16 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT16 Value
+ )
+{
+ return MmioBitFieldWrite16 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ Value
+ );
+}
+
+/**
+ Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+ writes the result back to the bit field in the 16-bit port.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 16-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized. Extra left bits in OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+ If StartBit is greater than 15, then ASSERT().
+ If EndBit is greater than 15, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..15.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..15.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldOr16 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT16 OrData
+ )
+{
+ return MmioBitFieldOr16 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+ AND, and writes the result back to the bit field in the 16-bit register.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 16-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized. Extra left bits in AndData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+ If StartBit is greater than 15, then ASSERT().
+ If EndBit is greater than 15, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..15.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..15.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAnd16 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT16 AndData
+ )
+{
+ return MmioBitFieldAnd16 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData
+ );
+}
+
+/**
+ Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+ bitwise OR, and writes the result back to the bit field in the
+ 16-bit port.
+
+ Reads the 16-bit PCI configuration register specified by Address, performs a
+ bitwise AND followed by a bitwise OR between the read result and
+ the value specified by AndData, and writes the result to the 16-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized. Extra left bits in both AndData and
+ OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 16-bit boundary, then ASSERT().
+ If StartBit is greater than 15, then ASSERT().
+ If EndBit is greater than 15, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..15.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..15.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciExpressBitFieldAndThenOr16 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT16 AndData,
+ IN UINT16 OrData
+ )
+{
+ return MmioBitFieldAndThenOr16 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a 32-bit PCI configuration register.
+
+ Reads and returns the 32-bit PCI configuration register specified by Address.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+
+ @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressRead32 (
+ IN UINTN Address
+ )
+{
+ return MmioRead32 (GetPciExpressAddress (Address));
+}
+
+/**
+ Writes a 32-bit PCI configuration register.
+
+ Writes the 32-bit PCI configuration register specified by Address with the
+ value specified by Value. Value is returned. This function must guarantee
+ that all PCI read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param Value The value to write.
+
+ @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressWrite32 (
+ IN UINTN Address,
+ IN UINT32 Value
+ )
+{
+ return MmioWrite32 (GetPciExpressAddress (Address), Value);
+}
+
+/**
+ Performs a bitwise OR of a 32-bit PCI configuration register with
+ a 32-bit value.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 32-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressOr32 (
+ IN UINTN Address,
+ IN UINT32 OrData
+ )
+{
+ return MmioOr32 (GetPciExpressAddress (Address), OrData);
+}
+
+/**
+ Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+ value.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 32-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAnd32 (
+ IN UINTN Address,
+ IN UINT32 AndData
+ )
+{
+ return MmioAnd32 (GetPciExpressAddress (Address), AndData);
+}
+
+/**
+ Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+ value, followed a bitwise OR with another 32-bit value.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData,
+ performs a bitwise OR between the result of the AND operation and
+ the value specified by OrData, and writes the result to the 32-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+ @param Address The address that encodes the PCI Bus, Device, Function and
+ Register.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressAndThenOr32 (
+ IN UINTN Address,
+ IN UINT32 AndData,
+ IN UINT32 OrData
+ )
+{
+ return MmioAndThenOr32 (
+ GetPciExpressAddress (Address),
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field of a PCI configuration register.
+
+ Reads the bit field in a 32-bit PCI configuration register. The bit field is
+ specified by the StartBit and the EndBit. The value of the bit field is
+ returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+ If StartBit is greater than 31, then ASSERT().
+ If EndBit is greater than 31, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+
+ @param Address The PCI configuration register to read.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..31.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..31.
+
+ @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldRead32 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit
+ )
+{
+ return MmioBitFieldRead32 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit
+ );
+}
+
+/**
+ Writes a bit field to a PCI configuration register.
+
+ Writes Value to the bit field of the PCI configuration register. The bit
+ field is specified by the StartBit and the EndBit. All other bits in the
+ destination PCI configuration register are preserved. The new value of the
+ 32-bit register is returned.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+ If StartBit is greater than 31, then ASSERT().
+ If EndBit is greater than 31, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..31.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..31.
+ @param Value The new value of the bit field.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldWrite32 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT32 Value
+ )
+{
+ return MmioBitFieldWrite32 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ Value
+ );
+}
+
+/**
+ Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+ writes the result back to the bit field in the 32-bit port.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise OR between the read result and the value specified by
+ OrData, and writes the result to the 32-bit PCI configuration register
+ specified by Address. The value written to the PCI configuration register is
+ returned. This function must guarantee that all PCI read and write operations
+ are serialized. Extra left bits in OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+ If StartBit is greater than 31, then ASSERT().
+ If EndBit is greater than 31, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..31.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..31.
+ @param OrData The value to OR with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldOr32 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT32 OrData
+ )
+{
+ return MmioBitFieldOr32 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ OrData
+ );
+}
+
+/**
+ Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+ AND, and writes the result back to the bit field in the 32-bit register.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise AND between the read result and the value specified by AndData, and
+ writes the result to the 32-bit PCI configuration register specified by
+ Address. The value written to the PCI configuration register is returned.
+ This function must guarantee that all PCI read and write operations are
+ serialized. Extra left bits in AndData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+ If StartBit is greater than 31, then ASSERT().
+ If EndBit is greater than 31, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..31.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..31.
+ @param AndData The value to AND with the PCI configuration register.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAnd32 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT32 AndData
+ )
+{
+ return MmioBitFieldAnd32 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData
+ );
+}
+
+/**
+ Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+ bitwise OR, and writes the result back to the bit field in the
+ 32-bit port.
+
+ Reads the 32-bit PCI configuration register specified by Address, performs a
+ bitwise AND followed by a bitwise OR between the read result and
+ the value specified by AndData, and writes the result to the 32-bit PCI
+ configuration register specified by Address. The value written to the PCI
+ configuration register is returned. This function must guarantee that all PCI
+ read and write operations are serialized. Extra left bits in both AndData and
+ OrData are stripped.
+
+ If Address > 0x0FFFFFFF, then ASSERT().
+ If Address is not aligned on a 32-bit boundary, then ASSERT().
+ If StartBit is greater than 31, then ASSERT().
+ If EndBit is greater than 31, then ASSERT().
+ If EndBit is less than StartBit, then ASSERT().
+ If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+ If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+ @param Address The PCI configuration register to write.
+ @param StartBit The ordinal of the least significant bit in the bit field.
+ Range 0..31.
+ @param EndBit The ordinal of the most significant bit in the bit field.
+ Range 0..31.
+ @param AndData The value to AND with the PCI configuration register.
+ @param OrData The value to OR with the result of the AND operation.
+
+ @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciExpressBitFieldAndThenOr32 (
+ IN UINTN Address,
+ IN UINTN StartBit,
+ IN UINTN EndBit,
+ IN UINT32 AndData,
+ IN UINT32 OrData
+ )
+{
+ return MmioBitFieldAndThenOr32 (
+ GetPciExpressAddress (Address),
+ StartBit,
+ EndBit,
+ AndData,
+ OrData
+ );
+}
+
+/**
+ Reads a range of PCI configuration registers into a caller supplied buffer.
+
+ Reads the range of PCI configuration registers specified by StartAddress and
+ Size into the buffer specified by Buffer. This function only allows the PCI
+ configuration registers from a single PCI function to be read. Size is
+ returned. When possible 32-bit PCI configuration read cycles are used to read
+ from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+ and 16-bit PCI configuration read cycles may be used at the beginning and the
+ end of the range.
+
+ If StartAddress > 0x0FFFFFFF, then ASSERT().
+ If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+ If Size > 0 and Buffer is NULL, then ASSERT().
+
+ @param StartAddress The starting address that encodes the PCI Bus, Device,
+ Function and Register.
+ @param Size The size in bytes of the transfer.
+ @param Buffer The pointer to a buffer receiving the data read.
+
+ @return Size read data from StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressReadBuffer (
+ IN UINTN StartAddress,
+ IN UINTN Size,
+ OUT VOID *Buffer
+ )
+{
+ UINTN ReturnValue;
+
+ //
+ // Make sure Address is valid
+ //
+ ASSERT_INVALID_PCI_ADDRESS (StartAddress);
+ ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+ if (Size == 0) {
+ return Size;
+ }
+
+ ASSERT (Buffer != NULL);
+
+ //
+ // Save Size for return
+ //
+ ReturnValue = Size;
+
+ if ((StartAddress & 1) != 0) {
+ //
+ // Read a byte if StartAddress is byte aligned
+ //
+ *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+ StartAddress += sizeof (UINT8);
+ Size -= sizeof (UINT8);
+ Buffer = (UINT8*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+ //
+ // Read a word if StartAddress is word aligned
+ //
+ WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+
+ StartAddress += sizeof (UINT16);
+ Size -= sizeof (UINT16);
+ Buffer = (UINT16*)Buffer + 1;
+ }
+
+ while (Size >= sizeof (UINT32)) {
+ //
+ // Read as many double words as possible
+ //
+ WriteUnaligned32 ((UINT32 *) Buffer, (UINT32) PciExpressRead32 (StartAddress));
+
+ StartAddress += sizeof (UINT32);
+ Size -= sizeof (UINT32);
+ Buffer = (UINT32*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT16)) {
+ //
+ // Read the last remaining word if exist
+ //
+ WriteUnaligned16 ((UINT16 *) Buffer, (UINT16) PciExpressRead16 (StartAddress));
+ StartAddress += sizeof (UINT16);
+ Size -= sizeof (UINT16);
+ Buffer = (UINT16*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT8)) {
+ //
+ // Read the last remaining byte if exist
+ //
+ *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
+ }
+
+ return ReturnValue;
+}
+
+/**
+ Copies the data in a caller supplied buffer to a specified range of PCI
+ configuration space.
+
+ Writes the range of PCI configuration registers specified by StartAddress and
+ Size from the buffer specified by Buffer. This function only allows the PCI
+ configuration registers from a single PCI function to be written. Size is
+ returned. When possible 32-bit PCI configuration write cycles are used to
+ write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+ 8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+ and the end of the range.
+
+ If StartAddress > 0x0FFFFFFF, then ASSERT().
+ If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+ If Size > 0 and Buffer is NULL, then ASSERT().
+
+ @param StartAddress The starting address that encodes the PCI Bus, Device,
+ Function and Register.
+ @param Size The size in bytes of the transfer.
+ @param Buffer The pointer to a buffer containing the data to write.
+
+ @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciExpressWriteBuffer (
+ IN UINTN StartAddress,
+ IN UINTN Size,
+ IN VOID *Buffer
+ )
+{
+ UINTN ReturnValue;
+
+ //
+ // Make sure Address is valid
+ //
+ ASSERT_INVALID_PCI_ADDRESS (StartAddress);
+ ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+
+ if (Size == 0) {
+ return 0;
+ }
+
+ ASSERT (Buffer != NULL);
+
+ //
+ // Save Size for return
+ //
+ ReturnValue = Size;
+
+ if ((StartAddress & 1) != 0) {
+ //
+ // Write a byte if StartAddress is byte aligned
+ //
+ PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+ StartAddress += sizeof (UINT8);
+ Size -= sizeof (UINT8);
+ Buffer = (UINT8*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT16) && (StartAddress & 2) != 0) {
+ //
+ // Write a word if StartAddress is word aligned
+ //
+ PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+ StartAddress += sizeof (UINT16);
+ Size -= sizeof (UINT16);
+ Buffer = (UINT16*)Buffer + 1;
+ }
+
+ while (Size >= sizeof (UINT32)) {
+ //
+ // Write as many double words as possible
+ //
+ PciExpressWrite32 (StartAddress, ReadUnaligned32 ((UINT32*)Buffer));
+ StartAddress += sizeof (UINT32);
+ Size -= sizeof (UINT32);
+ Buffer = (UINT32*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT16)) {
+ //
+ // Write the last remaining word if exist
+ //
+ PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16*)Buffer));
+ StartAddress += sizeof (UINT16);
+ Size -= sizeof (UINT16);
+ Buffer = (UINT16*)Buffer + 1;
+ }
+
+ if (Size >= sizeof (UINT8)) {
+ //
+ // Write the last remaining byte if exist
+ //
+ PciExpressWrite8 (StartAddress, *(UINT8*)Buffer);
+ }
+
+ return ReturnValue;
+}
diff --git a/MdePkg/Library/SmmPciExpressLib/SmmPciExpressLib.inf b/MdePkg/Library/SmmPciExpressLib/SmmPciExpressLib.inf
new file mode 100644
index 000000000000..b5e83b5cd0a6
--- /dev/null
+++ b/MdePkg/Library/SmmPciExpressLib/SmmPciExpressLib.inf
@@ -0,0 +1,42 @@
+## @file
+# Instance of PCI Express Library using the 256 MB PCI Express MMIO window.
+#
+# PCI Express Library that uses the 256 MB PCI Express MMIO window to perform
+# PCI Configuration cycles. Layers on top of an I/O Library instance.
+#
+# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.
+# Portions copyright (c) 2016, American Megatrends, Inc. All rights reserved.
+#
+# 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.
+#
+#
+##
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = SmmPciExpressLib
+ FILE_GUID = 00D24382-8231-4B18-A4F0-2D94D8FE2E81
+ MODULE_TYPE = DXE_SMM_DRIVER
+ VERSION_STRING = 1.0
+ LIBRARY_CLASS = PciExpressLib|DXE_SMM_DRIVER SMM_CORE
+ CONSTRUCTOR = SmmPciExpressLibConstructor
+
+[Sources]
+ PciExpressLib.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseLib
+ PcdLib
+ DebugLib
+ IoLib
+
+[Pcd]
+ gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress ## CONSUMES
diff --git a/MdePkg/Library/SmmPciLibPciRootBridgeIo/PciLib.c b/MdePkg/Library/SmmPciLibPciRootBridgeIo/PciLib.c
new file mode 100644
index 000000000000..2bd0401831aa
--- /dev/null
+++ b/MdePkg/Library/SmmPciLibPciRootBridgeIo/PciLib.c
@@ -0,0 +1,1434 @@
+/** @file
+  PCI Library using SMM PCI Root Bridge I/O Protocol.
+
+  Copyright (c) 2009 - 2012, 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 <PiSmm.h>
+#include <Protocol/SmmPciRootBridgeIo.h>
+#include <Library/PciLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/SmmServicesTableLib.h>
+
+
+/**
+  Assert the validity of a PCI address. A valid PCI address should contain 1's
+  only in the low 28 bits.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A,M) \
+  ASSERT (((A) & (~0xfffffff | (M))) == 0)
+
+/**
+  Translate PCI Lib address into format of PCI Root Bridge I/O Protocol.
+
+  @param  A  The address that encodes the PCI Bus, Device, Function and
+             Register.
+
+**/
+#define PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS(A) \
+  ((((A) << 4) & 0xff000000) | (((A) >> 4) & 0x00000700) | (((A) << 1) & 0x001f0000) | (LShiftU64((A) & 0xfff, 32)))
+
+//
+// Global varible to cache pointer to PCI Root Bridge I/O protocol.
+//
+EFI_SMM_PCI_ROOT_BRIDGE_IO_PROTOCOL      *mSmmPciRootBridgeIo = NULL; 
+
+/**
+  The constructor function caches the pointer to PCI Root Bridge I/O protocol.
+  
+  The constructor function locates PCI Root Bridge I/O protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+PciLibConstructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+  
+  Status = gSmst->SmmLocateProtocol (&gEfiSmmPciRootBridgeIoProtocolGuid, NULL, (VOID**) &mSmmPciRootBridgeIo);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (mSmmPciRootBridgeIo != NULL);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Read() service.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+SmmPciLibPciRootBridgeIoReadWorker (
+  IN    UINTN                                  Address,
+  IN    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width
+  )
+{
+  UINT32  Data;
+
+  mSmmPciRootBridgeIo->Pci.Read (
+                          mSmmPciRootBridgeIo,
+                          Width,
+                          PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                          1,
+                          &Data
+                          );
+
+  return Data;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Write() service.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specified by Width.
+  Data is returned.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+SmmPciLibPciRootBridgeIoWriteWorker (
+  IN    UINTN                                  Address,
+  IN    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width,
+  IN    UINT32                                 Data
+  )
+{
+  mSmmPciRootBridgeIo->Pci.Write (
+                          mSmmPciRootBridgeIo,
+                          Width,
+                          PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                          1,
+                          &Data
+                          );
+  return Data;
+}
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) SmmPciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint8);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) SmmPciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint8, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) ((PciRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldWrite8 (PciRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldOr8 (PciRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAnd8 (PciRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) SmmPciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint16);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) SmmPciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint16, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) ((PciRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldWrite16 (PciRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldOr16 (PciRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAnd16 (PciRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return SmmPciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint32);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return SmmPciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint32, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, (PciRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldWrite32 (PciRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldOr32 (PciRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAnd32 (PciRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.inf b/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.inf
new file mode 100644
index 000000000000..5ceabab34252
--- /dev/null
+++ b/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.inf
@@ -0,0 +1,55 @@
+## @file
+# PCI Library that layers on top of the SMM PCI Root Bridge I/O Protocol.
+#
+# This library produces the APIs from the PCI Library and implements these APIs
+#  by calling into SMM PCI Root Bridge I/O Protocol. SMM PCI Root Bridge I/O Protocol is
+#  typically produced by a chipset specific SMM driver.
+#  This library binds to the first SMM PCI Root Bridge I/O Protocol in the platform. As a result,
+#  it should only be used on platforms that contain a single PCI root bridge.
+#
+# Copyright (c) 2009 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmPciLibPciRootBridgeIo
+  MODULE_UNI_FILE                = SmmPciLibPciRootBridgeIo.uni
+  FILE_GUID                      = F6994CBA-2351-4ebc-A2DA-20BAC2FE2CF3
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib|DXE_SMM_DRIVER SMM_CORE
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+  CONSTRUCTOR                    = PciLibConstructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  PciLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  SmmServicesTableLib
+  DebugLib
+
+[Protocols]
+  gEfiSmmPciRootBridgeIoProtocolGuid               ## CONSUMES
+  
+[Depex.common.DXE_SMM_DRIVER]
+  gEfiSmmPciRootBridgeIoProtocolGuid
+
diff --git a/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.uni b/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.uni
new file mode 100644
index 000000000000..e2c5b9d0937c
--- /dev/null
+++ b/MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.uni
@@ -0,0 +1,25 @@
+// /** @file
+// PCI Library that layers on top of the SMM PCI Root Bridge I/O Protocol.
+//
+// This library produces the APIs from the PCI Library and implements these APIs
+// by calling into SMM PCI Root Bridge I/O Protocol. SMM PCI Root Bridge I/O Protocol is
+// typically produced by a chipset specific SMM driver.
+// This library binds to the first SMM PCI Root Bridge I/O Protocol in the platform. As a result,
+// it should only be used on platforms that contain a single PCI root bridge.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCI Library that layers on top of the SMM PCI Root Bridge I/O Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library produces the APIs from the PCI Library and implements these APIs by calling into SMM PCI Root Bridge I/O Protocol. SMM PCI Root Bridge I/O Protocol is typically produced by a chipset-specific SMM driver. This library binds to the first SMM PCI Root Bridge I/O Protocol in the platform. As a result, it should only be used on platforms that contain a single PCI root bridge."
+
diff --git a/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.c b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.c
new file mode 100644
index 000000000000..bd7bb3a11e0c
--- /dev/null
+++ b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.c
@@ -0,0 +1,1183 @@
+/** @file
+  SMM Periodic SMI Library.
+
+  Copyright (c) 2011, 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 <PiSmm.h>
+
+#include <Protocol/SmmPeriodicTimerDispatch2.h>
+
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/SynchronizationLib.h>
+#include <Library/DebugLib.h>
+#include <Library/TimerLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/SmmServicesTableLib.h>
+
+#include <Library/SmmPeriodicSmiLib.h>
+
+///
+/// Define the number of periodic SMI handler entries that should be allocated to the list
+/// of free periodic SMI handlers when the list of free periodic SMI handlers is empty.
+///
+#define PERIODIC_SMI_LIBRARY_ALLOCATE_SIZE  0x08
+
+///
+/// Signature for a PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure
+///
+#define PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE  SIGNATURE_32 ('P', 'S', 'M', 'I')
+
+///
+/// Structure that contains state information for an enabled periodic SMI handler
+///
+typedef struct {
+  ///
+  /// Signature value that must be set to PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE
+  ///
+  UINT32                                   Signature;
+  ///
+  /// The link entry to be inserted to the list of periodic SMI handlers.
+  ///
+  LIST_ENTRY                               Link;
+  ///
+  /// The dispatch function to called to invoke an enabled periodic SMI handler.
+  ///
+  PERIODIC_SMI_LIBRARY_HANDLER             DispatchFunction;
+  ///
+  /// The context to pass into DispatchFunction
+  ///
+  VOID                                     *Context;
+  ///
+  /// The tick period in 100 ns units that DispatchFunction should be called.
+  ///
+  UINT64                                   TickPeriod;
+  ///
+  /// The Cpu number that is required to execute DispatchFunction.  If Cpu is 
+  /// set to PERIODIC_SMI_LIBRARY_ANY_CPU, then DispatchFunction may be executed 
+  /// on any CPU.
+  ///
+  UINTN                                    Cpu;
+  ///
+  /// The size, in bytes, of the stack allocated for a periodic SMI handler.  
+  /// This value must be a multiple of EFI_PAGE_SIZE.
+  ///
+  UINTN                                    StackSize;
+  ///
+  /// A pointer to the stack allocated using AllocatePages().  This field will
+  /// be NULL if StackSize is 0.
+  ///
+  VOID                                     *Stack;
+  ///
+  /// Spin lock used to wait for an AP to complete the execution of a periodic SMI handler
+  ///
+  SPIN_LOCK                                DispatchLock;
+  ///
+  /// The rate in Hz of the performance counter that is used to measure the 
+  /// amount of time that a periodic SMI handler executes.
+  ///
+  UINT64                                   PerfomanceCounterRate;
+  ///
+  /// The start count value of the performance counter that is used to measure 
+  /// the amount of time that a periodic SMI handler executes.
+  ///
+  UINT64                                   PerfomanceCounterStartValue;
+  ///
+  /// The end count value of the performance counter that is used to measure 
+  /// the amount of time that a periodic SMI handler executes.
+  ///
+  UINT64                                   PerfomanceCounterEndValue;
+  ///
+  /// The context record passed into the Register() function of the SMM Periodic 
+  /// Timer Dispatch Protocol when a periodic SMI handler is enabled.
+  ///
+  EFI_SMM_PERIODIC_TIMER_REGISTER_CONTEXT  RegisterContext;
+  ///
+  /// The handle returned from the Register() function of the SMM Periodic 
+  /// Timer Dispatch Protocol when a periodic SMI handler is enabled.
+  ///
+  EFI_HANDLE                               DispatchHandle;
+  ///
+  /// The total number of performance counter ticks that the periodic SMI handler
+  /// has been executing in its current invocation.
+  ///
+  UINT64                                   DispatchTotalTime;
+  ///
+  /// The performance counter value that was captured the last time that the 
+  /// periodic SMI handler called PeriodcSmiExecutionTime().  This allows the
+  /// time value returned by PeriodcSmiExecutionTime() to be accurate even when
+  /// the performance counter rolls over.
+  ///
+  UINT64                                   DispatchCheckPointTime;
+  ///
+  /// Buffer used to save the context when control is transfer from this library
+  /// to an enabled periodic SMI handler.  This saved context is used when the 
+  /// periodic SMI handler exits or yields.  
+  ///
+  BASE_LIBRARY_JUMP_BUFFER                 DispatchJumpBuffer;
+  ///
+  /// Flag that is set to TRUE when a periodic SMI handler requests to yield 
+  /// using PeriodicSmiYield().  When this flag IS TRUE, YieldJumpBuffer is 
+  /// valid.  When this flag is FALSE, YieldJumpBuffer is not valid.
+  ///
+  BOOLEAN                                  YieldFlag;
+  ///
+  /// Buffer used to save the context when a periodic SMI handler requests to 
+  /// yield using PeriodicSmiYield().  This context is used to resume the 
+  /// execution of a periodic SMI handler the next time control is transferd
+  /// to the periodic SMI handler that yielded.
+  ///
+  BASE_LIBRARY_JUMP_BUFFER                 YieldJumpBuffer;
+  ///
+  /// The amount of time, in 100 ns units, that have elapsed since the last
+  /// time the periodic SMI handler was invoked.
+  ///
+  UINT64                                   ElapsedTime;
+} PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT;
+
+/**
+ Macro that returns a pointer to a PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT 
+ structure based on a pointer to a RegisterContext field.
+
+**/
+#define PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_REGISTER_CONTEXT(a) \
+  CR (                                                                \
+    a,                                                                \
+    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT,                             \
+    RegisterContext,                                                  \
+    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE                    \
+    )
+
+/**
+ Macro that returns a pointer to a PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT 
+ structure based on a pointer to a Link field.
+
+**/
+#define PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK(a)             \
+  CR (                                                                \
+    a,                                                                \
+    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT,                             \
+    Link,                                                             \
+    PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE                    \
+    )
+
+///
+/// Pointer to the SMM Periodic Timer Disatch Protocol that was located in the constuctor.
+///
+EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL  *gSmmPeriodicTimerDispatch2           = NULL;
+
+///
+/// Pointer to a table of supported periodic SMI tick periods in 100 ns units 
+/// sorted from largest to smallest terminated by a tick period value of 0.
+/// This table is allocated using AllocatePool() in the constructor and filled 
+/// in based on the values returned from the SMM Periodic Timer Dispatch 2 Protocol 
+/// function GetNextShorterInterval().
+///
+UINT64                                     *gSmiTickPeriodTable                  = NULL;
+
+///
+/// Linked list of free periodic SMI handlers that this library can use.
+///
+LIST_ENTRY                                 gFreePeriodicSmiLibraryHandlers       =
+                                           INITIALIZE_LIST_HEAD_VARIABLE (gFreePeriodicSmiLibraryHandlers);
+
+///
+/// Linked list of periodic SMI handlers that this library is currently managing.
+///
+LIST_ENTRY                                 gPeriodicSmiLibraryHandlers           =
+                                           INITIALIZE_LIST_HEAD_VARIABLE (gPeriodicSmiLibraryHandlers);
+
+///
+/// Pointer to the periodic SMI handler that is currently being executed.
+/// Is set to NULL if no periodic SMI handler is currently being executed.
+///
+PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT       *gActivePeriodicSmiLibraryHandler     = NULL;
+
+/**
+  Internal worker function that returns a pointer to the 
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure associated with the periodic 
+  SMI handler that is currently being executed.  If a periodic SMI handler is 
+  not currently being executed, the NULL is returned.
+  
+  @retval  NULL   A periodic SMI handler is not currently being executed.
+  @retval  other  Pointer to the PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT
+                  associated with the active periodic SMI handler.
+  
+**/
+PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
+GetActivePeriodicSmiLibraryHandler (
+  VOID
+  )
+{
+  return gActivePeriodicSmiLibraryHandler;
+}
+
+/**
+  Internal worker function that returns a pointer to the 
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure associated with the 
+  DispatchHandle that was returned when the periodic SMI handler was enabled
+  with PeriodicSmiEnable().  If DispatchHandle is NULL, then the active 
+  periodic SMI handler is returned.  If DispatchHandle is NULL and there is
+  no active periodic SMI handler, then NULL is returned.
+  
+  @param[in] DispatchHandle  DispatchHandle that was returned when the periodic 
+                             SMI handler was enabled with PeriodicSmiEnable().  
+                             This is an optional parameter that may be NULL.
+                             If this parameter is NULL, then the active periodic
+                             SMI handler is returned.
+  
+  @retval  NULL   DispatchHandle is NULL and there is no active periodic SMI 
+                  handler.
+  @retval  NULL   DispatchHandle does not match any of the periodic SMI handlers
+                  that have been enabled with PeriodicSmiEnable().
+  @retval  other  Pointer to the PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT
+                  associated with the DispatchHandle.
+  
+**/
+PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
+LookupPeriodicSmiLibraryHandler (
+  IN EFI_HANDLE                         DispatchHandle    OPTIONAL
+  )
+{
+  LIST_ENTRY                            *Link;
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+
+  //
+  // If DispatchHandle is NULL, then return the active periodic SMI handler
+  //
+  if (DispatchHandle == NULL) {
+    return GetActivePeriodicSmiLibraryHandler ();
+  }
+
+  //
+  // Search the periodic SMI handler entries for a a matching DispatchHandle
+  //
+  for ( Link = GetFirstNode (&gPeriodicSmiLibraryHandlers)
+      ; !IsNull (&gPeriodicSmiLibraryHandlers, Link)
+      ; Link = GetNextNode (&gPeriodicSmiLibraryHandlers, Link)
+      ) {
+    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
+
+    if (PeriodicSmiLibraryHandler->DispatchHandle == DispatchHandle) {
+      return PeriodicSmiLibraryHandler;
+    }
+  }
+  
+  //
+  // No entries match DispatchHandle, so return NULL
+  //
+  return NULL;
+}
+
+/**
+  Internal worker function that sets that active periodic SMI handler based on 
+  the Context used when the periodic SMI handler was registered with the 
+  SMM Periodic Timer Dispatch 2 Protocol.  If Context is NULL, then the 
+  state is updated to show that there is not active periodic SMI handler.
+  A pointer to the active PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure 
+  is returned.
+  
+  @retval  NULL   Context is NULL.
+  @retval  other  Pointer to the PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT
+                  associated with Context.
+  
+**/
+PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
+SetActivePeriodicSmiLibraryHandler (
+  IN CONST VOID  *Context  OPTIONAL
+  )
+{
+  if (Context == NULL) {
+    gActivePeriodicSmiLibraryHandler = NULL;
+  } else {
+    gActivePeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_REGISTER_CONTEXT (Context);
+  }
+  return gActivePeriodicSmiLibraryHandler;
+}
+
+/**
+  Internal worker function that moves the specified periodic SMI handler from the
+  list of managed periodic SMI handlers to the list of free periodic SMI handlers.
+
+  @param[in] PeriodicSmiLibraryHandler  Pointer to the periodic SMI handler to be reclaimed.
+**/
+VOID
+ReclaimPeriodicSmiLibraryHandler (
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT     *PeriodicSmiLibraryHandler
+  )
+{
+  ASSERT (PeriodicSmiLibraryHandler->DispatchHandle == NULL);
+  if (PeriodicSmiLibraryHandler->Stack != NULL) {
+    FreePages (
+      PeriodicSmiLibraryHandler->Stack,
+      EFI_SIZE_TO_PAGES (PeriodicSmiLibraryHandler->StackSize)
+      );
+    PeriodicSmiLibraryHandler->Stack = NULL;
+  }
+  RemoveEntryList (&PeriodicSmiLibraryHandler->Link);
+  InsertHeadList (&gFreePeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
+}
+
+/**
+  Add the additional entries to the list of free periodic SMI handlers.
+  The function is assumed to be called only when the list of free periodic SMI
+  handlers is empty.
+
+  @retval TRUE  The additional entries were added.
+  @retval FALSE There was no available resource for the additional entries.
+**/
+BOOLEAN
+EnlargeFreePeriodicSmiLibraryHandlerList (
+  VOID
+  )
+{
+  UINTN                                 Index;
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+
+  //
+  // Add the entries to the list
+  //
+  for (Index = 0; Index < PERIODIC_SMI_LIBRARY_ALLOCATE_SIZE; Index++) {
+    PeriodicSmiLibraryHandler = AllocatePool (sizeof (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT));
+    if (PeriodicSmiLibraryHandler == NULL) {
+      break;
+    }
+    PeriodicSmiLibraryHandler->Signature = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_SIGNATURE;
+    InsertHeadList (&gFreePeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
+  }
+
+  return (BOOLEAN) (Index > 0);
+}
+
+/**
+  Internal worker function that returns a free entry for a new periodic
+  SMI handler.  If no free entries are available, then additional
+  entries are allocated.
+  
+  @retval  NULL   There are not enough resources available to to allocate a free entry.
+  @retval  other  Pointer to a free PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure.
+  
+**/
+PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *
+FindFreePeriodicSmiLibraryHandler (
+  VOID
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  
+  if (IsListEmpty (&gFreePeriodicSmiLibraryHandlers)) {
+    if (!EnlargeFreePeriodicSmiLibraryHandlerList ()) {
+      return NULL;
+    }
+  }
+
+  //
+  // Get one from the list of free periodic SMI handlers.
+  //
+  PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (
+                                GetFirstNode (&gFreePeriodicSmiLibraryHandlers)
+                                );
+  RemoveEntryList (&PeriodicSmiLibraryHandler->Link);
+  InsertTailList (&gPeriodicSmiLibraryHandlers, &PeriodicSmiLibraryHandler->Link);
+
+  return PeriodicSmiLibraryHandler;
+}
+
+/**
+  This function returns a pointer to a table of supported periodic
+  SMI tick periods in 100 ns units sorted from largest to smallest.  
+  The table contains a array of UINT64 values terminated by a tick 
+  period value of 0.  The returned table must be treated as read-only
+  data and must not be freed.
+  
+  @return  A pointer to a table of UINT64 tick period values in 
+           100ns units sorted from largest to smallest terminated 
+           by a tick period of 0.
+  
+**/
+UINT64 *
+EFIAPI
+PeriodicSmiSupportedTickPeriod (
+  VOID
+  )
+{
+  //
+  // Return the table allocated and populated by SmmPeriodicSmiLibConstructor()
+  //
+  return gSmiTickPeriodTable;
+}
+
+/**
+  This function returns the time in 100ns units since the periodic SMI
+  handler function was called.  If the periodic SMI handler was resumed
+  through PeriodicSmiYield(), then the time returned is the time in
+  100ns units since PeriodicSmiYield() returned.
+
+  @return  The actual time in 100ns units that the periodic SMI handler
+           has been executing.  If this function is not called from within
+           an enabled periodic SMI handler, then 0 is returned.
+
+**/
+UINT64
+EFIAPI
+PeriodicSmiExecutionTime (
+  VOID
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  UINT64                                Current;
+  UINT64                                Count;
+
+  //
+  // If there is no active periodic SMI handler, then return 0 
+  //
+  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return 0;
+  }
+  
+  //
+  // Get the current performance counter value
+  //
+  Current = GetPerformanceCounter ();
+  
+  //
+  // Count the number of performance counter ticks since the periodic SMI handler 
+  // was dispatched or the last time this function was called. 
+  //
+  if (PeriodicSmiLibraryHandler->PerfomanceCounterEndValue > PeriodicSmiLibraryHandler->PerfomanceCounterStartValue) {
+    //
+    // The performance counter counts up.  Check for roll over condition.
+    //
+    if (Current > PeriodicSmiLibraryHandler->DispatchCheckPointTime) {
+      Count = Current - PeriodicSmiLibraryHandler->DispatchCheckPointTime;
+    } else {
+      Count = (Current - PeriodicSmiLibraryHandler->PerfomanceCounterStartValue) + (PeriodicSmiLibraryHandler->PerfomanceCounterEndValue - PeriodicSmiLibraryHandler->DispatchCheckPointTime);
+    }
+  } else {
+    //
+    // The performance counter counts down.  Check for roll over condition.
+    //
+    if (PeriodicSmiLibraryHandler->DispatchCheckPointTime > Current) {
+      Count = PeriodicSmiLibraryHandler->DispatchCheckPointTime - Current;
+    } else {
+      Count = (PeriodicSmiLibraryHandler->DispatchCheckPointTime - PeriodicSmiLibraryHandler->PerfomanceCounterEndValue) + (PeriodicSmiLibraryHandler->PerfomanceCounterStartValue - Current);
+    }
+  }
+  
+  //
+  // Accumulate the total number of performance counter ticks since the periodic 
+  // SMI handler was dispatched or resumed.
+  //
+  PeriodicSmiLibraryHandler->DispatchTotalTime += Count;
+  
+  //
+  // Update the checkpoint value to the current performance counter value
+  //
+  PeriodicSmiLibraryHandler->DispatchCheckPointTime = Current;
+  
+  //
+  // Convert the total number of performance counter ticks to 100 ns units
+  //
+  return DivU64x64Remainder (
+           MultU64x32 (PeriodicSmiLibraryHandler->DispatchTotalTime, 10000000), 
+           PeriodicSmiLibraryHandler->PerfomanceCounterRate, 
+           NULL
+           );
+}
+
+/**
+  This function returns control back to the SMM Foundation.  When the next 
+  periodic SMI for the currently executing handler is triggered, the periodic
+  SMI handler will restarted from its registered DispatchFunction entry point.
+  If this function is not called from within an enabled periodic SMI handler, 
+  then control is returned to the calling function.
+
+**/
+VOID
+EFIAPI  
+PeriodicSmiExit (
+  VOID
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  
+  //
+  // If there is no active periodic SMI handler, then return 
+  //
+  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return;
+  }
+  
+  //
+  // Perform a long jump back to the point when the currently executing dispatch 
+  // function was dispatched.
+  //
+  LongJump (&PeriodicSmiLibraryHandler->DispatchJumpBuffer, 1);
+  
+  //
+  // Must never return
+  //
+  ASSERT (FALSE);
+  CpuDeadLoop();
+}
+
+/**
+  This function yields control back to the SMM Foundation.  When the next 
+  periodic SMI for the currently executing handler is triggered, the periodic
+  SMI handler will be resumed and this function will return.  Use of this 
+  function requires a seperate stack for the periodic SMI handler.  A non zero
+  stack size must be specified in PeriodicSmiEnable() for this function to be 
+  used.  
+  
+  If the stack size passed into PeriodicSmiEnable() was zero, the 0 is returned.
+  
+  If this function is not called from within an enabled periodic SMI handler, 
+  then 0 is returned.
+
+  @return  The actual time in 100ns units elapsed since this function was
+           called.  A value of 0 indicates an unknown amount of time.
+
+**/
+UINT64
+EFIAPI  
+PeriodicSmiYield (
+  VOID
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  UINTN                                 SetJumpFlag;
+
+  //
+  // If there is no active periodic SMI handler, then return 
+  //
+  PeriodicSmiLibraryHandler = GetActivePeriodicSmiLibraryHandler ();
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return 0;
+  }
+  
+  //
+  // If PeriodicSmiYield() is called without an allocated stack, then just return 
+  // immediately with an elapsed time of 0.
+  //
+  if (PeriodicSmiLibraryHandler->Stack == NULL) {
+    return 0;
+  }
+  
+  //
+  // Set a flag so the next periodic SMI event will resume at where SetJump() 
+  // is called below.
+  //
+  PeriodicSmiLibraryHandler->YieldFlag = TRUE;
+
+  //
+  // Save context in YieldJumpBuffer
+  //  
+  SetJumpFlag = SetJump (&PeriodicSmiLibraryHandler->YieldJumpBuffer);
+  if (SetJumpFlag == 0) {
+    //
+    // The intial call to SetJump() always returns 0.
+    // If this is the initial call, then exit the current periodic SMI handler
+    //
+    PeriodicSmiExit ();
+  }
+  
+  //
+  // We get here when a LongJump is performed from PeriodicSmiDispatchFunctionOnCpu()
+  // to resume a periodic SMI handler that called PeriodicSmiYield() on the 
+  // previous time this periodic SMI handler was dispatched.
+  //
+  // Clear the flag so the next periodic SMI dispatch will not resume.
+  //
+  PeriodicSmiLibraryHandler->YieldFlag = FALSE;
+
+  //
+  // Return the amount elapsed time that occured while yielded
+  //  
+  return PeriodicSmiLibraryHandler->ElapsedTime;
+}
+
+/**
+  Internal worker function that transfers control to an enabled periodic SMI 
+  handler.  If the enabled periodic SMI handler was allocated its own stack, 
+  then this function is called on that allocated stack through the BaseLin 
+  function SwitchStack().
+
+  @param[in] Context1  Context1 parameter passed into SwitchStack().
+  @param[in] Context2  Context2 parameter passed into SwitchStack().
+
+**/
+VOID
+EFIAPI
+PeriodicSmiDispatchFunctionSwitchStack (
+  IN VOID  *Context1,  OPTIONAL
+  IN VOID  *Context2   OPTIONAL
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+
+  //
+  // Convert Context1 to PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT * 
+  //  
+  PeriodicSmiLibraryHandler = (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *)Context1;
+
+  //
+  // Dispatch the registered handler passing in the context that was registered
+  // and the amount of time that has elapsed since the previous time this 
+  // periodic SMI handler was dispacthed.
+  //  
+  PeriodicSmiLibraryHandler->DispatchFunction (
+    PeriodicSmiLibraryHandler->Context,
+    PeriodicSmiLibraryHandler->ElapsedTime
+    );
+    
+  //
+  // If this DispatchFunction() returns, then unconditially call PeriodicSmiExit()
+  // to perform a LongJump() back to PeriodicSmiDispatchFunctionOnCpu(). The 
+  // LongJump() will resume exection on the original stack.
+  //  
+  PeriodicSmiExit ();
+}
+
+/**
+  Internal worker function that transfers control to an enabled periodic SMI 
+  handler on the specified logial CPU.  This function determines if the periodic 
+  SMI handler yielded and needs to be resumed.  It also and switches to an 
+  allocated stack if one was allocated in PeriodicSmiEnable().
+
+  @param[in] PeriodicSmiLibraryHandler  A pointer to the context for the periodic
+                                        SMI handler to execute.
+  
+**/
+VOID
+EFIAPI
+PeriodicSmiDispatchFunctionOnCpu (
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler
+  )
+{
+  //
+  // Save context in DispatchJumpBuffer.  The intial call to SetJump() always 
+  // returns 0.  If this is the initial call, then either resume from a prior 
+  // call to PeriodicSmiYield() or call the DispatchFunction registerd in 
+  // PeriodicSmiEnable() using an allocated stack if one was specified.
+  //  
+  if (SetJump (&PeriodicSmiLibraryHandler->DispatchJumpBuffer) != 0) {
+    return;
+  }
+  
+  //
+  // Capture the performance counter value just before the periodic SMI handler 
+  // is resumed so the amount of time the periodic SMI handler executes can be 
+  // calculated.
+  //
+  PeriodicSmiLibraryHandler->DispatchTotalTime      = 0;
+  PeriodicSmiLibraryHandler->DispatchCheckPointTime = GetPerformanceCounter();
+  
+  if (PeriodicSmiLibraryHandler->YieldFlag) {
+    //
+    // Perform a long jump back to the point where the previously dispatched 
+    // function called PeriodicSmiYield(). 
+    //
+    LongJump (&PeriodicSmiLibraryHandler->YieldJumpBuffer, 1);
+  } else if (PeriodicSmiLibraryHandler->Stack == NULL) {
+    //
+    // If Stack is NULL then call DispatchFunction using current stack passing 
+    // in the context that was registered and the amount of time that has 
+    // elapsed since the previous time this periodic SMI handler was dispacthed.
+    //  
+    PeriodicSmiLibraryHandler->DispatchFunction (
+      PeriodicSmiLibraryHandler->Context,
+      PeriodicSmiLibraryHandler->ElapsedTime
+      );
+      
+    //
+    // If this DispatchFunction() returns, then unconditially call PeriodicSmiExit()
+    // to perform a LongJump() back to this function.
+    //  
+    PeriodicSmiExit ();
+  } else {
+    //
+    // If Stack is not NULL then call DispatchFunction switching to the allocated stack
+    //
+    SwitchStack (
+      PeriodicSmiDispatchFunctionSwitchStack,
+      PeriodicSmiLibraryHandler,
+      NULL,
+      (UINT8 *)PeriodicSmiLibraryHandler->Stack + PeriodicSmiLibraryHandler->StackSize
+      );
+  }    
+
+  //
+  // Must never return
+  //
+  ASSERT (FALSE);
+  CpuDeadLoop();
+}
+
+/**
+  Internal worker function that transfers control to an enabled periodic SMI 
+  handler on the specified logial CPU.  This worker function is only called 
+  using the SMM Services Table function SmmStartupThisAp() to execute the 
+  periodic SMI handler on a logical CPU that is different than the one that is 
+  running the SMM Foundation.  When the periodic SMI handler returns, a lock is
+  released to notify the CPU that is running the SMM Foundation that the periodic
+  SMI handler execution has finished its execution.
+
+  @param[in, out] Buffer  A pointer to the context for the periodic SMI handler.
+
+**/
+VOID
+EFIAPI
+PeriodicSmiDispatchFunctionWithLock (
+  IN OUT VOID  *Buffer
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  
+  //
+  // Get context
+  //  
+  PeriodicSmiLibraryHandler = (PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *)Buffer;
+
+  //
+  // Execute dispatch function on the currently excuting logical CPU
+  //  
+  PeriodicSmiDispatchFunctionOnCpu (PeriodicSmiLibraryHandler);
+  
+  //
+  // Release the dispatch spin lock
+  //
+  ReleaseSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
+}
+
+/**
+  Internal worker function that transfers control to a periodic SMI handler that
+  was enabled using PeriodicSmiEnable().
+
+  @param[in]     DispatchHandle  The unique handle assigned to this handler by 
+                                 SmiHandlerRegister().
+  @param[in]     Context         Points to an optional handler context which was 
+                                 specified when the handler was registered.
+  @param[in, out] CommBuffer     A pointer to a collection of data in memory that
+                                 will be conveyed from a non-SMM environment into 
+                                 an SMM environment.
+  @param[in, out] CommBufferSize The size of the CommBuffer.
+
+  @retval EFI_SUCCESS                         The interrupt was handled and quiesced.
+                                              No other handlers should still be called.
+  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other
+                                              handlers should still be called.
+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other
+                                              handlers should still be called.
+  @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
+  
+**/
+EFI_STATUS
+EFIAPI
+PeriodicSmiDispatchFunction (
+  IN EFI_HANDLE  DispatchHandle,
+  IN CONST VOID  *Context         OPTIONAL,
+  IN OUT VOID    *CommBuffer      OPTIONAL,
+  IN OUT UINTN   *CommBufferSize  OPTIONAL
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  EFI_SMM_PERIODIC_TIMER_CONTEXT        *TimerContext;
+  EFI_STATUS                            Status;
+  
+  //
+  // Set the active periodic SMI handler
+  //  
+  PeriodicSmiLibraryHandler = SetActivePeriodicSmiLibraryHandler (Context);
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return EFI_NOT_FOUND;
+  }
+  
+  //
+  // Retrieve the elapsed time since the last time this periodic SMI handler was called
+  //
+  PeriodicSmiLibraryHandler->ElapsedTime = 0;
+  if (CommBuffer != NULL) {
+    TimerContext = (EFI_SMM_PERIODIC_TIMER_CONTEXT  *)CommBuffer;
+    PeriodicSmiLibraryHandler->ElapsedTime = TimerContext->ElapsedTime;
+  }
+
+  //
+  // Dispatch the periodic SMI handler
+  //
+  if ((PeriodicSmiLibraryHandler->Cpu == PERIODIC_SMI_LIBRARY_ANY_CPU) ||
+      (PeriodicSmiLibraryHandler->Cpu == gSmst->CurrentlyExecutingCpu)    ) {
+    //
+    // Dispatch on the currently execution CPU if the CPU specified in PeriodicSmiEnable()
+    // was PERIODIC_SMI_LIBARRY_ANY_CPU or the currently executing CPU matches the CPU
+    // that was specified in PeriodicSmiEnable().
+    //
+    PeriodicSmiDispatchFunctionOnCpu (PeriodicSmiLibraryHandler);
+  } else {
+    //
+    // Acquire spin lock for ths periodic SMI handler.  The AP will release the
+    // spin lock when it is done executing the periodic SMI handler.
+    //
+    AcquireSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
+  
+    //
+    // Execute the periodic SMI handler on the CPU that was specified in 
+    // PeriodicSmiEnable().
+    //
+    Status = gSmst->SmmStartupThisAp (
+                      PeriodicSmiDispatchFunctionWithLock,
+                      PeriodicSmiLibraryHandler->Cpu,
+                      PeriodicSmiLibraryHandler
+                      );
+    if (!EFI_ERROR (Status)) {
+      //
+      // Wait for the AP to release the spin lock.
+      //
+      while (!AcquireSpinLockOrFail (&PeriodicSmiLibraryHandler->DispatchLock)) {
+        CpuPause ();
+      }
+    }
+    
+    //
+    // Release the spin lock for the periodic SMI handler.
+    //
+    ReleaseSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
+  }
+
+  //
+  // Reclaim the active periodic SMI handler if it was disabled during the current dispatch.
+  //
+  if (PeriodicSmiLibraryHandler->DispatchHandle == NULL) {
+    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
+  }
+  
+  //
+  // Update state to show that there is no active periodic SMI handler
+  //  
+  SetActivePeriodicSmiLibraryHandler (NULL);
+
+  return EFI_SUCCESS;
+}
+  
+/**
+  This function enables a periodic SMI handler.
+  
+  @param[in, out] DispatchHandle   A pointer to the handle associated with the 
+                                   enabled periodic SMI handler.  This is an 
+                                   optional parameter that may be NULL.  If it is 
+                                   NULL, then the handle will not be returned, 
+                                   which means that the periodic SMI handler can 
+                                   never be disabled.
+  @param[in]     DispatchFunction  A pointer to a periodic SMI handler function.
+  @param[in]     Context           Optional content to pass into DispatchFunction.
+  @param[in]     TickPeriod        The requested tick period in 100ns units that 
+                                   control should be givien to the periodic SMI
+                                   handler.  Must be one of the supported values
+                                   returned by PeriodicSmiSupportedPickPeriod().
+  @param[in]     Cpu               Specifies the CPU that is required to execute
+                                   the periodic SMI handler.  If Cpu is 
+                                   PERIODIC_SMI_LIBRARY_ANY_CPU, then the periodic 
+                                   SMI handler will always be executed on the SMST 
+                                   CurrentlyExecutingCpu, which may vary across 
+                                   periodic SMIs.  If Cpu is between 0 and the SMST 
+                                   NumberOfCpus, then the periodic SMI will always
+                                   be executed on the requested CPU.
+  @param[in]     StackSize         The size, in bytes, of the stack to allocate for
+                                   use by the periodic SMI handler.  If 0, then the
+                                   default stack will be used.
+                            
+  @retval EFI_INVALID_PARAMETER  DispatchFunction is NULL.
+  @retval EFI_UNSUPPORTED        TickPeriod is not a supported tick period.  The 
+                                 supported tick periods can be retrieved using 
+                                 PeriodicSmiSupportedTickPeriod().
+  @retval EFI_INVALID_PARAMETER  Cpu is not PERIODIC_SMI_LIBRARY_ANY_CPU or in 
+                                 the range 0 to SMST NumberOfCpus.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to enable the 
+                                 periodic SMI handler.
+  @retval EFI_OUT_OF_RESOURCES   There are not enough resources to allocate the 
+                                 stack speficied by StackSize.
+  @retval EFI_SUCCESS            The periodic SMI handler was enabled.
+  
+**/
+EFI_STATUS 
+EFIAPI
+PeriodicSmiEnable (
+  IN OUT EFI_HANDLE                    *DispatchHandle,    OPTIONAL
+  IN     PERIODIC_SMI_LIBRARY_HANDLER  DispatchFunction,
+  IN     CONST VOID                    *Context,           OPTIONAL
+  IN     UINT64                        TickPeriod,
+  IN     UINTN                         Cpu,
+  IN     UINTN                         StackSize
+  )
+{
+  EFI_STATUS                            Status;
+  UINTN                                 Index;
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+
+  //
+  // Make sure all the input parameters are valid
+  //  
+  if (DispatchFunction == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  for (Index = 0; gSmiTickPeriodTable[Index] != 0; Index++) {
+    if (gSmiTickPeriodTable[Index] == TickPeriod) {
+      break;
+    }
+  }  
+  if (gSmiTickPeriodTable[Index] == 0) {
+    return EFI_UNSUPPORTED;
+  }
+  
+  if (Cpu != PERIODIC_SMI_LIBRARY_ANY_CPU && Cpu >= gSmst->NumberOfCpus) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Find a free periodic SMI handler entry
+  //  
+  PeriodicSmiLibraryHandler = FindFreePeriodicSmiLibraryHandler();
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Initialize a new periodic SMI handler entry
+  //
+  PeriodicSmiLibraryHandler->YieldFlag        = FALSE;
+  PeriodicSmiLibraryHandler->DispatchHandle   = NULL;
+  PeriodicSmiLibraryHandler->DispatchFunction = DispatchFunction;
+  PeriodicSmiLibraryHandler->Context          = (VOID *)Context;
+  PeriodicSmiLibraryHandler->Cpu              = Cpu;
+  PeriodicSmiLibraryHandler->StackSize        = ALIGN_VALUE (StackSize, EFI_PAGE_SIZE);
+  if (PeriodicSmiLibraryHandler->StackSize > 0) {
+    PeriodicSmiLibraryHandler->Stack = AllocatePages (EFI_SIZE_TO_PAGES (PeriodicSmiLibraryHandler->StackSize));
+    if (PeriodicSmiLibraryHandler->Stack == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+    ZeroMem (PeriodicSmiLibraryHandler->Stack, PeriodicSmiLibraryHandler->StackSize);
+  } else {
+    PeriodicSmiLibraryHandler->Stack = NULL;
+  }
+  InitializeSpinLock (&PeriodicSmiLibraryHandler->DispatchLock);
+  PeriodicSmiLibraryHandler->PerfomanceCounterRate = GetPerformanceCounterProperties (
+                                                       &PeriodicSmiLibraryHandler->PerfomanceCounterStartValue,
+                                                       &PeriodicSmiLibraryHandler->PerfomanceCounterEndValue
+                                                       );
+  PeriodicSmiLibraryHandler->RegisterContext.Period          = TickPeriod;
+  PeriodicSmiLibraryHandler->RegisterContext.SmiTickInterval = TickPeriod;
+  Status = gSmmPeriodicTimerDispatch2->Register (
+                                         gSmmPeriodicTimerDispatch2,
+                                         PeriodicSmiDispatchFunction,
+                                         &PeriodicSmiLibraryHandler->RegisterContext,
+                                         &PeriodicSmiLibraryHandler->DispatchHandle
+                                         );
+  if (EFI_ERROR (Status)) {
+    PeriodicSmiLibraryHandler->DispatchHandle = NULL;
+    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
+    return EFI_OUT_OF_RESOURCES;
+  }
+  
+  //
+  // Return the registered handle if the optional DispatchHandle parameter is not NULL
+  //
+  if (DispatchHandle != NULL) {
+    *DispatchHandle = PeriodicSmiLibraryHandler->DispatchHandle;
+  }
+  return EFI_SUCCESS;                                         
+}
+
+/**
+  This function disables a periodic SMI handler that has been previously
+  enabled with PeriodicSmiEnable().
+  
+  @param[in] DispatchHandle  A handle associated with a previously enabled periodic 
+                             SMI handler.  This is an optional parameter that may
+                             be NULL.  If it is NULL, then the active periodic SMI
+                             handlers is disabled.
+
+  @retval FALSE  DispatchHandle is NULL and there is no active periodic SMI handler.
+  @retval FALSE  The periodic SMI handler specified by DispatchHandle has 
+                 not been enabled with PeriodicSmiEnable().
+  @retval TRUE   The periodic SMI handler specified by DispatchHandle has 
+                 been disabled.  If DispatchHandle is NULL, then the active
+                 periodic SMI handler has been disabled.
+  
+**/
+BOOLEAN 
+EFIAPI
+PeriodicSmiDisable (
+  IN EFI_HANDLE  DispatchHandle    OPTIONAL
+  )
+{
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+  EFI_STATUS                            Status;
+
+  //
+  // Lookup the periodic SMI handler specified by DispatchHandle
+  //
+  PeriodicSmiLibraryHandler = LookupPeriodicSmiLibraryHandler (DispatchHandle);
+  if (PeriodicSmiLibraryHandler == NULL) {
+    return FALSE;
+  }
+  
+  //
+  // Unregister the periodic SMI handler from the SMM Periodic Timer Dispatch 2 Protocol
+  //
+  Status = gSmmPeriodicTimerDispatch2->UnRegister (
+                                         gSmmPeriodicTimerDispatch2,
+                                         PeriodicSmiLibraryHandler->DispatchHandle
+                                         );
+  if (EFI_ERROR (Status)) {
+    return FALSE;
+  }
+
+  //
+  // Mark the entry for the disabled periodic SMI handler as free, and
+  // call ReclaimPeriodicSmiLibraryHandler to move it to the list of free
+  // periodic SMI handlers.
+  //
+  PeriodicSmiLibraryHandler->DispatchHandle = NULL;
+  if (PeriodicSmiLibraryHandler != GetActivePeriodicSmiLibraryHandler ()) {
+    ReclaimPeriodicSmiLibraryHandler (PeriodicSmiLibraryHandler);
+  }
+
+  return TRUE;
+}
+
+/**
+  This constructor function caches the pointer to the SMM Periodic Timer 
+  Dispatch 2 Protocol and collects the list SMI tick rates that the hardware
+  supports.
+
+  @param[in] ImageHandle  The firmware allocated handle for the EFI image.
+  @param[in] SystemTable  A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmPeriodicSmiLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      *SmiTickInterval;
+  UINTN       Count;
+
+  //
+  // Locate the SMM Periodic Timer Dispatch 2 Protocol
+  //
+  Status = gSmst->SmmLocateProtocol (
+                    &gEfiSmmPeriodicTimerDispatch2ProtocolGuid,
+                    NULL,
+                    (VOID **)&gSmmPeriodicTimerDispatch2
+                    );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (gSmmPeriodicTimerDispatch2 != NULL);
+
+  //
+  // Count the number of periodic SMI tick intervals that the SMM Periodic Timer 
+  // Dipatch 2 Protocol supports.
+  //
+  SmiTickInterval = NULL;
+  Count = 0;
+  do {
+    Status = gSmmPeriodicTimerDispatch2->GetNextShorterInterval (
+                                           gSmmPeriodicTimerDispatch2,
+                                           &SmiTickInterval
+                                           );
+    Count++;                                           
+  } while (SmiTickInterval != NULL);                                           
+
+  //
+  // Allocate a buffer for the table of supported periodic SMI tick periods.
+  //  
+  gSmiTickPeriodTable = AllocateZeroPool (Count * sizeof (UINT64));
+  ASSERT (gSmiTickPeriodTable != NULL);
+  
+  //
+  // Fill in the table of supported periodic SMI tick periods.
+  //
+  SmiTickInterval = NULL;
+  Count = 0;
+  do {
+    gSmiTickPeriodTable[Count] = 0;
+    Status = gSmmPeriodicTimerDispatch2->GetNextShorterInterval (
+                                           gSmmPeriodicTimerDispatch2,
+                                           &SmiTickInterval
+                                           );
+    if (SmiTickInterval != NULL) {
+      gSmiTickPeriodTable[Count] = *SmiTickInterval;
+    }
+    Count++;
+  } while (SmiTickInterval != NULL);
+
+  //
+  // Allocate buffer for initial set of periodic SMI handlers
+  //
+  EnlargeFreePeriodicSmiLibraryHandlerList ();
+
+  return EFI_SUCCESS;
+}
+
+/**
+  The constructor function caches the pointer to the SMM Periodic Timer Dispatch 2 
+  Protocol and collects the list SMI tick rates that the hardware supports.
+
+  @param[in] ImageHandle  The firmware allocated handle for the EFI image.
+  @param[in] SystemTable  A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmPeriodicSmiLibDestructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  LIST_ENTRY                            *Link;
+  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;
+
+  //
+  // Free the table of supported periodic SMI tick rates
+  //
+  if (gSmiTickPeriodTable != NULL) {
+    FreePool (gSmiTickPeriodTable);
+  }
+
+  //
+  // Disable all periodic SMI handlers
+  //
+  for (Link = GetFirstNode (&gPeriodicSmiLibraryHandlers); !IsNull (&gPeriodicSmiLibraryHandlers, Link);) {
+    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
+    Link = GetNextNode (&gPeriodicSmiLibraryHandlers, Link);
+    PeriodicSmiDisable (PeriodicSmiLibraryHandler->DispatchHandle);
+  }
+
+  //
+  // Free all the periodic SMI handler entries
+  //
+  for (Link = GetFirstNode (&gFreePeriodicSmiLibraryHandlers); !IsNull (&gFreePeriodicSmiLibraryHandlers, Link);) {    
+    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);
+    Link = RemoveEntryList (Link);
+    FreePool (PeriodicSmiLibraryHandler);
+  }
+
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.inf b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.inf
new file mode 100644
index 000000000000..831aed586512
--- /dev/null
+++ b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.inf
@@ -0,0 +1,52 @@
+## @file
+# SMM Periodic SMI Library.
+#
+# Copyright (c) 2011 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmPeriodicSmiLib
+  MODULE_UNI_FILE                = SmmPeriodicSmiLib.uni
+  FILE_GUID                      = AED5F3FB-4CFF-4b60-9E43-1541B55C8267
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmmPeriodicSmiLib|DXE_SMM_DRIVER
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+  CONSTRUCTOR                    = SmmPeriodicSmiLibConstructor
+  DESTRUCTOR                     = SmmPeriodicSmiLibDestructor
+  
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  SmmPeriodicSmiLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  BaseLib
+  BaseMemoryLib
+  SynchronizationLib
+  DebugLib
+  TimerLib
+  MemoryAllocationLib
+  SmmServicesTableLib
+  
+[Protocols]
+  gEfiSmmPeriodicTimerDispatch2ProtocolGuid  ## CONSUMES
+  
+[Depex]
+  gEfiSmmPeriodicTimerDispatch2ProtocolGuid
+
diff --git a/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.uni b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.uni
new file mode 100644
index 000000000000..bc59e9c5b596
--- /dev/null
+++ b/MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// SMM Periodic SMI Library.
+//
+// SMM Periodic SMI Library.
+//
+// Copyright (c) 2011 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "SMM Periodic SMI Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "SMM Periodic SMI Library."
+
diff --git a/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.c b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.c
new file mode 100644
index 000000000000..5f890476b0e6
--- /dev/null
+++ b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.c
@@ -0,0 +1,85 @@
+/** @file
+  SMM Services Table Library.
+
+  Copyright (c) 2009 - 2015, 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 <PiSmm.h>
+#include <Protocol/SmmBase2.h>
+#include <Library/SmmServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+EFI_SMM_SYSTEM_TABLE2   *gSmst             = NULL;
+
+/**
+  The constructor function caches the pointer of SMM Services Table.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+SmmServicesTableLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS              Status;
+  EFI_SMM_BASE2_PROTOCOL  *InternalSmmBase2;
+
+  InternalSmmBase2 = NULL;
+  //
+  // Retrieve SMM Base2 Protocol,  Do not use gBS from UefiBootServicesTableLib on purpose
+  // to prevent inclusion of gBS, gST, and gImageHandle from SMM Drivers unless the 
+  // SMM driver explicity declares that dependency. 
+  //
+  Status = SystemTable->BootServices->LocateProtocol (
+                                        &gEfiSmmBase2ProtocolGuid,
+                                        NULL,
+                                        (VOID **)&InternalSmmBase2
+                                        );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (InternalSmmBase2 != NULL);
+
+  //
+  // We are in SMM, retrieve the pointer to SMM System Table
+  //
+  InternalSmmBase2->GetSmstLocation (InternalSmmBase2, &gSmst);
+  ASSERT (gSmst != NULL);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  This function allows the caller to determine if the driver is executing in 
+  System Management Mode(SMM).
+
+  This function returns TRUE if the driver is executing in SMM and FALSE if the 
+  driver is not executing in SMM.
+
+  @retval  TRUE  The driver is executing in System Management Mode (SMM).
+  @retval  FALSE The driver is not executing in System Management Mode (SMM). 
+
+**/
+BOOLEAN
+EFIAPI
+InSmm (
+  VOID
+  )
+{
+  //
+  // We are already in SMM
+  //
+  return TRUE;
+}
diff --git a/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.inf b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.inf
new file mode 100644
index 000000000000..4a3d7dca9b46
--- /dev/null
+++ b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.inf
@@ -0,0 +1,45 @@
+## @file
+# SMM Services Table Library.
+#
+# Copyright (c) 2009 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = SmmServicesTableLib
+  MODULE_UNI_FILE                = SmmServicesTableLib.uni
+  FILE_GUID                      = 064B4C5B-C5EF-4eff-85DF-65518EF1314D
+  MODULE_TYPE                    = DXE_SMM_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SmmServicesTableLib|DXE_SMM_DRIVER
+  PI_SPECIFICATION_VERSION       = 0x0001000A
+  CONSTRUCTOR                    = SmmServicesTableLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+
+[Sources]
+  SmmServicesTableLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+
+[Protocols]
+  gEfiSmmBase2ProtocolGuid                      ## CONSUMES
+
+[Depex]
+  gEfiSmmBase2ProtocolGuid
+
diff --git a/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.uni b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.uni
new file mode 100644
index 000000000000..935682d3e558
--- /dev/null
+++ b/MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// SMM Services Table Library.
+//
+// SMM Services Table Library.
+//
+// Copyright (c) 2009 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "SMM Services Table Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "SMM Services Table Library."
+
diff --git a/MdePkg/Library/UefiApplicationEntryPoint/ApplicationEntryPoint.c b/MdePkg/Library/UefiApplicationEntryPoint/ApplicationEntryPoint.c
new file mode 100644
index 000000000000..4c05a381ae28
--- /dev/null
+++ b/MdePkg/Library/UefiApplicationEntryPoint/ApplicationEntryPoint.c
@@ -0,0 +1,121 @@
+/** @file
+  Entry point library instance to a UEFI application.
+
+Copyright (c) 2007 - 2010, 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 <Uefi.h>
+#include <Library/UefiApplicationEntryPoint.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+
+/**
+  Entry point to UEFI Application.
+
+  This function is the entry point for a UEFI Application. This function must call
+  ProcessLibraryConstructorList(), ProcessModuleEntryPointList(), and ProcessLibraryDestructorList().
+  The return value from ProcessModuleEntryPointList() is returned.
+  If _gUefiDriverRevision is not zero and SystemTable->Hdr.Revision is less than _gUefiDriverRevison,
+  then return EFI_INCOMPATIBLE_VERSION.
+
+  @param  ImageHandle                The image handle of the UEFI Application.
+  @param  SystemTable                A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The UEFI Application exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                 Status;
+
+  if (_gUefiDriverRevision != 0) {
+    //
+    // Make sure that the EFI/UEFI spec revision of the platform is >= EFI/UEFI spec revision of the application.
+    //
+    if (SystemTable->Hdr.Revision < _gUefiDriverRevision) {
+      return EFI_INCOMPATIBLE_VERSION;
+    }
+  }
+
+  //
+  // Call constructor for all libraries.
+  //
+  ProcessLibraryConstructorList (ImageHandle, SystemTable);
+
+  //
+  // Call the module's entry point
+  //
+  Status = ProcessModuleEntryPointList (ImageHandle, SystemTable);
+
+  //
+  // Process destructor for all libraries.
+  //
+  ProcessLibraryDestructorList (ImageHandle, SystemTable);
+
+  //
+  // Return the return status code from the driver entry point
+  //
+  return Status;
+}
+
+
+/**
+  Invokes the library destructors for all dependent libraries and terminates
+  the UEFI Application. 
+
+  This function calls ProcessLibraryDestructorList() and the EFI Boot Service Exit()
+  with a status specified by Status.
+
+  @param  Status  Status returned by the application that is exiting.
+  
+**/
+VOID
+EFIAPI
+Exit (
+  IN EFI_STATUS  Status
+  )
+
+{
+  ProcessLibraryDestructorList (gImageHandle, gST);
+
+  gBS->Exit (gImageHandle, Status, 0, NULL);
+}
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint(). 
+
+  @param  ImageHandle  The image handle of the UEFI Application.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The UEFI Application exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  return _ModuleEntryPoint (ImageHandle, SystemTable);
+}
diff --git a/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf b/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
new file mode 100644
index 000000000000..c9c85d0616ef
--- /dev/null
+++ b/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
@@ -0,0 +1,40 @@
+## @file
+# Module entry point library for UEFI Application.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiApplicationEntryPoint
+  MODULE_UNI_FILE                = UefiApplicationEntryPoint.uni
+  FILE_GUID                      = DADE8301-CB29-4fd5-8148-56FD246C5B88
+  MODULE_TYPE                    = UEFI_APPLICATION
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiApplicationEntryPoint|UEFI_APPLICATION
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  ApplicationEntryPoint.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  DebugLib
+  BaseLib
+
diff --git a/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.uni b/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.uni
new file mode 100644
index 000000000000..f81c3887aafd
--- /dev/null
+++ b/MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Module entry point library for UEFI Application.
+//
+// Module entry point library for UEFI Application.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Module entry point library for UEFI Application"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Module entry point library for UEFI Application."
+
diff --git a/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.c b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.c
new file mode 100644
index 000000000000..28acc19778bf
--- /dev/null
+++ b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.c
@@ -0,0 +1,66 @@
+/** @file
+  This library retrieve the EFI_BOOT_SERVICES pointer from EFI system table in 
+  library's constructor.
+
+  Copyright (c) 2006 - 2008, 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 <Uefi.h>
+
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+EFI_HANDLE         gImageHandle = NULL;
+EFI_SYSTEM_TABLE   *gST         = NULL;
+EFI_BOOT_SERVICES  *gBS         = NULL;
+
+/**
+  The constructor function caches the pointer of Boot Services Table.
+    
+  The constructor function caches the pointer of Boot Services Table through System Table.
+  It will ASSERT() if the pointer of System Table is NULL.
+  It will ASSERT() if the pointer of Boot Services Table is NULL.
+  It will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiBootServicesTableLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  //
+  // Cache the Image Handle
+  //
+  gImageHandle = ImageHandle;
+  ASSERT (gImageHandle != NULL);
+
+  //
+  // Cache pointer to the EFI System Table
+  //
+  gST = SystemTable;
+  ASSERT (gST != NULL);
+
+  //
+  // Cache pointer to the EFI Boot Services Table
+  //
+  gBS = SystemTable->BootServices;
+  ASSERT (gBS != NULL);
+
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
new file mode 100644
index 000000000000..912724cadc46
--- /dev/null
+++ b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
@@ -0,0 +1,40 @@
+## @file
+# UEFI Boot Services Table Library implementation.
+# 
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiBootServicesTableLib
+  MODULE_UNI_FILE                = UefiBootServicesTableLib.uni
+  FILE_GUID                      = ff5c7a2c-ab7a-4366-8616-11c6e53247b6
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiBootServicesTableLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+  CONSTRUCTOR                    = UefiBootServicesTableLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiBootServicesTableLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.uni b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.uni
new file mode 100644
index 000000000000..1c98829b3e3a
--- /dev/null
+++ b/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// UEFI Boot Services Table Library implementation.
+//
+// UEFI Boot Services Table Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI Boot Services Table Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "UEFI Boot Services Table Library implementation."
+
diff --git a/MdePkg/Library/UefiDebugLibConOut/DebugLib.c b/MdePkg/Library/UefiDebugLibConOut/DebugLib.c
new file mode 100644
index 000000000000..ec95538a4adb
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibConOut/DebugLib.c
@@ -0,0 +1,278 @@
+/** @file
+  UEFI Debug Library that sends messages to the Console Output Device in the EFI System Table.
+
+  Copyright (c) 2006 - 2015, 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 <Uefi.h>
+
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/PrintLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugPrintErrorLevelLib.h>
+
+//
+// Define the maximum debug and assert message length that this library supports 
+//
+#define MAX_DEBUG_MESSAGE_LENGTH  0x100
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      Format string for the debug message to print.
+  @param  ...         A variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  )
+{
+  CHAR16   Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+  VA_LIST  Marker;
+
+  //
+  // If Format is NULL, then ASSERT().
+  //
+  ASSERT (Format != NULL);
+
+  //
+  // Check driver debug mask value and global mask
+  //
+  if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
+    return;
+  }
+
+  //
+  // Convert the DEBUG() message to a Unicode String
+  //
+  VA_START (Marker, Format);
+  UnicodeVSPrintAsciiFormat (Buffer, MAX_DEBUG_MESSAGE_LENGTH,  Format, Marker);
+  VA_END (Marker);
+
+
+  //
+  // Send the print string to the Console Output device
+  //
+  if ((gST != NULL) && (gST->ConOut != NULL)) {
+    gST->ConOut->OutputString (gST->ConOut, Buffer);
+  }
+}
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated 
+                       the assert condition.
+  @param  LineNumber   The line number in the source file that generated the 
+                       assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  )
+{
+  CHAR16  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+
+  //
+  // Generate the ASSERT() message in Unicode format
+  //
+  UnicodeSPrintAsciiFormat (
+    Buffer, 
+    sizeof (Buffer), 
+    "ASSERT [%a] %a(%d): %a\n",
+    gEfiCallerBaseName,
+    FileName, 
+    LineNumber, 
+    Description
+    );
+    
+  //
+  // Send the print string to the Console Output device
+  //
+  if ((gST != NULL) && (gST->ConOut != NULL)) {
+    gST->ConOut->OutputString (gST->ConOut, Buffer);
+  }
+
+  //
+  // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
+  //
+  if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
+    CpuBreakpoint ();
+  } else if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
+    CpuDeadLoop ();
+  }
+}
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  //
+  // If Buffer is NULL, then ASSERT().
+  //
+  ASSERT (Buffer != NULL);
+
+  //
+  // SetMem() checks for the the ASSERT() condition on Length and returns Buffer
+  //
+  return SetMem (Buffer, Length, PcdGet8(PcdDebugClearMemoryValue));
+}
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
+}
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
+}
diff --git a/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf b/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
new file mode 100644
index 000000000000..ee824bd01fcb
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
@@ -0,0 +1,54 @@
+## @file
+#  Instance of Debug Library using Console Output Device.
+#
+#  Debug Lib that sends messages to the Console Output Device in the EFI System Table.
+#
+#  Copyright (c) 2007 - 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDebugLibConOut
+  MODULE_UNI_FILE                = UefiDebugLibConOut.uni
+  FILE_GUID                      = 5cddfaf3-e9a7-4d16-bdce-1e002df475bb
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+
+[Sources]
+  DebugLib.c
+
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  BaseLib
+  PcdLib
+  PrintLib
+  UefiBootServicesTableLib
+  DebugPrintErrorLevelLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue        ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask            ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel    ## CONSUMES
+
diff --git a/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.uni b/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.uni
new file mode 100644
index 000000000000..34e6bcf8cdf5
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Debug Library using Console Output Device.
+//
+// Debug Lib that sends messages to the Console Output Device in the EFI System Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Debug Library using Console Output Device"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Debug Lib that sends messages to the Console Output Device in the EFI System Table."
+
diff --git a/MdePkg/Library/UefiDebugLibDebugPortProtocol/DebugLib.c b/MdePkg/Library/UefiDebugLibDebugPortProtocol/DebugLib.c
new file mode 100644
index 000000000000..193fc1a9f9b4
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibDebugPortProtocol/DebugLib.c
@@ -0,0 +1,331 @@
+/** @file
+  UEFI Debug Library that sends messages to EFI_DEBUGPORT_PROTOCOL.Write.
+
+  Copyright (c) 2015, 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 <Uefi.h>
+
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/PrintLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugPrintErrorLevelLib.h>
+
+#include <Protocol/DebugPort.h>
+
+//
+// Define the maximum debug and assert message length that this library supports 
+//
+#define MAX_DEBUG_MESSAGE_LENGTH  0x100
+
+//
+// Define the timeout for EFI_DEBUGPORT_PROTOCOL.Write 
+//
+#define WRITE_TIMEOUT 1000
+
+
+EFI_DEBUGPORT_PROTOCOL *mDebugPort = NULL;
+
+/**
+  Send message to DebugPort Protocol.
+
+  If mDebugPort is NULL, i.e. EFI_DEBUGPORT_PROTOCOL is not located,
+  EFI_DEBUGPORT_PROTOCOL is located first.
+  Then, Buffer is sent via EFI_DEBUGPORT_PROTOCOL.Write.
+
+  @param  Buffer         The message to be sent.
+  @param  BufferLength   The byte length of Buffer.
+**/
+VOID
+UefiDebugLibDebugPortProtocolWrite (
+  IN  CONST CHAR8  *Buffer,
+  IN        UINTN  BufferLength
+  )
+{
+  UINTN      Length;
+  EFI_STATUS Status;
+
+  //
+  // If mDebugPort is NULL, initialize first.
+  //
+  if (mDebugPort == NULL) {
+      Status = gBS->LocateProtocol (&gEfiDebugPortProtocolGuid, NULL, (VOID **)&mDebugPort);
+      if (EFI_ERROR (Status)) {
+          return;
+      }
+
+      mDebugPort->Reset (mDebugPort);
+  }
+
+  //
+  // EFI_DEBUGPORT_PROTOCOL.Write is called until all message is sent.
+  //
+  while (BufferLength > 0) {
+    Length = BufferLength;
+
+    Status = mDebugPort->Write (mDebugPort, WRITE_TIMEOUT, &Length, (VOID *) Buffer);
+    if (EFI_ERROR (Status) || BufferLength < Length) {
+      break;
+    }
+
+    Buffer += Length;
+    BufferLength -= Length;
+  }
+}
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      Format string for the debug message to print.
+  @param  ...         A variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  )
+{
+  CHAR8      Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+  VA_LIST    Marker;
+
+  //
+  // If Format is NULL, then ASSERT().
+  //
+  ASSERT (Format != NULL);
+
+  //
+  // Check driver debug mask value and global mask
+  //
+  if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
+    return;
+  }
+
+  //
+  // Convert the DEBUG() message to an ASCII String
+  //
+  VA_START (Marker, Format);
+  AsciiVSPrint (Buffer, sizeof (Buffer), Format, Marker);
+  VA_END (Marker);
+
+  //
+  // Send the print string to EFI_DEBUGPORT_PROTOCOL.Write.
+  //
+  UefiDebugLibDebugPortProtocolWrite (Buffer, AsciiStrLen (Buffer));
+}
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated 
+                       the assert condition.
+  @param  LineNumber   The line number in the source file that generated the 
+                       assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  )
+{
+  CHAR8  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+
+  //
+  // Generate the ASSERT() message in ASCII format
+  //
+  AsciiSPrint (
+    Buffer, 
+    sizeof (Buffer), 
+    "ASSERT [%a] %a(%d): %a\n",
+    gEfiCallerBaseName,
+    FileName, 
+    LineNumber, 
+    Description
+    );
+
+  //
+  // Send the print string to EFI_DEBUGPORT_PROTOCOL.Write.
+  //
+  UefiDebugLibDebugPortProtocolWrite (Buffer, AsciiStrLen (Buffer));
+
+  //
+  // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
+  //
+  if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
+    CpuBreakpoint ();
+  } else if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
+    CpuDeadLoop ();
+  }
+}
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  //
+  // If Buffer is NULL, then ASSERT().
+  //
+  ASSERT (Buffer != NULL);
+
+  //
+  // SetMem() checks for the the ASSERT() condition on Length and returns Buffer
+  //
+  return SetMem (Buffer, Length, PcdGet8(PcdDebugClearMemoryValue));
+}
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
+}
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
+}
+
diff --git a/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.inf b/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.inf
new file mode 100644
index 000000000000..67c1e069a6a7
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.inf
@@ -0,0 +1,57 @@
+## @file
+#  Instance of Debug Library using EFI_DEBUGPORT_PROTOCOL.
+#
+#  Debug Lib that sends messages to EFI_DEBUGPORT_PROTOCOL.Write.
+#
+#  Copyright (c) 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDebugLibDebugPortProtocol
+  MODULE_UNI_FILE                = UefiDebugLibDebugPortProtocol.uni
+  FILE_GUID                      = 102287b4-6b12-4D41-91e1-ebee1f3aa614
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+
+[Sources]
+  DebugLib.c
+
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  BaseLib
+  PcdLib
+  PrintLib
+  UefiBootServicesTableLib
+  DebugPrintErrorLevelLib
+
+[Protocols]
+  gEfiDebugPortProtocolGuid                     ## CONSUMES
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue        ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask            ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel    ## CONSUMES
+
diff --git a/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.uni b/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.uni
new file mode 100644
index 000000000000..890f314659dd
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Debug Library using EFI_DEBUGPORT_PROTOCOL.
+//
+// Debug Lib that sends messages to EFI_DEBUGPORT_PROTOCOL.Write.
+//
+// Copyright (c) 2015, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Debug Library using EFI_DEBUGPORT_PROTOCOL"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Debug Lib that sends messages to EFI_DEBUGPORT_PROTOCOL.Write."
+
diff --git a/MdePkg/Library/UefiDebugLibStdErr/DebugLib.c b/MdePkg/Library/UefiDebugLibStdErr/DebugLib.c
new file mode 100644
index 000000000000..5d6ad539f85b
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibStdErr/DebugLib.c
@@ -0,0 +1,279 @@
+/** @file
+  UEFI Debug Lib that sends messages to the Standard Error Device in the EFI System Table.
+
+  Copyright (c) 2006 - 2015, 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 <Uefi.h>
+
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/PrintLib.h>
+#include <Library/PcdLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugPrintErrorLevelLib.h>
+
+//
+// Define the maximum debug and assert message length that this library supports 
+//
+#define MAX_DEBUG_MESSAGE_LENGTH  0x100
+
+
+/**
+  Prints a debug message to the debug output device if the specified error level is enabled.
+
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 
+  associated variable argument list to the debug output device.
+
+  If Format is NULL, then ASSERT().
+
+  @param  ErrorLevel  The error level of the debug message.
+  @param  Format      The format string for the debug message to print.
+  @param  ...         The variable argument list whose contents are accessed 
+                      based on the format string specified by Format.
+
+**/
+VOID
+EFIAPI
+DebugPrint (
+  IN  UINTN        ErrorLevel,
+  IN  CONST CHAR8  *Format,
+  ...
+  )
+{
+  CHAR16   Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+  VA_LIST  Marker;
+
+  //
+  // If Format is NULL, then ASSERT().
+  //
+  ASSERT (Format != NULL);
+
+  //
+  // Check driver debug mask value and global mask
+  //
+  if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
+    return;
+  }
+
+  //
+  // Convert the DEBUG() message to a Unicode String
+  //
+  VA_START (Marker, Format);
+  UnicodeVSPrintAsciiFormat (Buffer, MAX_DEBUG_MESSAGE_LENGTH, Format, Marker);
+  VA_END (Marker);
+
+  //
+  // Send the print string to the Standard Error device
+  //
+  if ((gST != NULL) && (gST->StdErr != NULL)) {
+    gST->StdErr->OutputString (gST->StdErr, Buffer);
+  }
+}
+
+
+/**
+  Prints an assert message containing a filename, line number, and description.  
+  This may be followed by a breakpoint or a dead loop.
+
+  Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of 
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if 
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then 
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function 
+  returns immediately after the message is printed to the debug output device.
+  DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
+  processing another DebugAssert(), then DebugAssert() must return immediately.
+
+  If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
+  If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
+
+  @param  FileName     The pointer to the name of the source file that generated 
+                       the assert condition.
+  @param  LineNumber   The line number in the source file that generated the 
+                       assert condition
+  @param  Description  The pointer to the description of the assert condition.
+
+**/
+VOID
+EFIAPI
+DebugAssert (
+  IN CONST CHAR8  *FileName,
+  IN UINTN        LineNumber,
+  IN CONST CHAR8  *Description
+  )
+{
+  CHAR16  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
+
+  //
+  // Generate the ASSERT() message in Unicode format
+  //
+  UnicodeSPrintAsciiFormat (
+    Buffer, 
+    sizeof (Buffer),
+    "ASSERT [%a] %a(%d): %a\n",
+    gEfiCallerBaseName,
+    FileName, 
+    LineNumber, 
+    Description
+    );
+    
+  //
+  // Send the print string to the Standard Error device
+  //
+  if ((gST != NULL) && (gST->StdErr != NULL)) {
+    gST->StdErr->OutputString (gST->StdErr, Buffer);
+  }
+
+  //
+  // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
+  //
+  if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
+    CpuBreakpoint ();
+  } else if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
+    CpuDeadLoop ();
+  }
+}
+
+
+/**
+  Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the value specified by 
+  PcdDebugClearMemoryValue, and returns Buffer.
+
+  If Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param   Buffer  The pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
+  @param   Length  The number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue. 
+
+  @return  Buffer  The pointer to the target buffer filled with PcdDebugClearMemoryValue.
+
+**/
+VOID *
+EFIAPI
+DebugClearMemory (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  //
+  // If Buffer is NULL, then ASSERT().
+  //
+  ASSERT (Buffer != NULL);
+
+  //
+  // SetMem() checks for the the ASSERT() condition on Length and returns Buffer
+  //
+  return SetMem (Buffer, Length, PcdGet8(PcdDebugClearMemoryValue));
+}
+
+
+/**
+  Returns TRUE if ASSERT() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugAssertEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CODE() macros are enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugCodeEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
+}
+
+
+/**  
+  Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
+
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of 
+  PcdDebugProperyMask is set.  Otherwise FALSE is returned.
+
+  @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
+  @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
+
+**/
+BOOLEAN
+EFIAPI
+DebugClearMemoryEnabled (
+  VOID
+  )
+{
+  return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
+}
+
+/**
+  Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
+
+  @retval  TRUE    Current ErrorLevel is supported.
+  @retval  FALSE   Current ErrorLevel is not supported.
+
+**/
+BOOLEAN
+EFIAPI
+DebugPrintLevelEnabled (
+  IN  CONST UINTN        ErrorLevel
+  )
+{
+  return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
+}
diff --git a/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.inf b/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.inf
new file mode 100644
index 000000000000..5febaf47ee4f
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.inf
@@ -0,0 +1,52 @@
+## @file
+#  Instance of Debug Library using the Standard Error Device.
+#
+#  Debug Lib that sends messages to the the Standard Error Device in the EFI System Table.
+#
+#  Copyright (c) 2007 - 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDebugLibStdErr
+  MODULE_UNI_FILE                = UefiDebugLibStdErr.uni
+  FILE_GUID                      = b57a1df6-ffdb-4247-a3df-3a562176751a
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DebugLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DebugLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  BaseLib
+  PcdLib
+  PrintLib
+  UefiBootServicesTableLib
+  DebugPrintErrorLevelLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue   ## SOMETIMES_CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask       ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel ## CONSUMES
+
diff --git a/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.uni b/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.uni
new file mode 100644
index 000000000000..50f217a0d4f0
--- /dev/null
+++ b/MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Debug Library using the Standard Error Device.
+//
+// Debug Lib that sends messages to the the Standard Error Device in the EFI System Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Debug Library using the Standard Error Device"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Debug Lib sends messages to the Standard Error Device in the EFI System Table."
+
diff --git a/MdePkg/Library/UefiDevicePathLib/DevicePathFromText.c b/MdePkg/Library/UefiDevicePathLib/DevicePathFromText.c
new file mode 100644
index 000000000000..aa94753169c9
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/DevicePathFromText.c
@@ -0,0 +1,3509 @@
+/** @file
+  DevicePathFromText protocol as defined in the UEFI 2.0 specification.
+
+Copyright (c) 2013 - 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 (
+  IN 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 (
+  IN CHAR16 *Str,
+  IN 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 (
+  IN OUT CHAR16 **List,
+  IN     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 (
+  IN OUT 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 (
+  IN OUT CHAR16   **DevicePath,
+  OUT    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 (
+  IN 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 (
+  IN 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 (
+  IN  CHAR16  *Str,
+  OUT 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 (
+  IN     CHAR16 *Str,
+  IN OUT 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 (
+  IN UINT8  Type,
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN CHAR16 *TextDeviceNode,
+  IN UINT8  Type,
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN CHAR16 *TextDeviceNode
+  )
+{
+  return DevPathFromTextGenericPath (ACPI_DEVICE_PATH, TextDeviceNode);
+}
+
+/**
+  Converts a string to EisaId.
+
+  @param Text   The input string.
+
+  @return UINT32 EISA ID.
+**/
+UINT32
+EisaIdFromText (
+  IN 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 (
+  IN 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 (
+  IN CHAR16 *TextDeviceNode,
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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, &gEfiDebugPortProtocolGuid);
+
+  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 (
+  IN 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);
+  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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN CHAR16         *TextDeviceNode,
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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.
+  //
+  CopyMem (
+    (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 (
+  IN 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 (
+  IN 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;
+
+  ISCSIDevPath->NetworkProtocol  = (UINT16) StrCmp (ProtocolStr, L"TCP");
+
+  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 (
+  IN 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 (
+  IN CHAR16 *TextDeviceNode
+  )
+{
+  CHAR16                  *BluetoothStr;
+  CHAR16                  *Walker;
+  CHAR16                  *TempNumBuffer;
+  UINTN                   TempBufferSize;
+  INT32                   Index;
+  BLUETOOTH_DEVICE_PATH   *BluetoothDp;
+
+  BluetoothStr = GetNextParamStr (&TextDeviceNode);
+  BluetoothDp = (BLUETOOTH_DEVICE_PATH *) CreateDeviceNode (
+                                   MESSAGING_DEVICE_PATH,
+                                   MSG_BLUETOOTH_DP,
+                                   (UINT16) sizeof (BLUETOOTH_DEVICE_PATH)
+                                   );
+
+  Index = sizeof (BLUETOOTH_ADDRESS) - 1;
+  Walker = BluetoothStr;
+  while (!IS_NULL(*Walker) && Index >= 0) {
+    TempBufferSize = 2 * sizeof(CHAR16) + StrSize(L"0x");
+    TempNumBuffer = AllocateZeroPool (TempBufferSize);
+    if (TempNumBuffer == NULL) {
+      break;
+    }
+    StrCpyS (TempNumBuffer, TempBufferSize / sizeof (CHAR16), L"0x");
+    StrnCatS (TempNumBuffer, TempBufferSize / sizeof (CHAR16), Walker, 2);
+    BluetoothDp->BD_ADDR.Address[Index] = (UINT8)Strtoi (TempNumBuffer);
+    FreePool (TempNumBuffer);
+    Walker += 2;
+    Index--;
+  }
+  
+  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 (
+  IN 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));
+    CopyMem (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 (
+  IN 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 (
+  IN 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 (
+  IN 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);
+    CopyMem (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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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 (
+  IN 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;
+}
+
+GLOBAL_REMOVE_IF_UNREFERENCED 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 *
+EFIAPI
+UefiDevicePathLibConvertTextToDeviceNode (
+  IN 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);
+    FreePool (ParamStr);
+  }
+
+  FreePool (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 *
+EFIAPI
+UefiDevicePathLibConvertTextToDevicePath (
+  IN 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);
+    FreePool (DevicePath);
+    FreePool (DeviceNode);
+    DevicePath = NewDevicePath;
+
+    if (IsInstanceEnd) {
+      DeviceNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
+      ASSERT (DeviceNode != NULL);
+      SetDevicePathEndNode (DeviceNode);
+
+      NewDevicePath = AppendDevicePathNode (DevicePath, DeviceNode);
+      FreePool (DevicePath);
+      FreePool (DeviceNode);
+      DevicePath = NewDevicePath;
+    }
+  }
+
+  FreePool (DevicePathStr);
+  return DevicePath;
+}
diff --git a/MdePkg/Library/UefiDevicePathLib/DevicePathToText.c b/MdePkg/Library/UefiDevicePathLib/DevicePathToText.c
new file mode 100644
index 000000000000..275bdee282e6
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/DevicePathToText.c
@@ -0,0 +1,2345 @@
+/** @file
+  DevicePathToText protocol as defined in the UEFI 2.0 specification.
+
+  (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
+Copyright (c) 2013 - 2015, 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"
+
+/**
+  Concatenates a formatted unicode string to allocated pool. The caller must
+  free the resulting buffer.
+
+  @param Str             Tracks the allocated pool, size in use, and
+                         amount of pool allocated.
+  @param Fmt             The format string
+  @param ...             Variable arguments based on the format string.
+
+  @return Allocated buffer with the formatted string printed in it.
+          The caller must free the allocated buffer. The buffer
+          allocation is not packed.
+
+**/
+CHAR16 *
+EFIAPI
+UefiDevicePathLibCatPrint (
+  IN OUT POOL_PRINT   *Str,
+  IN CHAR16           *Fmt,
+  ...
+  )
+{
+  UINTN   Count;
+  VA_LIST Args;
+
+  VA_START (Args, Fmt);
+  Count = SPrintLength (Fmt, Args);
+  VA_END(Args);
+
+  if ((Str->Count + (Count + 1)) * sizeof (CHAR16) > Str->Capacity) {
+    Str->Capacity = (Str->Count + (Count + 1) * 2) * sizeof (CHAR16);
+    Str->Str = ReallocatePool (
+                 Str->Count * sizeof (CHAR16),
+                 Str->Capacity,
+                 Str->Str
+                 );
+    ASSERT (Str->Str != NULL);
+  }
+  VA_START (Args, Fmt);
+  UnicodeVSPrint (&Str->Str[Str->Count], Str->Capacity - Str->Count * sizeof (CHAR16), Fmt, Args);
+  Str->Count += Count;
+  
+  VA_END (Args);
+  return Str->Str;
+}
+
+/**
+  Converts a PCI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextPci (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  PCI_DEVICE_PATH *Pci;
+
+  Pci = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Pci(0x%x,0x%x)", Pci->Device, Pci->Function);
+}
+
+/**
+  Converts a PC Card device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextPccard (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  PCCARD_DEVICE_PATH  *Pccard;
+
+  Pccard = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"PcCard(0x%x)", Pccard->FunctionNumber);
+}
+
+/**
+  Converts a Memory Map device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextMemMap (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  MEMMAP_DEVICE_PATH  *MemMap;
+
+  MemMap = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"MemoryMapped(0x%x,0x%lx,0x%lx)",
+    MemMap->MemoryType,
+    MemMap->StartingAddress,
+    MemMap->EndingAddress
+    );
+}
+
+/**
+  Converts a Vendor device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextVendor (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  VENDOR_DEVICE_PATH  *Vendor;
+  CHAR16              *Type;
+  UINTN               Index;
+  UINTN               DataLength;
+  UINT32              FlowControlMap;
+  UINT16              Info;
+
+  Vendor = (VENDOR_DEVICE_PATH *) DevPath;
+  switch (DevicePathType (&Vendor->Header)) {
+  case HARDWARE_DEVICE_PATH:
+    Type = L"Hw";
+    break;
+
+  case MESSAGING_DEVICE_PATH:
+    Type = L"Msg";
+    if (AllowShortcuts) {
+      if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) {
+        UefiDevicePathLibCatPrint (Str, L"VenPcAnsi()");
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) {
+        UefiDevicePathLibCatPrint (Str, L"VenVt100()");
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) {
+        UefiDevicePathLibCatPrint (Str, L"VenVt100Plus()");
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) {
+        UefiDevicePathLibCatPrint (Str, L"VenUft8()");
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) {
+        FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap);
+        switch (FlowControlMap & 0x00000003) {
+        case 0:
+          UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"None");
+          break;
+
+        case 1:
+          UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"Hardware");
+          break;
+
+        case 2:
+          UefiDevicePathLibCatPrint (Str, L"UartFlowCtrl(%s)", L"XonXoff");
+          break;
+
+        default:
+          break;
+        }
+
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) {
+        UefiDevicePathLibCatPrint (
+          Str,
+          L"SAS(0x%lx,0x%lx,0x%x,",
+          ((SAS_DEVICE_PATH *) Vendor)->SasAddress,
+          ((SAS_DEVICE_PATH *) Vendor)->Lun,
+          ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort
+          );
+        Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology);
+        if (((Info & 0x0f) == 0) && ((Info & BIT7) == 0)) {
+          UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0,");
+        } else if (((Info & 0x0f) <= 2) && ((Info & BIT7) == 0)) {
+          UefiDevicePathLibCatPrint (
+            Str,
+            L"%s,%s,%s,",
+            ((Info & BIT4) != 0) ? L"SATA" : L"SAS",
+            ((Info & BIT5) != 0) ? L"External" : L"Internal",
+            ((Info & BIT6) != 0) ? L"Expanded" : L"Direct"
+            );
+          if ((Info & 0x0f) == 1) {
+            UefiDevicePathLibCatPrint (Str, L"0,");
+          } else {
+            //
+            // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
+            //
+            UefiDevicePathLibCatPrint (Str, L"0x%x,", ((Info >> 8) & 0xff) + 1);
+          }
+        } else {
+          UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0,", Info);
+        }
+
+        UefiDevicePathLibCatPrint (Str, L"0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved);
+        return ;
+      } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) {
+        UefiDevicePathLibCatPrint (Str, L"DebugPort()");
+        return ;
+      }
+    }
+    break;
+
+  case MEDIA_DEVICE_PATH:
+    Type = L"Media";
+    break;
+
+  default:
+    Type = L"?";
+    break;
+  }
+
+  DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH);
+  UefiDevicePathLibCatPrint (Str, L"Ven%s(%g", Type, &Vendor->Guid);
+  if (DataLength != 0) {
+    UefiDevicePathLibCatPrint (Str, L",");
+    for (Index = 0; Index < DataLength; Index++) {
+      UefiDevicePathLibCatPrint (Str, L"%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]);
+    }
+  }
+
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+/**
+  Converts a Controller device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextController (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  CONTROLLER_DEVICE_PATH  *Controller;
+
+  Controller = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"Ctrl(0x%x)",
+    Controller->ControllerNumber
+    );
+}
+
+/**
+  Converts a BMC device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextBmc (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  BMC_DEVICE_PATH    *Bmc;
+
+  Bmc = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"BMC(0x%x,0x%lx)",
+    Bmc->InterfaceType,
+    ReadUnaligned64 ((UINT64 *) (&Bmc->BaseAddress))
+    );
+}
+
+/**
+  Converts a ACPI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextAcpi (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  ACPI_HID_DEVICE_PATH  *Acpi;
+
+  Acpi = DevPath;
+  if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) {
+    switch (EISA_ID_TO_NUM (Acpi->HID)) {
+    case 0x0a03:
+      UefiDevicePathLibCatPrint (Str, L"PciRoot(0x%x)", Acpi->UID);
+      break;
+
+    case 0x0a08:
+      UefiDevicePathLibCatPrint (Str, L"PcieRoot(0x%x)", Acpi->UID);
+      break;
+
+    case 0x0604:
+      UefiDevicePathLibCatPrint (Str, L"Floppy(0x%x)", Acpi->UID);
+      break;
+
+    case 0x0301:
+      UefiDevicePathLibCatPrint (Str, L"Keyboard(0x%x)", Acpi->UID);
+      break;
+
+    case 0x0501:
+      UefiDevicePathLibCatPrint (Str, L"Serial(0x%x)", Acpi->UID);
+      break;
+
+    case 0x0401:
+      UefiDevicePathLibCatPrint (Str, L"ParallelPort(0x%x)", Acpi->UID);
+      break;
+
+    default:
+      UefiDevicePathLibCatPrint (Str, L"Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID);
+      break;
+    }
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID);
+  }
+}
+
+/**
+  Converts a ACPI extended HID device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextAcpiEx (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  ACPI_EXTENDED_HID_DEVICE_PATH  *AcpiEx;
+  CHAR8                          *HIDStr;
+  CHAR8                          *UIDStr;
+  CHAR8                          *CIDStr;
+  CHAR16                         HIDText[11];
+  CHAR16                         CIDText[11];
+
+  AcpiEx = DevPath;
+  HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH));
+  UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1;
+  CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1;
+
+  //
+  // Converts EISA identification to string.
+  // 
+  UnicodeSPrint (
+    HIDText,
+    sizeof (HIDText),
+    L"%c%c%c%04X",
+    ((AcpiEx->HID >> 10) & 0x1f) + 'A' - 1,
+    ((AcpiEx->HID >>  5) & 0x1f) + 'A' - 1,
+    ((AcpiEx->HID >>  0) & 0x1f) + 'A' - 1,
+    (AcpiEx->HID >> 16) & 0xFFFF
+    );
+  UnicodeSPrint (
+    CIDText,
+    sizeof (CIDText),
+    L"%c%c%c%04X",
+    ((AcpiEx->CID >> 10) & 0x1f) + 'A' - 1,
+    ((AcpiEx->CID >>  5) & 0x1f) + 'A' - 1,
+    ((AcpiEx->CID >>  0) & 0x1f) + 'A' - 1,
+    (AcpiEx->CID >> 16) & 0xFFFF
+    );
+
+  if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) {
+    //
+    // use AcpiExp()
+    //
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"AcpiExp(%s,%s,%a)",
+      HIDText,
+      CIDText,
+      UIDStr
+      );
+  } else {
+    if (AllowShortcuts) {
+      //
+      // display only
+      //
+      if (AcpiEx->HID == 0) {
+        UefiDevicePathLibCatPrint (Str, L"AcpiEx(%a,", HIDStr);
+      } else {
+        UefiDevicePathLibCatPrint (Str, L"AcpiEx(%s,", HIDText);
+      }
+
+      if (AcpiEx->UID == 0) {
+        UefiDevicePathLibCatPrint (Str, L"%a,", UIDStr);
+      } else {
+        UefiDevicePathLibCatPrint (Str, L"0x%x,", AcpiEx->UID);
+      }
+
+      if (AcpiEx->CID == 0) {
+        UefiDevicePathLibCatPrint (Str, L"%a)", CIDStr);
+      } else {
+        UefiDevicePathLibCatPrint (Str, L"%s)", CIDText);
+      }
+    } else {
+      UefiDevicePathLibCatPrint (
+        Str,
+        L"AcpiEx(%s,%s,0x%x,%a,%a,%a)",
+        HIDText,
+        CIDText,
+        AcpiEx->UID,
+        HIDStr,
+        CIDStr,
+        UIDStr
+        );
+    }
+  }
+}
+
+/**
+  Converts a ACPI address device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextAcpiAdr (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  ACPI_ADR_DEVICE_PATH    *AcpiAdr;
+  UINT16                  Index;
+  UINT16                  Length;
+  UINT16                  AdditionalAdrCount;
+
+  AcpiAdr            = DevPath;
+  Length             = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr);
+  AdditionalAdrCount = (UINT16) ((Length - 8) / 4);
+
+  UefiDevicePathLibCatPrint (Str, L"AcpiAdr(0x%x", AcpiAdr->ADR);
+  for (Index = 0; Index < AdditionalAdrCount; Index++) {
+    UefiDevicePathLibCatPrint (Str, L",0x%x", *(UINT32 *) ((UINT8 *) AcpiAdr + 8 + Index * 4));
+  }
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+/**
+  Converts a ATAPI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextAtapi (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  ATAPI_DEVICE_PATH *Atapi;
+
+  Atapi = DevPath;
+
+  if (DisplayOnly) {
+    UefiDevicePathLibCatPrint (Str, L"Ata(0x%x)", Atapi->Lun);
+  } else {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"Ata(%s,%s,0x%x)",
+      (Atapi->PrimarySecondary == 1) ? L"Secondary" : L"Primary",
+      (Atapi->SlaveMaster == 1) ? L"Slave" : L"Master",
+      Atapi->Lun
+      );
+  }
+}
+
+/**
+  Converts a SCSI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextScsi (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  SCSI_DEVICE_PATH  *Scsi;
+
+  Scsi = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun);
+}
+
+/**
+  Converts a Fibre device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextFibre (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  FIBRECHANNEL_DEVICE_PATH  *Fibre;
+
+  Fibre = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun);
+}
+
+/**
+  Converts a FibreEx device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextFibreEx (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  FIBRECHANNELEX_DEVICE_PATH  *FibreEx;
+  UINTN                       Index;
+
+  FibreEx = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"FibreEx(0x");
+  for (Index = 0; Index < sizeof (FibreEx->WWN) / sizeof (FibreEx->WWN[0]); Index++) {
+    UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->WWN[Index]);
+  }
+  UefiDevicePathLibCatPrint (Str, L",0x");
+  for (Index = 0; Index < sizeof (FibreEx->Lun) / sizeof (FibreEx->Lun[0]); Index++) {
+    UefiDevicePathLibCatPrint (Str, L"%02x", FibreEx->Lun[Index]);
+  }
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+/**
+  Converts a Sas Ex device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextSasEx (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  SASEX_DEVICE_PATH  *SasEx;
+  UINTN              Index;
+
+  SasEx = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"SasEx(0x");
+
+  for (Index = 0; Index < sizeof (SasEx->SasAddress) / sizeof (SasEx->SasAddress[0]); Index++) {
+    UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->SasAddress[Index]);
+  }
+  UefiDevicePathLibCatPrint (Str, L",0x");
+  for (Index = 0; Index < sizeof (SasEx->Lun) / sizeof (SasEx->Lun[0]); Index++) {
+    UefiDevicePathLibCatPrint (Str, L"%02x", SasEx->Lun[Index]);
+  }
+  UefiDevicePathLibCatPrint (Str, L",0x%x,", SasEx->RelativeTargetPort);
+
+  if (((SasEx->DeviceTopology & 0x0f) == 0) && ((SasEx->DeviceTopology & BIT7) == 0)) {
+    UefiDevicePathLibCatPrint (Str, L"NoTopology,0,0,0");
+  } else if (((SasEx->DeviceTopology & 0x0f) <= 2) && ((SasEx->DeviceTopology & BIT7) == 0)) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"%s,%s,%s,",
+      ((SasEx->DeviceTopology & BIT4) != 0) ? L"SATA" : L"SAS",
+      ((SasEx->DeviceTopology & BIT5) != 0) ? L"External" : L"Internal",
+      ((SasEx->DeviceTopology & BIT6) != 0) ? L"Expanded" : L"Direct"
+      );
+    if ((SasEx->DeviceTopology & 0x0f) == 1) {
+      UefiDevicePathLibCatPrint (Str, L"0");
+    } else {
+      //
+      // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256
+      //
+      UefiDevicePathLibCatPrint (Str, L"0x%x", ((SasEx->DeviceTopology >> 8) & 0xff) + 1);
+    }
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"0x%x,0,0,0", SasEx->DeviceTopology);
+  }
+
+  UefiDevicePathLibCatPrint (Str, L")");
+  return ;
+
+}
+
+/**
+  Converts a NVM Express Namespace device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextNVMe (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  NVME_NAMESPACE_DEVICE_PATH *Nvme;
+  UINT8                      *Uuid;
+
+  Nvme = DevPath;
+  Uuid = (UINT8 *) &Nvme->NamespaceUuid;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"NVMe(0x%x,%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x)",
+    Nvme->NamespaceId,
+    Uuid[7], Uuid[6], Uuid[5], Uuid[4],
+    Uuid[3], Uuid[2], Uuid[1], Uuid[0]
+    );
+}
+
+/**
+  Converts a UFS device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUfs (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  UFS_DEVICE_PATH  *Ufs;
+
+  Ufs = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"UFS(0x%x,0x%x)", Ufs->Pun, Ufs->Lun);
+}
+
+/**
+  Converts a SD (Secure Digital) device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextSd (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  SD_DEVICE_PATH             *Sd;
+
+  Sd = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"SD(0x%x)",
+    Sd->SlotNumber
+    );
+}
+
+/**
+  Converts a EMMC (Embedded MMC) device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextEmmc (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  EMMC_DEVICE_PATH             *Emmc;
+
+  Emmc = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"eMMC(0x%x)",
+    Emmc->SlotNumber
+    );
+}
+
+/**
+  Converts a 1394 device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToText1394 (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  F1394_DEVICE_PATH *F1394DevPath;
+
+  F1394DevPath = DevPath;
+  //
+  // Guid has format of IEEE-EUI64
+  //
+  UefiDevicePathLibCatPrint (Str, L"I1394(%016lx)", F1394DevPath->Guid);
+}
+
+/**
+  Converts a USB device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUsb (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  USB_DEVICE_PATH *Usb;
+
+  Usb = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber);
+}
+
+/**
+  Converts a USB WWID device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUsbWWID (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  USB_WWID_DEVICE_PATH  *UsbWWId;
+  CHAR16                *SerialNumberStr;
+  CHAR16                *NewStr;
+  UINT16                Length;
+
+  UsbWWId = DevPath;
+
+  SerialNumberStr = (CHAR16 *) ((UINT8 *) UsbWWId + sizeof (USB_WWID_DEVICE_PATH));
+  Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16));
+  if (SerialNumberStr [Length - 1] != 0) {
+    //
+    // In case no NULL terminator in SerialNumber, create a new one with NULL terminator
+    //
+    NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr);
+    ASSERT (NewStr != NULL);
+    NewStr [Length] = 0;
+    SerialNumberStr = NewStr;
+  }
+
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"UsbWwid(0x%x,0x%x,0x%x,\"%s\")",
+    UsbWWId->VendorId,
+    UsbWWId->ProductId,
+    UsbWWId->InterfaceNumber,
+    SerialNumberStr
+    );
+}
+
+/**
+  Converts a Logic Unit device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextLogicalUnit (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit;
+
+  LogicalUnit = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Unit(0x%x)", LogicalUnit->Lun);
+}
+
+/**
+  Converts a USB class device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUsbClass (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  USB_CLASS_DEVICE_PATH *UsbClass;
+  BOOLEAN               IsKnownSubClass;
+
+
+  UsbClass = DevPath;
+
+  IsKnownSubClass = TRUE;
+  switch (UsbClass->DeviceClass) {
+  case USB_CLASS_AUDIO:
+    UefiDevicePathLibCatPrint (Str, L"UsbAudio");
+    break;
+
+  case USB_CLASS_CDCCONTROL:
+    UefiDevicePathLibCatPrint (Str, L"UsbCDCControl");
+    break;
+
+  case USB_CLASS_HID:
+    UefiDevicePathLibCatPrint (Str, L"UsbHID");
+    break;
+
+  case USB_CLASS_IMAGE:
+    UefiDevicePathLibCatPrint (Str, L"UsbImage");
+    break;
+
+  case USB_CLASS_PRINTER:
+    UefiDevicePathLibCatPrint (Str, L"UsbPrinter");
+    break;
+
+  case USB_CLASS_MASS_STORAGE:
+    UefiDevicePathLibCatPrint (Str, L"UsbMassStorage");
+    break;
+
+  case USB_CLASS_HUB:
+    UefiDevicePathLibCatPrint (Str, L"UsbHub");
+    break;
+
+  case USB_CLASS_CDCDATA:
+    UefiDevicePathLibCatPrint (Str, L"UsbCDCData");
+    break;
+
+  case USB_CLASS_SMART_CARD:
+    UefiDevicePathLibCatPrint (Str, L"UsbSmartCard");
+    break;
+
+  case USB_CLASS_VIDEO:
+    UefiDevicePathLibCatPrint (Str, L"UsbVideo");
+    break;
+
+  case USB_CLASS_DIAGNOSTIC:
+    UefiDevicePathLibCatPrint (Str, L"UsbDiagnostic");
+    break;
+
+  case USB_CLASS_WIRELESS:
+    UefiDevicePathLibCatPrint (Str, L"UsbWireless");
+    break;
+
+  default:
+    IsKnownSubClass = FALSE;
+    break;
+  }
+
+  if (IsKnownSubClass) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"(0x%x,0x%x,0x%x,0x%x)",
+      UsbClass->VendorId,
+      UsbClass->ProductId,
+      UsbClass->DeviceSubClass,
+      UsbClass->DeviceProtocol
+      );
+    return;
+  }
+
+  if (UsbClass->DeviceClass == USB_CLASS_RESERVE) {
+    if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) {
+      UefiDevicePathLibCatPrint (
+        Str,
+        L"UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)",
+        UsbClass->VendorId,
+        UsbClass->ProductId,
+        UsbClass->DeviceProtocol
+        );
+      return;
+    } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) {
+      UefiDevicePathLibCatPrint (
+        Str,
+        L"UsbIrdaBridge(0x%x,0x%x,0x%x)",
+        UsbClass->VendorId,
+        UsbClass->ProductId,
+        UsbClass->DeviceProtocol
+        );
+      return;
+    } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) {
+      UefiDevicePathLibCatPrint (
+        Str,
+        L"UsbTestAndMeasurement(0x%x,0x%x,0x%x)",
+        UsbClass->VendorId,
+        UsbClass->ProductId,
+        UsbClass->DeviceProtocol
+        );
+      return;
+    }
+  }
+
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)",
+    UsbClass->VendorId,
+    UsbClass->ProductId,
+    UsbClass->DeviceClass,
+    UsbClass->DeviceSubClass,
+    UsbClass->DeviceProtocol
+    );
+}
+
+/**
+  Converts a SATA device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextSata (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  SATA_DEVICE_PATH *Sata;
+
+  Sata = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"Sata(0x%x,0x%x,0x%x)",
+    Sata->HBAPortNumber,
+    Sata->PortMultiplierPortNumber,
+    Sata->Lun
+    );
+}
+
+/**
+  Converts a I20 device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextI2O (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  I2O_DEVICE_PATH *I2ODevPath;
+
+  I2ODevPath = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"I2O(0x%x)", I2ODevPath->Tid);
+}
+
+/**
+  Converts a MAC address device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextMacAddr (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  MAC_ADDR_DEVICE_PATH  *MacDevPath;
+  UINTN                 HwAddressSize;
+  UINTN                 Index;
+
+  MacDevPath = DevPath;
+
+  HwAddressSize = sizeof (EFI_MAC_ADDRESS);
+  if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) {
+    HwAddressSize = 6;
+  }
+
+  UefiDevicePathLibCatPrint (Str, L"MAC(");
+
+  for (Index = 0; Index < HwAddressSize; Index++) {
+    UefiDevicePathLibCatPrint (Str, L"%02x", MacDevPath->MacAddress.Addr[Index]);
+  }
+
+  UefiDevicePathLibCatPrint (Str, L",0x%x)", MacDevPath->IfType);
+}
+
+/**
+  Converts network protocol string to its text representation.
+
+  @param Str             The string representative of input device.
+  @param Protocol        The network protocol ID.
+
+**/
+VOID
+CatNetworkProtocol (
+  IN OUT POOL_PRINT  *Str,
+  IN UINT16          Protocol
+  )
+{
+  if (Protocol == RFC_1700_TCP_PROTOCOL) {
+    UefiDevicePathLibCatPrint (Str, L"TCP");
+  } else if (Protocol == RFC_1700_UDP_PROTOCOL) {
+    UefiDevicePathLibCatPrint (Str, L"UDP");
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"0x%x", Protocol);
+  }
+}
+
+/**
+  Converts IP v4 address to its text representation.
+
+  @param Str             The string representative of input device.
+  @param Address         The IP v4 address.
+**/
+VOID
+CatIPv4Address (
+  IN OUT POOL_PRINT   *Str,
+  IN EFI_IPv4_ADDRESS *Address
+  )
+{
+  UefiDevicePathLibCatPrint (Str, L"%d.%d.%d.%d", Address->Addr[0], Address->Addr[1], Address->Addr[2], Address->Addr[3]);
+}
+
+/**
+  Converts IP v6 address to its text representation.
+
+  @param Str             The string representative of input device.
+  @param Address         The IP v6 address.
+**/
+VOID
+CatIPv6Address (
+  IN OUT POOL_PRINT   *Str,
+  IN EFI_IPv6_ADDRESS *Address
+  )
+{
+  UefiDevicePathLibCatPrint (
+    Str, L"%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x",
+    Address->Addr[0],  Address->Addr[1],
+    Address->Addr[2],  Address->Addr[3],
+    Address->Addr[4],  Address->Addr[5],
+    Address->Addr[6],  Address->Addr[7],
+    Address->Addr[8],  Address->Addr[9],
+    Address->Addr[10], Address->Addr[11],
+    Address->Addr[12], Address->Addr[13],
+    Address->Addr[14], Address->Addr[15]
+  );
+}
+
+/**
+  Converts a IPv4 device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextIPv4 (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  IPv4_DEVICE_PATH  *IPDevPath;
+
+  IPDevPath = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"IPv4(");
+  CatIPv4Address (Str, &IPDevPath->RemoteIpAddress);
+
+  if (DisplayOnly) {
+    UefiDevicePathLibCatPrint (Str, L")");
+    return ;
+  }
+
+  UefiDevicePathLibCatPrint (Str, L",");
+  CatNetworkProtocol (Str, IPDevPath->Protocol);
+
+  UefiDevicePathLibCatPrint (Str, L",%s,", IPDevPath->StaticIpAddress ? L"Static" : L"DHCP");
+  CatIPv4Address (Str, &IPDevPath->LocalIpAddress);
+  if (DevicePathNodeLength (IPDevPath) == sizeof (IPv4_DEVICE_PATH)) {
+    UefiDevicePathLibCatPrint (Str, L",");
+    CatIPv4Address (Str, &IPDevPath->GatewayIpAddress);
+    UefiDevicePathLibCatPrint (Str, L",");
+    CatIPv4Address (Str, &IPDevPath->SubnetMask);
+  }
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+/**
+  Converts a IPv6 device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextIPv6 (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  IPv6_DEVICE_PATH  *IPDevPath;
+
+  IPDevPath = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"IPv6(");
+  CatIPv6Address (Str, &IPDevPath->RemoteIpAddress);
+  if (DisplayOnly) {
+    UefiDevicePathLibCatPrint (Str, L")");
+    return ;
+  }
+  
+  UefiDevicePathLibCatPrint (Str, L",");
+  CatNetworkProtocol (Str, IPDevPath->Protocol);
+
+  switch (IPDevPath->IpAddressOrigin) {
+    case 0:
+      UefiDevicePathLibCatPrint (Str, L",Static,");
+      break;
+    case 1:
+      UefiDevicePathLibCatPrint (Str, L",StatelessAutoConfigure,");
+      break;
+    default:
+      UefiDevicePathLibCatPrint (Str, L",StatefulAutoConfigure,");
+      break;
+  }
+
+  CatIPv6Address (Str, &IPDevPath->LocalIpAddress);
+
+  if (DevicePathNodeLength (IPDevPath) == sizeof (IPv6_DEVICE_PATH)) {
+    UefiDevicePathLibCatPrint (Str, L",0x%x,", IPDevPath->PrefixLength);
+    CatIPv6Address (Str, &IPDevPath->GatewayIpAddress);
+  }
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+/**
+  Converts an Infini Band device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextInfiniBand (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  INFINIBAND_DEVICE_PATH  *InfiniBand;
+
+  InfiniBand = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"Infiniband(0x%x,%g,0x%lx,0x%lx,0x%lx)",
+    InfiniBand->ResourceFlags,
+    InfiniBand->PortGid,
+    InfiniBand->ServiceId,
+    InfiniBand->TargetPortId,
+    InfiniBand->DeviceId
+    );
+}
+
+/**
+  Converts a UART device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUart (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  UART_DEVICE_PATH  *Uart;
+  CHAR8             Parity;
+
+  Uart = DevPath;
+  switch (Uart->Parity) {
+  case 0:
+    Parity = 'D';
+    break;
+
+  case 1:
+    Parity = 'N';
+    break;
+
+  case 2:
+    Parity = 'E';
+    break;
+
+  case 3:
+    Parity = 'O';
+    break;
+
+  case 4:
+    Parity = 'M';
+    break;
+
+  case 5:
+    Parity = 'S';
+    break;
+
+  default:
+    Parity = 'x';
+    break;
+  }
+
+  if (Uart->BaudRate == 0) {
+    UefiDevicePathLibCatPrint (Str, L"Uart(DEFAULT,");
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"Uart(%ld,", Uart->BaudRate);
+  }
+
+  if (Uart->DataBits == 0) {
+    UefiDevicePathLibCatPrint (Str, L"DEFAULT,");
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"%d,", Uart->DataBits);
+  }
+
+  UefiDevicePathLibCatPrint (Str, L"%c,", Parity);
+
+  switch (Uart->StopBits) {
+  case 0:
+    UefiDevicePathLibCatPrint (Str, L"D)");
+    break;
+
+  case 1:
+    UefiDevicePathLibCatPrint (Str, L"1)");
+    break;
+
+  case 2:
+    UefiDevicePathLibCatPrint (Str, L"1.5)");
+    break;
+
+  case 3:
+    UefiDevicePathLibCatPrint (Str, L"2)");
+    break;
+
+  default:
+    UefiDevicePathLibCatPrint (Str, L"x)");
+    break;
+  }
+}
+
+/**
+  Converts an iSCSI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextiSCSI (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath;
+  UINT16                      Options;
+
+  ISCSIDevPath = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"iSCSI(%a,0x%x,0x%lx,",
+    ISCSIDevPath->TargetName,
+    ISCSIDevPath->TargetPortalGroupTag,
+    ISCSIDevPath->Lun
+    );
+
+  Options = ISCSIDevPath->LoginOption;
+  UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 1) & 0x0001) != 0) ? L"CRC32C" : L"None");
+  UefiDevicePathLibCatPrint (Str, L"%s,", (((Options >> 3) & 0x0001) != 0) ? L"CRC32C" : L"None");
+  if (((Options >> 11) & 0x0001) != 0) {
+    UefiDevicePathLibCatPrint (Str, L"%s,", L"None");
+  } else if (((Options >> 12) & 0x0001) != 0) {
+    UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_UNI");
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"%s,", L"CHAP_BI");
+
+  }
+
+  UefiDevicePathLibCatPrint (Str, L"%s)", (ISCSIDevPath->NetworkProtocol == 0) ? L"TCP" : L"reserved");
+}
+
+/**
+  Converts a VLAN device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextVlan (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  VLAN_DEVICE_PATH  *Vlan;
+
+  Vlan = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Vlan(%d)", Vlan->VlanId);
+}
+
+/**
+  Converts a Bluetooth device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextBluetooth (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  BLUETOOTH_DEVICE_PATH  *Bluetooth;
+
+  Bluetooth = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"Bluetooth(%02x%02x%02x%02x%02x%02x)",
+    Bluetooth->BD_ADDR.Address[5],
+    Bluetooth->BD_ADDR.Address[4],
+    Bluetooth->BD_ADDR.Address[3],
+    Bluetooth->BD_ADDR.Address[2],
+    Bluetooth->BD_ADDR.Address[1],
+    Bluetooth->BD_ADDR.Address[0]
+    );
+}
+
+/**
+  Converts a Wi-Fi device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextWiFi (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  WIFI_DEVICE_PATH      *WiFi;
+  UINT8                 SSId[33];
+
+  WiFi = DevPath;
+
+  SSId[32] = '\0';
+  CopyMem (SSId, WiFi->SSId, 32);
+
+  UefiDevicePathLibCatPrint (Str, L"Wi-Fi(%a)", SSId);
+}
+
+/**
+  Converts a URI device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextUri (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  URI_DEVICE_PATH    *Uri;
+  UINTN              UriLength;
+  CHAR8              *UriStr;
+
+  //
+  // Uri in the device path may not be null terminated.
+  //
+  Uri       = DevPath;
+  UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH);
+  UriStr = AllocatePool (UriLength + 1);
+  ASSERT (UriStr != NULL);
+
+  CopyMem (UriStr, Uri->Uri, UriLength);
+  UriStr[UriLength] = '\0';
+  UefiDevicePathLibCatPrint (Str, L"Uri(%a)", UriStr);
+  FreePool (UriStr);
+}
+
+/**
+  Converts a Hard drive device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextHardDrive (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  HARDDRIVE_DEVICE_PATH *Hd;
+
+  Hd = DevPath;
+  switch (Hd->SignatureType) {
+  case SIGNATURE_TYPE_MBR:
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"HD(%d,%s,0x%08x,",
+      Hd->PartitionNumber,
+      L"MBR",
+      *((UINT32 *) (&(Hd->Signature[0])))
+      );
+    break;
+
+  case SIGNATURE_TYPE_GUID:
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"HD(%d,%s,%g,",
+      Hd->PartitionNumber,
+      L"GPT",
+      (EFI_GUID *) &(Hd->Signature[0])
+      );
+    break;
+
+  default:
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"HD(%d,%d,0,",
+      Hd->PartitionNumber,
+      Hd->SignatureType
+      );
+    break;
+  }
+
+  UefiDevicePathLibCatPrint (Str, L"0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize);
+}
+
+/**
+  Converts a CDROM device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextCDROM (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  CDROM_DEVICE_PATH *Cd;
+
+  Cd = DevPath;
+  if (DisplayOnly) {
+    UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x)", Cd->BootEntry);
+    return ;
+  }
+
+  UefiDevicePathLibCatPrint (Str, L"CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize);
+}
+
+/**
+  Converts a File device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextFilePath (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  FILEPATH_DEVICE_PATH  *Fp;
+
+  Fp = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"%s", Fp->PathName);
+}
+
+/**
+  Converts a Media protocol device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextMediaProtocol (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  MEDIA_PROTOCOL_DEVICE_PATH  *MediaProt;
+
+  MediaProt = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Media(%g)", &MediaProt->Protocol);
+}
+
+/**
+  Converts a Firmware Volume device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextFv (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  MEDIA_FW_VOL_DEVICE_PATH  *Fv;
+
+  Fv = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"Fv(%g)", &Fv->FvName);
+}
+
+/**
+  Converts a Firmware Volume File device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextFvFile (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvFile;
+
+  FvFile = DevPath;
+  UefiDevicePathLibCatPrint (Str, L"FvFile(%g)", &FvFile->FvFileName);
+}
+
+/**
+  Converts a Relative Offset device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathRelativeOffsetRange (
+  IN OUT POOL_PRINT       *Str,
+  IN VOID                 *DevPath,
+  IN BOOLEAN              DisplayOnly,
+  IN BOOLEAN              AllowShortcuts
+  )
+{
+  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset;
+
+  Offset = DevPath;
+  UefiDevicePathLibCatPrint (
+    Str,
+    L"Offset(0x%lx,0x%lx)",
+    Offset->StartingOffset,
+    Offset->EndingOffset
+    );
+}
+
+/**
+  Converts a Ram Disk device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextRamDisk (
+  IN OUT POOL_PRINT       *Str,
+  IN VOID                 *DevPath,
+  IN BOOLEAN              DisplayOnly,
+  IN BOOLEAN              AllowShortcuts
+  )
+{
+  MEDIA_RAM_DISK_DEVICE_PATH *RamDisk;
+
+  RamDisk = DevPath;
+
+  if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"VirtualDisk(0x%lx,0x%lx,%d)",
+      LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
+      LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
+      RamDisk->Instance
+      );
+  } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"VirtualCD(0x%lx,0x%lx,%d)",
+      LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
+      LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
+      RamDisk->Instance
+      );
+  } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"PersistentVirtualDisk(0x%lx,0x%lx,%d)",
+      LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
+      LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
+      RamDisk->Instance
+      );
+  } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"PersistentVirtualCD(0x%lx,0x%lx,%d)",
+      LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
+      LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
+      RamDisk->Instance
+      );
+  } else {
+    UefiDevicePathLibCatPrint (
+      Str,
+      L"RamDisk(0x%lx,0x%lx,%d,%g)",
+      LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0],
+      LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0],
+      RamDisk->Instance,
+      &RamDisk->TypeGuid
+      );
+  }
+}
+
+/**
+  Converts a BIOS Boot Specification device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextBBS (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  BBS_BBS_DEVICE_PATH *Bbs;
+  CHAR16              *Type;
+
+  Bbs = DevPath;
+  switch (Bbs->DeviceType) {
+  case BBS_TYPE_FLOPPY:
+    Type = L"Floppy";
+    break;
+
+  case BBS_TYPE_HARDDRIVE:
+    Type = L"HD";
+    break;
+
+  case BBS_TYPE_CDROM:
+    Type = L"CDROM";
+    break;
+
+  case BBS_TYPE_PCMCIA:
+    Type = L"PCMCIA";
+    break;
+
+  case BBS_TYPE_USB:
+    Type = L"USB";
+    break;
+
+  case BBS_TYPE_EMBEDDED_NETWORK:
+    Type = L"Network";
+    break;
+
+  default:
+    Type = NULL;
+    break;
+  }
+
+  if (Type != NULL) {
+    UefiDevicePathLibCatPrint (Str, L"BBS(%s,%a", Type, Bbs->String);
+  } else {
+    UefiDevicePathLibCatPrint (Str, L"BBS(0x%x,%a", Bbs->DeviceType, Bbs->String);
+  }
+
+  if (DisplayOnly) {
+    UefiDevicePathLibCatPrint (Str, L")");
+    return ;
+  }
+
+  UefiDevicePathLibCatPrint (Str, L",0x%x)", Bbs->StatusFlag);
+}
+
+/**
+  Converts an End-of-Device-Path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextEndInstance (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  UefiDevicePathLibCatPrint (Str, L",");
+}
+
+GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE mUefiDevicePathLibToTextTableGeneric[] = {
+  {HARDWARE_DEVICE_PATH,  L"HardwarePath"   },
+  {ACPI_DEVICE_PATH,      L"AcpiPath"       },
+  {MESSAGING_DEVICE_PATH, L"Msg"            },
+  {MEDIA_DEVICE_PATH,     L"MediaPath"      },
+  {BBS_DEVICE_PATH,       L"BbsPath"        },
+  {0, NULL}
+};
+
+/**
+  Converts an unknown device path structure to its string representative.
+
+  @param Str             The string representative of input device.
+  @param DevPath         The input device path structure.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+**/
+VOID
+DevPathToTextNodeGeneric (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevPath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL *Node;
+  UINTN                    Index;
+
+  Node = DevPath;
+
+  for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) {
+    if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) {
+      break;
+    }
+  }
+
+  if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) {
+    //
+    // It's a node whose type cannot be recognized
+    //
+    UefiDevicePathLibCatPrint (Str, L"Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node));
+  } else {
+    //
+    // It's a node whose type can be recognized
+    //
+    UefiDevicePathLibCatPrint (Str, L"%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node));
+  }
+
+  Index = sizeof (EFI_DEVICE_PATH_PROTOCOL);
+  if (Index < DevicePathNodeLength (Node)) {
+    UefiDevicePathLibCatPrint (Str, L",");
+    for (; Index < DevicePathNodeLength (Node); Index++) {
+      UefiDevicePathLibCatPrint (Str, L"%02x", ((UINT8 *) Node)[Index]);
+    }
+  }
+
+  UefiDevicePathLibCatPrint (Str, L")");
+}
+
+GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_TABLE mUefiDevicePathLibToTextTable[] = {
+  {HARDWARE_DEVICE_PATH,  HW_PCI_DP,                        DevPathToTextPci            },
+  {HARDWARE_DEVICE_PATH,  HW_PCCARD_DP,                     DevPathToTextPccard         },
+  {HARDWARE_DEVICE_PATH,  HW_MEMMAP_DP,                     DevPathToTextMemMap         },
+  {HARDWARE_DEVICE_PATH,  HW_VENDOR_DP,                     DevPathToTextVendor         },
+  {HARDWARE_DEVICE_PATH,  HW_CONTROLLER_DP,                 DevPathToTextController     },
+  {HARDWARE_DEVICE_PATH,  HW_BMC_DP,                        DevPathToTextBmc            },
+  {ACPI_DEVICE_PATH,      ACPI_DP,                          DevPathToTextAcpi           },
+  {ACPI_DEVICE_PATH,      ACPI_EXTENDED_DP,                 DevPathToTextAcpiEx         },
+  {ACPI_DEVICE_PATH,      ACPI_ADR_DP,                      DevPathToTextAcpiAdr        },
+  {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP,                     DevPathToTextAtapi          },
+  {MESSAGING_DEVICE_PATH, MSG_SCSI_DP,                      DevPathToTextScsi           },
+  {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP,              DevPathToTextFibre          },
+  {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP,            DevPathToTextFibreEx        },
+  {MESSAGING_DEVICE_PATH, MSG_SASEX_DP,                     DevPathToTextSasEx          },
+  {MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP,            DevPathToTextNVMe           },
+  {MESSAGING_DEVICE_PATH, MSG_UFS_DP,                       DevPathToTextUfs            },
+  {MESSAGING_DEVICE_PATH, MSG_SD_DP,                        DevPathToTextSd             },
+  {MESSAGING_DEVICE_PATH, MSG_EMMC_DP,                      DevPathToTextEmmc           },
+  {MESSAGING_DEVICE_PATH, MSG_1394_DP,                      DevPathToText1394           },
+  {MESSAGING_DEVICE_PATH, MSG_USB_DP,                       DevPathToTextUsb            },
+  {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP,                  DevPathToTextUsbWWID        },
+  {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP,       DevPathToTextLogicalUnit    },
+  {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP,                 DevPathToTextUsbClass       },
+  {MESSAGING_DEVICE_PATH, MSG_SATA_DP,                      DevPathToTextSata           },
+  {MESSAGING_DEVICE_PATH, MSG_I2O_DP,                       DevPathToTextI2O            },
+  {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,                  DevPathToTextMacAddr        },
+  {MESSAGING_DEVICE_PATH, MSG_IPv4_DP,                      DevPathToTextIPv4           },
+  {MESSAGING_DEVICE_PATH, MSG_IPv6_DP,                      DevPathToTextIPv6           },
+  {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP,                DevPathToTextInfiniBand     },
+  {MESSAGING_DEVICE_PATH, MSG_UART_DP,                      DevPathToTextUart           },
+  {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP,                    DevPathToTextVendor         },
+  {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP,                     DevPathToTextiSCSI          },
+  {MESSAGING_DEVICE_PATH, MSG_VLAN_DP,                      DevPathToTextVlan           },
+  {MESSAGING_DEVICE_PATH, MSG_URI_DP,                       DevPathToTextUri            },
+  {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP,                 DevPathToTextBluetooth      },
+  {MESSAGING_DEVICE_PATH, MSG_WIFI_DP,                      DevPathToTextWiFi           },
+  {MEDIA_DEVICE_PATH,     MEDIA_HARDDRIVE_DP,               DevPathToTextHardDrive      },
+  {MEDIA_DEVICE_PATH,     MEDIA_CDROM_DP,                   DevPathToTextCDROM          },
+  {MEDIA_DEVICE_PATH,     MEDIA_VENDOR_DP,                  DevPathToTextVendor         },
+  {MEDIA_DEVICE_PATH,     MEDIA_PROTOCOL_DP,                DevPathToTextMediaProtocol  },
+  {MEDIA_DEVICE_PATH,     MEDIA_FILEPATH_DP,                DevPathToTextFilePath       },
+  {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_VOL_DP,             DevPathToTextFv             },
+  {MEDIA_DEVICE_PATH,     MEDIA_PIWG_FW_FILE_DP,            DevPathToTextFvFile         },
+  {MEDIA_DEVICE_PATH,     MEDIA_RELATIVE_OFFSET_RANGE_DP,   DevPathRelativeOffsetRange  },
+  {MEDIA_DEVICE_PATH,     MEDIA_RAM_DISK_DP,                DevPathToTextRamDisk        },
+  {BBS_DEVICE_PATH,       BBS_BBS_DP,                       DevPathToTextBBS            },
+  {END_DEVICE_PATH_TYPE,  END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance    },
+  {0, 0, NULL}
+};
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+UefiDevicePathLibConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  )
+{
+  POOL_PRINT          Str;
+  UINTN               Index;
+  DEVICE_PATH_TO_TEXT ToText;
+
+  if (DeviceNode == NULL) {
+    return NULL;
+  }
+
+  ZeroMem (&Str, sizeof (Str));
+
+  //
+  // Process the device path node
+  // If not found, use a generic function
+  //
+  ToText = DevPathToTextNodeGeneric;
+  for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) {
+    if (DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type &&
+        DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType
+        ) {
+      ToText = mUefiDevicePathLibToTextTable[Index].Function;
+      break;
+    }
+  }
+
+  //
+  // Print this node
+  //
+  ToText (&Str, (VOID *) DeviceNode, DisplayOnly, AllowShortcuts);
+
+  ASSERT (Str.Str != NULL);
+  return Str.Str;
+}
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+UefiDevicePathLibConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  )
+{
+  POOL_PRINT               Str;
+  EFI_DEVICE_PATH_PROTOCOL *Node;
+  EFI_DEVICE_PATH_PROTOCOL *AlignedNode;
+  UINTN                    Index;
+  DEVICE_PATH_TO_TEXT      ToText;
+
+  if (DevicePath == NULL) {
+    return NULL;
+  }
+
+  ZeroMem (&Str, sizeof (Str));
+
+  //
+  // Process each device path node
+  //
+  Node = (EFI_DEVICE_PATH_PROTOCOL *) DevicePath;
+  while (!IsDevicePathEnd (Node)) {
+    //
+    // Find the handler to dump this device path node
+    // If not found, use a generic function
+    //
+    ToText = DevPathToTextNodeGeneric;
+    for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) {
+
+      if (DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type &&
+          DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType
+          ) {
+        ToText = mUefiDevicePathLibToTextTable[Index].Function;
+        break;
+      }
+    }
+    //
+    //  Put a path separator in if needed
+    //
+    if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) {
+      if (Str.Str[Str.Count] != L',') {
+        UefiDevicePathLibCatPrint (&Str, L"/");
+      }
+    }
+    
+    AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node);
+    //
+    // Print this node of the device path
+    //
+    ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts);
+    FreePool (AlignedNode);
+    
+    //
+    // Next device path node
+    //
+    Node = NextDevicePathNode (Node);
+  }
+
+  if (Str.Str == NULL) {
+    return AllocateZeroPool (sizeof (CHAR16));
+  } else {
+    return Str.Str;
+  }
+}
diff --git a/MdePkg/Library/UefiDevicePathLib/DevicePathUtilities.c b/MdePkg/Library/UefiDevicePathLib/DevicePathUtilities.c
new file mode 100644
index 000000000000..27fac77a2a56
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/DevicePathUtilities.c
@@ -0,0 +1,895 @@
+/** @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) 2006 - 2016, 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"
+
+//
+// Template for an end-of-device path node.
+//
+GLOBAL_REMOVE_IF_UNREFERENCED 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
+EFIAPI
+IsDevicePathValid (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN       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;
+    }
+
+    if (PcdGet32 (PcdMaximumDevicePathNodeCount) > 0) {
+      Count++;
+      if (Count >= PcdGet32 (PcdMaximumDevicePathNodeCount)) {
+        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
+EFIAPI
+DevicePathType (
+  IN 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
+EFIAPI
+DevicePathSubType (
+  IN 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
+EFIAPI
+DevicePathNodeLength (
+  IN 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 *
+EFIAPI
+NextDevicePathNode (
+  IN 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
+EFIAPI
+IsDevicePathEndType (
+  IN 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
+EFIAPI
+IsDevicePathEnd (
+  IN 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
+EFIAPI
+IsDevicePathEndInstance (
+  IN 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
+EFIAPI
+SetDevicePathNodeLength (
+  IN OUT VOID  *Node,
+  IN 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
+EFIAPI
+SetDevicePathEndNode (
+  OUT VOID  *Node
+  )
+{
+  ASSERT (Node != NULL);
+  CopyMem (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
+EFIAPI
+UefiDevicePathLibGetDevicePathSize (
+  IN 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 *
+EFIAPI
+UefiDevicePathLibDuplicateDevicePath (
+  IN 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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
+  )
+{
+  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 = CopyMem (NewDevicePath, FirstDevicePath, Size1);
+    //
+    // Over write FirstDevicePath EndNode and do the copy
+    //
+    DevicePath2 = (EFI_DEVICE_PATH_PROTOCOL *) ((CHAR8 *) NewDevicePath +
+                  (Size1 - END_DEVICE_PATH_LENGTH));
+    CopyMem (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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
+  )
+{
+  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 = CopyMem (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);
+
+  FreePool (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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathInstance OPTIONAL
+  )
+{
+  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 = CopyMem (NewDevicePath, DevicePath, SrcSize);;
+ 
+    while (!IsDevicePathEnd (TempDevicePath)) {
+      TempDevicePath = NextDevicePathNode (TempDevicePath);
+    }
+    
+    TempDevicePath->SubType  = END_INSTANCE_DEVICE_PATH_SUBTYPE;
+    TempDevicePath           = NextDevicePathNode (TempDevicePath);
+    CopyMem (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 *
+EFIAPI
+UefiDevicePathLibGetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT 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 *
+EFIAPI
+UefiDevicePathLibCreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN 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
+EFIAPI
+UefiDevicePathLibIsDevicePathMultiInstance (
+  IN 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 *
+EFIAPI
+DevicePathFromHandle (
+  IN 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 *
+EFIAPI
+FileDevicePath (
+  IN EFI_HANDLE                      Device,     OPTIONAL
+  IN 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;
+    CopyMem (&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);
+    FreePool (FileDevicePath);
+  }
+
+  return DevicePath;
+}
+
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.c b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.c
new file mode 100644
index 000000000000..a20c12291401
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.c
@@ -0,0 +1,360 @@
+/** @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) 2006 - 2013, 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
+EFIAPI
+GetDevicePathSize (
+  IN 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 *
+EFIAPI
+DuplicateDevicePath (
+  IN 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 *
+EFIAPI
+AppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN 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 *
+EFIAPI
+AppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN 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 *
+EFIAPI
+AppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN 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 *
+EFIAPI
+GetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT 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 *
+EFIAPI
+CreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN 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
+EFIAPI
+IsDevicePathMultiInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  return UefiDevicePathLibIsDevicePathMultiInstance (DevicePath);
+}
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  )
+{
+  return UefiDevicePathLibConvertDeviceNodeToText (DeviceNode, DisplayOnly, AllowShortcuts);
+}
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  )
+{
+  return UefiDevicePathLibConvertDevicePathToText (DevicePath, DisplayOnly, AllowShortcuts);
+}
+
+/**
+  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 *
+EFIAPI
+ConvertTextToDeviceNode (
+  IN 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 *
+EFIAPI
+ConvertTextToDevicePath (
+  IN CONST CHAR16 *TextDevicePath
+  )
+{
+  return UefiDevicePathLibConvertTextToDevicePath (TextDevicePath);
+}
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.h b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.h
new file mode 100644
index 000000000000..9904f9ec8956
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.h
@@ -0,0 +1,457 @@
+/** @file
+  Definition for Device Path library.
+
+Copyright (c) 2013 - 2015, 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 <Uefi.h>
+#include <Protocol/DevicePathUtilities.h>
+#include <Protocol/DebugPort.h>
+#include <Protocol/DevicePathToText.h>
+#include <Protocol/DevicePathFromText.h>
+#include <Guid/PcAnsi.h>
+#include <Library/DebugLib.h>
+#include <Library/PrintLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/PcdLib.h>
+#include <IndustryStandard/Bluetooth.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')
+
+
+//
+// Private Data structure
+//
+typedef struct {
+  CHAR16  *Str;
+  UINTN   Count;
+  UINTN   Capacity;
+} POOL_PRINT;
+
+typedef
+EFI_DEVICE_PATH_PROTOCOL  *
+(*DEVICE_PATH_FROM_TEXT) (
+  IN  CHAR16 *Str
+  );
+
+typedef
+VOID
+(*DEVICE_PATH_TO_TEXT) (
+  IN OUT POOL_PRINT  *Str,
+  IN VOID            *DevicePath,
+  IN BOOLEAN         DisplayOnly,
+  IN BOOLEAN         AllowShortcuts
+  );
+
+typedef struct {
+  UINT8                Type;
+  UINT8                SubType;
+  DEVICE_PATH_TO_TEXT  Function;
+} DEVICE_PATH_TO_TEXT_TABLE;
+
+typedef struct {
+  UINT8                Type;
+  CHAR16               *Text;
+} DEVICE_PATH_TO_TEXT_GENERIC_TABLE;
+
+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
+EFIAPI
+UefiDevicePathLibGetDevicePathSize (
+  IN 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 *
+EFIAPI
+UefiDevicePathLibDuplicateDevicePath (
+  IN 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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN 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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN 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 *
+EFIAPI
+UefiDevicePathLibAppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN 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 *
+EFIAPI
+UefiDevicePathLibGetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT 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 *
+EFIAPI
+UefiDevicePathLibCreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN 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
+EFIAPI
+UefiDevicePathLibIsDevicePathMultiInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  );
+
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+UefiDevicePathLibConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  );
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+UefiDevicePathLibConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  );
+
+/**
+  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 *
+EFIAPI
+UefiDevicePathLibConvertTextToDeviceNode (
+  IN 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 *
+EFIAPI
+UefiDevicePathLibConvertTextToDevicePath (
+  IN CONST CHAR16 *TextDevicePath
+  );
+
+#endif
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
new file mode 100644
index 000000000000..516c26e6a948
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
@@ -0,0 +1,79 @@
+## @file
+# Instance of Device Path Library based on Memory Allocation Library.
+#
+# Device Path Library that layers on top of the Memory Allocation Library.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDevicePathLib
+  MODULE_UNI_FILE                = UefiDevicePathLib.uni
+  FILE_GUID                      = 91c1677a-e57f-4191-8b8e-eb7711a716e0
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DevicePathLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DevicePathUtilities.c
+  DevicePathToText.c
+  DevicePathFromText.c
+  UefiDevicePathLib.c
+  UefiDevicePathLib.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  MemoryAllocationLib
+  DebugLib
+  BaseMemoryLib
+  PcdLib
+  PrintLib
+
+[Guids]
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVTUTF8Guid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVT100Guid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVT100PlusGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPcAnsiGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiUartDevicePathGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiSasDevicePathGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVirtualDiskGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVirtualCdGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPersistentVirtualDiskGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPersistentVirtualCdGuid
+
+[Protocols]
+  gEfiDevicePathProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiDebugPortProtocolGuid                     ## UNDEFINED
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumDevicePathNodeCount    ## SOMETIMES_CONSUMES
+
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.uni b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.uni
new file mode 100644
index 000000000000..9ea680da348f
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Instance of Device Path Library based on Memory Allocation Library.
+//
+// Device Path Library that layers on top of the Memory Allocation Library.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Device Path Library based on Memory Allocation Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Device Path Library layers on top of the Memory Allocation Library."
+
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.c b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.c
new file mode 100644
index 000000000000..75a04d0589ef
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.c
@@ -0,0 +1,484 @@
+/** @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) 2013, 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"
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_UTILITIES_PROTOCOL *mDevicePathLibDevicePathUtilities = NULL;
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_TO_TEXT_PROTOCOL   *mDevicePathLibDevicePathToText    = NULL;
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *mDevicePathLibDevicePathFromText  = NULL;
+
+/**
+  The constructor function caches the pointer to DevicePathUtilites protocol,
+  DevicePathToText protocol and DevicePathFromText protocol.
+  
+  The constructor function locates these three protocols from protocol database.
+  It will caches the pointer to local protocol instance if that operation fails
+  and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiDevicePathLibOptionalDevicePathProtocolConstructor (
+  IN      EFI_HANDLE                ImageHandle,
+  IN      EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS                        Status;
+
+  Status = gBS->LocateProtocol (
+                  &gEfiDevicePathUtilitiesProtocolGuid,
+                  NULL,
+                  (VOID**) &mDevicePathLibDevicePathUtilities
+                  );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (mDevicePathLibDevicePathUtilities != NULL);
+  return Status;
+}
+
+/**
+  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
+EFIAPI
+GetDevicePathSize (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->GetDevicePathSize (DevicePath);
+  } else {
+    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 *
+EFIAPI
+DuplicateDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->DuplicateDevicePath (DevicePath);
+  } else {
+    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 *
+EFIAPI
+AppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->AppendDevicePath (FirstDevicePath, SecondDevicePath);
+  } else {
+    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 *
+EFIAPI
+AppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->AppendDeviceNode (DevicePath, DevicePathNode);
+  } else {
+    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 *
+EFIAPI
+AppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathInstance OPTIONAL
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->AppendDevicePathInstance (DevicePath, DevicePathInstance);
+  } else {
+    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 *
+EFIAPI
+GetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT UINTN                          *Size
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->GetNextDevicePathInstance (DevicePath, Size);
+  } else {
+    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 *
+EFIAPI
+CreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN UINT16                          NodeLength
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->CreateDeviceNode (NodeType, NodeSubType, NodeLength);
+  } else {
+    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
+EFIAPI
+IsDevicePathMultiInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  if (mDevicePathLibDevicePathUtilities != NULL) {
+    return mDevicePathLibDevicePathUtilities->IsDevicePathMultiInstance (DevicePath);
+  } else {
+    return UefiDevicePathLibIsDevicePathMultiInstance (DevicePath);
+  }
+}
+
+/**
+  Locate and return the protocol instance identified by the ProtocolGuid.
+
+  @param ProtocolGuid     The GUID of the protocol.
+
+  @return A pointer to the protocol instance or NULL when absent.
+**/
+VOID *
+UefiDevicePathLibLocateProtocol (
+  EFI_GUID                         *ProtocolGuid
+  )
+{
+  EFI_STATUS Status;
+  VOID       *Protocol;
+  Status = gBS->LocateProtocol (
+                  ProtocolGuid,
+                  NULL,
+                  (VOID**) &Protocol
+                  );
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  } else {
+    return Protocol;
+  }
+}
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  )
+{
+  if (mDevicePathLibDevicePathToText == NULL) {
+    mDevicePathLibDevicePathToText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathToTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathToText != NULL) {
+    return mDevicePathLibDevicePathToText->ConvertDeviceNodeToText (DeviceNode, DisplayOnly, AllowShortcuts);
+  }
+
+  return UefiDevicePathLibConvertDeviceNodeToText (DeviceNode, DisplayOnly, AllowShortcuts);
+}
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  )
+{
+  if (mDevicePathLibDevicePathToText == NULL) {
+    mDevicePathLibDevicePathToText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathToTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathToText != NULL) {
+    return mDevicePathLibDevicePathToText->ConvertDevicePathToText (DevicePath, DisplayOnly, AllowShortcuts);
+  }
+
+  return UefiDevicePathLibConvertDevicePathToText (DevicePath, DisplayOnly, AllowShortcuts);
+}
+
+/**
+  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 *
+EFIAPI
+ConvertTextToDeviceNode (
+  IN CONST CHAR16 *TextDeviceNode
+  )
+{
+  if (mDevicePathLibDevicePathFromText == NULL) {
+    mDevicePathLibDevicePathFromText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathFromTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathFromText != NULL) {
+    return mDevicePathLibDevicePathFromText->ConvertTextToDeviceNode (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 *
+EFIAPI
+ConvertTextToDevicePath (
+  IN CONST CHAR16 *TextDevicePath
+  )
+{
+  if (mDevicePathLibDevicePathFromText == NULL) {
+    mDevicePathLibDevicePathFromText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathFromTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathFromText != NULL) {
+    return mDevicePathLibDevicePathFromText->ConvertTextToDevicePath (TextDevicePath);
+  }
+
+  return UefiDevicePathLibConvertTextToDevicePath (TextDevicePath);
+}
+
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.inf b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.inf
new file mode 100644
index 000000000000..4663fad8922a
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.inf
@@ -0,0 +1,89 @@
+## @file
+# Instance of Device Path Library based on Device Path Protocol.
+#
+#  Device Path Library that layers on top of the UEFI 2.0 Device Path Protocol.
+#  If the DevicePathFromText/DevicePathToText protocol doesn't exist, the library
+#  uses its internal conversion logic.
+#
+# Copyright (c) 2013 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDevicePathLibOptionalDevicePathProtocol
+  MODULE_UNI_FILE                = UefiDevicePathLibOptionalDevicePathProtocol.uni
+  FILE_GUID                      = 3E1C696D-FCF0-45a7-85A7-E86C2A1C1080
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DevicePathLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+  CONSTRUCTOR                    = UefiDevicePathLibOptionalDevicePathProtocolConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DevicePathUtilities.c
+  DevicePathToText.c
+  DevicePathFromText.c
+  UefiDevicePathLibOptionalDevicePathProtocol.c
+  UefiDevicePathLib.h
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  DebugLib
+  BaseMemoryLib
+  PcdLib
+  PrintLib
+
+[Guids]
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVTUTF8Guid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVT100Guid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVT100PlusGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPcAnsiGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiUartDevicePathGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiSasDevicePathGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVirtualDiskGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiVirtualCdGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPersistentVirtualDiskGuid
+  ## SOMETIMES_CONSUMES  ## GUID
+  gEfiPersistentVirtualCdGuid
+
+[Protocols]
+  gEfiDevicePathProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiDevicePathUtilitiesProtocolGuid           ## CONSUMES
+  gEfiDevicePathToTextProtocolGuid              ## SOMETIMES_CONSUMES
+  gEfiDevicePathFromTextProtocolGuid            ## SOMETIMES_CONSUMES
+  gEfiDebugPortProtocolGuid                     ## UNDEFINED
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumDevicePathNodeCount ## SOMETIMES_CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiDevicePathUtilitiesProtocolGuid
+  
\ No newline at end of file
diff --git a/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.uni b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.uni
new file mode 100644
index 000000000000..3a42133fa755
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of Device Path Library based on Device Path Protocol.
+//
+// Device Path Library that layers on top of the UEFI 2.0 Device Path Protocol.
+// If the DevicePathFromText/DevicePathToText protocol doesn't exist, the library
+// uses its internal conversion logic.
+//
+// Copyright (c) 2013 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Device Path Library based on Device Path Protocol."
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Instance of Device Path Library based on Device Path Protocol."
+
diff --git a/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLib.c b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLib.c
new file mode 100644
index 000000000000..bd3f3c4db648
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLib.c
@@ -0,0 +1,862 @@
+/** @file
+  Library instance that implement UEFI Device Path Library class based on protocol
+  gEfiDevicePathUtilitiesProtocolGuid.
+
+  Copyright (c) 2006 - 2016, 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 <Uefi.h>
+
+#include <Protocol/DevicePathUtilities.h>
+#include <Protocol/DevicePathToText.h>
+#include <Protocol/DevicePathFromText.h>
+
+#include <Library/DevicePathLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/PcdLib.h>
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_UTILITIES_PROTOCOL *mDevicePathLibDevicePathUtilities = NULL;
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_TO_TEXT_PROTOCOL   *mDevicePathLibDevicePathToText    = NULL;
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *mDevicePathLibDevicePathFromText  = NULL;
+
+//
+// Template for an end-of-device path node.
+//
+GLOBAL_REMOVE_IF_UNREFERENCED CONST EFI_DEVICE_PATH_PROTOCOL  mUefiDevicePathLibEndDevicePath = {
+  END_DEVICE_PATH_TYPE,
+  END_ENTIRE_DEVICE_PATH_SUBTYPE,
+  {
+    END_DEVICE_PATH_LENGTH,
+    0
+  }
+};
+
+/**
+  The constructor function caches the pointer to DevicePathUtilites protocol.
+  
+  The constructor function locates DevicePathUtilities protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+DevicePathLibConstructor (
+  IN      EFI_HANDLE                ImageHandle,
+  IN      EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS                        Status;
+
+  Status = gBS->LocateProtocol (
+                  &gEfiDevicePathUtilitiesProtocolGuid,
+                  NULL,
+                  (VOID**) &mDevicePathLibDevicePathUtilities
+                  );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (mDevicePathLibDevicePathUtilities != NULL);
+  return Status;
+}
+
+/**
+  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
+EFIAPI
+IsDevicePathValid (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  IN       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;
+    }
+
+    if (PcdGet32 (PcdMaximumDevicePathNodeCount) > 0) {
+      Count++;
+      if (Count >= PcdGet32 (PcdMaximumDevicePathNodeCount)) {
+        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
+EFIAPI
+DevicePathType (
+  IN 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
+EFIAPI
+DevicePathSubType (
+  IN 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
+EFIAPI
+DevicePathNodeLength (
+  IN 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 *
+EFIAPI
+NextDevicePathNode (
+  IN 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
+EFIAPI
+IsDevicePathEndType (
+  IN 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
+EFIAPI
+IsDevicePathEnd (
+  IN 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
+EFIAPI
+IsDevicePathEndInstance (
+  IN 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
+EFIAPI
+SetDevicePathNodeLength (
+  IN OUT VOID  *Node,
+  IN 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
+EFIAPI
+SetDevicePathEndNode (
+  OUT VOID  *Node
+  )
+{
+  ASSERT (Node != NULL);
+  CopyMem (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
+EFIAPI
+GetDevicePathSize (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  return mDevicePathLibDevicePathUtilities->GetDevicePathSize (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    If DevicePath is NULL or invalid.
+  @retval Others  A pointer to the duplicated device path.
+  
+**/
+EFI_DEVICE_PATH_PROTOCOL *
+EFIAPI
+DuplicateDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  return mDevicePathLibDevicePathUtilities->DuplicateDevicePath (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 *
+EFIAPI
+AppendDevicePath (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
+  )
+{
+  return mDevicePathLibDevicePathUtilities->AppendDevicePath (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 *
+EFIAPI
+AppendDevicePathNode (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
+  )
+{
+  return mDevicePathLibDevicePathUtilities->AppendDeviceNode (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 *
+EFIAPI
+AppendDevicePathInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathInstance OPTIONAL
+  )
+{
+  return mDevicePathLibDevicePathUtilities->AppendDevicePathInstance (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 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 *
+EFIAPI
+GetNextDevicePathInstance (
+  IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
+  OUT UINTN                          *Size
+  )
+{
+  ASSERT (Size != NULL);
+  return mDevicePathLibDevicePathUtilities->GetNextDevicePathInstance (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 *
+EFIAPI
+CreateDeviceNode (
+  IN UINT8                           NodeType,
+  IN UINT8                           NodeSubType,
+  IN UINT16                          NodeLength
+  )
+{
+  return mDevicePathLibDevicePathUtilities->CreateDeviceNode (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
+EFIAPI
+IsDevicePathMultiInstance (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  return mDevicePathLibDevicePathUtilities->IsDevicePathMultiInstance (DevicePath);
+}
+
+/**
+  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 *
+EFIAPI
+DevicePathFromHandle (
+  IN 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 *
+EFIAPI
+FileDevicePath (
+  IN EFI_HANDLE                      Device,     OPTIONAL
+  IN 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;
+    CopyMem (&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);
+    FreePool (FileDevicePath);
+  }
+
+  return DevicePath;
+}
+
+/**
+  Locate and return the protocol instance identified by the ProtocolGuid.
+
+  @param ProtocolGuid     The GUID of the protocol.
+
+  @return A pointer to the protocol instance or NULL when absent.
+**/
+VOID *
+UefiDevicePathLibLocateProtocol (
+  EFI_GUID                         *ProtocolGuid
+  )
+{
+  EFI_STATUS Status;
+  VOID       *Protocol;
+  Status = gBS->LocateProtocol (
+                  ProtocolGuid,
+                  NULL,
+                  (VOID**) &Protocol
+                  );
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  } else {
+    return Protocol;
+  }
+}
+
+/**
+  Converts a device node to its string representation.
+
+  @param DeviceNode        A Pointer to the device node to be converted.
+  @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
+                           of the display node is used, where applicable. If DisplayOnly
+                           is FALSE, then the longer text representation of the display node
+                           is used.
+  @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
+                           representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
+          is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDeviceNodeToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
+  IN BOOLEAN                         DisplayOnly,
+  IN BOOLEAN                         AllowShortcuts
+  )
+{
+  if (mDevicePathLibDevicePathToText == NULL) {
+    mDevicePathLibDevicePathToText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathToTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathToText != NULL) {
+    return mDevicePathLibDevicePathToText->ConvertDeviceNodeToText (DeviceNode, DisplayOnly, AllowShortcuts);
+  } else {
+    return NULL;
+  }
+}
+
+/**
+  Converts a device path to its text representation.
+
+  @param DevicePath      A Pointer to the device to be converted.
+  @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
+                         of the display node is used, where applicable. If DisplayOnly
+                         is FALSE, then the longer text representation of the display node
+                         is used.
+  @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
+                         representation for a device node can be used, where applicable.
+
+  @return A pointer to the allocated text representation of the device path or
+          NULL if DeviceNode is NULL or there was insufficient memory.
+
+**/
+CHAR16 *
+EFIAPI
+ConvertDevicePathToText (
+  IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
+  IN BOOLEAN                          DisplayOnly,
+  IN BOOLEAN                          AllowShortcuts
+  )
+{
+  if (mDevicePathLibDevicePathToText == NULL) {
+    mDevicePathLibDevicePathToText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathToTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathToText != NULL) {
+    return mDevicePathLibDevicePathToText->ConvertDevicePathToText (DevicePath, DisplayOnly, AllowShortcuts);
+  } else {
+    return 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 *
+EFIAPI
+ConvertTextToDeviceNode (
+  IN CONST CHAR16 *TextDeviceNode
+  )
+{
+  if (mDevicePathLibDevicePathFromText == NULL) {
+    mDevicePathLibDevicePathFromText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathFromTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathFromText != NULL) {
+    return mDevicePathLibDevicePathFromText->ConvertTextToDeviceNode (TextDeviceNode);
+  } else {
+    return NULL;
+  }
+}
+
+/**
+  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 *
+EFIAPI
+ConvertTextToDevicePath (
+  IN CONST CHAR16 *TextDevicePath
+  )
+{
+  if (mDevicePathLibDevicePathFromText == NULL) {
+    mDevicePathLibDevicePathFromText = UefiDevicePathLibLocateProtocol (&gEfiDevicePathFromTextProtocolGuid);
+  }
+  if (mDevicePathLibDevicePathFromText != NULL) {
+    return mDevicePathLibDevicePathFromText->ConvertTextToDevicePath (TextDevicePath);
+  } else {
+    return NULL;
+  }
+}
+
diff --git a/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.inf b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.inf
new file mode 100644
index 000000000000..24e33831749c
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.inf
@@ -0,0 +1,61 @@
+## @file
+# Instance of Device Path Library based on Device Path Utilities Protocol.
+#
+#  Device Path Library that layers on top of the UEFI 2.0 Device Path Utilities Protocol.
+#  This library is not available for EFI 1.10 modules.
+#
+#  Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDevicePathLibDevicePathProtocol
+  MODULE_UNI_FILE                = UefiDevicePathLibDevicePathProtocol.uni
+  FILE_GUID                      = 050EB8C6-C12E-4b86-892B-40985E8B3137
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = DevicePathLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+  CONSTRUCTOR                    = DevicePathLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiDevicePathLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  BaseMemoryLib
+  MemoryAllocationLib
+  BaseLib
+  DebugLib
+  PcdLib
+
+[Protocols]
+  gEfiDevicePathProtocolGuid                    ## SOMETIMES_CONSUMES
+  gEfiDevicePathUtilitiesProtocolGuid           ## CONSUMES
+  gEfiDevicePathToTextProtocolGuid              ## SOMETIMES_CONSUMES
+  gEfiDevicePathFromTextProtocolGuid            ## SOMETIMES_CONSUMES
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumDevicePathNodeCount    ## SOMETIMES_CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiDevicePathUtilitiesProtocolGuid
+
diff --git a/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.uni b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.uni
new file mode 100644
index 000000000000..6f78e46e4a16
--- /dev/null
+++ b/MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Device Path Library based on Device Path Utilities Protocol.
+//
+// Device Path Library that layers on top of the UEFI 2.0 Device Path Utilities Protocol.
+// This library is not available for EFI 1.10 modules.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Device Path Library based on Device Path Utilities Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The Device Path Library that layers on top of the UEFI 2.0 Device Path Utilities Protocol. This library is not available for EFI 1.10 modules."
+
diff --git a/MdePkg/Library/UefiDriverEntryPoint/DriverEntryPoint.c b/MdePkg/Library/UefiDriverEntryPoint/DriverEntryPoint.c
new file mode 100644
index 000000000000..021e4b777b82
--- /dev/null
+++ b/MdePkg/Library/UefiDriverEntryPoint/DriverEntryPoint.c
@@ -0,0 +1,173 @@
+/** @file
+  Entry point to a EFI/DXE driver.
+
+Copyright (c) 2006 - 2011, 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 <Uefi.h>
+
+#include <Protocol/LoadedImage.h>
+
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+
+/**
+  Unloads an image from memory.
+
+  This function is a callback that a driver registers to do cleanup 
+  when the UnloadImage boot service function is called.
+
+  @param  ImageHandle The handle to the image to unload.
+
+  @return Status returned by all unload().
+
+**/
+EFI_STATUS
+EFIAPI
+_DriverUnloadHandler (
+  EFI_HANDLE ImageHandle
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // If an UnloadImage() handler is specified, then call it
+  //
+  Status = ProcessModuleUnloadList (ImageHandle);
+
+  //
+  // If the driver specific unload handler does not return an error, then call all of the
+  // library destructors.  If the unload handler returned an error, then the driver can not be
+  // unloaded, and the library destructors should not be called
+  //
+  if (!EFI_ERROR (Status)) {
+    ProcessLibraryDestructorList (ImageHandle, gST);
+  }
+
+  //
+  // Return the status from the driver specific unload handler
+  //
+  return Status;
+}
+
+
+/**
+  The entry point of PE/COFF Image for a DXE Driver, DXE Runtime Driver, DXE SMM 
+  Driver, or UEFI Driver. 
+
+  This function is the entry point for a DXE Driver, DXE Runtime Driver, DXE SMM Driver,
+  or UEFI Driver.  This function must call ProcessLibraryConstructorList() and
+  ProcessModuleEntryPointList(). If the return status from ProcessModuleEntryPointList()
+  is an error status, then ProcessLibraryDestructorList() must be called. The return 
+  value from ProcessModuleEntryPointList() is returned. If _gDriverUnloadImageCount 
+  is greater than zero, then an unload handler must be registered for this image 
+  and the unload handler must invoke ProcessModuleUnloadList().
+  If _gUefiDriverRevision is not zero and SystemTable->Hdr.Revision is less than 
+  _gUefiDriverRevison, then return EFI_INCOMPATIBLE_VERSION.
+
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, 
+                       DXE SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The DXE Driver, DXE Runtime Driver, DXE SMM 
+                                     Driver, or UEFI Driver exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than 
+                                    SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+
+**/
+EFI_STATUS
+EFIAPI
+_ModuleEntryPoint (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                 Status;
+  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;
+
+  if (_gUefiDriverRevision != 0) {
+    //
+    // Make sure that the EFI/UEFI spec revision of the platform is >= EFI/UEFI spec revision of the driver
+    //
+    if (SystemTable->Hdr.Revision < _gUefiDriverRevision) {
+      return EFI_INCOMPATIBLE_VERSION;
+    }
+  }
+
+  //
+  // Call constructor for all libraries
+  //
+  ProcessLibraryConstructorList (ImageHandle, SystemTable);
+
+  //
+  //  Install unload handler...
+  //
+  if (_gDriverUnloadImageCount != 0) {
+    Status = gBS->HandleProtocol (
+                    ImageHandle,
+                    &gEfiLoadedImageProtocolGuid,
+                    (VOID **)&LoadedImage
+                    );
+    ASSERT_EFI_ERROR (Status);
+    LoadedImage->Unload = _DriverUnloadHandler;
+  }
+
+  //
+  // Call the driver entry point
+  //
+  Status = ProcessModuleEntryPointList (ImageHandle, SystemTable);
+
+  //
+  // If all of the drivers returned errors, then invoke all of the library destructors
+  //
+  if (EFI_ERROR (Status)) {
+    ProcessLibraryDestructorList (ImageHandle, SystemTable);
+  }
+
+  //
+  // Return the cummalative return status code from all of the driver entry points
+  //
+  return Status;
+}
+
+
+/**
+  Required by the EBC compiler and identical in functionality to _ModuleEntryPoint(). 
+
+  This function is required to call _ModuleEntryPoint() passing in ImageHandle,
+  and SystemTable.
+
+  @param  ImageHandle  The image handle of the DXE Driver, DXE Runtime Driver, DXE 
+                       SMM Driver, or UEFI Driver.
+  @param  SystemTable  A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The DXE Driver, DXE Runtime Driver, DXE SMM 
+                                     Driver, or UEFI Driver exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than 
+                                     SystemTable->Hdr.Revision.
+  @retval  Other                     Return value from ProcessModuleEntryPointList().
+**/
+EFI_STATUS
+EFIAPI
+EfiMain (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  return _ModuleEntryPoint (ImageHandle, SystemTable);
+}
diff --git a/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf b/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
new file mode 100644
index 000000000000..e07393cd0ec4
--- /dev/null
+++ b/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
@@ -0,0 +1,67 @@
+## @file
+# Module entry point library for UEFI driver, DXE driver and SMM driver.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiDriverEntryPoint
+  MODULE_UNI_FILE                = UefiDriverEntryPoint.uni
+  FILE_GUID                      = 331deb15-454b-48d8-9b74-70d01f3f3556
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiDriverEntryPoint|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER UEFI_DRIVER SMM_CORE DXE_SMM_DRIVER
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  DriverEntryPoint.c
+
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  DebugLib
+  BaseLib
+
+
+[Protocols]
+  gEfiLoadedImageProtocolGuid                   ## SOMETIMES_CONSUMES
+
+
+#
+# For UEFI drivers, these architectural protocols defined in PI 1.0 spec need
+# to be appended and merged to the final dependency section.
+#
+[Depex.common.UEFI_DRIVER]
+  gEfiBdsArchProtocolGuid AND
+  gEfiCpuArchProtocolGuid AND
+  gEfiMetronomeArchProtocolGuid AND
+  gEfiMonotonicCounterArchProtocolGuid AND
+  gEfiRealTimeClockArchProtocolGuid AND
+  gEfiResetArchProtocolGuid AND
+  gEfiRuntimeArchProtocolGuid AND
+  gEfiSecurityArchProtocolGuid AND
+  gEfiTimerArchProtocolGuid AND
+  gEfiVariableWriteArchProtocolGuid AND
+  gEfiVariableArchProtocolGuid AND
+  gEfiWatchdogTimerArchProtocolGuid
+
diff --git a/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.uni b/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.uni
new file mode 100644
index 000000000000..3cbbde46841d
--- /dev/null
+++ b/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.uni
@@ -0,0 +1,21 @@
+// /** @file
+// Module entry point library for UEFI driver, DXE driver and SMM driver.
+//
+// Module entry point library for UEFI driver, DXE driver and SMM driver.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Module entry point library for UEFI driver, DXE driver and SMM driver"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Module entry point library for UEFI driver, DXE driver and SMM driver."
+
diff --git a/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.c b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.c
new file mode 100644
index 000000000000..87dd52c6bd9f
--- /dev/null
+++ b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.c
@@ -0,0 +1,1272 @@
+/** @file
+  Provides interface to EFI_FILE_HANDLE functionality.
+
+  Copyright (c) 2006 - 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 <Uefi.h>
+
+#include <Protocol/SimpleFileSystem.h>
+#include <Protocol/UnicodeCollation.h>
+
+#include <Guid/FileInfo.h>
+
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/FileHandleLib.h>
+#include <Library/PcdLib.h>
+#include <Library/PrintLib.h>
+
+CONST UINT16 gUnicodeFileTag = EFI_UNICODE_BYTE_ORDER_MARK;
+
+#define MAX_FILE_NAME_LEN 522 // (20 * (6+5+2))+1) unicode characters from EFI FAT spec (doubled for bytes)
+#define FIND_XXXXX_FILE_BUFFER_SIZE (SIZE_OF_EFI_FILE_INFO + MAX_FILE_NAME_LEN)
+
+/**
+  This function will retrieve the information about the file for the handle
+  specified and store it in allocated pool memory.
+
+  This function allocates a buffer to store the file's information. It is the
+  caller's responsibility to free the buffer
+
+  @param  FileHandle  The file handle of the file for which information is
+  being requested.
+
+  @retval NULL information could not be retrieved.
+
+  @return the information about the file
+**/
+EFI_FILE_INFO*
+EFIAPI
+FileHandleGetInfo (
+  IN EFI_FILE_HANDLE            FileHandle
+  )
+{
+  EFI_FILE_INFO   *FileInfo;
+  UINTN           FileInfoSize;
+  EFI_STATUS      Status;
+
+  if (FileHandle == NULL) {
+    return (NULL);
+  }
+
+  //
+  // Get the required size to allocate
+  //
+  FileInfoSize = 0;
+  FileInfo = NULL;
+  Status = FileHandle->GetInfo(FileHandle,
+                               &gEfiFileInfoGuid,
+                               &FileInfoSize,
+                               NULL);
+  if (Status == EFI_BUFFER_TOO_SMALL){
+    //
+    // error is expected.  getting size to allocate
+    //
+    FileInfo = AllocateZeroPool(FileInfoSize);
+    //
+    // now get the information
+    //
+    Status = FileHandle->GetInfo(FileHandle,
+                                 &gEfiFileInfoGuid,
+                                 &FileInfoSize,
+                                 FileInfo);
+    //
+    // if we got an error free the memory and return NULL
+    //
+    if (EFI_ERROR(Status) && (FileInfo != NULL)) {
+      FreePool(FileInfo);
+      FileInfo = NULL;
+    }
+  }
+  return (FileInfo);
+}
+
+/**
+  This function sets the information about the file for the opened handle
+  specified.
+
+  @param[in]  FileHandle        The file handle of the file for which information
+                                is being set.
+
+  @param[in]  FileInfo          The information to set.
+
+  @retval EFI_SUCCESS           The information was set.
+  @retval EFI_INVALID_PARAMETER A parameter was out of range or invalid.
+  @retval EFI_UNSUPPORTED       The FileHandle does not support FileInfo.
+  @retval EFI_NO_MEDIA          The device has no medium.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED     The file was opened read only.
+  @retval EFI_VOLUME_FULL       The volume is full.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetInfo (
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN CONST EFI_FILE_INFO        *FileInfo
+  )
+{
+
+  if (FileHandle == NULL || FileInfo == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Set the info
+  //
+  return (FileHandle->SetInfo(FileHandle,
+                              &gEfiFileInfoGuid,
+                              (UINTN)FileInfo->Size,
+                              (EFI_FILE_INFO*)FileInfo));
+}
+
+/**
+  This function reads information from an opened file.
+
+  If FileHandle is not a directory, the function reads the requested number of
+  bytes from the file at the file's current position and returns them in Buffer.
+  If the read goes beyond the end of the file, the read length is truncated to the
+  end of the file. The file's current position is increased by the number of bytes
+  returned.  If FileHandle is a directory, the function reads the directory entry
+  at the file's current position and returns the entry in Buffer. If the Buffer
+  is not large enough to hold the current directory entry, then
+  EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated.
+  BufferSize is set to be the size of the buffer needed to read the entry. On
+  success, the current position is updated to the next directory entry. If there
+  are no more directory entries, the read returns a zero-length buffer.
+  EFI_FILE_INFO is the structure returned as the directory entry.
+
+  @param FileHandle             the opened file handle
+  @param BufferSize             on input the size of buffer in bytes.  on return
+                                the number of bytes written.
+  @param Buffer                 the buffer to put read data into.
+
+  @retval EFI_SUCCESS           Data was read.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_BUFFER_TO_SMALL   Buffer is too small. ReadSize contains required
+                                size.
+
+**/
+EFI_STATUS
+EFIAPI
+FileHandleRead(
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN OUT UINTN                  *BufferSize,
+  OUT VOID                      *Buffer
+  )
+{
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the read based on EFI_FILE_PROTOCOL
+  //
+  return (FileHandle->Read(FileHandle, BufferSize, Buffer));
+}
+
+
+/**
+  Write data to a file.
+
+  This function writes the specified number of bytes to the file at the current
+  file position. The current file position is advanced the actual number of bytes
+  written, which is returned in BufferSize. Partial writes only occur when there
+  has been a data error during the write attempt (such as "volume space full").
+  The file is automatically grown to hold the data if required. Direct writes to
+  opened directories are not supported.
+
+  @param FileHandle           The opened file for writing
+  @param BufferSize           on input the number of bytes in Buffer.  On output
+                              the number of bytes written.
+  @param Buffer               the buffer containing data to write is stored.
+
+ @retval EFI_SUCCESS          Data was written.
+ @retval EFI_UNSUPPORTED      Writes to an open directory are not supported.
+ @retval EFI_NO_MEDIA         The device has no media.
+ @retval EFI_DEVICE_ERROR     The device reported an error.
+ @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+ @retval EFI_WRITE_PROTECTED  The device is write-protected.
+ @retval EFI_ACCESS_DENIED    The file was open for read only.
+ @retval EFI_VOLUME_FULL      The volume is full.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleWrite(
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN OUT UINTN                  *BufferSize,
+  IN VOID                       *Buffer
+  )
+{
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the write based on EFI_FILE_PROTOCOL
+  //
+  return (FileHandle->Write(FileHandle, BufferSize, Buffer));
+}
+
+/**
+  Close an open file handle.
+
+  This function closes a specified file handle. All "dirty" cached file data is
+  flushed to the device, and the file is closed. In all cases the handle is
+  closed.
+
+@param FileHandle               the file handle to close.
+
+@retval EFI_SUCCESS             the file handle was closed successfully.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleClose (
+  IN EFI_FILE_HANDLE            FileHandle
+  )
+{
+  EFI_STATUS Status;
+
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the Close based on EFI_FILE_PROTOCOL
+  //
+  Status = FileHandle->Close(FileHandle);
+  return Status;
+}
+
+/**
+  Delete a file and close the handle
+
+  This function closes and deletes a file. In all cases the file handle is closed.
+  If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is
+  returned, but the handle is still closed.
+
+  @param FileHandle             the file handle to delete
+
+  @retval EFI_SUCCESS           the file was closed successfully
+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
+                                deleted
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleDelete (
+  IN EFI_FILE_HANDLE    FileHandle
+  )
+{
+  EFI_STATUS Status;
+
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the Delete based on EFI_FILE_PROTOCOL
+  //
+  Status = FileHandle->Delete(FileHandle);
+  return Status;
+}
+
+/**
+  Set the current position in a file.
+
+  This function sets the current file position for the handle to the position
+  supplied. With the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only
+  absolute positioning is supported, and seeking past the end of the file is
+  allowed (a subsequent write would grow the file). Seeking to position
+  0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
+  If FileHandle is a directory, the only position that may be set is zero. This
+  has the effect of starting the read process of the directory entries over.
+
+  @param FileHandle             The file handle on which the position is being set
+  @param Position               Byte position from beginning of file
+
+  @retval EFI_SUCCESS           Operation completed successfully.
+  @retval EFI_UNSUPPORTED       the seek request for non-zero is not valid on
+                                directories.
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetPosition (
+  IN EFI_FILE_HANDLE    FileHandle,
+  IN UINT64             Position
+  )
+{
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the SetPosition based on EFI_FILE_PROTOCOL
+  //
+  return (FileHandle->SetPosition(FileHandle, Position));
+}
+
+/**
+  Gets a file's current position
+
+  This function retrieves the current file position for the file handle. For
+  directories, the current file position has no meaning outside of the file
+  system driver and as such the operation is not supported. An error is returned
+  if FileHandle is a directory.
+
+  @param FileHandle             The open file handle on which to get the position.
+  @param Position               Byte position from beginning of file.
+
+  @retval EFI_SUCCESS           the operation completed successfully.
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.
+  @retval EFI_UNSUPPORTED       the request is not valid on directories.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetPosition (
+  IN EFI_FILE_HANDLE            FileHandle,
+  OUT UINT64                    *Position
+  )
+{
+  if (Position == NULL || FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the GetPosition based on EFI_FILE_PROTOCOL
+  //
+  return (FileHandle->GetPosition(FileHandle, Position));
+}
+/**
+  Flushes data on a file
+
+  This function flushes all modified data associated with a file to a device.
+
+  @param FileHandle             The file handle on which to flush data
+
+  @retval EFI_SUCCESS           The data was flushed.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED     The file was opened for read only.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFlush (
+  IN EFI_FILE_HANDLE            FileHandle
+  )
+{
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // Perform the Flush based on EFI_FILE_PROTOCOL
+  //
+  return (FileHandle->Flush(FileHandle));
+}
+
+/**
+  Function to determine if a given handle is a directory handle.
+
+  Open the file information on the DirHandle and verify that the Attribute
+  includes EFI_FILE_DIRECTORY bit set.
+
+  @param[in] DirHandle          Handle to open file.
+
+  @retval EFI_SUCCESS           DirHandle is a directory.
+  @retval EFI_INVALID_PARAMETER DirHandle is NULL. 
+                                The file information returns from FileHandleGetInfo is NULL. 
+  @retval EFI_NOT_FOUND         DirHandle is not a directory.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleIsDirectory (
+  IN EFI_FILE_HANDLE            DirHandle
+  )
+{
+  EFI_FILE_INFO *DirInfo;
+
+  if (DirHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // get the file information for DirHandle
+  //
+  DirInfo = FileHandleGetInfo (DirHandle);
+
+  //
+  // Parse DirInfo
+  //
+  if (DirInfo == NULL) {
+    //
+    // We got nothing...
+    //
+    return (EFI_INVALID_PARAMETER);
+  }
+  if ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
+    //
+    // Attributes say this is not a directory
+    //
+    FreePool (DirInfo);
+    return (EFI_NOT_FOUND);
+  }
+  //
+  // all good...
+  //
+  FreePool (DirInfo);
+  return (EFI_SUCCESS);
+}
+
+/** Retrieve first entry from a directory.
+
+  This function takes an open directory handle and gets information from the
+  first entry in the directory.  A buffer is allocated to contain
+  the information and a pointer to the buffer is returned in *Buffer.  The
+  caller can use FileHandleFindNextFile() to get subsequent directory entries.
+
+  The buffer will be freed by FileHandleFindNextFile() when the last directory
+  entry is read.  Otherwise, the caller must free the buffer, using FreePool,
+  when finished with it.
+
+  @param[in]  DirHandle         The file handle of the directory to search.
+  @param[out] Buffer            The pointer to pointer to buffer for file's information.
+
+  @retval EFI_SUCCESS           Found the first file.
+  @retval EFI_NOT_FOUND         Cannot find the directory.
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+  @return Others                status of FileHandleGetInfo, FileHandleSetPosition,
+                                or FileHandleRead
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFindFirstFile (
+  IN EFI_FILE_HANDLE            DirHandle,
+  OUT EFI_FILE_INFO             **Buffer
+  )
+{
+  EFI_STATUS    Status;
+  UINTN         BufferSize;
+
+  if (Buffer == NULL || DirHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // verify that DirHandle is a directory
+  //
+  Status = FileHandleIsDirectory(DirHandle);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+
+  //
+  // Allocate a buffer sized to struct size + enough for the string at the end
+  //
+  BufferSize = FIND_XXXXX_FILE_BUFFER_SIZE;
+  *Buffer = AllocateZeroPool(BufferSize);
+  if (*Buffer == NULL){
+    return (EFI_OUT_OF_RESOURCES);
+  }
+
+  //
+  // reset to the beginning of the directory
+  //
+  Status = FileHandleSetPosition(DirHandle, 0);
+  if (EFI_ERROR(Status)) {
+    FreePool(*Buffer);
+    *Buffer = NULL;
+    return (Status);
+  }
+
+  //
+  // read in the info about the first file
+  //
+  Status = FileHandleRead (DirHandle, &BufferSize, *Buffer);
+  ASSERT(Status != EFI_BUFFER_TOO_SMALL);
+  if (EFI_ERROR(Status) || BufferSize == 0) {
+    FreePool(*Buffer);
+    *Buffer = NULL;
+    if (BufferSize == 0) {
+      return (EFI_NOT_FOUND);
+    }
+    return (Status);
+  }
+  return (EFI_SUCCESS);
+}
+
+/** Retrieve next entries from a directory.
+
+  To use this function, the caller must first call the FileHandleFindFirstFile()
+  function to get the first directory entry.  Subsequent directory entries are
+  retrieved by using the FileHandleFindNextFile() function.  This function can
+  be called several times to get each entry from the directory.  If the call of
+  FileHandleFindNextFile() retrieved the last directory entry, the next call of
+  this function will set *NoFile to TRUE and free the buffer.
+
+  @param[in]  DirHandle         The file handle of the directory.
+  @param[out] Buffer            The pointer to buffer for file's information.
+  @param[out] NoFile            The pointer to boolean when last file is found.
+
+  @retval EFI_SUCCESS           Found the next file, or reached last file
+  @retval EFI_NO_MEDIA          The device has no media.
+  @retval EFI_DEVICE_ERROR      The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleFindNextFile(
+  IN EFI_FILE_HANDLE          DirHandle,
+  OUT EFI_FILE_INFO          *Buffer,
+  OUT BOOLEAN                *NoFile
+  )
+{
+  EFI_STATUS    Status;
+  UINTN         BufferSize;
+
+  if (DirHandle == NULL || Buffer == NULL || NoFile == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // This BufferSize MUST stay equal to the originally allocated one in GetFirstFile
+  //
+  BufferSize = FIND_XXXXX_FILE_BUFFER_SIZE;
+
+  //
+  // read in the info about the next file
+  //
+  Status = FileHandleRead (DirHandle, &BufferSize, Buffer);
+  ASSERT(Status != EFI_BUFFER_TOO_SMALL);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+
+  //
+  // If we read 0 bytes (but did not have erros) we already read in the last file.
+  //
+  if (BufferSize == 0) {
+    FreePool(Buffer);
+    *NoFile = TRUE;
+  }
+
+  return (EFI_SUCCESS);
+}
+
+/**
+  Retrieve the size of a file.
+
+  This function extracts the file size info from the FileHandle's EFI_FILE_INFO
+  data.
+
+  @param[in] FileHandle         The file handle from which size is retrieved.
+  @param[out] Size              The pointer to size.
+
+  @retval EFI_SUCCESS           Operation was completed successfully.
+  @retval EFI_DEVICE_ERROR      Cannot access the file.
+  @retval EFI_INVALID_PARAMETER FileHandle is NULL.
+                                Size is NULL.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetSize (
+  IN EFI_FILE_HANDLE            FileHandle,
+  OUT UINT64                    *Size
+  )
+{
+  EFI_FILE_INFO                 *FileInfo;
+
+  if (FileHandle == NULL || Size == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // get the FileInfo structure
+  //
+  FileInfo = FileHandleGetInfo(FileHandle);
+  if (FileInfo == NULL) {
+    return (EFI_DEVICE_ERROR);
+  }
+
+  //
+  // Assign the Size pointer to the correct value
+  //
+  *Size = FileInfo->FileSize;
+
+  //
+  // free the FileInfo memory
+  //
+  FreePool(FileInfo);
+
+  return (EFI_SUCCESS);
+}
+
+/**
+  Set the size of a file.
+
+  This function changes the file size info from the FileHandle's EFI_FILE_INFO
+  data.
+
+  @param[in] FileHandle         The file handle whose size is to be changed.
+  @param[in] Size               The new size.
+
+  @retval EFI_SUCCESS           The operation completed successfully.
+  @retval EFI_DEVICE_ERROR      Cannot access the file.
+  @retval EFI_INVALID_PARAMETER FileHandle is NULL.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleSetSize (
+  IN EFI_FILE_HANDLE            FileHandle,
+  IN UINT64                     Size
+  )
+{
+  EFI_FILE_INFO                 *FileInfo;
+  EFI_STATUS                    Status;
+
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  //
+  // get the FileInfo structure
+  //
+  FileInfo = FileHandleGetInfo(FileHandle);
+  if (FileInfo == NULL) {
+    return (EFI_DEVICE_ERROR);
+  }
+
+  //
+  // Assign the FileSize pointer to the new value
+  //
+  FileInfo->FileSize = Size;
+
+  Status = FileHandleSetInfo(FileHandle, FileInfo);
+  //
+  // free the FileInfo memory
+  //
+  FreePool(FileInfo);
+
+  return (Status);
+}
+
+/**
+  Safely append (on the left) with automatic string resizing given length of Destination and
+  desired length of copy from Source.
+
+  append the first D characters of Source to the end of Destination, where D is
+  the lesser of Count and the StrLen() of Source. If appending those D characters
+  will fit within Destination (whose Size is given as CurrentSize) and
+  still leave room for a NULL terminator, then those characters are appended,
+  starting at the original terminating NULL of Destination, and a new terminating
+  NULL is appended.
+
+  If appending D characters onto Destination will result in a overflow of the size
+  given in CurrentSize the string will be grown such that the copy can be performed
+  and CurrentSize will be updated to the new size.
+
+  If Source is NULL, there is nothing to append, just return the current buffer in
+  Destination.
+
+  if Destination is NULL, then return error
+  if Destination's current length (including NULL terminator) is already more then
+  CurrentSize, then ASSERT()
+
+  @param[in, out] Destination   The String to append onto
+  @param[in, out] CurrentSize   on call the number of bytes in Destination.  On
+                                return possibly the new size (still in bytes).  if NULL
+                                then allocate whatever is needed.
+  @param[in]      Source        The String to append from
+  @param[in]      Count         Maximum number of characters to append.  if 0 then
+                                all are appended.
+
+  @return Destination           return the resultant string.
+**/
+CHAR16*
+EFIAPI
+StrnCatGrowLeft (
+  IN OUT CHAR16           **Destination,
+  IN OUT UINTN            *CurrentSize,
+  IN     CONST CHAR16     *Source,
+  IN     UINTN            Count
+  )
+{
+  UINTN DestinationStartSize;
+  UINTN NewSize;
+  UINTN CopySize;
+
+  if (Destination == NULL) {
+    return (NULL);
+  }
+
+  //
+  // If there's nothing to do then just return Destination
+  //
+  if (Source == NULL) {
+    return (*Destination);
+  }
+
+  //
+  // allow for NULL pointers address as Destination
+  //
+  if (*Destination != NULL) {
+    ASSERT(CurrentSize != 0);
+    DestinationStartSize = StrSize(*Destination);
+    ASSERT(DestinationStartSize <= *CurrentSize);
+  } else {
+    DestinationStartSize = 0;
+//    ASSERT(*CurrentSize == 0);
+  }
+
+  //
+  // Append all of Source?
+  //
+  if (Count == 0) {
+    Count = StrSize(Source);
+  }
+
+  //
+  // Test and grow if required
+  //
+  if (CurrentSize != NULL) {
+    NewSize = *CurrentSize;
+    while (NewSize < (DestinationStartSize + Count)) {
+      NewSize += 2 * Count;
+    }
+    *Destination = ReallocatePool(*CurrentSize, NewSize, *Destination);
+    *CurrentSize = NewSize;
+  } else {
+    *Destination = AllocateZeroPool(Count+sizeof(CHAR16));
+  }
+  if (*Destination == NULL) {
+    return NULL;
+  }
+
+  CopySize = StrSize(*Destination);
+  CopyMem((*Destination)+((Count-2)/sizeof(CHAR16)), *Destination, CopySize);
+  CopyMem(*Destination, Source, Count-2);
+  return (*Destination);
+}
+
+/**
+  Function to get a full filename given a EFI_FILE_HANDLE somewhere lower on the
+  directory 'stack'. If the file is a directory, then append the '\' char at the 
+  end of name string. If it's not a directory, then the last '\' should not be 
+  added.
+
+  if Handle is NULL, return EFI_INVALID_PARAMETER
+
+  @param[in] Handle             Handle to the Directory or File to create path to.
+  @param[out] FullFileName      pointer to pointer to generated full file name.  It
+                                is the responsibility of the caller to free this memory
+                                with a call to FreePool().
+  @retval EFI_SUCCESS           the operation was sucessful and the FullFileName is valid.
+  @retval EFI_INVALID_PARAMETER Handle was NULL.
+  @retval EFI_INVALID_PARAMETER FullFileName was NULL.
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.
+**/
+EFI_STATUS
+EFIAPI
+FileHandleGetFileName (
+  IN CONST EFI_FILE_HANDLE      Handle,
+  OUT CHAR16                    **FullFileName
+  )
+{
+  EFI_STATUS      Status;
+  UINTN           Size;
+  EFI_FILE_HANDLE CurrentHandle;
+  EFI_FILE_HANDLE NextHigherHandle;
+  EFI_FILE_INFO   *FileInfo;
+
+  Size = 0;
+
+  //
+  // Check our parameters
+  //
+  if (FullFileName == NULL || Handle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+
+  *FullFileName = NULL;
+  CurrentHandle = NULL;
+
+  Status = Handle->Open(Handle, &CurrentHandle, L".", EFI_FILE_MODE_READ, 0);
+  if (!EFI_ERROR(Status)) {
+    //
+    // Reverse out the current directory on the device
+    //
+    for (;;) {
+      FileInfo = FileHandleGetInfo(CurrentHandle);
+      if (FileInfo == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        break;
+      } else {
+        //
+        // We got info... do we have a name? if yes precede the current path with it...
+        //
+        if (StrLen (FileInfo->FileName) == 0) {
+          if (*FullFileName == NULL) {
+            ASSERT((*FullFileName == NULL && Size == 0) || (*FullFileName != NULL));
+            *FullFileName = StrnCatGrowLeft(FullFileName, &Size, L"\\", 0);
+          }
+          FreePool(FileInfo);
+          break;
+        } else {
+          if (*FullFileName == NULL) {
+            ASSERT((*FullFileName == NULL && Size == 0) || (*FullFileName != NULL));
+            *FullFileName = StrnCatGrowLeft(FullFileName, &Size, L"\\", 0);
+          }
+          ASSERT((*FullFileName == NULL && Size == 0) || (*FullFileName != NULL));
+          *FullFileName = StrnCatGrowLeft(FullFileName, &Size, FileInfo->FileName, 0);
+          *FullFileName = StrnCatGrowLeft(FullFileName, &Size, L"\\", 0);
+          FreePool(FileInfo);
+        }
+      }
+      //
+      // Move to the parent directory
+      //
+      Status = CurrentHandle->Open (CurrentHandle, &NextHigherHandle, L"..", EFI_FILE_MODE_READ, 0);
+      if (EFI_ERROR (Status)) {
+        break;
+      }
+
+      FileHandleClose(CurrentHandle);
+      CurrentHandle = NextHigherHandle;
+    }
+  } else if (Status == EFI_NOT_FOUND) {
+    Status = EFI_SUCCESS;
+    ASSERT((*FullFileName == NULL && Size == 0) || (*FullFileName != NULL));
+    *FullFileName = StrnCatGrowLeft(FullFileName, &Size, L"\\", 0);
+  }
+
+  if (*FullFileName != NULL && 
+      (*FullFileName)[StrLen(*FullFileName) - 1] == L'\\' && 
+      StrLen(*FullFileName) > 1 &&
+      FileHandleIsDirectory(Handle) == EFI_NOT_FOUND
+     ) {
+    (*FullFileName)[StrLen(*FullFileName) - 1] = CHAR_NULL;
+  }
+
+  if (CurrentHandle != NULL) {
+    CurrentHandle->Close (CurrentHandle);
+  }
+
+  if (EFI_ERROR(Status) && *FullFileName != NULL) {
+    FreePool(*FullFileName);
+  }
+
+  return (Status);
+}
+
+/**
+  Function to read a single line from a file. The \n is not included in the returned
+  buffer.  The returned buffer must be callee freed.
+
+  If the position upon start is 0, then the Ascii Boolean will be set.  This should be
+  maintained and not changed for all operations with the same file.
+
+  @param[in]       Handle        FileHandle to read from.
+  @param[in, out]  Ascii         Boolean value for indicating whether the file is Ascii (TRUE) or UCS2 (FALSE);
+
+  @return                       The line of text from the file.
+
+  @sa FileHandleReadLine
+**/
+CHAR16*
+EFIAPI
+FileHandleReturnLine(
+  IN EFI_FILE_HANDLE            Handle,
+  IN OUT BOOLEAN                *Ascii
+  )
+{
+  CHAR16          *RetVal;
+  UINTN           Size;
+  EFI_STATUS      Status;
+
+  Size = 0;
+  RetVal = NULL;
+
+  Status = FileHandleReadLine(Handle, RetVal, &Size, FALSE, Ascii);
+  if (Status == EFI_BUFFER_TOO_SMALL) {
+    RetVal = AllocateZeroPool(Size);
+    Status = FileHandleReadLine(Handle, RetVal, &Size, FALSE, Ascii);
+  }
+  ASSERT_EFI_ERROR(Status);
+  if (EFI_ERROR(Status) && (RetVal != NULL)) {
+    FreePool(RetVal);
+    RetVal = NULL;
+  }
+  return (RetVal);
+}
+
+/**
+  Function to read a single line (up to but not including the \n) from a file.
+
+  If the position upon start is 0, then the Ascii Boolean will be set.  This should be
+  maintained and not changed for all operations with the same file.
+  The function will not return the \r and \n character in buffer. When an empty line is
+  read a CHAR_NULL character will be returned in buffer.
+
+  @param[in]       Handle        FileHandle to read from.
+  @param[in, out]  Buffer        The pointer to buffer to read into.
+  @param[in, out]  Size          The pointer to number of bytes in Buffer.
+  @param[in]       Truncate      If the buffer is large enough, this has no effect.
+                                 If the buffer is is too small and Truncate is TRUE,
+                                 the line will be truncated.
+                                 If the buffer is is too small and Truncate is FALSE,
+                                 then no read will occur.
+
+  @param[in, out]  Ascii         Boolean value for indicating whether the file is
+                                 Ascii (TRUE) or UCS2 (FALSE).
+
+  @retval EFI_SUCCESS           The operation was successful.  The line is stored in
+                                Buffer.
+  @retval EFI_INVALID_PARAMETER Handle was NULL.
+  @retval EFI_INVALID_PARAMETER Size was NULL.
+  @retval EFI_BUFFER_TOO_SMALL  Size was not large enough to store the line.
+                                Size was updated to the minimum space required.
+  @sa FileHandleRead
+**/
+EFI_STATUS
+EFIAPI
+FileHandleReadLine(
+  IN EFI_FILE_HANDLE            Handle,
+  IN OUT CHAR16                 *Buffer,
+  IN OUT UINTN                  *Size,
+  IN BOOLEAN                    Truncate,
+  IN OUT BOOLEAN                *Ascii
+  )
+{
+  EFI_STATUS  Status;
+  CHAR16      CharBuffer;
+  UINT64      FileSize;
+  UINTN       CharSize;
+  UINTN       CountSoFar;
+  UINTN       CrCount;
+  UINT64      OriginalFilePosition;
+
+  if (Handle == NULL
+    ||Size   == NULL
+    ||(Buffer==NULL&&*Size!=0)
+   ){
+    return (EFI_INVALID_PARAMETER);
+  } 
+  
+  if (Buffer != NULL && *Size != 0) {
+    *Buffer = CHAR_NULL;
+  } 
+  
+  Status = FileHandleGetSize (Handle, &FileSize);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  } else if (FileSize == 0) {
+    *Ascii = TRUE;
+    return EFI_SUCCESS;
+  }  
+  
+  FileHandleGetPosition(Handle, &OriginalFilePosition);
+  if (OriginalFilePosition == 0) {
+    CharSize = sizeof(CHAR16);
+    Status = FileHandleRead(Handle, &CharSize, &CharBuffer);
+    ASSERT_EFI_ERROR(Status);
+    if (CharBuffer == gUnicodeFileTag) {
+      *Ascii = FALSE;
+    } else {
+      *Ascii = TRUE;
+      FileHandleSetPosition(Handle, OriginalFilePosition);
+    }
+  }
+
+  CrCount = 0;
+  for (CountSoFar = 0;;CountSoFar++){
+    CharBuffer = 0;
+    if (*Ascii) {
+      CharSize = sizeof(CHAR8);
+    } else {
+      CharSize = sizeof(CHAR16);
+    }
+    Status = FileHandleRead(Handle, &CharSize, &CharBuffer);
+    if (  EFI_ERROR(Status)
+       || CharSize == 0
+       || (CharBuffer == L'\n' && !(*Ascii))
+       || (CharBuffer ==  '\n' && *Ascii)
+     ){
+      break;
+    } else if (
+        (CharBuffer == L'\r' && !(*Ascii)) ||
+        (CharBuffer ==  '\r' && *Ascii)
+      ) {
+      CrCount++;
+      continue;
+    }
+    //
+    // if we have space save it...
+    //
+    if ((CountSoFar+1-CrCount)*sizeof(CHAR16) < *Size){
+      ASSERT(Buffer != NULL);
+      ((CHAR16*)Buffer)[CountSoFar-CrCount] = CharBuffer;
+      ((CHAR16*)Buffer)[CountSoFar+1-CrCount] = CHAR_NULL;
+    }
+  }
+
+  //
+  // if we ran out of space tell when...
+  //
+  if ((CountSoFar+1-CrCount)*sizeof(CHAR16) > *Size){
+    *Size = (CountSoFar+1-CrCount)*sizeof(CHAR16);
+    if (!Truncate) {
+      if (Buffer != NULL && *Size != 0) {
+        ZeroMem(Buffer, *Size);
+      }
+      FileHandleSetPosition(Handle, OriginalFilePosition);
+      return (EFI_BUFFER_TOO_SMALL);
+    } else {
+      DEBUG((DEBUG_WARN, "The line was truncated in FileHandleReadLine"));
+      return (EFI_SUCCESS);
+    }
+  }
+
+  return (Status);
+}
+
+/**
+  Function to write a line of text to a file.
+  
+  If the file is a Unicode file (with UNICODE file tag) then write the unicode 
+  text.
+  If the file is an ASCII file then write the ASCII text.
+  If the size of file is zero (without file tag at the beginning) then write 
+  ASCII text as default.
+
+  @param[in]     Handle         FileHandle to write to.
+  @param[in]     Buffer         Buffer to write, if NULL the function will
+                                take no action and return EFI_SUCCESS.
+
+  @retval  EFI_SUCCESS            The data was written.
+                                  Buffer is NULL.
+  @retval  EFI_INVALID_PARAMETER  Handle is NULL.
+  @retval  EFI_OUT_OF_RESOURCES   Unable to allocate temporary space for ASCII 
+                                  string due to out of resources.
+
+  @sa FileHandleWrite
+**/
+EFI_STATUS
+EFIAPI
+FileHandleWriteLine(
+  IN EFI_FILE_HANDLE Handle,
+  IN CHAR16          *Buffer
+  )
+{
+  EFI_STATUS  Status;
+  CHAR16      CharBuffer;
+  UINTN       Size;
+  UINTN       Index;
+  UINTN       CharSize;
+  UINT64      FileSize;
+  UINT64      OriginalFilePosition;
+  BOOLEAN     Ascii;
+  CHAR8       *AsciiBuffer;
+
+  if (Buffer == NULL) {
+    return (EFI_SUCCESS);
+  }
+
+  if (Handle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+  
+  Ascii = FALSE;
+  AsciiBuffer = NULL;
+  
+  Status = FileHandleGetPosition(Handle, &OriginalFilePosition);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+  
+  Status = FileHandleSetPosition(Handle, 0);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+  
+  Status = FileHandleGetSize(Handle, &FileSize);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+  
+  if (FileSize == 0) {
+    Ascii = TRUE;
+  } else {
+    CharSize = sizeof (CHAR16);
+    Status = FileHandleRead (Handle, &CharSize, &CharBuffer);
+    ASSERT_EFI_ERROR (Status);
+    if (CharBuffer == gUnicodeFileTag) {
+      Ascii = FALSE;
+    } else {
+      Ascii = TRUE;
+    }
+  }
+  
+  Status = FileHandleSetPosition(Handle, OriginalFilePosition);
+  if (EFI_ERROR(Status)) {
+    return Status;
+  }
+  
+  if (Ascii) {
+    Size = ( StrSize(Buffer) / sizeof(CHAR16) ) * sizeof(CHAR8);
+    AsciiBuffer = (CHAR8 *)AllocateZeroPool(Size);
+    if (AsciiBuffer == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+    UnicodeStrToAsciiStrS (Buffer, AsciiBuffer, Size);
+    for (Index = 0; Index < Size; Index++) {
+      if ((AsciiBuffer[Index] & BIT7) != 0) {
+        FreePool(AsciiBuffer);
+        return EFI_INVALID_PARAMETER;
+      }
+    }
+    
+    Size = AsciiStrSize(AsciiBuffer) - sizeof(CHAR8);
+    Status = FileHandleWrite(Handle, &Size, AsciiBuffer);
+    if (EFI_ERROR(Status)) {
+      FreePool (AsciiBuffer);
+      return (Status);
+    }
+    Size = AsciiStrSize("\r\n") - sizeof(CHAR8);
+    Status = FileHandleWrite(Handle, &Size, "\r\n");
+  } else {
+    if (OriginalFilePosition == 0) {
+      Status = FileHandleSetPosition (Handle, sizeof(CHAR16));
+      if (EFI_ERROR(Status)) {
+        return Status;
+      }
+    }
+    Size = StrSize(Buffer) - sizeof(CHAR16);
+    Status = FileHandleWrite(Handle, &Size, Buffer);
+    if (EFI_ERROR(Status)) {
+      return (Status);
+    }
+    Size = StrSize(L"\r\n") - sizeof(CHAR16);
+    Status = FileHandleWrite(Handle, &Size, L"\r\n");
+  }
+  
+  if (AsciiBuffer != NULL) {
+    FreePool (AsciiBuffer);
+  }
+  return Status;
+}
+
+/**
+  function to take a formatted argument and print it to a file.
+
+  @param[in] Handle   the file handle for the file to write to
+  @param[in] Format   the format argument (see printlib for format specifier)
+  @param[in] ...      the variable arguments for the format
+
+  @retval EFI_SUCCESS the operation was successful
+  @return other       a return value from FileHandleWriteLine
+
+  @sa FileHandleWriteLine
+**/
+EFI_STATUS
+EFIAPI
+FileHandlePrintLine(
+  IN EFI_FILE_HANDLE  Handle,
+  IN CONST CHAR16     *Format,
+  ...
+  )
+{
+  VA_LIST           Marker;
+  CHAR16            *Buffer;
+  EFI_STATUS        Status;
+
+  //
+  // Get a buffer to print into
+  //
+  Buffer = AllocateZeroPool (PcdGet16 (PcdUefiFileHandleLibPrintBufferSize));
+  if (Buffer == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+
+  //
+  // Print into our buffer
+  //
+  VA_START (Marker, Format);
+  UnicodeVSPrint (Buffer, PcdGet16 (PcdUefiFileHandleLibPrintBufferSize), Format, Marker);
+  VA_END (Marker);
+
+  //
+  // Print buffer into file
+  //
+  Status = FileHandleWriteLine(Handle, Buffer);
+
+  //
+  // Cleanup and return
+  //
+  FreePool(Buffer);
+  return (Status);
+}
+
+/**
+  Function to determine if a FILE_HANDLE is at the end of the file.
+
+  This will NOT work on directories.
+
+  If Handle is NULL, then return False.
+
+  @param[in] Handle     the file handle
+
+  @retval TRUE          the position is at the end of the file
+  @retval FALSE         the position is not at the end of the file
+**/
+BOOLEAN
+EFIAPI
+FileHandleEof(
+  IN EFI_FILE_HANDLE Handle
+  )
+{
+  EFI_FILE_INFO *Info;
+  UINT64        Pos;
+  BOOLEAN       RetVal;
+
+  if (Handle == NULL) {
+    return (FALSE);
+  }
+
+  FileHandleGetPosition(Handle, &Pos);
+  Info = FileHandleGetInfo (Handle);
+
+  if (Info == NULL) {
+    return (FALSE);
+  }
+
+  FileHandleSetPosition(Handle, Pos);
+
+  if (Pos == Info->FileSize) {
+    RetVal = TRUE;
+  } else {
+    RetVal = FALSE;
+  }
+
+  FreePool (Info);
+
+  return (RetVal);
+}
diff --git a/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
new file mode 100644
index 000000000000..9697a7e759c0
--- /dev/null
+++ b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
@@ -0,0 +1,48 @@
+##  @file
+# Provides interface to shell functionality for shell commands and applications.
+#
+#   Copyright (c) 2006 - 2015, 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.
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010006
+  BASE_NAME                      = UefiFileHandleLib
+  MODULE_UNI_FILE                = UefiFileHandleLib.uni
+  FILE_GUID                      = 9495D344-9D8A-41f3-8D17-E2FD238C4E71
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = FileHandleLib|DXE_DRIVER UEFI_APPLICATION UEFI_DRIVER DXE_RUNTIME_DRIVER
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources.common]
+  UefiFileHandleLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  MemoryAllocationLib
+  BaseLib
+  BaseMemoryLib
+  DebugLib
+  PrintLib
+  PcdLib
+
+[Protocols]
+  gEfiSimpleFileSystemProtocolGuid              ## SOMETIMES_CONSUMES
+
+[Guids]
+  gEfiFileInfoGuid                              ## SOMETIMES_CONSUMES ## GUID
+
+[Pcd.common]
+  gEfiMdePkgTokenSpaceGuid.PcdUefiFileHandleLibPrintBufferSize  ## SOMETIMES_CONSUMES
diff --git a/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.uni b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.uni
new file mode 100644
index 000000000000..23eca00bc52f
--- /dev/null
+++ b/MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.uni
@@ -0,0 +1,26 @@
+// /** @file
+// Provides interface to shell functionality for shell commands and applications.
+//
+// Provides interface to shell functionality for shell commands and applications.
+//
+// Copyright (c) 2015, 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.
+//
+// **/
+
+#string STR_MODULE_ABSTRACT
+#language en-US
+"Provides interface to shell functionality for shell commands and applications."
+
+#string STR_MODULE_DESCRIPTION
+#language en-US
+"Provides interface to shell functionality for shell commands and applications."
+
+
diff --git a/MdePkg/Library/UefiLib/Console.c b/MdePkg/Library/UefiLib/Console.c
new file mode 100644
index 000000000000..d78a01e881ec
--- /dev/null
+++ b/MdePkg/Library/UefiLib/Console.c
@@ -0,0 +1,572 @@
+/** @file
+  This module provide help function for displaying unicode string.
+
+  Copyright (c) 2006 - 2015, 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 "UefiLibInternal.h"
+
+typedef struct {
+  CHAR16  WChar;
+  UINT32  Width;
+} UNICODE_WIDTH_ENTRY;
+
+#define NARROW_CHAR         0xFFF0
+#define WIDE_CHAR           0xFFF1
+
+GLOBAL_REMOVE_IF_UNREFERENCED CONST UNICODE_WIDTH_ENTRY mUnicodeWidthTable[] = {
+  //
+  // General script area
+  //
+  {(CHAR16)0x1FFF,  1},
+  /*
+   * Merge the blocks and replace them with the above entry as they fall to 
+   * the same category and they are all narrow glyph. This will reduce search
+   * time and table size. The merge will omit the reserved code.
+   *
+   * Remove the above item if below is un-commented.
+   *
+  {(CHAR16)0x007F,  1},       // C0 controls and basic Latin. 0x0000-0x007F
+  {(CHAR16)0x00FF,  1},       // C1 controls and Latin-1 support. 0x0080-0x00FF
+  {(CHAR16)0x017F,  1},       // Latin extended-A. 0x0100-0x017F
+  {(CHAR16)0x024F,  1},       // Latin extended-B. 0x0180-0x024F
+  {(CHAR16)0x02AF,  1},       // IPA extensions. 0x0250-0x02AF
+  {(CHAR16)0x02FF,  1},       // Spacing modifier letters. 0x02B0-0x02FF
+  {(CHAR16)0x036F,  1},       // Combining diacritical marks. 0x0300-0x036F
+  {(CHAR16)0x03FF,  1},       // Greek. 0x0370-0x03FF
+  {(CHAR16)0x04FF,  1},       // Cyrillic. 0x0400-0x04FF
+  {(CHAR16)0x052F,  0},       // Unassigned. As Armenian in ver3.0. 0x0500-0x052F
+  {(CHAR16)0x058F,  1},       // Armenian. 0x0530-0x058F
+  {(CHAR16)0x05FF,  1},       // Hebrew. 0x0590-0x05FF
+  {(CHAR16)0x06FF,  1},       // Arabic. 0x0600-0x06FF
+  {(CHAR16)0x08FF,  0},       // Unassigned. 0x0700-0x08FF
+  {(CHAR16)0x097F,  1},       // Devanagari. 0x0900-0x097F
+  {(CHAR16)0x09FF,  1},       // Bengali. 0x0980-0x09FF
+  {(CHAR16)0x0A7F,  1},       // Gurmukhi. 0x0A00-0x0A7F
+  {(CHAR16)0x0AFF,  1},       // Gujarati. 0x0A80-0x0AFF
+  {(CHAR16)0x0B7F,  1},       // Oriya. 0x0B00-0x0B7F
+  {(CHAR16)0x0BFF,  1},       // Tamil. (See page 7-92). 0x0B80-0x0BFF
+  {(CHAR16)0x0C7F,  1},       // Telugu. 0x0C00-0x0C7F
+  {(CHAR16)0x0CFF,  1},       // Kannada. (See page 7-100). 0x0C80-0x0CFF
+  {(CHAR16)0x0D7F,  1},       // Malayalam (See page 7-104). 0x0D00-0x0D7F
+  {(CHAR16)0x0DFF,  0},       // Unassigned. 0x0D80-0x0DFF
+  {(CHAR16)0x0E7F,  1},       // Thai. 0x0E00-0x0E7F
+  {(CHAR16)0x0EFF,  1},       // Lao. 0x0E80-0x0EFF
+  {(CHAR16)0x0FBF,  1},       // Tibetan. 0x0F00-0x0FBF
+  {(CHAR16)0x109F,  0},       // Unassigned. 0x0FC0-0x109F
+  {(CHAR16)0x10FF,  1},       // Georgian. 0x10A0-0x10FF
+  {(CHAR16)0x11FF,  1},       // Hangul Jamo. 0x1100-0x11FF
+  {(CHAR16)0x1DFF,  0},       // Unassigned. 0x1200-0x1DFF
+  {(CHAR16)0x1EFF,  1},       // Latin extended additional. 0x1E00-0x1EFF
+  {(CHAR16)0x1FFF,  1},       // Greek extended. 0x1F00-0x1FFF
+  *
+  */
+
+  //
+  // Symbol area
+  //
+  {(CHAR16)0x2FFF,  1},
+  /*
+   * Merge the blocks and replace them with the above entry as they fall to 
+   * the same category and they are all narrow glyph. This will reduce search
+   * time and table size. The merge will omit the reserved code.
+   *
+   * Remove the above item if below is un-commented.
+   *
+  {(CHAR16)0x206F,  1},       // General punctuation. (See page7-154). 0x200-0x206F
+  {(CHAR16)0x209F,  1},       // Superscripts and subscripts. 0x2070-0x209F
+  {(CHAR16)0x20CF,  1},       // Currency symbols. 0x20A0-0x20CF
+  {(CHAR16)0x20FF,  1},       // Combining diacritical marks for symbols. 0x20D0-0x20FF
+  {(CHAR16)0x214F,  1},       // Letterlike sympbols. 0x2100-0x214F
+  {(CHAR16)0x218F,  1},       // Number forms. 0x2150-0x218F
+  {(CHAR16)0x21FF,  1},       // Arrows. 0x2190-0x21FF
+  {(CHAR16)0x22FF,  1},       // Mathematical operators. 0x2200-0x22FF
+  {(CHAR16)0x23FF,  1},       // Miscellaneous technical. 0x2300-0x23FF
+  {(CHAR16)0x243F,  1},       // Control pictures. 0x2400-0x243F
+  {(CHAR16)0x245F,  1},       // Optical character recognition. 0x2440-0x245F
+  {(CHAR16)0x24FF,  1},       // Enclosed alphanumerics. 0x2460-0x24FF
+  {(CHAR16)0x257F,  1},       // Box drawing. 0x2500-0x257F
+  {(CHAR16)0x259F,  1},       // Block elements. 0x2580-0x259F
+  {(CHAR16)0x25FF,  1},       // Geometric shapes. 0x25A0-0x25FF
+  {(CHAR16)0x26FF,  1},       // Miscellaneous symbols. 0x2600-0x26FF
+  {(CHAR16)0x27BF,  1},       // Dingbats. 0x2700-0x27BF
+  {(CHAR16)0x2FFF,  0},       // Reserved. 0x27C0-0x2FFF
+  *
+  */
+
+  //
+  // CJK phonetics and symbol area
+  //
+  {(CHAR16)0x33FF,  2},
+  /*
+   * Merge the blocks and replace them with the above entry as they fall to 
+   * the same category and they are all wide glyph. This will reduce search
+   * time and table size. The merge will omit the reserved code.
+   *
+   * Remove the above item if below is un-commented.
+   *
+  {(CHAR16)0x303F,  2},       // CJK symbols and punctuation. 0x3000-0x303F
+  {(CHAR16)0x309F,  2},       // Hiragana. 0x3040-0x309F
+  {(CHAR16)0x30FF,  2},       // Katakana. 0x30A0-0x30FF
+  {(CHAR16)0x312F,  2},       // Bopomofo. 0x3100-0x312F
+  {(CHAR16)0x318F,  2},       // Hangul compatibility jamo. 0x3130-0x318F
+  {(CHAR16)0x319F,  2},       // Kanbun. 0x3190-0x319F
+  {(CHAR16)0x31FF,  0},       // Reserved. As Bopomofo extended in ver3.0. 0x31A0-0x31FF
+  {(CHAR16)0x32FF,  2},       // Enclosed CJK letters and months. 0x3200-0x32FF
+  {(CHAR16)0x33FF,  2},       // CJK compatibility. 0x3300-0x33FF
+  *
+  */
+
+  //
+  // CJK ideograph area
+  //
+  {(CHAR16)0x9FFF,  2},
+  /*
+   * Merge the blocks and replace them with the above entry as they fall to 
+   * the same category and they are all wide glyph. This will reduce search
+   * time and table size. The merge will omit the reserved code.
+   *
+   * Remove the above item if below is un-commented.
+   *
+  {(CHAR16)0x4DFF,  0},       // Reserved. 0x3400-0x4DBF as CJK unified ideographs 
+                      // extension A in ver3.0. 0x3400-0x4DFF
+  {(CHAR16)0x9FFF,  2},       // CJK unified ideographs. 0x4E00-0x9FFF
+  *
+  */
+
+  //
+  // Reserved
+  //
+  {(CHAR16)0xABFF,  0},       // Reserved. 0xA000-0xA490 as Yi syllables. 0xA490-0xA4D0
+  // as Yi radicals in ver3.0. 0xA000-0xABFF
+  //
+  // Hangul syllables
+  //
+  {(CHAR16)0xD7FF,  2},
+  /*
+   * Merge the blocks and replace them with the above entry as they fall to 
+   * the same category and they are all wide glyph. This will reduce search
+   * time and table size. The merge will omit the reserved code.
+   *
+   * Remove the above item if below is un-commented.
+   *
+  {(CHAR16)0xD7A3,  2},       // Hangul syllables. 0xAC00-0xD7A3
+  {(CHAR16)0xD7FF,  0},       // Reserved. 0xD7A3-0xD7FF
+  *
+  */
+
+  //
+  // Surrogates area
+  //
+  {(CHAR16)0xDFFF,  0},       // Surrogates, not used now. 0xD800-0xDFFF
+
+  //
+  // Private use area
+  //
+  {(CHAR16)0xF8FF,  0},       // Private use area. 0xE000-0xF8FF
+
+  //
+  // Compatibility area and specials
+  //
+  {(CHAR16)0xFAFF,  2},       // CJK compatibility ideographs. 0xF900-0xFAFF
+  {(CHAR16)0xFB4F,  1},       // Alphabetic presentation forms. 0xFB00-0xFB4F
+  {(CHAR16)0xFDFF,  1},       // Arabic presentation forms-A. 0xFB50-0xFDFF
+  {(CHAR16)0xFE1F,  0},       // Reserved. As variation selectors in ver3.0. 0xFE00-0xFE1F
+  {(CHAR16)0xFE2F,  1},       // Combining half marks. 0xFE20-0xFE2F
+  {(CHAR16)0xFE4F,  2},       // CJK compatibility forms. 0xFE30-0xFE4F
+  {(CHAR16)0xFE6F,  1},       // Small Form Variants. 0xFE50-0xFE6F
+  {(CHAR16)0xFEFF,  1},       // Arabic presentation forms-B. 0xFE70-0xFEFF
+  {(CHAR16)0xFFEF,  1},       // Half width and full width forms. 0xFF00-0xFFEF
+  {(CHAR16)0xFFFF,  0},       // Speicials. 0xFFF0-0xFFFF
+};
+
+/**
+  Retrieves the width of a Unicode character.
+
+  This function computes and returns the width of the Unicode character specified
+  by UnicodeChar.
+
+  @param  UnicodeChar   A Unicode character.
+
+  @retval 0             The width if UnicodeChar could not be determined.
+  @retval 1             UnicodeChar is a narrow glyph.
+  @retval 2             UnicodeChar is a wide glyph.
+
+**/
+UINTN
+EFIAPI
+GetGlyphWidth (
+  IN CHAR16  UnicodeChar
+  )
+{
+  UINTN                     Index;
+  UINTN                     Low;
+  UINTN                     High;
+  CONST UNICODE_WIDTH_ENTRY *Item;
+
+  Item  = NULL;
+  Low   = 0;
+  High  = (sizeof (mUnicodeWidthTable)) / (sizeof (UNICODE_WIDTH_ENTRY)) - 1;
+  while (Low <= High) {
+    Index = (Low + High) >> 1;
+    Item  = &(mUnicodeWidthTable[Index]);
+    if (Index == 0) {
+      if (UnicodeChar <= Item->WChar) {
+        break;
+      }
+
+      return 0;
+    }
+
+    if (UnicodeChar > Item->WChar) {
+      Low = Index + 1;
+    } else if (UnicodeChar <= mUnicodeWidthTable[Index - 1].WChar) {
+      High = Index - 1;
+    } else {
+      //
+      // Index - 1 < UnicodeChar <= Index. Found
+      //
+      break;
+    }
+  }
+
+  if (Low <= High) {
+    return Item->Width;
+  }
+
+  return 0;
+}
+
+/**
+  Computes the display length of a Null-terminated Unicode String.
+
+  This function computes and returns the display length of the Null-terminated 
+  Unicode string specified by String.  If String is NULL then 0 is returned. If 
+  any of the widths of the Unicode characters in String can not be determined, 
+  then 0 is returned. The display width of String can be computed by summing the 
+  display widths of each Unicode character in String.  Unicode characters that 
+  are narrow glyphs have a width of 1, and Unicode characters that are width glyphs 
+  have a width of 2.  If String is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  String      A pointer to a Null-terminated Unicode string.
+
+  @return The display length of the Null-terminated Unicode string specified by String.
+  
+**/
+UINTN
+EFIAPI
+UnicodeStringDisplayLength (
+  IN CONST CHAR16  *String
+  )
+{
+  UINTN      Length;
+  UINTN      Width;
+
+  if (String == NULL) {
+    return 0;
+  }
+
+  Length = 0;
+  while (*String != 0) {
+    Width = GetGlyphWidth (*String);
+    if (Width == 0) {
+      return 0;
+    }
+
+    Length += Width;
+    String++;
+  }
+
+  return Length;
+}
+
+/**
+  Count the storage space of a Unicode string. 
+
+  This function handles the Unicode string with NARROW_CHAR
+  and WIDE_CHAR control characters. NARROW_HCAR and WIDE_CHAR
+  does not count in the resultant output. If a WIDE_CHAR is
+  hit, then 2 Unicode character will consume an output storage
+  space with size of CHAR16 till a NARROW_CHAR is hit.
+
+  @param String          The input string to be counted.
+  @param LimitLen        Whether need to limit the string length.
+  @param MaxWidth        The max length this function supported.
+  @param Offset          The max index of the string can be show out. 
+
+  @return Storage space for the input string.
+
+**/
+UINTN
+UefiLibGetStringWidth (
+  IN  CHAR16               *String,
+  IN  BOOLEAN              LimitLen,
+  IN  UINTN                MaxWidth,
+  OUT UINTN                *Offset
+  )
+{
+  UINTN Index;
+  UINTN Count;
+  UINTN IncrementValue;
+
+  if (String == NULL) {
+    return 0;
+  }
+
+  Index           = 0;
+  Count           = 0;
+  IncrementValue  = 1;
+
+  do {
+    //
+    // Advance to the null-terminator or to the first width directive
+    //
+    for (;(String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0); Index++) {
+      Count = Count + IncrementValue;
+
+      if (LimitLen && Count > MaxWidth) {
+        break;
+      }
+    }
+
+    //
+    // We hit the null-terminator, we now have a count
+    //
+    if (String[Index] == 0) {
+      break;
+    }
+
+    if (LimitLen && Count > MaxWidth) {
+      *Offset = Index;
+      break;
+    }
+
+    //
+    // We encountered a narrow directive - strip it from the size calculation since it doesn't get printed
+    // and also set the flag that determines what we increment by.(if narrow, increment by 1, if wide increment by 2)
+    //
+    if (String[Index] == NARROW_CHAR) {
+      //
+      // Skip to the next character
+      //
+      Index++;
+      IncrementValue = 1;
+    } else {
+      //
+      // Skip to the next character
+      //
+      Index++;
+      IncrementValue = 2;
+    }
+  } while (String[Index] != 0);
+
+  return Count * sizeof (CHAR16);
+}
+
+/**
+  Draws a dialog box to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE and waits for a keystroke
+  from the console input device specified by ConIn defined in the 
+  EFI_SYSTEM_TABLE.
+
+  If there are no strings in the variable argument list, then ASSERT().
+  If all the strings in the variable argument list are empty, then ASSERT().
+
+  @param[in]   Attribute  Specifies the foreground and background color of the popup.
+  @param[out]  Key        A pointer to the EFI_KEY value of the key that was 
+                          pressed.  This is an optional parameter that may be NULL.
+                          If it is NULL then no wait for a keypress will be performed.
+  @param[in]  ...         The variable argument list that contains pointers to Null-
+                          terminated Unicode strings to display in the dialog box.  
+                          The variable argument list is terminated by a NULL.
+
+**/
+VOID
+EFIAPI
+CreatePopUp (
+  IN  UINTN          Attribute,                
+  OUT EFI_INPUT_KEY  *Key,      OPTIONAL
+  ...
+  )
+{
+  EFI_STATUS                       Status;
+  VA_LIST                          Args;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
+  EFI_SIMPLE_TEXT_OUTPUT_MODE      SavedConsoleMode;
+  UINTN                            Columns;
+  UINTN                            Rows;
+  UINTN                            Column;
+  UINTN                            Row;
+  UINTN                            NumberOfLines;
+  UINTN                            MaxLength;
+  CHAR16                           *String;
+  UINTN                            Length;
+  CHAR16                           *Line;
+  UINTN                            EventIndex;
+  CHAR16                           *TmpString;
+
+  //
+  // Determine the length of the longest line in the popup and the the total 
+  // number of lines in the popup
+  //
+  VA_START (Args, Key);
+  MaxLength = 0;
+  NumberOfLines = 0;
+  while ((String = VA_ARG (Args, CHAR16 *)) != NULL) {
+    MaxLength = MAX (MaxLength, UefiLibGetStringWidth (String, FALSE, 0, NULL) / 2);
+    NumberOfLines++;
+  }
+  VA_END (Args);
+
+  //
+  // If the total number of lines in the popup is zero, then ASSERT()
+  //
+  ASSERT (NumberOfLines != 0);
+
+  //
+  // If the maximum length of all the strings is zero, then ASSERT()
+  //
+  ASSERT (MaxLength != 0);
+
+  //
+  // Cache a pointer to the Simple Text Output Protocol in the EFI System Table
+  //
+  ConOut = gST->ConOut;
+  
+  //
+  // Save the current console cursor position and attributes
+  //
+  CopyMem (&SavedConsoleMode, ConOut->Mode, sizeof (SavedConsoleMode));
+
+  //
+  // Retrieve the number of columns and rows in the current console mode
+  //
+  ConOut->QueryMode (ConOut, SavedConsoleMode.Mode, &Columns, &Rows);
+
+  //
+  // Disable cursor and set the foreground and background colors specified by Attribute
+  //
+  ConOut->EnableCursor (ConOut, FALSE);
+  ConOut->SetAttribute (ConOut, Attribute);
+
+  //
+  // Limit NumberOfLines to height of the screen minus 3 rows for the box itself
+  //
+  NumberOfLines = MIN (NumberOfLines, Rows - 3);
+
+  //
+  // Limit MaxLength to width of the screen minus 2 columns for the box itself
+  //
+  MaxLength = MIN (MaxLength, Columns - 2);
+
+  //
+  // Compute the starting row and starting column for the popup
+  //
+  Row    = (Rows - (NumberOfLines + 3)) / 2;
+  Column = (Columns - (MaxLength + 2)) / 2;
+
+  //
+  // Allocate a buffer for a single line of the popup with borders and a Null-terminator
+  //
+  Line = AllocateZeroPool ((MaxLength + 3) * sizeof (CHAR16));
+  ASSERT (Line != NULL);
+
+  //
+  // Draw top of popup box   
+  //
+  SetMem16 (Line, (MaxLength + 2) * 2, BOXDRAW_HORIZONTAL);
+  Line[0]             = BOXDRAW_DOWN_RIGHT;
+  Line[MaxLength + 1] = BOXDRAW_DOWN_LEFT;
+  Line[MaxLength + 2] = L'\0';
+  ConOut->SetCursorPosition (ConOut, Column, Row++);
+  ConOut->OutputString (ConOut, Line);
+
+  //
+  // Draw middle of the popup with strings
+  //
+  VA_START (Args, Key);
+  while ((String = VA_ARG (Args, CHAR16 *)) != NULL && NumberOfLines > 0) {
+    SetMem16 (Line, (MaxLength + 2) * 2, L' ');
+    Line[0]             = BOXDRAW_VERTICAL;
+    Line[MaxLength + 1] = BOXDRAW_VERTICAL;
+    Line[MaxLength + 2] = L'\0';
+    ConOut->SetCursorPosition (ConOut, Column, Row);
+    ConOut->OutputString (ConOut, Line);
+    Length = UefiLibGetStringWidth (String, FALSE, 0, NULL) / 2;
+    if (Length <= MaxLength) {
+      //
+      // Length <= MaxLength
+      //
+      ConOut->SetCursorPosition (ConOut, Column + 1 + (MaxLength - Length) / 2, Row++);
+      ConOut->OutputString (ConOut, String);
+    } else {
+      //
+      // Length > MaxLength
+      //
+      UefiLibGetStringWidth (String, TRUE, MaxLength, &Length);
+      TmpString = AllocateZeroPool ((Length + 1) * sizeof (CHAR16));
+      ASSERT (TmpString != NULL);
+      StrnCpyS (TmpString, Length + 1, String, Length - 3);
+      StrCatS (TmpString, Length + 1, L"...");
+
+      ConOut->SetCursorPosition (ConOut, Column + 1, Row++);
+      ConOut->OutputString (ConOut, TmpString);
+      FreePool (TmpString);
+    }
+    NumberOfLines--;
+  }
+  VA_END (Args);
+
+  //
+  // Draw bottom of popup box
+  //
+  SetMem16 (Line, (MaxLength + 2) * 2, BOXDRAW_HORIZONTAL);
+  Line[0]             = BOXDRAW_UP_RIGHT;
+  Line[MaxLength + 1] = BOXDRAW_UP_LEFT;
+  Line[MaxLength + 2] = L'\0';
+  ConOut->SetCursorPosition (ConOut, Column, Row++);
+  ConOut->OutputString (ConOut, Line);
+
+  //
+  // Free the allocated line buffer
+  //
+  FreePool (Line);
+
+  //
+  // Restore the cursor visibility, position, and attributes
+  //
+  ConOut->EnableCursor      (ConOut, SavedConsoleMode.CursorVisible);
+  ConOut->SetCursorPosition (ConOut, SavedConsoleMode.CursorColumn, SavedConsoleMode.CursorRow);
+  ConOut->SetAttribute      (ConOut, SavedConsoleMode.Attribute);
+
+  //
+  // Wait for a keystroke
+  //
+  if (Key != NULL) {
+    while (TRUE) {
+      Status = gST->ConIn->ReadKeyStroke (gST->ConIn, Key);
+      if (!EFI_ERROR (Status)) {
+        break;
+      }
+
+      //
+      // If we encounter error, continue to read another key in.
+      //
+      if (Status != EFI_NOT_READY) {
+        continue;
+      }
+      gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
+    }
+  }
+}
diff --git a/MdePkg/Library/UefiLib/UefiDriverModel.c b/MdePkg/Library/UefiLib/UefiDriverModel.c
new file mode 100644
index 000000000000..c1254ece40dc
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiDriverModel.c
@@ -0,0 +1,1056 @@
+/** @file
+  Library functions that abstract driver model protocols
+  installation.
+
+  Copyright (c) 2006 - 2013, 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 "UefiLibInternal.h"
+
+/**
+  Installs and completes the initialization of a Driver Binding Protocol instance.
+  
+  Installs the Driver Binding Protocol specified by DriverBinding onto the handle
+  specified by DriverBindingHandle. If DriverBindingHandle is NULL, then DriverBinding
+  is installed onto a newly created handle. DriverBindingHandle is typically the same
+  as the driver's ImageHandle, but it can be different if the driver produces multiple
+  Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If DriverBinding can not be installed onto a handle, then ASSERT().
+
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+
+  @retval EFI_SUCCESS           The protocol installation successfully completed.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough system resources to install the protocol.
+  @retval Others                Status from gBS->InstallMultipleProtocolInterfaces().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallDriverBinding (
+  IN CONST EFI_HANDLE             ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE       *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding,
+  IN EFI_HANDLE                   DriverBindingHandle
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (DriverBinding != NULL);
+
+  //
+  // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
+  //
+  DriverBinding->ImageHandle         = ImageHandle;
+  DriverBinding->DriverBindingHandle = DriverBindingHandle;
+
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                  &DriverBinding->DriverBindingHandle,
+                  &gEfiDriverBindingProtocolGuid, DriverBinding,
+                  NULL
+                  );
+  //
+  // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+
+/**
+  Installs and completes the initialization of a Driver Binding Protocol instance and
+  optionally installs the Component Name, Driver Configuration and Driver Diagnostics Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the
+  optional Component Name, optional Driver Configure and optional Driver Diagnostic
+  Protocols onto the driver's DriverBindingHandle. If DriverBindingHandle is NULL,
+  then the protocols are  installed onto a newly created handle. DriverBindingHandle
+  is typically the same as the driver's ImageHandle, but it can be different if the
+  driver produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+  
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+  @param  ComponentName        A Component Name Protocol instance that this driver is producing.
+  @param  DriverConfiguration  A Driver Configuration Protocol instance that this driver is producing.
+  @param  DriverDiagnostics    A Driver Diagnostics Protocol instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation successfully completed.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallAllDriverProtocols (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics    OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (DriverBinding != NULL);
+
+  //
+  // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
+  //
+  DriverBinding->ImageHandle         = ImageHandle;
+  DriverBinding->DriverBindingHandle = DriverBindingHandle;
+  
+  if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
+    if (DriverConfiguration == NULL) {
+      if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid, DriverBinding,
+                        NULL
+                        );
+      } else {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid, DriverBinding,
+                        &gEfiComponentNameProtocolGuid, ComponentName,
+                        NULL
+                        );
+      }
+    } else {
+      if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,       DriverBinding,
+                        &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                        NULL
+                        );
+      } else {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,       DriverBinding,
+                        &gEfiComponentNameProtocolGuid,       ComponentName,
+                        &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                        NULL
+                        );
+      }
+    }
+  } else {
+    if (DriverConfiguration == NULL) {
+      if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,     DriverBinding,
+                        &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                        NULL
+                        );
+      } else {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,     DriverBinding,
+                        &gEfiComponentNameProtocolGuid,     ComponentName,
+                        &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                        NULL
+                        );
+      }
+    } else {
+      if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+       Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,       DriverBinding,
+                        &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                        &gEfiDriverDiagnosticsProtocolGuid,   DriverDiagnostics,
+                        NULL
+                        );
+      } else {
+        Status = gBS->InstallMultipleProtocolInterfaces (
+                        &DriverBinding->DriverBindingHandle,
+                        &gEfiDriverBindingProtocolGuid,       DriverBinding,
+                        &gEfiComponentNameProtocolGuid,       ComponentName,
+                        &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                        &gEfiDriverDiagnosticsProtocolGuid,   DriverDiagnostics,
+                        NULL
+                        );
+      }
+    }
+  }
+
+  //
+  // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+
+
+/**
+  Installs Driver Binding Protocol with optional Component Name and Component Name 2 Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the
+  optional Component Name and optional Component Name 2 protocols onto the driver's
+  DriverBindingHandle.  If DriverBindingHandle is NULL, then the protocols are installed
+  onto a newly created handle.  DriverBindingHandle is typically the same as the driver's
+  ImageHandle, but it can be different if the driver produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+
+  @param  ImageHandle          The image handle of the driver.
+  @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
+                               parameter is NULL, then a new handle is created.
+  @param  ComponentName        A Component Name Protocol instance that this driver is producing.
+  @param  ComponentName2       A Component Name 2 Protocol instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation successfully completed.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallDriverBindingComponentName2 (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN CONST EFI_COMPONENT_NAME2_PROTOCOL       *ComponentName2       OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (DriverBinding != NULL);
+
+  //
+  // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
+  //
+  DriverBinding->ImageHandle         = ImageHandle;
+  DriverBinding->DriverBindingHandle = DriverBindingHandle;
+
+  if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+    if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+      Status = gBS->InstallMultipleProtocolInterfaces (
+                      &DriverBinding->DriverBindingHandle,
+                      &gEfiDriverBindingProtocolGuid, DriverBinding,
+                      NULL
+                      );
+      } else {
+      Status = gBS->InstallMultipleProtocolInterfaces (
+                      &DriverBinding->DriverBindingHandle,
+                      &gEfiDriverBindingProtocolGuid, DriverBinding,
+                      &gEfiComponentName2ProtocolGuid, ComponentName2,
+                      NULL
+                      );
+     }
+  } else {
+     if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+       Status = gBS->InstallMultipleProtocolInterfaces (
+                       &DriverBinding->DriverBindingHandle,
+                       &gEfiDriverBindingProtocolGuid, DriverBinding,
+                       &gEfiComponentNameProtocolGuid, ComponentName,
+                       NULL
+                       );
+     } else {
+       Status = gBS->InstallMultipleProtocolInterfaces (
+                       &DriverBinding->DriverBindingHandle,
+                       &gEfiDriverBindingProtocolGuid, DriverBinding,
+                       &gEfiComponentNameProtocolGuid, ComponentName,
+                       &gEfiComponentName2ProtocolGuid, ComponentName2,
+                       NULL
+                       );
+    }
+  }
+
+  //
+  // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+
+
+/**
+  Installs Driver Binding Protocol with optional Component Name, Component Name 2, Driver
+  Configuration, Driver Configuration 2, Driver Diagnostics, and Driver Diagnostics 2 Protocols.
+
+  Initializes a driver by installing the Driver Binding Protocol together with the optional
+  Component Name, optional Component Name 2, optional Driver Configuration, optional Driver Configuration 2,
+  optional Driver Diagnostic, and optional Driver Diagnostic 2 Protocols onto the driver's DriverBindingHandle.
+  DriverBindingHandle is typically the same as the driver's ImageHandle, but it can be different if the driver
+  produces multiple Driver Binding Protocols. 
+  If DriverBinding is NULL, then ASSERT(). 
+  If the installation fails, then ASSERT().
+
+
+  @param  ImageHandle           The image handle of the driver.
+  @param  SystemTable           The EFI System Table that was passed to the driver's entry point.
+  @param  DriverBinding         A Driver Binding Protocol instance that this driver is producing.
+  @param  DriverBindingHandle   The handle that DriverBinding is to be installed onto.  If this
+                                parameter is NULL, then a new handle is created.
+  @param  ComponentName         A Component Name Protocol instance that this driver is producing.
+  @param  ComponentName2        A Component Name 2 Protocol instance that this driver is producing.
+  @param  DriverConfiguration   A Driver Configuration Protocol instance that this driver is producing.
+  @param  DriverConfiguration2  A Driver Configuration Protocol 2 instance that this driver is producing.
+  @param  DriverDiagnostics     A Driver Diagnostics Protocol instance that this driver is producing.
+  @param  DriverDiagnostics2    A Driver Diagnostics Protocol 2 instance that this driver is producing.
+
+  @retval EFI_SUCCESS           The protocol installation successfully completed.
+  @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiLibInstallAllDriverProtocols2 (
+  IN CONST EFI_HANDLE                         ImageHandle,
+  IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
+  IN EFI_HANDLE                               DriverBindingHandle,
+  IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,        OPTIONAL
+  IN CONST EFI_COMPONENT_NAME2_PROTOCOL       *ComponentName2,       OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration,  OPTIONAL
+  IN CONST EFI_DRIVER_CONFIGURATION2_PROTOCOL *DriverConfiguration2, OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics,    OPTIONAL
+  IN CONST EFI_DRIVER_DIAGNOSTICS2_PROTOCOL   *DriverDiagnostics2    OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (DriverBinding != NULL); 
+
+  //
+  // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
+  //
+  DriverBinding->ImageHandle         = ImageHandle;
+  DriverBinding->DriverBindingHandle = DriverBindingHandle;
+  
+  if (DriverConfiguration2 == NULL) {
+    if (DriverConfiguration == NULL) {
+      if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      } else {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      }
+    } else {
+      if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      } else {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      }
+    }
+  } else {
+    if (DriverConfiguration == NULL) {
+      if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      } else {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      }
+    } else {
+      if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      } else {
+        if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              NULL
+                              );
+            }
+          }
+        } else {
+          if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          } else {
+            if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            } else {
+              Status = gBS->InstallMultipleProtocolInterfaces (
+                              &DriverBinding->DriverBindingHandle,
+                              &gEfiDriverBindingProtocolGuid, DriverBinding,
+                              &gEfiComponentNameProtocolGuid, ComponentName,
+                              &gEfiComponentName2ProtocolGuid, ComponentName2,
+                              &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
+                              &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
+                              &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
+                              &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
+                              NULL
+                              );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  //
+  // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
diff --git a/MdePkg/Library/UefiLib/UefiLib.c b/MdePkg/Library/UefiLib/UefiLib.c
new file mode 100644
index 000000000000..c46f4fa896ce
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiLib.c
@@ -0,0 +1,1607 @@
+/** @file
+  The UEFI Library provides functions and macros that simplify the development of 
+  UEFI Drivers and UEFI Applications.  These functions and macros help manage EFI 
+  events, build simple locks utilizing EFI Task Priority Levels (TPLs), install 
+  EFI Driver Model related protocols, manage Unicode string tables for UEFI Drivers, 
+  and print messages on the console output and standard error devices.
+
+  Copyright (c) 2006 - 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 "UefiLibInternal.h"
+
+/**
+  Empty constructor function that is required to resolve dependencies between 
+  libraries.
+  
+    ** DO NOT REMOVE **
+  
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor executed correctly.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  return EFI_SUCCESS;
+}
+
+/**
+  Compare whether two names of languages are identical.
+
+  @param  Language1 Name of language 1.
+  @param  Language2 Name of language 2.
+
+  @retval TRUE      Language 1 and language 2 are the same.
+  @retval FALSE     Language 1 and language 2 are not the same.
+
+**/
+BOOLEAN
+CompareIso639LanguageCode (
+  IN CONST CHAR8  *Language1,
+  IN CONST CHAR8  *Language2
+  )
+{
+  UINT32  Name1;
+  UINT32  Name2;
+
+  Name1 = ReadUnaligned24 ((CONST UINT32 *) Language1);
+  Name2 = ReadUnaligned24 ((CONST UINT32 *) Language2);
+
+  return (BOOLEAN) (Name1 == Name2);
+}
+
+/**
+  Retrieves a pointer to the system configuration table from the EFI System Table
+  based on a specified GUID.
+  
+  This function searches the list of configuration tables stored in the EFI System Table
+  for a table with a GUID that matches TableGuid.  If a match is found, then a pointer to
+  the configuration table is returned in Table., and EFI_SUCCESS is returned. If a matching GUID
+  is not found, then EFI_NOT_FOUND is returned.
+  If TableGuid is NULL, then ASSERT().
+  If Table is NULL, then ASSERT().
+
+  @param  TableGuid       The pointer to table's GUID type.
+  @param  Table           The pointer to the table associated with TableGuid in the EFI System Table.
+
+  @retval EFI_SUCCESS     A configuration table matching TableGuid was found.
+  @retval EFI_NOT_FOUND   A configuration table matching TableGuid could not be found.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetSystemConfigurationTable (
+  IN  EFI_GUID  *TableGuid,
+  OUT VOID      **Table
+  )
+{
+  EFI_SYSTEM_TABLE  *SystemTable;
+  UINTN             Index;
+
+  ASSERT (TableGuid != NULL);
+  ASSERT (Table != NULL);
+
+  SystemTable = gST;
+  *Table = NULL;
+  for (Index = 0; Index < SystemTable->NumberOfTableEntries; Index++) {
+    if (CompareGuid (TableGuid, &(SystemTable->ConfigurationTable[Index].VendorGuid))) {
+      *Table = SystemTable->ConfigurationTable[Index].VendorTable;
+      return EFI_SUCCESS;
+    }
+  }
+
+  return EFI_NOT_FOUND;
+}
+
+/**
+  Creates and returns a notification event and registers that event with all the protocol
+  instances specified by ProtocolGuid.
+
+  This function causes the notification function to be executed for every protocol of type
+  ProtocolGuid instance that exists in the system when this function is invoked. If there are
+  no instances of ProtocolGuid in the handle database at the time this function is invoked,
+  then the notification function is still executed one time. In addition, every time a protocol
+  of type ProtocolGuid instance is installed or reinstalled, the notification function is also
+  executed. This function returns the notification event that was created. 
+  If ProtocolGuid is NULL, then ASSERT().
+  If NotifyTpl is not a legal TPL value, then ASSERT().
+  If NotifyFunction is NULL, then ASSERT().
+  If Registration is NULL, then ASSERT().
+
+
+  @param  ProtocolGuid    Supplies GUID of the protocol upon whose installation the event is fired.
+  @param  NotifyTpl       Supplies the task priority level of the event notifications.
+  @param  NotifyFunction  Supplies the function to notify when the event is signaled.
+  @param  NotifyContext   The context parameter to pass to NotifyFunction.
+  @param  Registration    A pointer to a memory location to receive the registration value.
+                          This value is passed to LocateHandle() to obtain new handles that
+                          have been added that support the ProtocolGuid-specified protocol. 
+
+  @return The notification event that was created.
+
+**/
+EFI_EVENT
+EFIAPI
+EfiCreateProtocolNotifyEvent(
+  IN  EFI_GUID          *ProtocolGuid,
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT VOID              **Registration
+  )
+{
+  EFI_STATUS  Status;
+  EFI_EVENT   Event;
+
+  ASSERT (ProtocolGuid != NULL);
+  ASSERT (NotifyFunction != NULL);
+  ASSERT (Registration != NULL);
+
+  //
+  // Create the event
+  //
+
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  NotifyTpl,
+                  NotifyFunction,
+                  NotifyContext,
+                  &Event
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Register for protocol notifications on this event
+  //
+
+  Status = gBS->RegisterProtocolNotify (
+                  ProtocolGuid,
+                  Event,
+                  Registration
+                  );
+
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Kick the event so we will perform an initial pass of
+  // current installed drivers
+  //
+
+  gBS->SignalEvent (Event);
+  return Event;
+}
+
+/**
+  Creates a named event that can be signaled with EfiNamedEventSignal().
+
+  This function creates an event using NotifyTpl, NoifyFunction, and NotifyContext.
+  This event is signaled with EfiNamedEventSignal(). This provides the ability for one or more
+  listeners on the same event named by the GUID specified by Name. 
+  If Name is NULL, then ASSERT().
+  If NotifyTpl is not a legal TPL value, then ASSERT().
+  If NotifyFunction is NULL, then ASSERT().
+
+  @param  Name                  Supplies the GUID name of the event.
+  @param  NotifyTpl             Supplies the task priority level of the event notifications.
+  @param  NotifyFunction        Supplies the function to notify when the event is signaled.
+  @param  NotifyContext         The context parameter to pass to NotifyFunction. 
+  @param  Registration          A pointer to a memory location to receive the registration value.
+
+  @retval EFI_SUCCESS           A named event was created.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resource to create the named event.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiNamedEventListen (
+  IN CONST EFI_GUID    *Name,
+  IN EFI_TPL           NotifyTpl,
+  IN EFI_EVENT_NOTIFY  NotifyFunction,
+  IN CONST VOID        *NotifyContext,  OPTIONAL
+  OUT VOID             *Registration OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+  EFI_EVENT   Event;
+  VOID        *RegistrationLocal;
+
+  ASSERT (Name != NULL);
+  ASSERT (NotifyFunction != NULL);
+  ASSERT (NotifyTpl <= TPL_HIGH_LEVEL);
+  
+  //
+  // Create event
+  //
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  NotifyTpl,
+                  NotifyFunction,
+                  (VOID *) NotifyContext,
+                  &Event
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // The Registration is not optional to RegisterProtocolNotify().
+  // To make it optional to EfiNamedEventListen(), may need to substitute with a local.
+  //
+  if (Registration != NULL) {
+    RegistrationLocal = Registration;
+  } else {
+    RegistrationLocal = &RegistrationLocal;
+  }
+
+  //
+  // Register for an installation of protocol interface
+  //
+
+  Status = gBS->RegisterProtocolNotify (
+                  (EFI_GUID *) Name,
+                  Event,
+                  RegistrationLocal
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  Signals a named event created with EfiNamedEventListen().
+
+  This function signals the named event specified by Name. The named event must have been
+  created with EfiNamedEventListen().
+  If Name is NULL, then ASSERT().
+
+  @param  Name                  Supplies the GUID name of the event.
+
+  @retval EFI_SUCCESS           A named event was signaled.
+  @retval EFI_OUT_OF_RESOURCES  There are not enough resource to signal the named event.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiNamedEventSignal (
+  IN CONST EFI_GUID  *Name
+  )
+{
+  EFI_STATUS  Status;
+  EFI_HANDLE  Handle;
+
+  ASSERT(Name != NULL);
+
+  Handle = NULL;
+  Status = gBS->InstallProtocolInterface (
+                  &Handle,
+                  (EFI_GUID *) Name,
+                  EFI_NATIVE_INTERFACE,
+                  NULL
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  Status = gBS->UninstallProtocolInterface (
+                  Handle,
+                  (EFI_GUID *) Name,
+                  NULL
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  Signals an event group by placing a new event in the group temporarily and
+  signaling it.
+
+  @param[in] EventGroup          Supplies the unique identifier of the event
+                                 group to signal.
+
+  @retval EFI_SUCCESS            The event group was signaled successfully.
+  @retval EFI_INVALID_PARAMETER  EventGroup is NULL.
+  @return                        Error codes that report problems about event
+                                 creation or signaling.
+**/
+EFI_STATUS
+EFIAPI
+EfiEventGroupSignal (
+  IN CONST EFI_GUID *EventGroup
+  )
+{
+  EFI_STATUS Status;
+  EFI_EVENT  Event;
+
+  if (EventGroup == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_CALLBACK,
+                  EfiEventEmptyFunction,
+                  NULL,
+                  EventGroup,
+                  &Event
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = gBS->SignalEvent (Event);
+  gBS->CloseEvent (Event);
+
+  return Status;
+}
+
+/**
+  An empty function that can be used as NotifyFunction parameter of
+  CreateEvent() or CreateEventEx().
+
+  @param Event              Event whose notification function is being invoked.
+  @param Context            The pointer to the notification function's context,
+                            which is implementation-dependent.
+
+**/
+VOID
+EFIAPI
+EfiEventEmptyFunction (
+  IN EFI_EVENT              Event,
+  IN VOID                   *Context
+  )
+{
+}
+
+/** 
+  Returns the current TPL.
+
+  This function returns the current TPL.  There is no EFI service to directly 
+  retrieve the current TPL. Instead, the RaiseTPL() function is used to raise 
+  the TPL to TPL_HIGH_LEVEL.  This will return the current TPL.  The TPL level 
+  can then immediately be restored back to the current TPL level with a call 
+  to RestoreTPL().
+
+  @return The current TPL.
+
+**/
+EFI_TPL
+EFIAPI
+EfiGetCurrentTpl (
+  VOID
+  )
+{
+  EFI_TPL Tpl;
+
+  Tpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
+  gBS->RestoreTPL (Tpl);
+
+  return Tpl;
+}
+
+
+/**
+  Initializes a basic mutual exclusion lock.
+
+  This function initializes a basic mutual exclusion lock to the released state 
+  and returns the lock.  Each lock provides mutual exclusion access at its task 
+  priority level.  Since there is no preemption or multiprocessor support in EFI,
+  acquiring the lock only consists of raising to the locks TPL.
+  If Lock is NULL, then ASSERT().
+  If Priority is not a valid TPL value, then ASSERT().
+
+  @param  Lock       A pointer to the lock data structure to initialize.
+  @param  Priority   EFI TPL is associated with the lock.
+
+  @return The lock.
+
+**/
+EFI_LOCK *
+EFIAPI
+EfiInitializeLock (
+  IN OUT EFI_LOCK  *Lock,
+  IN EFI_TPL        Priority
+  )
+{
+  ASSERT (Lock != NULL);
+  ASSERT (Priority <= TPL_HIGH_LEVEL);
+
+  Lock->Tpl       = Priority;
+  Lock->OwnerTpl  = TPL_APPLICATION;
+  Lock->Lock      = EfiLockReleased ;
+  return Lock;
+}
+
+/**
+  Acquires ownership of a lock.
+
+  This function raises the system's current task priority level to the task 
+  priority level of the mutual exclusion lock.  Then, it places the lock in the 
+  acquired state.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+  If Lock is already in the acquired state, then ASSERT().
+
+  @param  Lock              A pointer to the lock to acquire.
+
+**/
+VOID
+EFIAPI
+EfiAcquireLock (
+  IN EFI_LOCK  *Lock
+  )
+{
+  ASSERT (Lock != NULL);
+  ASSERT (Lock->Lock == EfiLockReleased);
+
+  Lock->OwnerTpl = gBS->RaiseTPL (Lock->Tpl);
+  Lock->Lock     = EfiLockAcquired;
+}
+
+/**
+  Acquires ownership of a lock.
+
+  This function raises the system's current task priority level to the task priority
+  level of the mutual exclusion lock.  Then, it attempts to place the lock in the acquired state.
+  If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned.
+  Otherwise, EFI_SUCCESS is returned.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+
+  @param  Lock              A pointer to the lock to acquire.
+
+  @retval EFI_SUCCESS       The lock was acquired.
+  @retval EFI_ACCESS_DENIED The lock could not be acquired because it is already owned.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiAcquireLockOrFail (
+  IN EFI_LOCK  *Lock
+  )
+{
+
+  ASSERT (Lock != NULL);
+  ASSERT (Lock->Lock != EfiLockUninitialized);
+
+  if (Lock->Lock == EfiLockAcquired) {
+    //
+    // Lock is already owned, so bail out
+    //
+    return EFI_ACCESS_DENIED;
+  }
+
+  Lock->OwnerTpl = gBS->RaiseTPL (Lock->Tpl);
+
+  Lock->Lock = EfiLockAcquired;
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Releases ownership of a lock.
+
+  This function transitions a mutual exclusion lock from the acquired state to 
+  the released state, and restores the system's task priority level to its 
+  previous level.
+  If Lock is NULL, then ASSERT().
+  If Lock is not initialized, then ASSERT().
+  If Lock is already in the released state, then ASSERT().
+
+  @param  Lock  A pointer to the lock to release.
+
+**/
+VOID
+EFIAPI
+EfiReleaseLock (
+  IN EFI_LOCK  *Lock
+  )
+{
+  EFI_TPL Tpl;
+
+  ASSERT (Lock != NULL);
+  ASSERT (Lock->Lock == EfiLockAcquired);
+
+  Tpl = Lock->OwnerTpl;
+
+  Lock->Lock = EfiLockReleased;
+
+  gBS->RestoreTPL (Tpl);
+}
+
+/**
+  Tests whether a controller handle is being managed by a specific driver.
+
+  This function tests whether the driver specified by DriverBindingHandle is
+  currently managing the controller specified by ControllerHandle.  This test
+  is performed by evaluating if the the protocol specified by ProtocolGuid is
+  present on ControllerHandle and is was opened by DriverBindingHandle with an
+  attribute of EFI_OPEN_PROTOCOL_BY_DRIVER. 
+  If ProtocolGuid is NULL, then ASSERT().
+
+  @param  ControllerHandle     A handle for a controller to test.
+  @param  DriverBindingHandle  Specifies the driver binding handle for the
+                               driver.
+  @param  ProtocolGuid         Specifies the protocol that the driver specified
+                               by DriverBindingHandle opens in its Start()
+                               function.
+
+  @retval EFI_SUCCESS          ControllerHandle is managed by the driver
+                               specified by DriverBindingHandle.
+  @retval EFI_UNSUPPORTED      ControllerHandle is not managed by the driver
+                               specified by DriverBindingHandle.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiTestManagedDevice (
+  IN CONST EFI_HANDLE       ControllerHandle,
+  IN CONST EFI_HANDLE       DriverBindingHandle,
+  IN CONST EFI_GUID         *ProtocolGuid
+  )
+{
+  EFI_STATUS     Status;
+  VOID           *ManagedInterface;
+
+  ASSERT (ProtocolGuid != NULL);
+
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  (EFI_GUID *) ProtocolGuid,
+                  &ManagedInterface,
+                  DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_BY_DRIVER
+                  );
+  if (!EFI_ERROR (Status)) {
+    gBS->CloseProtocol (
+           ControllerHandle,
+           (EFI_GUID *) ProtocolGuid,
+           DriverBindingHandle,
+           ControllerHandle
+           );
+    return EFI_UNSUPPORTED;
+  }
+
+  if (Status != EFI_ALREADY_STARTED) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Tests whether a child handle is a child device of the controller.
+
+  This function tests whether ChildHandle is one of the children of
+  ControllerHandle.  This test is performed by checking to see if the protocol
+  specified by ProtocolGuid is present on ControllerHandle and opened by
+  ChildHandle with an attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
+  If ProtocolGuid is NULL, then ASSERT().
+
+  @param  ControllerHandle     A handle for a (parent) controller to test. 
+  @param  ChildHandle          A child handle to test.
+  @param  ProtocolGuid         Supplies the protocol that the child controller
+                               opens on its parent controller. 
+
+  @retval EFI_SUCCESS          ChildHandle is a child of the ControllerHandle.
+  @retval EFI_UNSUPPORTED      ChildHandle is not a child of the
+                               ControllerHandle.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiTestChildHandle (
+  IN CONST EFI_HANDLE       ControllerHandle,
+  IN CONST EFI_HANDLE       ChildHandle,
+  IN CONST EFI_GUID         *ProtocolGuid
+  )
+{
+  EFI_STATUS                            Status;
+  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY   *OpenInfoBuffer;
+  UINTN                                 EntryCount;
+  UINTN                                 Index;
+
+  ASSERT (ProtocolGuid != NULL);
+
+  //
+  // Retrieve the list of agents that are consuming the specific protocol
+  // on ControllerHandle.
+  //
+  Status = gBS->OpenProtocolInformation (
+                  ControllerHandle,
+                  (EFI_GUID *) ProtocolGuid,
+                  &OpenInfoBuffer,
+                  &EntryCount
+                  );
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Inspect if ChildHandle is one of the agents.
+  //
+  Status = EFI_UNSUPPORTED;
+  for (Index = 0; Index < EntryCount; Index++) {
+    if ((OpenInfoBuffer[Index].ControllerHandle == ChildHandle) &&
+        (OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+      Status = EFI_SUCCESS;
+      break;
+    }
+  }
+
+  FreePool (OpenInfoBuffer);
+  return Status;
+}
+
+/**
+  This function looks up a Unicode string in UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages and a Unicode string is found in
+  UnicodeStringTable that matches the language code specified by Language, then it
+  is returned in UnicodeString.
+
+  @param  Language                A pointer to the ISO 639-2 language code for the 
+                                  Unicode string to look up and return.
+  @param  SupportedLanguages      A pointer to the set of ISO 639-2 language codes 
+                                  that the Unicode string table supports.  Language 
+                                  must be a member of this set.
+  @param  UnicodeStringTable      A pointer to the table of Unicode strings.
+  @param  UnicodeString           A pointer to the Unicode string from UnicodeStringTable
+                                  that matches the language specified by Language.
+
+  @retval EFI_SUCCESS             The Unicode string that matches the language 
+                                  specified by Language was found
+                                  in the table of Unicode strings UnicodeStringTable, 
+                                  and it was returned in UnicodeString.
+  @retval EFI_INVALID_PARAMETER   Language is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is NULL.
+  @retval EFI_UNSUPPORTED         SupportedLanguages is NULL.
+  @retval EFI_UNSUPPORTED         UnicodeStringTable is NULL.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not a 
+                                  member of SupportedLanguages.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not 
+                                  supported by UnicodeStringTable.
+
+**/
+EFI_STATUS
+EFIAPI
+LookupUnicodeString (
+  IN CONST CHAR8                     *Language,
+  IN CONST CHAR8                     *SupportedLanguages,
+  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
+  OUT CHAR16                         **UnicodeString
+  )
+{
+  //
+  // Make sure the parameters are valid
+  //
+  if (Language == NULL || UnicodeString == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // If there are no supported languages, or the Unicode String Table is empty, then the
+  // Unicode String specified by Language is not supported by this Unicode String Table
+  //
+  if (SupportedLanguages == NULL || UnicodeStringTable == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Make sure Language is in the set of Supported Languages
+  //
+  while (*SupportedLanguages != 0) {
+    if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
+
+      //
+      // Search the Unicode String Table for the matching Language specifier
+      //
+      while (UnicodeStringTable->Language != NULL) {
+        if (CompareIso639LanguageCode (Language, UnicodeStringTable->Language)) {
+
+          //
+          // A matching string was found, so return it
+          //
+          *UnicodeString = UnicodeStringTable->UnicodeString;
+          return EFI_SUCCESS;
+        }
+
+        UnicodeStringTable++;
+      }
+
+      return EFI_UNSUPPORTED;
+    }
+
+    SupportedLanguages += 3;
+  }
+
+  return EFI_UNSUPPORTED;
+}
+
+
+
+/**
+  This function looks up a Unicode string in UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages and a Unicode string is found in
+  UnicodeStringTable that matches the language code specified by Language, then
+  it is returned in UnicodeString.
+
+  @param  Language             A pointer to an ASCII string containing the ISO 639-2 or the
+                               RFC 4646 language code for the Unicode string to look up and
+                               return. If Iso639Language is TRUE, then this ASCII string is
+                               not assumed to be Null-terminated, and only the first three
+                               characters are used. If Iso639Language is FALSE, then this ASCII
+                               string must be Null-terminated. 
+  @param  SupportedLanguages   A pointer to a Null-terminated ASCII string that contains a
+                               set of ISO 639-2 or RFC 4646 language codes that the Unicode
+                               string table supports.  Language must be a member of this set.
+                               If Iso639Language is TRUE, then this string contains one or more
+                               ISO 639-2 language codes with no separator characters. If Iso639Language
+                               is FALSE, then is string contains one or more RFC 4646 language
+                               codes separated by ';'.
+  @param  UnicodeStringTable   A pointer to the table of Unicode strings. Type EFI_UNICODE_STRING_TABLE
+                               is defined in "Related Definitions".
+  @param  UnicodeString        A pointer to the Null-terminated Unicode string from UnicodeStringTable
+                               that matches the language specified by Language.
+  @param  Iso639Language       Specifies the supported language code format. If it is TRUE, then
+                               Language and SupportedLanguages follow ISO 639-2 language code format.
+                               Otherwise, they follow RFC 4646 language code format.
+
+
+  @retval  EFI_SUCCESS            The Unicode string that matches the language specified by Language
+                                  was found in the table of Unicode strings UnicodeStringTable, and
+                                  it was returned in UnicodeString.
+  @retval  EFI_INVALID_PARAMETER  Language is NULL.  
+  @retval  EFI_INVALID_PARAMETER  UnicodeString is NULL.  
+  @retval  EFI_UNSUPPORTED        SupportedLanguages is NULL.  
+  @retval  EFI_UNSUPPORTED        UnicodeStringTable is NULL.  
+  @retval  EFI_UNSUPPORTED        The language specified by Language is not a member of SupportedLanguages.  
+  @retval  EFI_UNSUPPORTED        The language specified by Language is not supported by UnicodeStringTable.
+
+**/
+EFI_STATUS
+EFIAPI
+LookupUnicodeString2 (
+  IN CONST CHAR8                     *Language,
+  IN CONST CHAR8                     *SupportedLanguages,
+  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
+  OUT CHAR16                         **UnicodeString,
+  IN BOOLEAN                         Iso639Language
+  )
+{
+  BOOLEAN   Found;
+  UINTN     Index;
+  CHAR8     *LanguageString;
+
+  //
+  // Make sure the parameters are valid
+  //
+  if (Language == NULL || UnicodeString == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // If there are no supported languages, or the Unicode String Table is empty, then the
+  // Unicode String specified by Language is not supported by this Unicode String Table
+  //
+  if (SupportedLanguages == NULL || UnicodeStringTable == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Make sure Language is in the set of Supported Languages
+  //
+  Found = FALSE;
+  while (*SupportedLanguages != 0) {
+    if (Iso639Language) {
+      if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
+        Found = TRUE;
+        break;
+      }
+      SupportedLanguages += 3;
+    } else {
+      for (Index = 0; SupportedLanguages[Index] != 0 && SupportedLanguages[Index] != ';'; Index++);
+      if ((AsciiStrnCmp(SupportedLanguages, Language, Index) == 0) && (Language[Index] == 0)) {
+        Found = TRUE;
+        break;
+      }
+      SupportedLanguages += Index;
+      for (; *SupportedLanguages != 0 && *SupportedLanguages == ';'; SupportedLanguages++);
+    }
+  }
+
+  //
+  // If Language is not a member of SupportedLanguages, then return EFI_UNSUPPORTED
+  //
+  if (!Found) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Search the Unicode String Table for the matching Language specifier
+  //
+  while (UnicodeStringTable->Language != NULL) {
+    LanguageString = UnicodeStringTable->Language;
+    while (0 != *LanguageString) {
+      for (Index = 0 ;LanguageString[Index] != 0 && LanguageString[Index] != ';'; Index++);
+      if (AsciiStrnCmp(LanguageString, Language, Index) == 0) {
+        *UnicodeString = UnicodeStringTable->UnicodeString;
+        return EFI_SUCCESS;
+      }
+      LanguageString += Index;
+      for (Index = 0 ;LanguageString[Index] != 0 && LanguageString[Index] == ';'; Index++);
+    }
+    UnicodeStringTable++;
+  }
+
+  return EFI_UNSUPPORTED;
+}
+
+
+/**
+  This function adds a Unicode string to UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages then UnicodeString is added to 
+  UnicodeStringTable.  New buffers are allocated for both Language and 
+  UnicodeString.  The contents of Language and UnicodeString are copied into 
+  these new buffers.  These buffers are automatically freed when 
+  FreeUnicodeStringTable() is called.
+
+  @param  Language                A pointer to the ISO 639-2 language code for the Unicode 
+                                  string to add.
+  @param  SupportedLanguages      A pointer to the set of ISO 639-2 language codes
+                                  that the Unicode string table supports.
+                                  Language must be a member of this set.
+  @param  UnicodeStringTable      A pointer to the table of Unicode strings.
+  @param  UnicodeString           A pointer to the Unicode string to add.
+
+  @retval EFI_SUCCESS             The Unicode string that matches the language 
+                                  specified by Language was found in the table of 
+                                  Unicode strings UnicodeStringTable, and it was 
+                                  returned in UnicodeString.
+  @retval EFI_INVALID_PARAMETER   Language is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is NULL.
+  @retval EFI_INVALID_PARAMETER   UnicodeString is an empty string.
+  @retval EFI_UNSUPPORTED         SupportedLanguages is NULL.
+  @retval EFI_ALREADY_STARTED     A Unicode string with language Language is 
+                                  already present in UnicodeStringTable.
+  @retval EFI_OUT_OF_RESOURCES    There is not enough memory to add another 
+                                  Unicode string to UnicodeStringTable.
+  @retval EFI_UNSUPPORTED         The language specified by Language is not a 
+                                  member of SupportedLanguages.
+
+**/
+EFI_STATUS
+EFIAPI
+AddUnicodeString (
+  IN CONST CHAR8               *Language,
+  IN CONST CHAR8               *SupportedLanguages,
+  IN EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
+  IN CONST CHAR16              *UnicodeString
+  )
+{
+  UINTN                     NumberOfEntries;
+  EFI_UNICODE_STRING_TABLE  *OldUnicodeStringTable;
+  EFI_UNICODE_STRING_TABLE  *NewUnicodeStringTable;
+  UINTN                     UnicodeStringLength;
+
+  //
+  // Make sure the parameter are valid
+  //
+  if (Language == NULL || UnicodeString == NULL || UnicodeStringTable == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // If there are no supported languages, then a Unicode String can not be added
+  //
+  if (SupportedLanguages == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // If the Unicode String is empty, then a Unicode String can not be added
+  //
+  if (UnicodeString[0] == 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Make sure Language is a member of SupportedLanguages
+  //
+  while (*SupportedLanguages != 0) {
+    if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
+
+      //
+      // Determine the size of the Unicode String Table by looking for a NULL Language entry
+      //
+      NumberOfEntries = 0;
+      if (*UnicodeStringTable != NULL) {
+        OldUnicodeStringTable = *UnicodeStringTable;
+        while (OldUnicodeStringTable->Language != NULL) {
+          if (CompareIso639LanguageCode (Language, OldUnicodeStringTable->Language)) {
+            return EFI_ALREADY_STARTED;
+          }
+
+          OldUnicodeStringTable++;
+          NumberOfEntries++;
+        }
+      }
+
+      //
+      // Allocate space for a new Unicode String Table.  It must hold the current number of
+      // entries, plus 1 entry for the new Unicode String, plus 1 entry for the end of table
+      // marker
+      //
+      NewUnicodeStringTable = AllocatePool ((NumberOfEntries + 2) * sizeof (EFI_UNICODE_STRING_TABLE));
+      if (NewUnicodeStringTable == NULL) {
+        return EFI_OUT_OF_RESOURCES;
+      }
+
+      //
+      // If the current Unicode String Table contains any entries, then copy them to the
+      // newly allocated Unicode String Table.
+      //
+      if (*UnicodeStringTable != NULL) {
+        CopyMem (
+           NewUnicodeStringTable,
+           *UnicodeStringTable,
+           NumberOfEntries * sizeof (EFI_UNICODE_STRING_TABLE)
+           );
+      }
+
+      //
+      // Allocate space for a copy of the Language specifier
+      //
+      NewUnicodeStringTable[NumberOfEntries].Language = AllocateCopyPool (3, Language);
+      if (NewUnicodeStringTable[NumberOfEntries].Language == NULL) {
+        FreePool (NewUnicodeStringTable);
+        return EFI_OUT_OF_RESOURCES;
+      }
+
+      //
+      // Compute the length of the Unicode String
+      //
+      for (UnicodeStringLength = 0; UnicodeString[UnicodeStringLength] != 0; UnicodeStringLength++)
+        ;
+
+      //
+      // Allocate space for a copy of the Unicode String
+      //
+      NewUnicodeStringTable[NumberOfEntries].UnicodeString = AllocateCopyPool (
+                                                              (UnicodeStringLength + 1) * sizeof (CHAR16),
+                                                              UnicodeString
+                                                              );
+      if (NewUnicodeStringTable[NumberOfEntries].UnicodeString == NULL) {
+        FreePool (NewUnicodeStringTable[NumberOfEntries].Language);
+        FreePool (NewUnicodeStringTable);
+        return EFI_OUT_OF_RESOURCES;
+      }
+
+      //
+      // Mark the end of the Unicode String Table
+      //
+      NewUnicodeStringTable[NumberOfEntries + 1].Language       = NULL;
+      NewUnicodeStringTable[NumberOfEntries + 1].UnicodeString  = NULL;
+
+      //
+      // Free the old Unicode String Table
+      //
+      if (*UnicodeStringTable != NULL) {
+        FreePool (*UnicodeStringTable);
+      }
+
+      //
+      // Point UnicodeStringTable at the newly allocated Unicode String Table
+      //
+      *UnicodeStringTable = NewUnicodeStringTable;
+
+      return EFI_SUCCESS;
+    }
+
+    SupportedLanguages += 3;
+  }
+
+  return EFI_UNSUPPORTED;
+}
+
+
+/**
+  This function adds the Null-terminated Unicode string specified by UnicodeString
+  to UnicodeStringTable.
+
+  If Language is a member of SupportedLanguages then UnicodeString is added to
+  UnicodeStringTable.  New buffers are allocated for both Language and UnicodeString.
+  The contents of Language and UnicodeString are copied into these new buffers.
+  These buffers are automatically freed when EfiLibFreeUnicodeStringTable() is called.
+
+  @param  Language            A pointer to an ASCII string containing the ISO 639-2 or
+                              the RFC 4646 language code for the Unicode string to add.
+                              If Iso639Language is TRUE, then this ASCII string is not
+                              assumed to be Null-terminated, and only the first three
+                              chacters are used. If Iso639Language is FALSE, then this
+                              ASCII string must be Null-terminated.
+  @param  SupportedLanguages  A pointer to a Null-terminated ASCII string that contains
+                              a set of ISO 639-2 or RFC 4646 language codes that the Unicode
+                              string table supports.  Language must be a member of this set.
+                              If Iso639Language is TRUE, then this string contains one or more
+                              ISO 639-2 language codes with no separator characters.
+                              If Iso639Language is FALSE, then is string contains one or more
+                              RFC 4646 language codes separated by ';'.
+  @param  UnicodeStringTable  A pointer to the table of Unicode strings. Type EFI_UNICODE_STRING_TABLE
+                              is defined in "Related Definitions".
+  @param  UnicodeString       A pointer to the Unicode string to add.  
+  @param  Iso639Language      Specifies the supported language code format. If it is TRUE,
+                              then Language and SupportedLanguages follow ISO 639-2 language code format.
+                              Otherwise, they follow RFC 4646 language code format.
+
+  @retval EFI_SUCCESS            The Unicode string that matches the language specified by
+                                 Language was found in the table of Unicode strings UnicodeStringTable,
+                                 and it was returned in UnicodeString.  
+  @retval EFI_INVALID_PARAMETER  Language is NULL.  
+  @retval EFI_INVALID_PARAMETER  UnicodeString is NULL.  
+  @retval EFI_INVALID_PARAMETER  UnicodeString is an empty string.  
+  @retval EFI_UNSUPPORTED        SupportedLanguages is NULL.  
+  @retval EFI_ALREADY_STARTED    A Unicode string with language Language is already present in
+                                 UnicodeStringTable.  
+  @retval EFI_OUT_OF_RESOURCES   There is not enough memory to add another Unicode string UnicodeStringTable.  
+  @retval EFI_UNSUPPORTED        The language specified by Language is not a member of SupportedLanguages.
+
+**/
+EFI_STATUS
+EFIAPI
+AddUnicodeString2 (
+  IN CONST CHAR8               *Language,
+  IN CONST CHAR8               *SupportedLanguages,
+  IN EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
+  IN CONST CHAR16              *UnicodeString,
+  IN BOOLEAN                   Iso639Language
+  )
+{
+  UINTN                     NumberOfEntries;
+  EFI_UNICODE_STRING_TABLE  *OldUnicodeStringTable;
+  EFI_UNICODE_STRING_TABLE  *NewUnicodeStringTable;
+  UINTN                     UnicodeStringLength;
+  BOOLEAN                   Found;
+  UINTN                     Index;
+  CHAR8                     *LanguageString;
+
+  //
+  // Make sure the parameter are valid
+  //
+  if (Language == NULL || UnicodeString == NULL || UnicodeStringTable == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // If there are no supported languages, then a Unicode String can not be added
+  //
+  if (SupportedLanguages == NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // If the Unicode String is empty, then a Unicode String can not be added
+  //
+  if (UnicodeString[0] == 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Make sure Language is a member of SupportedLanguages
+  //
+  Found = FALSE;
+  while (*SupportedLanguages != 0) {
+    if (Iso639Language) {
+      if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
+        Found = TRUE;
+        break;
+      }
+      SupportedLanguages += 3;
+    } else {
+      for (Index = 0; SupportedLanguages[Index] != 0 && SupportedLanguages[Index] != ';'; Index++);
+      if (AsciiStrnCmp(SupportedLanguages, Language, Index) == 0) {
+        Found = TRUE;
+        break;
+      }
+      SupportedLanguages += Index;
+      for (; *SupportedLanguages != 0 && *SupportedLanguages == ';'; SupportedLanguages++);
+    }
+  }
+
+  //
+  // If Language is not a member of SupportedLanguages, then return EFI_UNSUPPORTED
+  //
+  if (!Found) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Determine the size of the Unicode String Table by looking for a NULL Language entry
+  //
+  NumberOfEntries = 0;
+  if (*UnicodeStringTable != NULL) {
+    OldUnicodeStringTable = *UnicodeStringTable;
+    while (OldUnicodeStringTable->Language != NULL) {
+      LanguageString = OldUnicodeStringTable->Language;
+
+      while (*LanguageString != 0) {
+        for (Index = 0; LanguageString[Index] != 0 && LanguageString[Index] != ';'; Index++);
+
+        if (AsciiStrnCmp (Language, LanguageString, Index) == 0) { 
+          return EFI_ALREADY_STARTED;
+        }
+        LanguageString += Index;
+        for (; *LanguageString != 0 && *LanguageString == ';'; LanguageString++);
+      }
+      OldUnicodeStringTable++;
+      NumberOfEntries++;
+    }
+  }
+
+  //
+  // Allocate space for a new Unicode String Table.  It must hold the current number of
+  // entries, plus 1 entry for the new Unicode String, plus 1 entry for the end of table
+  // marker
+  //
+  NewUnicodeStringTable = AllocatePool ((NumberOfEntries + 2) * sizeof (EFI_UNICODE_STRING_TABLE));
+  if (NewUnicodeStringTable == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // If the current Unicode String Table contains any entries, then copy them to the
+  // newly allocated Unicode String Table.
+  //
+  if (*UnicodeStringTable != NULL) {
+    CopyMem (
+      NewUnicodeStringTable,
+      *UnicodeStringTable,
+      NumberOfEntries * sizeof (EFI_UNICODE_STRING_TABLE)
+      );
+  }
+
+  //
+  // Allocate space for a copy of the Language specifier
+  //
+  NewUnicodeStringTable[NumberOfEntries].Language = AllocateCopyPool (AsciiStrSize(Language), Language);
+  if (NewUnicodeStringTable[NumberOfEntries].Language == NULL) {
+    FreePool (NewUnicodeStringTable);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Compute the length of the Unicode String
+  //
+  for (UnicodeStringLength = 0; UnicodeString[UnicodeStringLength] != 0; UnicodeStringLength++);
+
+  //
+  // Allocate space for a copy of the Unicode String
+  //
+  NewUnicodeStringTable[NumberOfEntries].UnicodeString = AllocateCopyPool (StrSize (UnicodeString), UnicodeString);
+  if (NewUnicodeStringTable[NumberOfEntries].UnicodeString == NULL) {
+    FreePool (NewUnicodeStringTable[NumberOfEntries].Language);
+    FreePool (NewUnicodeStringTable);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Mark the end of the Unicode String Table
+  //
+  NewUnicodeStringTable[NumberOfEntries + 1].Language       = NULL;
+  NewUnicodeStringTable[NumberOfEntries + 1].UnicodeString  = NULL;
+
+  //
+  // Free the old Unicode String Table
+  //
+  if (*UnicodeStringTable != NULL) {
+    FreePool (*UnicodeStringTable);
+  }
+
+  //
+  // Point UnicodeStringTable at the newly allocated Unicode String Table
+  //
+  *UnicodeStringTable = NewUnicodeStringTable;
+
+  return EFI_SUCCESS;
+}
+
+/**
+  This function frees the table of Unicode strings in UnicodeStringTable.
+
+  If UnicodeStringTable is NULL, then EFI_SUCCESS is returned.
+  Otherwise, each language code, and each Unicode string in the Unicode string 
+  table are freed, and EFI_SUCCESS is returned.
+
+  @param  UnicodeStringTable  A pointer to the table of Unicode strings.
+
+  @retval EFI_SUCCESS         The Unicode string table was freed.
+
+**/
+EFI_STATUS
+EFIAPI
+FreeUnicodeStringTable (
+  IN EFI_UNICODE_STRING_TABLE  *UnicodeStringTable
+  )
+{
+  UINTN Index;
+
+  //
+  // If the Unicode String Table is NULL, then it is already freed
+  //
+  if (UnicodeStringTable == NULL) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Loop through the Unicode String Table until we reach the end of table marker
+  //
+  for (Index = 0; UnicodeStringTable[Index].Language != NULL; Index++) {
+
+    //
+    // Free the Language string from the Unicode String Table
+    //
+    FreePool (UnicodeStringTable[Index].Language);
+
+    //
+    // Free the Unicode String from the Unicode String Table
+    //
+    if (UnicodeStringTable[Index].UnicodeString != NULL) {
+      FreePool (UnicodeStringTable[Index].UnicodeString);
+    }
+  }
+
+  //
+  // Free the Unicode String Table itself
+  //
+  FreePool (UnicodeStringTable);
+
+  return EFI_SUCCESS;
+}
+
+#ifndef DISABLE_NEW_DEPRECATED_INTERFACES
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  The 
+  returned buffer is allocated using AllocatePool().  The caller is responsible
+  for freeing this buffer with FreePool().
+
+  If Name is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[in]  Guid  The pointer to an EFI_GUID structure
+
+  @retval NULL   The variable could not be retrieved.
+  @retval NULL   There are not enough resources available for the variable contents.
+  @retval Other  A pointer to allocated buffer containing the variable contents.
+
+**/
+VOID *
+EFIAPI
+GetVariable (
+  IN CONST CHAR16    *Name,
+  IN CONST EFI_GUID  *Guid
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       Size;
+  VOID        *Value;
+
+  ASSERT (Name != NULL);
+  ASSERT (Guid != NULL);
+
+  //
+  // Try to get the variable size.
+  //
+  Value = NULL;
+  Size = 0;
+  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &Size, Value);
+  if (Status != EFI_BUFFER_TOO_SMALL) {
+    return NULL;
+  }
+
+  //
+  // Allocate buffer to get the variable.
+  //
+  Value = AllocatePool (Size);
+  if (Value == NULL) {
+    return NULL;
+  }
+
+  //
+  // Get the variable data.
+  //
+  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &Size, Value);
+  if (EFI_ERROR (Status)) {
+    FreePool(Value);
+    return NULL;
+  }
+
+  return Value;
+}
+
+/**
+  [ATTENTION] This function will be deprecated for security reason.
+
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  This 
+  function always uses the EFI_GLOBAL_VARIABLE GUID to retrieve variables.
+  The returned buffer is allocated using AllocatePool().  The caller is 
+  responsible for freeing this buffer with FreePool().
+
+  If Name is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+
+  @retval NULL   The variable could not be retrieved.
+  @retval NULL   There are not enough resources available for the variable contents.
+  @retval Other  A pointer to allocated buffer containing the variable contents.
+
+**/
+VOID *
+EFIAPI
+GetEfiGlobalVariable (
+  IN CONST CHAR16  *Name
+  )
+{
+  return GetVariable (Name, &gEfiGlobalVariableGuid);
+}
+#endif
+
+/**
+  Returns the status whether get the variable success. The function retrieves 
+  variable  through the UEFI Runtime Service GetVariable().  The 
+  returned buffer is allocated using AllocatePool().  The caller is responsible
+  for freeing this buffer with FreePool().
+
+  If Name  is NULL, then ASSERT().
+  If Guid  is NULL, then ASSERT().
+  If Value is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[in]  Guid  The pointer to an EFI_GUID structure
+  @param[out] Value The buffer point saved the variable info.
+  @param[out] Size  The buffer size of the variable.
+
+  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.
+  @return EFI_SUCCESS               Find the specified variable.
+  @return Others Errors             Return errors from call to gRT->GetVariable.
+
+**/
+EFI_STATUS
+EFIAPI
+GetVariable2 (
+  IN CONST CHAR16    *Name,
+  IN CONST EFI_GUID  *Guid,
+  OUT VOID           **Value,
+  OUT UINTN          *Size OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       BufferSize;
+
+  ASSERT (Name != NULL && Guid != NULL && Value != NULL);
+
+  //
+  // Try to get the variable size.
+  //
+  BufferSize = 0;
+  *Value     = NULL;
+  if (Size != NULL) {
+    *Size  = 0;
+  }
+  
+  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);
+  if (Status != EFI_BUFFER_TOO_SMALL) {
+    return Status;
+  }
+
+  //
+  // Allocate buffer to get the variable.
+  //
+  *Value = AllocatePool (BufferSize);
+  ASSERT (*Value != NULL);
+  if (*Value == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Get the variable data.
+  //
+  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);
+  if (EFI_ERROR (Status)) {
+    FreePool(*Value);
+    *Value = NULL;
+  }
+
+  if (Size != NULL) {
+    *Size = BufferSize;
+  }
+
+  return Status;
+}
+
+/**
+  Returns a pointer to an allocated buffer that contains the contents of a 
+  variable retrieved through the UEFI Runtime Service GetVariable().  This 
+  function always uses the EFI_GLOBAL_VARIABLE GUID to retrieve variables.
+  The returned buffer is allocated using AllocatePool().  The caller is 
+  responsible for freeing this buffer with FreePool().
+
+  If Name is NULL, then ASSERT().
+  If Value is NULL, then ASSERT().
+
+  @param[in]  Name  The pointer to a Null-terminated Unicode string.
+  @param[out] Value The buffer point saved the variable info.
+  @param[out] Size  The buffer size of the variable.
+
+  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.
+  @return EFI_SUCCESS               Find the specified variable.
+  @return Others Errors             Return errors from call to gRT->GetVariable.
+
+**/
+EFI_STATUS
+EFIAPI
+GetEfiGlobalVariable2 (
+  IN CONST CHAR16    *Name,
+  OUT VOID           **Value,
+  OUT UINTN          *Size OPTIONAL
+  )
+{
+  return GetVariable2 (Name, &gEfiGlobalVariableGuid, Value, Size);
+}
+
+/**
+  Returns a pointer to an allocated buffer that contains the best matching language 
+  from a set of supported languages.  
+  
+  This function supports both ISO 639-2 and RFC 4646 language codes, but language 
+  code types may not be mixed in a single call to this function.  The language 
+  code returned is allocated using AllocatePool().  The caller is responsible for 
+  freeing the allocated buffer using FreePool().  This function supports a variable
+  argument list that allows the caller to pass in a prioritized list of language 
+  codes to test against all the language codes in SupportedLanguages. 
+
+  If SupportedLanguages is NULL, then ASSERT().
+
+  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that
+                                  contains a set of language codes in the format 
+                                  specified by Iso639Language.
+  @param[in]  Iso639Language      If TRUE, then all language codes are assumed to be
+                                  in ISO 639-2 format.  If FALSE, then all language
+                                  codes are assumed to be in RFC 4646 language format
+  @param[in]  ...                 A variable argument list that contains pointers to 
+                                  Null-terminated ASCII strings that contain one or more
+                                  language codes in the format specified by Iso639Language.
+                                  The first language code from each of these language
+                                  code lists is used to determine if it is an exact or
+                                  close match to any of the language codes in 
+                                  SupportedLanguages.  Close matches only apply to RFC 4646
+                                  language codes, and the matching algorithm from RFC 4647
+                                  is used to determine if a close match is present.  If 
+                                  an exact or close match is found, then the matching
+                                  language code from SupportedLanguages is returned.  If
+                                  no matches are found, then the next variable argument
+                                  parameter is evaluated.  The variable argument list 
+                                  is terminated by a NULL.
+
+  @retval NULL   The best matching language could not be found in SupportedLanguages.
+  @retval NULL   There are not enough resources available to return the best matching 
+                 language.
+  @retval Other  A pointer to a Null-terminated ASCII string that is the best matching 
+                 language in SupportedLanguages.
+
+**/
+CHAR8 *
+EFIAPI
+GetBestLanguage (
+  IN CONST CHAR8  *SupportedLanguages, 
+  IN BOOLEAN      Iso639Language,
+  ...
+  )
+{
+  VA_LIST      Args;
+  CHAR8        *Language;
+  UINTN        CompareLength;
+  UINTN        LanguageLength;
+  CONST CHAR8  *Supported;
+  CHAR8        *BestLanguage;
+
+  ASSERT (SupportedLanguages != NULL);
+
+  VA_START (Args, Iso639Language);
+  while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {
+    //
+    // Default to ISO 639-2 mode
+    //
+    CompareLength  = 3;
+    LanguageLength = MIN (3, AsciiStrLen (Language));
+
+    //
+    // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language
+    //
+    if (!Iso639Language) {
+      for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);
+    }
+
+    //
+    // Trim back the length of Language used until it is empty
+    //
+    while (LanguageLength > 0) {
+      //
+      // Loop through all language codes in SupportedLanguages
+      //
+      for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {
+        //
+        // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages
+        //
+        if (!Iso639Language) {
+          //
+          // Skip ';' characters in Supported
+          //
+          for (; *Supported != '\0' && *Supported == ';'; Supported++);
+          //
+          // Determine the length of the next language code in Supported
+          //
+          for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);
+          //
+          // If Language is longer than the Supported, then skip to the next language
+          //
+          if (LanguageLength > CompareLength) {
+            continue;
+          }
+        }
+        //
+        // See if the first LanguageLength characters in Supported match Language
+        //
+        if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {
+          VA_END (Args);
+          //
+          // Allocate, copy, and return the best matching language code from SupportedLanguages
+          //
+          BestLanguage = AllocateZeroPool (CompareLength + 1);
+          if (BestLanguage == NULL) {
+            return NULL;
+          }
+          return CopyMem (BestLanguage, Supported, CompareLength);
+        }
+      }
+
+      if (Iso639Language) {
+        //
+        // If ISO 639 mode, then each language can only be tested once
+        //
+        LanguageLength = 0;
+      } else {
+        //
+        // If RFC 4646 mode, then trim Language from the right to the next '-' character 
+        //
+        for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);
+      }
+    }
+  }
+  VA_END (Args);
+
+  //
+  // No matches were found 
+  //
+  return NULL;
+}
diff --git a/MdePkg/Library/UefiLib/UefiLib.inf b/MdePkg/Library/UefiLib/UefiLib.inf
new file mode 100644
index 000000000000..17e57ae29e3d
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiLib.inf
@@ -0,0 +1,89 @@
+## @file
+# Instance of UEFI Library.
+#
+# The UEFI Library provides functions and macros that simplify the development of 
+#  UEFI Drivers and UEFI Applications.  These functions and macros help manage EFI 
+#  events, build simple locks utilizing EFI Task Priority Levels (TPLs), install 
+#  EFI Driver Model related protocols, manage Unicode string tables for UEFI Drivers, 
+#  and print messages on the console output and standard error devices.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiLib
+  MODULE_UNI_FILE                = UefiLib.uni
+  FILE_GUID                      = 3a004ba5-efe0-4a61-9f1a-267a46ae5ba9
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+  CONSTRUCTOR                    = UefiLibConstructor
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiLibPrint.c
+  UefiNotTiano.c
+  UefiDriverModel.c
+  Console.c
+  UefiLib.c
+  UefiLibInternal.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  PrintLib
+  PcdLib
+  MemoryAllocationLib
+  DebugLib
+  BaseMemoryLib
+  BaseLib
+  UefiBootServicesTableLib
+  DevicePathLib
+  UefiRuntimeServicesTableLib
+  
+[Guids]
+  gEfiEventReadyToBootGuid                      ## SOMETIMES_CONSUMES  ## Event
+  gEfiEventLegacyBootGuid                       ## SOMETIMES_CONSUMES  ## Event
+  gEfiGlobalVariableGuid                        ## SOMETIMES_CONSUMES  ## Variable
+
+[Protocols]
+  gEfiDriverBindingProtocolGuid                   ## SOMETIMES_PRODUCES
+  gEfiSimpleTextOutProtocolGuid                   ## SOMETIMES_CONSUMES
+  gEfiGraphicsOutputProtocolGuid                  ## SOMETIMES_CONSUMES
+  gEfiHiiFontProtocolGuid                         ## SOMETIMES_CONSUMES
+  gEfiUgaDrawProtocolGuid | gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport                 ## SOMETIMES_CONSUMES # Consumes if gEfiGraphicsOutputProtocolGuid uninstalled
+  gEfiComponentNameProtocolGuid  | NOT gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable   ## SOMETIMES_PRODUCES # User chooses to produce it
+  gEfiComponentName2ProtocolGuid | NOT gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable  ## SOMETIMES_PRODUCES # User chooses to produce it
+  gEfiDriverConfigurationProtocolGuid                            ## SOMETIMES_PRODUCES # User chooses to produce it
+  gEfiDriverConfiguration2ProtocolGuid                           ## SOMETIMES_PRODUCES # User chooses to produce it
+  gEfiDriverDiagnosticsProtocolGuid | NOT gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable  ## SOMETIMES_PRODUCES # User chooses to produce it
+  gEfiDriverDiagnostics2ProtocolGuid| NOT gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable ## SOMETIMES_PRODUCES # User chooses to produce it
+
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize   ## SOMETIMES_CONSUMES
+
+[FeaturePcd]
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable    ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable        ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable   ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable       ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport           ## CONSUMES
+
diff --git a/MdePkg/Library/UefiLib/UefiLib.uni b/MdePkg/Library/UefiLib/UefiLib.uni
new file mode 100644
index 000000000000..d8bf83eae04d
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiLib.uni
@@ -0,0 +1,25 @@
+// /** @file
+// Instance of UEFI Library.
+//
+// The UEFI Library provides functions and macros that simplify the development of
+// UEFI Drivers and UEFI Applications.  These functions and macros help manage EFI
+// events, build simple locks utilizing EFI Task Priority Levels (TPLs), install
+// EFI Driver Model related protocols, manage Unicode string tables for UEFI Drivers,
+// and print messages on the console output and standard error devices.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of UEFI Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "The UEFI Library provides functions and macros that simplify the development of UEFI Drivers and UEFI Applications.  These functions and macros help manage EFI events, build simple locks utilizing EFI Task Priority Levels (TPLs), install EFI Driver Model related protocols, manage Unicode string tables for UEFI Drivers, and print messages on the console output and standard error devices."
+
diff --git a/MdePkg/Library/UefiLib/UefiLibInternal.h b/MdePkg/Library/UefiLib/UefiLibInternal.h
new file mode 100644
index 000000000000..4a3145cd738c
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiLibInternal.h
@@ -0,0 +1,44 @@
+/** @file
+  Internal include file for UefiLib.
+
+  Copyright (c) 2007 - 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_LIB_INTERNAL_H_
+#define __UEFI_LIB_INTERNAL_H_
+
+
+#include <Uefi.h>
+#include <Protocol/DriverBinding.h>
+#include <Protocol/ComponentName.h>
+#include <Protocol/ComponentName2.h>
+#include <Protocol/DriverConfiguration.h>
+#include <Protocol/DriverConfiguration2.h>
+#include <Protocol/DriverDiagnostics.h>
+#include <Protocol/DriverDiagnostics2.h>
+#include <Protocol/LoadedImage.h>
+#include <Protocol/GraphicsOutput.h>
+#include <Protocol/UgaDraw.h>
+#include <Protocol/HiiFont.h>
+
+#include <Guid/EventGroup.h>
+#include <Guid/EventLegacyBios.h>
+#include <Guid/GlobalVariable.h>
+#include <Library/UefiLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+#include <Library/PrintLib.h>
+#include <Library/DevicePathLib.h>
+
+#endif
diff --git a/MdePkg/Library/UefiLib/UefiLibPrint.c b/MdePkg/Library/UefiLib/UefiLibPrint.c
new file mode 100644
index 000000000000..f10d54169cac
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiLibPrint.c
@@ -0,0 +1,815 @@
+/** @file
+  Mde UEFI library API implementation.
+  Print to StdErr or ConOut defined in EFI_SYSTEM_TABLE
+
+  Copyright (c) 2007 - 2015, 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 "UefiLibInternal.h"
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_GRAPHICS_OUTPUT_BLT_PIXEL mEfiColors[16] = {
+  { 0x00, 0x00, 0x00, 0x00 },
+  { 0x98, 0x00, 0x00, 0x00 },
+  { 0x00, 0x98, 0x00, 0x00 },
+  { 0x98, 0x98, 0x00, 0x00 },
+  { 0x00, 0x00, 0x98, 0x00 },
+  { 0x98, 0x00, 0x98, 0x00 },
+  { 0x00, 0x98, 0x98, 0x00 },
+  { 0x98, 0x98, 0x98, 0x00 },
+  { 0x10, 0x10, 0x10, 0x00 },
+  { 0xff, 0x10, 0x10, 0x00 },
+  { 0x10, 0xff, 0x10, 0x00 },
+  { 0xff, 0xff, 0x10, 0x00 },
+  { 0x10, 0x10, 0xff, 0x00 },
+  { 0xf0, 0x10, 0xff, 0x00 },
+  { 0x10, 0xff, 0xff, 0x00 },
+  { 0xff, 0xff, 0xff, 0x00 }
+};
+
+/**
+  Internal function which prints a formatted Unicode string to the console output device
+  specified by Console
+
+  This function prints a formatted Unicode string to the console output device
+  specified by Console and returns the number of Unicode characters that printed
+  to it.  If the length of the formatted Unicode string is greater than PcdUefiLibMaxPrintBufferSize,
+  then only the first PcdUefiLibMaxPrintBufferSize characters are sent to Console.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param Format   A Null-terminated Unicode format string.
+  @param Console  The output console.
+  @param Marker   A VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced
+          output buffer, not including the Null-terminator.
+**/
+UINTN
+InternalPrint (
+  IN  CONST CHAR16                     *Format,
+  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Console,
+  IN  VA_LIST                          Marker
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       Return;
+  CHAR16      *Buffer;
+  UINTN       BufferSize;
+
+  ASSERT (Format != NULL);
+  ASSERT (((UINTN) Format & BIT0) == 0);
+  ASSERT (Console != NULL);
+
+  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
+
+  Buffer = (CHAR16 *) AllocatePool(BufferSize);
+  ASSERT (Buffer != NULL);
+
+  Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
+
+  if (Console != NULL && Return > 0) {
+    //
+    // To be extra safe make sure Console has been initialized
+    //
+    Status = Console->OutputString (Console, Buffer);
+    if (EFI_ERROR (Status)) {
+      Return = 0;
+    }
+  }
+
+  FreePool (Buffer);
+
+  return Return;
+}
+
+/** 
+  Prints a formatted Unicode string to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted Unicode string to the console output device 
+  specified by ConOut in EFI_SYSTEM_TABLE and returns the number of Unicode 
+  characters that printed to ConOut.  If the length of the formatted Unicode 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->ConOut is NULL, then ASSERT().
+
+  @param Format   A Null-terminated Unicode format string.
+  @param ...      A Variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return The number of Unicode characters printed to ConOut.
+
+**/
+UINTN
+EFIAPI
+Print (
+  IN CONST CHAR16  *Format,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   Return;
+
+  VA_START (Marker, Format);
+
+  Return = InternalPrint (Format, gST->ConOut, Marker);
+
+  VA_END (Marker);
+
+  return Return;
+}
+
+/** 
+  Prints a formatted Unicode string to the console output device specified by 
+  StdErr defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted Unicode string to the console output device 
+  specified by StdErr in EFI_SYSTEM_TABLE and returns the number of Unicode 
+  characters that printed to StdErr.  If the length of the formatted Unicode 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->StdErr is NULL, then ASSERT().
+
+  @param Format   A Null-terminated Unicode format string.
+  @param ...      Variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return The number of Unicode characters printed to StdErr.
+
+**/
+UINTN
+EFIAPI
+ErrorPrint (
+  IN CONST CHAR16  *Format,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   Return;
+
+  VA_START (Marker, Format);
+
+  Return = InternalPrint( Format, gST->StdErr, Marker);
+
+  VA_END (Marker);
+
+  return Return;
+}
+
+
+/**
+  Internal function which prints a formatted ASCII string to the console output device
+  specified by Console
+
+  This function prints a formatted ASCII string to the console output device
+  specified by Console and returns the number of ASCII characters that printed
+  to it.  If the length of the formatted ASCII string is greater than PcdUefiLibMaxPrintBufferSize,
+  then only the first PcdUefiLibMaxPrintBufferSize characters are sent to Console.
+
+  If Format is NULL, then ASSERT().
+
+  @param Format   A Null-terminated ASCII format string.
+  @param Console  The output console.
+  @param Marker   VA_LIST marker for the variable argument list.
+
+  @return The number of Unicode characters in the produced
+          output buffer not including the Null-terminator.
+
+**/
+UINTN
+AsciiInternalPrint (
+  IN  CONST CHAR8                      *Format,
+  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Console,
+  IN  VA_LIST                          Marker
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       Return;
+  CHAR16      *Buffer;
+  UINTN       BufferSize;
+
+  ASSERT (Format != NULL);
+  ASSERT (Console != NULL);
+
+  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
+
+  Buffer = (CHAR16 *) AllocatePool(BufferSize);
+  ASSERT (Buffer != NULL);
+
+  Return = UnicodeVSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
+
+  if (Console != NULL) {
+    //
+    // To be extra safe make sure Console has been initialized
+    //
+    Status = Console->OutputString (Console, Buffer);
+    if (EFI_ERROR (Status)) {
+      Return = 0;
+    }
+  }
+
+  FreePool (Buffer);
+
+  return Return;
+}
+
+/** 
+  Prints a formatted ASCII string to the console output device specified by 
+  ConOut defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted ASCII string to the console output device 
+  specified by ConOut in EFI_SYSTEM_TABLE and returns the number of ASCII 
+  characters that printed to ConOut.  If the length of the formatted ASCII 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to ConOut.
+  If Format is NULL, then ASSERT().
+  If gST->ConOut is NULL, then ASSERT().
+
+  @param Format   A Null-terminated ASCII format string.
+  @param ...      Variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return The number of ASCII characters printed to ConOut.
+
+**/
+UINTN
+EFIAPI
+AsciiPrint (
+  IN CONST CHAR8  *Format,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   Return;
+  ASSERT (Format != NULL);
+
+  VA_START (Marker, Format);
+
+  Return = AsciiInternalPrint( Format, gST->ConOut, Marker);
+
+  VA_END (Marker);
+
+  return Return;
+}
+
+/** 
+  Prints a formatted ASCII string to the console output device specified by 
+  StdErr defined in the EFI_SYSTEM_TABLE.
+
+  This function prints a formatted ASCII string to the console output device 
+  specified by StdErr in EFI_SYSTEM_TABLE and returns the number of ASCII 
+  characters that printed to StdErr.  If the length of the formatted ASCII 
+  string is greater than PcdUefiLibMaxPrintBufferSize, then only the first 
+  PcdUefiLibMaxPrintBufferSize characters are sent to StdErr.
+  If Format is NULL, then ASSERT().
+  If gST->StdErr is NULL, then ASSERT().
+
+  @param Format   A Null-terminated ASCII format string.
+  @param ...      Variable argument list whose contents are accessed based 
+                  on the format string specified by Format.
+  
+  @return The number of ASCII characters printed to ConErr.
+
+**/
+UINTN
+EFIAPI
+AsciiErrorPrint (
+  IN CONST CHAR8  *Format,
+  ...
+  )
+{
+  VA_LIST Marker;
+  UINTN   Return;
+
+  ASSERT (Format != NULL);
+
+  VA_START (Marker, Format);
+
+  Return = AsciiInternalPrint( Format, gST->StdErr, Marker);
+
+  VA_END (Marker);
+
+  return Return;
+}
+
+/**
+  Internal function to print a formatted Unicode string to a graphics console device specified by
+  ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
+
+  This function prints a formatted Unicode string to the graphics console device
+  specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of
+  Unicode characters printed. The EFI_HII_FONT_PROTOCOL is used to convert the
+  string to a bitmap using the glyphs registered with the
+  HII database.  No wrapping is performed, so any portions of the string the fall
+  outside the active display region will not be displayed.
+
+  If a graphics console device is not associated with the ConsoleOutputHandle
+  defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
+  If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no
+  string is printed, and 0 is returned.
+
+  @param  PointX       An X coordinate to print the string.
+  @param  PointY       A Y coordinate to print the string.
+  @param  Foreground   The foreground color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the foreground color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Background   The background color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the background color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Buffer       A Null-terminated Unicode formatted string.
+  @param  PrintNum     The number of Unicode formatted string to be printed.
+
+  @return  The number of Unicode Characters printed. Zero means no any character
+           displayed successfully.
+
+**/
+UINTN
+InternalPrintGraphic (
+  IN UINTN                            PointX,
+  IN UINTN                            PointY,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *Foreground,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *Background,
+  IN CHAR16                           *Buffer,
+  IN UINTN                            PrintNum
+  )
+{
+  EFI_STATUS                          Status;
+  UINT32                              HorizontalResolution;
+  UINT32                              VerticalResolution;
+  UINT32                              ColorDepth;
+  UINT32                              RefreshRate;
+  EFI_HII_FONT_PROTOCOL               *HiiFont;
+  EFI_IMAGE_OUTPUT                    *Blt;
+  EFI_FONT_DISPLAY_INFO               FontInfo;
+  EFI_HII_ROW_INFO                    *RowInfoArray;
+  UINTN                               RowInfoArraySize;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL        *GraphicsOutput;
+  EFI_UGA_DRAW_PROTOCOL               *UgaDraw;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL     *Sto;
+  EFI_HANDLE                          ConsoleHandle;
+  UINTN                               Width;
+  UINTN                               Height;
+  UINTN                               Delta;
+
+  HorizontalResolution  = 0;
+  VerticalResolution    = 0;
+  Blt                   = NULL;
+  RowInfoArray          = NULL;
+
+  ConsoleHandle = gST->ConsoleOutHandle;
+  
+  ASSERT( ConsoleHandle != NULL);
+
+  Status = gBS->HandleProtocol (
+                  ConsoleHandle,
+                  &gEfiGraphicsOutputProtocolGuid,
+                  (VOID **) &GraphicsOutput
+                  );
+
+  UgaDraw = NULL;
+  if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
+    //
+    // If no GOP available, try to open UGA Draw protocol if supported.
+    //
+    GraphicsOutput = NULL;
+
+    Status = gBS->HandleProtocol (
+                    ConsoleHandle,
+                    &gEfiUgaDrawProtocolGuid,
+                    (VOID **) &UgaDraw
+                    );
+  }
+  if (EFI_ERROR (Status)) {
+    goto Error;
+  }
+
+  Status = gBS->HandleProtocol (
+                  ConsoleHandle,
+                  &gEfiSimpleTextOutProtocolGuid,
+                  (VOID **) &Sto
+                  );
+
+  if (EFI_ERROR (Status)) {
+    goto Error;
+  }
+
+  if (GraphicsOutput != NULL) {
+    HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
+    VerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
+  } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
+    UgaDraw->GetMode (UgaDraw, &HorizontalResolution, &VerticalResolution, &ColorDepth, &RefreshRate);
+  } else {
+    goto Error;
+  }
+
+  ASSERT ((HorizontalResolution != 0) && (VerticalResolution !=0));
+
+  Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **) &HiiFont);
+  if (EFI_ERROR (Status)) {
+    goto Error;
+  }
+
+  Blt = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
+  ASSERT (Blt != NULL);
+
+  Blt->Width        = (UINT16) (HorizontalResolution);
+  Blt->Height       = (UINT16) (VerticalResolution);
+
+  ZeroMem (&FontInfo, sizeof (EFI_FONT_DISPLAY_INFO));
+
+  if (Foreground != NULL) {
+    CopyMem (&FontInfo.ForegroundColor, Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+  } else {
+    CopyMem (
+      &FontInfo.ForegroundColor,
+      &mEfiColors[Sto->Mode->Attribute & 0x0f],
+      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+      );
+  }
+  if (Background != NULL) {
+    CopyMem (&FontInfo.BackgroundColor, Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+  } else {
+    CopyMem (
+      &FontInfo.BackgroundColor,
+      &mEfiColors[Sto->Mode->Attribute >> 4],
+      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+      );
+  }
+
+  if (GraphicsOutput != NULL) {
+    Blt->Image.Screen = GraphicsOutput;
+
+    Status = HiiFont->StringToImage (
+                         HiiFont,
+                         EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_OUT_FLAG_CLIP |
+                         EFI_HII_OUT_FLAG_CLIP_CLEAN_X | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y |
+                         EFI_HII_IGNORE_LINE_BREAK | EFI_HII_DIRECT_TO_SCREEN,
+                         Buffer,
+                         &FontInfo,
+                         &Blt,
+                         PointX,
+                         PointY,
+                         &RowInfoArray,
+                         &RowInfoArraySize,
+                         NULL
+                         );
+    if (EFI_ERROR (Status)) {
+      goto Error;
+    }
+
+  } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
+    ASSERT (UgaDraw!= NULL);
+
+    Blt->Image.Bitmap = AllocateZeroPool (Blt->Width * Blt->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+    ASSERT (Blt->Image.Bitmap != NULL);
+
+    //
+    //  StringToImage only support blt'ing image to device using GOP protocol. If GOP is not supported in this platform,
+    //  we ask StringToImage to print the string to blt buffer, then blt to device using UgaDraw.
+    //
+    Status = HiiFont->StringToImage (
+                         HiiFont,
+                         EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_OUT_FLAG_CLIP |
+                         EFI_HII_OUT_FLAG_CLIP_CLEAN_X | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y |
+                         EFI_HII_IGNORE_LINE_BREAK,
+                         Buffer,
+                         &FontInfo,
+                         &Blt,
+                         PointX,
+                         PointY,
+                         &RowInfoArray,
+                         &RowInfoArraySize,
+                         NULL
+                         );
+
+    if (!EFI_ERROR (Status)) {
+      ASSERT (RowInfoArray != NULL);
+      //
+      // Explicit Line break characters are ignored, so the updated parameter RowInfoArraySize by StringToImage will
+      // always be 1 or 0 (if there is no valid Unicode Char can be printed). ASSERT here to make sure.
+      //
+      ASSERT (RowInfoArraySize <= 1);
+
+      if (RowInfoArraySize != 0) {
+        Width  = RowInfoArray[0].LineWidth;
+        Height = RowInfoArray[0].LineHeight;
+        Delta  = Blt->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
+      } else {
+        Width  = 0;
+        Height = 0;
+        Delta  = 0;
+      }
+      Status = UgaDraw->Blt (
+                          UgaDraw,
+                          (EFI_UGA_PIXEL *) Blt->Image.Bitmap,
+                          EfiUgaBltBufferToVideo,
+                          PointX,
+                          PointY,
+                          PointX,
+                          PointY,
+                          Width,
+                          Height,
+                          Delta
+                          );
+    } else {
+      goto Error;
+    }
+    FreePool (Blt->Image.Bitmap);
+  } else {
+    goto Error;
+  }
+  //
+  // Calculate the number of actual printed characters
+  //
+  if (RowInfoArraySize != 0) {
+    PrintNum = RowInfoArray[0].EndIndex - RowInfoArray[0].StartIndex + 1;
+  } else {
+    PrintNum = 0;
+  }
+
+  FreePool (RowInfoArray);
+  FreePool (Blt);
+  return PrintNum;
+
+Error:
+  if (Blt != NULL) {
+    FreePool (Blt);
+  }
+  return 0;
+}
+
+/**
+  Prints a formatted Unicode string to a graphics console device specified by 
+  ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
+
+  This function prints a formatted Unicode string to the graphics console device 
+  specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of 
+  Unicode characters displayed, not including partial characters that may be clipped 
+  by the right edge of the display.  If the length of the formatted Unicode string is
+  greater than PcdUefiLibMaxPrintBufferSize, then at most the first 
+  PcdUefiLibMaxPrintBufferSize characters are printed.The EFI_HII_FONT_PROTOCOL
+  StringToImage() service is used to convert the string to a bitmap using the glyphs 
+  registered with the HII database. No wrapping is performed, so any portions of the 
+  string the fall outside the active display region will not be displayed. Please see 
+  Section 27.2.6 of the UEFI Specification for a description of the supported string
+  format including the set of control codes supported by the StringToImage() service.
+
+  If a graphics console device is not associated with the ConsoleOutputHandle 
+  defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
+  If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no 
+  string is printed, and 0 is returned.
+  If Format is NULL, then ASSERT().
+  If Format is not aligned on a 16-bit boundary, then ASSERT().
+  If gST->ConsoleOutputHandle is NULL, then ASSERT().
+
+  @param  PointX       An X coordinate to print the string.
+  @param  PointY       A Y coordinate to print the string.
+  @param  ForeGround   The foreground color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the foreground color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  BackGround   The background color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL, 
+                       then the background color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Format       A Null-terminated Unicode format string.  See Print Library 
+                       for the supported format string syntax.
+  @param  ...          A Variable argument list whose contents are accessed based on 
+                       the format string specified by Format.         
+
+  @return  The number of Unicode characters printed.
+
+**/
+UINTN
+EFIAPI
+PrintXY (
+  IN UINTN                            PointX,
+  IN UINTN                            PointY,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *ForeGround, OPTIONAL
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *BackGround, OPTIONAL
+  IN CONST CHAR16                     *Format,
+  ...
+  )
+{
+  VA_LIST                             Marker;
+  CHAR16                              *Buffer;
+  UINTN                               BufferSize;
+  UINTN                               PrintNum;
+  UINTN                               ReturnNum;
+
+  ASSERT (Format != NULL);
+  ASSERT (((UINTN) Format & BIT0) == 0);
+
+  VA_START (Marker, Format);
+
+  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
+
+  Buffer = (CHAR16 *) AllocatePool (BufferSize);
+  ASSERT (Buffer != NULL);
+
+  PrintNum = UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
+
+  VA_END (Marker);
+
+  ReturnNum = InternalPrintGraphic (PointX, PointY, ForeGround, BackGround, Buffer, PrintNum);
+
+  FreePool (Buffer);
+
+  return ReturnNum;
+}
+
+/**
+  Prints a formatted ASCII string to a graphics console device specified by 
+  ConsoleOutputHandle defined in the EFI_SYSTEM_TABLE at the given (X,Y) coordinates.
+
+  This function prints a formatted ASCII string to the graphics console device 
+  specified by ConsoleOutputHandle in EFI_SYSTEM_TABLE and returns the number of 
+  ASCII characters displayed, not including partial characters that may be clipped 
+  by the right edge of the display.  If the length of the formatted ASCII string is
+  greater than PcdUefiLibMaxPrintBufferSize, then at most the first 
+  PcdUefiLibMaxPrintBufferSize characters are printed.The EFI_HII_FONT_PROTOCOL
+  StringToImage() service is used to convert the string to a bitmap using the glyphs 
+  registered with the HII database. No wrapping is performed, so any portions of the 
+  string the fall outside the active display region will not be displayed. Please see 
+  Section 27.2.6 of the UEFI Specification for a description of the supported string
+  format including the set of control codes supported by the StringToImage() service.
+
+  If a graphics console device is not associated with the ConsoleOutputHandle 
+  defined in the EFI_SYSTEM_TABLE then no string is printed, and 0 is returned.
+  If the EFI_HII_FONT_PROTOCOL is not present in the handle database, then no 
+  string is printed, and 0 is returned.
+  If Format is NULL, then ASSERT().
+  If gST->ConsoleOutputHandle is NULL, then ASSERT().
+
+  @param  PointX       An X coordinate to print the string.
+  @param  PointY       A Y coordinate to print the string.
+  @param  ForeGround   The foreground color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL,
+                       then the foreground color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  BackGround   The background color of the string being printed.  This is
+                       an optional parameter that may be NULL.  If it is NULL, 
+                       then the background color of the current ConOut device
+                       in the EFI_SYSTEM_TABLE is used.
+  @param  Format       A Null-terminated ASCII format string.  See Print Library 
+                       for the supported format string syntax.
+  @param  ...          Variable argument list whose contents are accessed based on 
+                       the format string specified by Format.         
+
+  @return  The number of ASCII characters printed.
+
+**/
+UINTN
+EFIAPI
+AsciiPrintXY (
+  IN UINTN                            PointX,
+  IN UINTN                            PointY,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *ForeGround, OPTIONAL
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *BackGround, OPTIONAL
+  IN CONST CHAR8                      *Format,
+  ...
+  )
+{
+  VA_LIST                             Marker;
+  CHAR16                              *Buffer;
+  UINTN                               BufferSize;
+  UINTN                               PrintNum;
+  UINTN                               ReturnNum;
+
+  ASSERT (Format != NULL);
+
+  VA_START (Marker, Format);
+
+  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
+
+  Buffer = (CHAR16 *) AllocatePool (BufferSize);
+  ASSERT (Buffer != NULL);
+
+  PrintNum = UnicodeSPrintAsciiFormat (Buffer, BufferSize, Format, Marker);
+
+  VA_END (Marker);
+
+  ReturnNum = InternalPrintGraphic (PointX, PointY, ForeGround, BackGround, Buffer, PrintNum);
+
+  FreePool (Buffer);
+
+  return ReturnNum;
+}
+
+/** 
+  Appends a formatted Unicode string to a Null-terminated Unicode string
+ 
+  This function appends a formatted Unicode string to the Null-terminated 
+  Unicode string specified by String.   String is optional and may be NULL.
+  Storage for the formatted Unicode string returned is allocated using 
+  AllocatePool().  The pointer to the appended string is returned.  The caller
+  is responsible for freeing the returned string.
+ 
+  If String is not NULL and not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is NULL, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  @param[in] String         A Null-terminated Unicode string.
+  @param[in] FormatString   A Null-terminated Unicode format string.
+  @param[in]  Marker        VA_LIST marker for the variable argument list.
+
+  @retval NULL    There was not enough available memory.
+  @return         Null-terminated Unicode string is that is the formatted 
+                  string appended to String.
+**/
+CHAR16*
+EFIAPI
+CatVSPrint (
+  IN  CHAR16  *String, OPTIONAL
+  IN  CONST CHAR16  *FormatString,
+  IN  VA_LIST       Marker
+  )
+{
+  UINTN   CharactersRequired;
+  UINTN   SizeRequired;
+  CHAR16  *BufferToReturn;
+  VA_LIST ExtraMarker;
+
+  VA_COPY (ExtraMarker, Marker);
+  CharactersRequired = SPrintLength(FormatString, ExtraMarker);
+  VA_END (ExtraMarker);
+
+  if (String != NULL) {
+    SizeRequired = StrSize(String) + (CharactersRequired * sizeof(CHAR16));
+  } else {
+    SizeRequired = sizeof(CHAR16) + (CharactersRequired * sizeof(CHAR16));
+  }
+
+  BufferToReturn = AllocatePool(SizeRequired);
+
+  if (BufferToReturn == NULL) {
+    return NULL;
+  } else {
+    BufferToReturn[0] = L'\0';
+  }
+
+  if (String != NULL) {
+    StrCpyS(BufferToReturn, SizeRequired / sizeof(CHAR16), String);
+  }
+
+  UnicodeVSPrint(BufferToReturn + StrLen(BufferToReturn), (CharactersRequired+1) * sizeof(CHAR16), FormatString, Marker);
+
+  ASSERT(StrSize(BufferToReturn)==SizeRequired);
+
+  return (BufferToReturn);
+}
+
+/** 
+  Appends a formatted Unicode string to a Null-terminated Unicode string
+ 
+  This function appends a formatted Unicode string to the Null-terminated 
+  Unicode string specified by String.   String is optional and may be NULL.
+  Storage for the formatted Unicode string returned is allocated using 
+  AllocatePool().  The pointer to the appended string is returned.  The caller
+  is responsible for freeing the returned string.
+ 
+  If String is not NULL and not aligned on a 16-bit boundary, then ASSERT().
+  If FormatString is NULL, then ASSERT().
+  If FormatString is not aligned on a 16-bit boundary, then ASSERT().
+ 
+  @param[in] String         A Null-terminated Unicode string.
+  @param[in] FormatString   A Null-terminated Unicode format string.
+  @param[in] ...            The variable argument list whose contents are 
+                            accessed based on the format string specified by 
+                            FormatString.
+
+  @retval NULL    There was not enough available memory.
+  @return         Null-terminated Unicode string is that is the formatted 
+                  string appended to String.
+**/
+CHAR16 *
+EFIAPI
+CatSPrint (
+  IN  CHAR16  *String, OPTIONAL
+  IN  CONST CHAR16  *FormatString,
+  ...
+  )
+{
+  VA_LIST   Marker;
+  CHAR16    *NewString;
+
+  VA_START (Marker, FormatString);
+  NewString = CatVSPrint(String, FormatString, Marker);
+  VA_END (Marker);
+  return NewString;
+}
+
diff --git a/MdePkg/Library/UefiLib/UefiNotTiano.c b/MdePkg/Library/UefiLib/UefiNotTiano.c
new file mode 100644
index 000000000000..680d7f91cb9b
--- /dev/null
+++ b/MdePkg/Library/UefiLib/UefiNotTiano.c
@@ -0,0 +1,336 @@
+/** @file
+  Library functions that abstract areas of conflict between framework and UEFI 2.0.
+
+  Help Port Framework code that has conflicts with UEFI 2.0 by hiding the
+  old conflicts with library functions and supporting implementations of the old
+  (EDK/EFI 1.10) and new (EDK II/UEFI 2.0) way. This module is a DXE driver as
+  it contains DXE enum extensions for EFI event services.
+
+Copyright (c) 2006 - 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 "UefiLibInternal.h"
+
+/**
+  Creates an EFI event in the Legacy Boot Event Group.
+
+  Prior to UEFI 2.0 this was done via a non blessed UEFI extensions and this library
+  abstracts the implementation mechanism of this event from the caller. This function
+  abstracts the creation of the Legacy Boot Event. The Framework moved from a proprietary
+  to UEFI 2.0 based mechanism.  This library abstracts the caller from how this event
+  is created to prevent to code form having to change with the version of the
+  specification supported.
+  If LegacyBootEvent is NULL, then ASSERT().
+
+  @param  LegacyBootEvent   Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       Event was created.
+  @retval Other             Event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventLegacyBoot (
+  OUT EFI_EVENT  *LegacyBootEvent
+  )
+{
+  return EfiCreateEventLegacyBootEx (
+           TPL_CALLBACK,
+           EfiEventEmptyFunction,
+           NULL,
+           LegacyBootEvent
+           );
+}
+
+/**
+  Create an EFI event in the Legacy Boot Event Group and allows
+  the caller to specify a notification function.  
+  
+  This function abstracts the creation of the Legacy Boot Event.
+  The Framework moved from a proprietary to UEFI 2.0 based mechanism.
+  This library abstracts the caller from how this event is created to prevent
+  to code form having to change with the version of the specification supported.
+  If LegacyBootEvent is NULL, then ASSERT().
+
+  @param  NotifyTpl         The task priority level of the event.
+  @param  NotifyFunction    The notification function to call when the event is signaled.
+  @param  NotifyContext     The content to pass to NotifyFunction when the event is signaled.
+  @param  LegacyBootEvent   Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       Event was created.
+  @retval Other             Event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventLegacyBootEx (
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,  OPTIONAL
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT EFI_EVENT         *LegacyBootEvent
+  )
+{
+  EFI_STATUS        Status;
+  EFI_EVENT_NOTIFY  WorkerNotifyFunction;
+
+  ASSERT (LegacyBootEvent != NULL);
+
+  if (gST->Hdr.Revision < EFI_2_00_SYSTEM_TABLE_REVISION) {
+    DEBUG ((EFI_D_ERROR, "EFI1.1 can't support LegacyBootEvent!"));
+    ASSERT (FALSE);
+
+    return EFI_UNSUPPORTED;
+  } else {
+    //
+    // For UEFI 2.0 and the future use an Event Group
+    //
+    if (NotifyFunction == NULL) {
+      //
+      // CreateEventEx will check NotifyFunction is NULL or not and return error.
+      // Use dummy routine for the case NotifyFunction is NULL.
+      //
+      WorkerNotifyFunction = EfiEventEmptyFunction;
+    } else {
+      WorkerNotifyFunction = NotifyFunction;
+    }
+    Status = gBS->CreateEventEx (
+                    EVT_NOTIFY_SIGNAL,
+                    NotifyTpl,
+                    WorkerNotifyFunction,
+                    NotifyContext,
+                    &gEfiEventLegacyBootGuid,
+                    LegacyBootEvent
+                    );
+  }
+
+  return Status;
+}
+
+/**
+  Create an EFI event in the Ready To Boot Event Group.
+
+  Prior to UEFI 2.0 this was done via a non-standard UEFI extension, and this library
+  abstracts the implementation mechanism of this event from the caller.   
+  This function abstracts the creation of the Ready to Boot Event.  The Framework 
+  moved from a proprietary to UEFI 2.0-based mechanism.  This library abstracts 
+  the caller from how this event is created to prevent the code form having to 
+  change with the version of the specification supported.
+  If ReadyToBootEvent is NULL, then ASSERT().
+
+  @param  ReadyToBootEvent  Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       Event was created.
+  @retval Other             Event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventReadyToBoot (
+  OUT EFI_EVENT  *ReadyToBootEvent
+  )
+{
+  return EfiCreateEventReadyToBootEx (
+           TPL_CALLBACK,
+           EfiEventEmptyFunction,
+           NULL,
+           ReadyToBootEvent
+           );
+}
+
+/**
+  Create an EFI event in the Ready To Boot Event Group and allows
+  the caller to specify a notification function.  
+  
+  This function abstracts the creation of the Ready to Boot Event.
+  The Framework moved from a proprietary to UEFI 2.0 based mechanism.
+  This library abstracts the caller from how this event is created to prevent
+  to code form having to change with the version of the specification supported.
+  If ReadyToBootEvent is NULL, then ASSERT().
+
+  @param  NotifyTpl         The task priority level of the event.
+  @param  NotifyFunction    The notification function to call when the event is signaled.
+  @param  NotifyContext     The content to pass to NotifyFunction when the event is signaled.
+  @param  ReadyToBootEvent  Returns the EFI event returned from gBS->CreateEvent(Ex).
+
+  @retval EFI_SUCCESS       Event was created.
+  @retval Other             Event was not created.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiCreateEventReadyToBootEx (
+  IN  EFI_TPL           NotifyTpl,
+  IN  EFI_EVENT_NOTIFY  NotifyFunction,  OPTIONAL
+  IN  VOID              *NotifyContext,  OPTIONAL
+  OUT EFI_EVENT         *ReadyToBootEvent
+  )
+{
+  EFI_STATUS        Status;
+  EFI_EVENT_NOTIFY  WorkerNotifyFunction;
+
+  ASSERT (ReadyToBootEvent != NULL);
+
+  if (gST->Hdr.Revision < EFI_2_00_SYSTEM_TABLE_REVISION) {
+    DEBUG ((EFI_D_ERROR, "EFI1.1 can't support ReadyToBootEvent!"));
+    ASSERT (FALSE);
+
+    return EFI_UNSUPPORTED;
+  } else {
+    //
+    // For UEFI 2.0 and the future use an Event Group
+    //
+    if (NotifyFunction == NULL) {
+      //
+      // CreateEventEx will check NotifyFunction is NULL or not and return error.
+      // Use dummy routine for the case NotifyFunction is NULL.
+      //
+      WorkerNotifyFunction = EfiEventEmptyFunction;
+    } else {
+      WorkerNotifyFunction = NotifyFunction;
+    }
+    Status = gBS->CreateEventEx (
+                    EVT_NOTIFY_SIGNAL,
+                    NotifyTpl,
+                    WorkerNotifyFunction,
+                    NotifyContext,
+                    &gEfiEventReadyToBootGuid,
+                    ReadyToBootEvent
+                    );
+  }
+
+  return Status;
+}
+
+
+/**
+  Create, Signal, and Close the Ready to Boot event using EfiSignalEventReadyToBoot().
+  
+  This function abstracts the signaling of the Ready to Boot Event. The Framework moved
+  from a proprietary to UEFI 2.0 based mechanism. This library abstracts the caller
+  from how this event is created to prevent to code form having to change with the
+  version of the specification supported.
+
+**/
+VOID
+EFIAPI
+EfiSignalEventReadyToBoot (
+  VOID
+  )
+{
+  EFI_STATUS    Status;
+  EFI_EVENT     ReadyToBootEvent;
+
+  Status = EfiCreateEventReadyToBoot (&ReadyToBootEvent);
+  if (!EFI_ERROR (Status)) {
+    gBS->SignalEvent (ReadyToBootEvent);
+    gBS->CloseEvent (ReadyToBootEvent);
+  }
+}
+
+/**
+  Create, Signal, and Close the Ready to Boot event using EfiSignalEventLegacyBoot().
+
+  This function abstracts the signaling of the Legacy Boot Event. The Framework moved from
+  a proprietary to UEFI 2.0 based mechanism.  This library abstracts the caller from how
+  this event is created to prevent to code form having to change with the version of the
+  specification supported.
+
+**/
+VOID
+EFIAPI
+EfiSignalEventLegacyBoot (
+  VOID
+  )
+{
+  EFI_STATUS    Status;
+  EFI_EVENT     LegacyBootEvent;
+
+  Status = EfiCreateEventLegacyBoot (&LegacyBootEvent);
+  if (!EFI_ERROR (Status)) {
+    gBS->SignalEvent (LegacyBootEvent);
+    gBS->CloseEvent (LegacyBootEvent);
+  }
+}
+
+
+/**
+  Check to see if the Firmware Volume (FV) Media Device Path is valid 
+  
+  The Framework FwVol Device Path changed to conform to the UEFI 2.0 specification.  
+  This library function abstracts validating a device path node.
+  Check the MEDIA_FW_VOL_FILEPATH_DEVICE_PATH data structure to see if it's valid.  
+  If it is valid, then return the GUID file name from the device path node.  Otherwise, 
+  return NULL.  This device path changed in the DXE CIS version 0.92 in a non back ward 
+  compatible way to not conflict with the UEFI 2.0 specification.  This function abstracts 
+  the differences from the caller.
+  If FvDevicePathNode is NULL, then ASSERT().
+
+  @param  FvDevicePathNode  The pointer to FV device path to check.
+
+  @retval NULL              FvDevicePathNode is not valid.
+  @retval Other             FvDevicePathNode is valid and pointer to NameGuid was returned.
+
+**/
+EFI_GUID *
+EFIAPI
+EfiGetNameGuidFromFwVolDevicePathNode (
+  IN CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvDevicePathNode
+  )
+{
+  ASSERT (FvDevicePathNode != NULL);
+
+  if (DevicePathType (&FvDevicePathNode->Header) == MEDIA_DEVICE_PATH &&
+      DevicePathSubType (&FvDevicePathNode->Header) == MEDIA_PIWG_FW_FILE_DP) {
+    return (EFI_GUID *) &FvDevicePathNode->FvFileName;
+  }
+
+  return NULL;
+}
+
+
+/**
+  Initialize a Firmware Volume (FV) Media Device Path node.
+  
+  The Framework FwVol Device Path changed to conform to the UEFI 2.0 specification.  
+  This library function abstracts initializing a device path node.  
+  Initialize the MEDIA_FW_VOL_FILEPATH_DEVICE_PATH data structure.  This device 
+  path changed in the DXE CIS version 0.92 in a non back ward compatible way to 
+  not conflict with the UEFI 2.0 specification.  This function abstracts the 
+  differences from the caller.
+  If FvDevicePathNode is NULL, then ASSERT().
+  If NameGuid is NULL, then ASSERT().
+  
+  @param  FvDevicePathNode  The pointer to a FV device path node to initialize
+  @param  NameGuid          FV file name to use in FvDevicePathNode
+
+**/
+VOID
+EFIAPI
+EfiInitializeFwVolDevicepathNode (
+  IN OUT MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *FvDevicePathNode,
+  IN CONST EFI_GUID                         *NameGuid
+  )
+{
+  ASSERT (FvDevicePathNode != NULL);
+  ASSERT (NameGuid          != NULL);
+
+  //
+  // Use the new Device path that does not conflict with the UEFI
+  //
+  FvDevicePathNode->Header.Type     = MEDIA_DEVICE_PATH;
+  FvDevicePathNode->Header.SubType  = MEDIA_PIWG_FW_FILE_DP;
+  SetDevicePathNodeLength (&FvDevicePathNode->Header, sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH));
+
+  CopyGuid (&FvDevicePathNode->FvFileName, NameGuid);
+}
+
diff --git a/MdePkg/Library/UefiMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/UefiMemoryAllocationLib/MemoryAllocationLib.c
new file mode 100644
index 000000000000..ef7d92887f22
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryAllocationLib/MemoryAllocationLib.c
@@ -0,0 +1,821 @@
+/** @file
+  Support routines for memory allocation routines based 
+  on boot services for Dxe phase drivers.
+
+  Copyright (c) 2006 - 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 <Uefi.h>
+
+
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Allocates one or more 4KB pages of a certain memory type.
+
+  Allocates the number of 4KB pages of a certain memory type and returns a pointer to the allocated
+  buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL is returned.
+  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory; 
+
+  if (Pages == 0) {
+    return NULL;
+  }
+
+  Status = gBS->AllocatePages (AllocateAnyPages, MemoryType, Pages, &Memory);
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+  return (VOID *) (UINTN) Memory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData.
+
+  Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiBootServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
+
+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiRuntimeServicesData, Pages);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType.
+
+  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a pointer to the
+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
+  returned.
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPages (
+  IN UINTN  Pages
+  )
+{
+  return InternalAllocatePages (EfiReservedMemoryType, Pages);
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the page allocation
+  functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will
+  perform no actions.
+  
+  If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
+  then ASSERT().
+  If Pages is zero, then ASSERT().
+ 
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreePages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (Pages != 0);
+  Status = gBS->FreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Allocates one or more 4KB pages of a certain memory type at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of a certain memory type with an alignment
+  specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is returned.
+  If there is not enough memory at the specified alignment remaining to satisfy the request, then
+  NULL is returned.
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateAlignedPages (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            Pages,
+  IN UINTN            Alignment
+  )
+{
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory;
+  UINTN                 AlignedMemory;
+  UINTN                 AlignmentMask;
+  UINTN                 UnalignedPages;
+  UINTN                 RealPages;
+
+  //
+  // Alignment must be a power of two or zero.
+  //
+  ASSERT ((Alignment & (Alignment - 1)) == 0);
+ 
+  if (Pages == 0) {
+    return NULL;
+  }
+  if (Alignment > EFI_PAGE_SIZE) {
+    //
+    // Calculate the total number of pages since alignment is larger than page size.
+    //
+    AlignmentMask  = Alignment - 1;
+    RealPages      = Pages + EFI_SIZE_TO_PAGES (Alignment);
+    //
+    // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
+    //
+    ASSERT (RealPages > Pages);
+ 
+    Status         = gBS->AllocatePages (AllocateAnyPages, MemoryType, RealPages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
+    }
+    AlignedMemory  = ((UINTN) Memory + AlignmentMask) & ~AlignmentMask;
+    UnalignedPages = EFI_SIZE_TO_PAGES (AlignedMemory - (UINTN) Memory);
+    if (UnalignedPages > 0) {
+      //
+      // Free first unaligned page(s).
+      //
+      Status = gBS->FreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
+    Memory         = AlignedMemory + EFI_PAGES_TO_SIZE (Pages);
+    UnalignedPages = RealPages - Pages - UnalignedPages;
+    if (UnalignedPages > 0) {
+      //
+      // Free last unaligned page(s).
+      //
+      Status = gBS->FreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
+  } else {
+    //
+    // Do not over-allocate pages in this case.
+    //
+    Status = gBS->AllocatePages (AllocateAnyPages, MemoryType, Pages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
+    }
+    AlignedMemory  = (UINTN) Memory;
+  }
+  return (VOID *) AlignedMemory;
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiBootServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedRuntimePages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiRuntimeServicesData, Pages, Alignment);
+}
+
+/**
+  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
+
+  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType with an
+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
+  request, then NULL is returned.
+  
+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
+  If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
+
+  @param  Pages                 The number of 4 KB pages to allocate.
+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
+                                If Alignment is zero, then byte alignment is used.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateAlignedReservedPages (
+  IN UINTN  Pages,
+  IN UINTN  Alignment
+  )
+{
+  return InternalAllocateAlignedPages (EfiReservedMemoryType, Pages, Alignment);
+}
+
+/**
+  Frees one or more 4KB pages that were previously allocated with one of the aligned page
+  allocation functions in the Memory Allocation Library.
+
+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
+  must have been allocated on a previous call to the aligned page allocation services of the Memory
+  Allocation Library.  If it is not possible to free allocated pages, then this function will 
+  perform no actions.
+  
+  If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
+  Library, then ASSERT().
+  If Pages is zero, then ASSERT().
+  
+  @param  Buffer                The pointer to the buffer of pages to free.
+  @param  Pages                 The number of 4 KB pages to free.
+
+**/
+VOID
+EFIAPI
+FreeAlignedPages (
+  IN VOID   *Buffer,
+  IN UINTN  Pages
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (Pages != 0);
+  Status = gBS->FreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  ASSERT_EFI_ERROR (Status);
+}
+
+/**
+  Allocates a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type and returns a
+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  MemoryType            The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocatePool (
+  IN EFI_MEMORY_TYPE  MemoryType,  
+  IN UINTN            AllocationSize
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *Memory;
+
+  Status = gBS->AllocatePool (MemoryType, AllocationSize, &Memory);
+  if (EFI_ERROR (Status)) {
+    Memory = NULL;
+  }
+  return Memory;
+}
+
+/**
+  Allocates a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocatePool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiBootServicesData, AllocationSize);
+}
+
+/**
+  Allocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimePool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType and returns
+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocatePool (EfiReservedMemoryType, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, clears the buffer
+  with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a valid
+  buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the request,
+  then NULL is returned.
+
+  @param  PoolType              The type of memory to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateZeroPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize
+  ) 
+{
+  VOID  *Memory;
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+    Memory = ZeroMem (Memory, AllocationSize);
+  }
+  return Memory;
+}
+
+/**
+  Allocates and zeros a buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiBootServicesData, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiRuntimeServicesData, AllocationSize);
+}
+
+/**
+  Allocates and zeros a buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, clears the
+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
+  request, then NULL is returned.
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedZeroPool (
+  IN UINTN  AllocationSize
+  )
+{
+  return InternalAllocateZeroPool (EfiReservedMemoryType, AllocationSize);
+}
+
+/**
+  Copies a buffer to an allocated buffer of a certain pool type.
+
+  Allocates the number bytes specified by AllocationSize of a certain pool type, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  PoolType              The type of pool to allocate.
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalAllocateCopyPool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            AllocationSize,
+  IN CONST VOID       *Buffer
+  ) 
+{
+  VOID  *Memory;
+
+  ASSERT (Buffer != NULL);
+  ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
+
+  Memory = InternalAllocatePool (PoolType, AllocationSize);
+  if (Memory != NULL) {
+     Memory = CopyMem (Memory, Buffer, AllocationSize);
+  }
+  return Memory;
+} 
+
+/**
+  Copies a buffer to an allocated buffer of type EfiBootServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiBootServicesData, AllocationSize, Buffer);
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
+
+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateRuntimeCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer);
+}
+
+/**
+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
+
+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, copies
+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
+  is not enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If Buffer is NULL, then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). 
+
+  @param  AllocationSize        The number of bytes to allocate and zero.
+  @param  Buffer                The buffer to copy to the allocated buffer.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+AllocateReservedCopyPool (
+  IN UINTN       AllocationSize,
+  IN CONST VOID  *Buffer
+  )
+{
+  return InternalAllocateCopyPool (EfiReservedMemoryType, AllocationSize, Buffer);
+}
+
+/**
+  Reallocates a buffer of a specified memory type.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of the type
+  specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  PoolType       The type of pool to allocate.
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+InternalReallocatePool (
+  IN EFI_MEMORY_TYPE  PoolType,  
+  IN UINTN            OldSize,
+  IN UINTN            NewSize,
+  IN VOID             *OldBuffer  OPTIONAL
+  )
+{
+  VOID  *NewBuffer;
+
+  NewBuffer = InternalAllocateZeroPool (PoolType, NewSize);
+  if (NewBuffer != NULL && OldBuffer != NULL) {
+    CopyMem (NewBuffer, OldBuffer, MIN (OldSize, NewSize));
+    FreePool (OldBuffer);
+  }
+  return NewBuffer;
+}
+
+/**
+  Reallocates a buffer of type EfiBootServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+  
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocatePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiBootServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiRuntimeServicesData.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateRuntimePool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiRuntimeServicesData, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Reallocates a buffer of type EfiReservedMemoryType.
+
+  Allocates and zeros the number bytes specified by NewSize from memory of type
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and 
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and 
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.  
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not 
+  enough memory remaining to satisfy the request, then NULL is returned.
+
+  If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
+  is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
+
+  @param  OldSize        The size, in bytes, of OldBuffer.
+  @param  NewSize        The size, in bytes, of the buffer to reallocate.
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional 
+                         parameter that may be NULL.
+
+  @return A pointer to the allocated buffer or NULL if allocation fails.
+
+**/
+VOID *
+EFIAPI
+ReallocateReservedPool (
+  IN UINTN  OldSize,
+  IN UINTN  NewSize,
+  IN VOID   *OldBuffer  OPTIONAL
+  )
+{
+  return InternalReallocatePool (EfiReservedMemoryType, OldSize, NewSize, OldBuffer);
+}
+
+/**
+  Frees a buffer that was previously allocated with one of the pool allocation functions in the
+  Memory Allocation Library.
+
+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
+  pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
+  resources, then this function will perform no actions.
+  
+  If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
+  then ASSERT().
+
+  @param  Buffer                The pointer to the buffer to free.
+
+**/
+VOID
+EFIAPI
+FreePool (
+  IN VOID   *Buffer
+  )
+{
+  EFI_STATUS    Status;
+
+  Status = gBS->FreePool (Buffer);
+  ASSERT_EFI_ERROR (Status);
+}
+
diff --git a/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf b/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
new file mode 100644
index 000000000000..b73d5617f9d0
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
@@ -0,0 +1,42 @@
+## @file
+# Instance of Memory Allocation Library using EFI Boot Services.
+#
+# Memory Allocation Library that uses EFI Boot Services to allocate
+#  and free memory.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiMemoryAllocationLib
+  MODULE_UNI_FILE                = UefiMemoryAllocationLib.uni
+  FILE_GUID                      = 4674739d-3195-4fb2-8094-ac1d22d00194
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = MemoryAllocationLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  MemoryAllocationLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseMemoryLib
+  UefiBootServicesTableLib
+
diff --git a/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.uni b/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.uni
new file mode 100644
index 000000000000..b97ef82823a7
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Memory Allocation Library using EFI Boot Services.
+//
+// Memory Allocation Library that uses EFI Boot Services to allocate
+// and free memory.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Memory Allocation Library using EFI Boot Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This Memory Allocation Library uses EFI Boot Services to allocate and free memory."
+
diff --git a/MdePkg/Library/UefiMemoryLib/CompareMemWrapper.c b/MdePkg/Library/UefiMemoryLib/CompareMemWrapper.c
new file mode 100644
index 000000000000..dc347f963813
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/CompareMemWrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  CompareMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Compares the contents of two buffers.
+
+  This function compares Length bytes of SourceBuffer to Length bytes of DestinationBuffer.
+  If all Length bytes of the two buffers are identical, then 0 is returned.  Otherwise, the
+  value returned is the first mismatched byte in SourceBuffer subtracted from the first
+  mismatched byte in DestinationBuffer.
+  
+  If Length > 0 and DestinationBuffer is NULL, then ASSERT().
+  If Length > 0 and SourceBuffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer The pointer to the destination buffer to compare.
+  @param  SourceBuffer      The pointer to the source buffer to compare.
+  @param  Length            The number of bytes to compare.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+                            
+**/
+INTN
+EFIAPI
+CompareMem (
+  IN CONST VOID  *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0 || DestinationBuffer == SourceBuffer) {
+    return 0;
+  }
+  ASSERT (DestinationBuffer != NULL);
+  ASSERT (SourceBuffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/CopyMemWrapper.c b/MdePkg/Library/UefiMemoryLib/CopyMemWrapper.c
new file mode 100644
index 000000000000..340fe76936eb
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/CopyMemWrapper.c
@@ -0,0 +1,63 @@
+/** @file
+  CopyMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function copies Length bytes from SourceBuffer to DestinationBuffer, and returns
+  DestinationBuffer.  The implementation must be reentrant, and it must handle the case
+  where SourceBuffer overlaps DestinationBuffer.
+  
+  If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+CopyMem (
+  OUT VOID       *DestinationBuffer,
+  IN CONST VOID  *SourceBuffer,
+  IN UINTN       Length
+  )
+{
+  if (Length == 0) {
+    return DestinationBuffer;
+  }
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)DestinationBuffer));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)SourceBuffer));
+
+  if (DestinationBuffer == SourceBuffer) {
+    return DestinationBuffer;
+  }
+  return InternalMemCopyMem (DestinationBuffer, SourceBuffer, Length);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/IsZeroBufferWrapper.c b/MdePkg/Library/UefiMemoryLib/IsZeroBufferWrapper.c
new file mode 100644
index 000000000000..078c924da153
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/IsZeroBufferWrapper.c
@@ -0,0 +1,54 @@
+/** @file
+  Implementation of IsZeroBuffer function.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2016, 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 "MemLibInternals.h"
+
+/**
+  Checks if the contents of a buffer are all zeros.
+
+  This function checks whether the contents of a buffer are all zeros. If the
+  contents are all zeros, return TRUE. Otherwise, return FALSE.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the buffer to be checked.
+  @param  Length      The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE        Contents of the buffer are all zeros.
+  @retval FALSE       Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  ASSERT (!(Buffer == NULL && Length > 0));
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  return InternalMemIsZeroBuffer (Buffer, Length);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/MemLib.c b/MdePkg/Library/UefiMemoryLib/MemLib.c
new file mode 100644
index 000000000000..84b853e9e2aa
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/MemLib.c
@@ -0,0 +1,63 @@
+/** @file
+  Base Memory Library functions implementation bases on Uefi Boot Service.
+
+  Copyright (c) 2006 - 2008, 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 "MemLibInternals.h"
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function wraps the gBS->CopyMem().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *Destination,
+  IN      CONST VOID                *Source,
+  IN      UINTN                     Length
+  )
+{
+  gBS->CopyMem (Destination, (VOID*)Source, Length);
+  return Destination;
+}
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function wraps the gBS->SetMem().
+
+  @param  Buffer    Memory to set.
+  @param  Size      The number of bytes to set.
+  @param  Value     Value of the set operation.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Size,
+  IN      UINT8                     Value
+  )
+{
+  gBS->SetMem (Buffer, Size, Value);
+  return Buffer;
+}
diff --git a/MdePkg/Library/UefiMemoryLib/MemLibGeneric.c b/MdePkg/Library/UefiMemoryLib/MemLibGeneric.c
new file mode 100644
index 000000000000..e4930462bb65
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/MemLibGeneric.c
@@ -0,0 +1,289 @@
+/** @file
+  Architecture Independent Base Memory Library Implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT16*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT32*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  for (; Length != 0; Length--) {
+    ((UINT64*)Buffer)[Length - 1] = Value;
+  }
+  return Buffer;
+}
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer Memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  )
+{
+  return InternalMemSetMem (Buffer, Length, 0);
+}
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer
+  @param  SourceBuffer      The second memory buffer
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  )
+{
+  while ((--Length != 0) &&
+         (*(INT8*)DestinationBuffer == *(INT8*)SourceBuffer)) {
+    DestinationBuffer = (INT8*)DestinationBuffer + 1;
+    SourceBuffer = (INT8*)SourceBuffer + 1;
+  }
+  return (INTN)*(UINT8*)DestinationBuffer - (INTN)*(UINT8*)SourceBuffer;
+}
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  )
+{
+  CONST UINT8                       *Pointer;
+
+  Pointer = (CONST UINT8*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  )
+{
+  CONST UINT16                      *Pointer;
+
+  Pointer = (CONST UINT16*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  )
+{
+  CONST UINT32                      *Pointer;
+
+  Pointer = (CONST UINT32*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  )
+{
+  CONST UINT64                      *Pointer;
+
+  Pointer = (CONST UINT64*)Buffer;
+  do {
+    if (*(Pointer++) == Value) {
+      return --Pointer;
+    }
+  } while (--Length != 0);
+  return NULL;
+}
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  )
+{
+  CONST UINT8 *BufferData;
+  UINTN       Index;
+
+  BufferData = Buffer;
+  for (Index = 0; Index < Length; Index++) {
+    if (BufferData[Index] != 0) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
diff --git a/MdePkg/Library/UefiMemoryLib/MemLibGuid.c b/MdePkg/Library/UefiMemoryLib/MemLibGuid.c
new file mode 100644
index 000000000000..4aab05d53b67
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/MemLibGuid.c
@@ -0,0 +1,171 @@
+/** @file
+  Implementation of GUID functions.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+  
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2016, 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 "MemLibInternals.h"
+
+/**
+  Copies a source GUID to a destination GUID.
+
+  This function copies the contents of the 128-bit GUID specified by SourceGuid to
+  DestinationGuid, and returns DestinationGuid.
+  
+  If DestinationGuid is NULL, then ASSERT().
+  If SourceGuid is NULL, then ASSERT().
+
+  @param  DestinationGuid   The pointer to the destination GUID.
+  @param  SourceGuid        The pointer to the source GUID.
+
+  @return DestinationGuid.
+
+**/
+GUID *
+EFIAPI
+CopyGuid (
+  OUT GUID       *DestinationGuid,
+  IN CONST GUID  *SourceGuid
+  )
+{
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid)
+    );
+  WriteUnaligned64 (
+    (UINT64*)DestinationGuid + 1,
+    ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
+    );
+  return DestinationGuid;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+  
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  IN CONST GUID  *Guid1,
+  IN CONST GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Scans a target buffer for a GUID, and returns a pointer to the matching GUID
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from
+  the lowest address to the highest address at 128-bit increments for the 128-bit
+  GUID value that matches Guid.  If a match is found, then a pointer to the matching
+  GUID in the target buffer is returned.  If no match is found, then NULL is returned.
+  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 128-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The number of bytes in Buffer to scan.
+  @param  Guid    The value to search for in the target buffer.
+
+  @return A pointer to the matching Guid in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanGuid (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN CONST GUID  *Guid
+  )
+{
+  CONST GUID                        *GuidPtr;
+
+  ASSERT (((UINTN)Buffer & (sizeof (Guid->Data1) - 1)) == 0);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  ASSERT ((Length & (sizeof (*GuidPtr) - 1)) == 0);
+
+  GuidPtr = (GUID*)Buffer;
+  Buffer  = GuidPtr + Length / sizeof (*GuidPtr);
+  while (GuidPtr < (CONST GUID*)Buffer) {
+    if (CompareGuid (GuidPtr, Guid)) {
+      return (VOID*)GuidPtr;
+    }
+    GuidPtr++;
+  }
+  return NULL;
+}
+
+/**
+  Checks if the given GUID is a zero GUID.
+
+  This function checks whether the given GUID is a zero GUID. If the GUID is
+  identical to a zero GUID then TRUE is returned. Otherwise, FALSE is returned.
+
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid        The pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid is a zero GUID.
+  @retval FALSE       Guid is not a zero GUID.
+
+**/
+BOOLEAN
+EFIAPI
+IsZeroGuid (
+  IN CONST GUID  *Guid
+  )
+{
+  UINT64  LowPartOfGuid;
+  UINT64  HighPartOfGuid;
+
+  LowPartOfGuid  = ReadUnaligned64 ((CONST UINT64*) Guid);
+  HighPartOfGuid = ReadUnaligned64 ((CONST UINT64*) Guid + 1);
+
+  return (BOOLEAN) (LowPartOfGuid == 0 && HighPartOfGuid == 0);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/MemLibInternals.h b/MdePkg/Library/UefiMemoryLib/MemLibInternals.h
new file mode 100644
index 000000000000..9aab2c1b95b5
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/MemLibInternals.h
@@ -0,0 +1,249 @@
+/** @file
+  Declaration of internal functions for Base Memory Library.
+
+  Copyright (c) 2006 - 2016, 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 __MEM_LIB_INTERNALS__
+#define __MEM_LIB_INTERNALS__
+
+#include <Uefi.h>
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+/**
+  Copies a source buffer to a destination buffer, and returns the destination buffer.
+
+  This function wraps the gBS->CopyMem().
+
+  @param  DestinationBuffer   The pointer to the destination buffer of the memory copy.
+  @param  SourceBuffer        The pointer to the source buffer of the memory copy.
+  @param  Length              The number of bytes to copy from SourceBuffer to DestinationBuffer.
+
+  @return DestinationBuffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemCopyMem (
+  OUT     VOID                      *Destination,
+  IN      CONST VOID                *Source,
+  IN      UINTN                     Length
+  );
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function wraps the gBS->SetMem().
+
+  @param  Buffer    Memory to set.
+  @param  Size      The number of bytes to set.
+  @param  Value     Value of the set operation.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Size,
+  IN      UINT8                     Value
+  );
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 16-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem16 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 32-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem32 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The count of 64-bit value to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemSetMem64 (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Set Buffer to 0 for Size bytes.
+
+  @param  Buffer The memory to set.
+  @param  Length The number of bytes to set
+
+  @return Buffer
+
+**/
+VOID *
+EFIAPI
+InternalMemZeroMem (
+  OUT     VOID                      *Buffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Compares two memory buffers of a given length.
+
+  @param  DestinationBuffer The first memory buffer
+  @param  SourceBuffer      The second memory buffer
+  @param  Length            The length of DestinationBuffer and SourceBuffer memory
+                            regions to compare. Must be non-zero.
+
+  @return 0                 All Length bytes of the two buffers are identical.
+  @retval Non-zero          The first mismatched byte in SourceBuffer subtracted from the first
+                            mismatched byte in DestinationBuffer.
+
+**/
+INTN
+EFIAPI
+InternalMemCompareMem (
+  IN      CONST VOID                *DestinationBuffer,
+  IN      CONST VOID                *SourceBuffer,
+  IN      UINTN                     Length
+  );
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the
+  matching 8-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 8-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem8 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT8                     Value
+  );
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the
+  matching 16-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 16-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem16 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT16                    Value
+  );
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the
+  matching 32-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 32-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem32 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT32                    Value
+  );
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the
+  matching 64-bit value in the target buffer.
+
+  @param  Buffer  The pointer to the target buffer to scan.
+  @param  Length  The count of 64-bit value to scan. Must be non-zero.
+  @param  Value   The value to search for in the target buffer.
+
+  @return The pointer to the first occurrence or NULL if not found.
+
+**/
+CONST VOID *
+EFIAPI
+InternalMemScanMem64 (
+  IN      CONST VOID                *Buffer,
+  IN      UINTN                     Length,
+  IN      UINT64                    Value
+  );
+
+/**
+  Checks whether the contents of a buffer are all zeros.
+
+  @param  Buffer  The pointer to the buffer to be checked.
+  @param  Length  The size of the buffer (in bytes) to be checked.
+
+  @retval TRUE    Contents of the buffer are all zeros.
+  @retval FALSE   Contents of the buffer are not all zeros.
+
+**/
+BOOLEAN
+EFIAPI
+InternalMemIsZeroBuffer (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length
+  );
+
+#endif
diff --git a/MdePkg/Library/UefiMemoryLib/ScanMem16Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem16Wrapper.c
new file mode 100644
index 000000000000..606338675fe9
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/ScanMem16Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 16-bit value, and returns a pointer to the matching 16-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 16-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem16 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT16      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/ScanMem32Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem32Wrapper.c
new file mode 100644
index 000000000000..e82fc5878761
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/ScanMem32Wrapper.c
@@ -0,0 +1,66 @@
+/** @file
+  ScanMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 32-bit value, and returns a pointer to the matching 32-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 32-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem32 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT32      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/ScanMem64Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem64Wrapper.c
new file mode 100644
index 000000000000..80af31a43cbc
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/ScanMem64Wrapper.c
@@ -0,0 +1,67 @@
+/** @file
+  ScanMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for a 64-bit value, and returns a pointer to the matching 64-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a 64-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem64 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT64      Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return (VOID*)InternalMemScanMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/ScanMem8Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem8Wrapper.c
new file mode 100644
index 000000000000..16ff60098286
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/ScanMem8Wrapper.c
@@ -0,0 +1,99 @@
+/** @file
+  ScanMem8() and ScanMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Scans a target buffer for an 8-bit value, and returns a pointer to the matching 8-bit value
+  in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for an 8-bit value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMem8 (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINT8       Value
+  )
+{
+  if (Length == 0) {
+    return NULL;
+  }
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+ 
+  return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
+}
+
+/**
+  Scans a target buffer for a UINTN sized value, and returns a pointer to the matching 
+  UINTN sized value in the target buffer.
+
+  This function searches the target buffer specified by Buffer and Length from the lowest
+  address to the highest address for a UINTN sized value that matches Value.  If a match is found,
+  then a pointer to the matching byte in the target buffer is returned.  If no match is found,
+  then NULL is returned.  If Length is 0, then NULL is returned.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to scan.
+  @param  Length      The number of bytes in Buffer to scan.
+  @param  Value       The value to search for in the target buffer.
+
+  @return A pointer to the matching byte in the target buffer or NULL otherwise.
+
+**/
+VOID *
+EFIAPI
+ScanMemN (
+  IN CONST VOID  *Buffer,
+  IN UINTN       Length,
+  IN UINTN       Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return ScanMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return ScanMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
+
diff --git a/MdePkg/Library/UefiMemoryLib/SetMem16Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem16Wrapper.c
new file mode 100644
index 000000000000..7001f29ae8e9
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/SetMem16Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem16() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 16-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 16-bit value specified by
+  Value, and returns Buffer. Value is repeated every 16-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 16-bit boundary, then ASSERT().
+  If Length is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem16 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT16  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem16 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/SetMem32Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem32Wrapper.c
new file mode 100644
index 000000000000..c51b846acf8a
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/SetMem32Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem32() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 32-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 32-bit value specified by
+  Value, and returns Buffer. Value is repeated every 32-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 32-bit boundary, then ASSERT().
+  If Length is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem32 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT32  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem32 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/SetMem64Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem64Wrapper.c
new file mode 100644
index 000000000000..f4128970d48a
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/SetMem64Wrapper.c
@@ -0,0 +1,64 @@
+/** @file
+  SetMem64() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a 64-bit value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the 64-bit value specified by
+  Value, and returns Buffer. Value is repeated every 64-bits in for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a 64-bit boundary, then ASSERT().
+  If Length is not aligned on a 64-bit boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem64 (
+  OUT VOID   *Buffer,
+  IN UINTN   Length,
+  IN UINT64  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+  ASSERT ((((UINTN)Buffer) & (sizeof (Value) - 1)) == 0);
+  ASSERT ((Length & (sizeof (Value) - 1)) == 0);
+
+  return InternalMemSetMem64 (Buffer, Length / sizeof (Value), Value);
+}
diff --git a/MdePkg/Library/UefiMemoryLib/SetMemWrapper.c b/MdePkg/Library/UefiMemoryLib/SetMemWrapper.c
new file mode 100644
index 000000000000..64f128881804
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/SetMemWrapper.c
@@ -0,0 +1,91 @@
+/** @file
+  SetMem() and SetMemN() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with a byte value, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with Value, and returns Buffer.
+  
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer    Memory to set.
+  @param  Length    The number of bytes to set.
+  @param  Value     The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINT8  Value
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
+
+  return InternalMemSetMem (Buffer, Length, Value);
+}
+
+/**
+  Fills a target buffer with a value that is size UINTN, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with the UINTN sized value specified by
+  Value, and returns Buffer. Value is repeated every sizeof(UINTN) bytes for Length
+  bytes of Buffer.
+
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Buffer is not aligned on a UINTN boundary, then ASSERT().
+  If Length is not aligned on a UINTN boundary, then ASSERT().
+
+  @param  Buffer  The pointer to the target buffer to fill.
+  @param  Length  The number of bytes in Buffer to fill.
+  @param  Value   The value with which to fill Length bytes of Buffer.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+SetMemN (
+  OUT VOID  *Buffer,
+  IN UINTN  Length,
+  IN UINTN  Value
+  )
+{
+  if (sizeof (UINTN) == sizeof (UINT64)) {
+    return SetMem64 (Buffer, Length, (UINT64)Value);
+  } else {
+    return SetMem32 (Buffer, Length, (UINT32)Value);
+  }
+}
diff --git a/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf b/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf
new file mode 100644
index 000000000000..780dd5c02561
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf
@@ -0,0 +1,60 @@
+## @file
+# Instance of Base Memory Library using EFI Boot Services.
+#
+# Base Memory Library implementation that uses EFI Boot Services
+#  where possible for size reduction.
+#
+# Copyright (c) 2006 - 2016, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiMemoryLib
+  MODULE_UNI_FILE                = UefiMemoryLib.uni
+  FILE_GUID                      = f1bbe03d-2f28-4dee-bec7-d98d7a30c36a
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = BaseMemoryLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  ScanMem64Wrapper.c
+  ScanMem32Wrapper.c
+  ScanMem16Wrapper.c
+  ScanMem8Wrapper.c
+  ZeroMemWrapper.c
+  CompareMemWrapper.c
+  SetMem64Wrapper.c
+  SetMem32Wrapper.c
+  SetMem16Wrapper.c
+  SetMemWrapper.c
+  CopyMemWrapper.c
+  IsZeroBufferWrapper.c
+  MemLibGeneric.c
+  MemLibGuid.c
+  MemLib.c
+  MemLibInternals.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  UefiBootServicesTableLib
+  DebugLib
+
diff --git a/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.uni b/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.uni
new file mode 100644
index 000000000000..8eb667ad61b8
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Instance of Base Memory Library using EFI Boot Services.
+//
+// Base Memory Library implementation that uses EFI Boot Services
+// where possible for size reduction.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of Base Memory Library using EFI Boot Services"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Base Memory Library implementation that uses EFI Boot Services where possible, for size reduction."
+
diff --git a/MdePkg/Library/UefiMemoryLib/ZeroMemWrapper.c b/MdePkg/Library/UefiMemoryLib/ZeroMemWrapper.c
new file mode 100644
index 000000000000..c6902cd2f055
--- /dev/null
+++ b/MdePkg/Library/UefiMemoryLib/ZeroMemWrapper.c
@@ -0,0 +1,56 @@
+/** @file
+  ZeroMem() implementation.
+
+  The following BaseMemoryLib instances contain the same copy of this file:
+
+    BaseMemoryLib
+    BaseMemoryLibMmx
+    BaseMemoryLibSse2
+    BaseMemoryLibRepStr
+    BaseMemoryLibOptDxe
+    BaseMemoryLibOptPei
+    PeiMemoryLib
+    UefiMemoryLib
+    
+  Copyright (c) 2006 - 2009, 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 "MemLibInternals.h"
+
+/**
+  Fills a target buffer with zeros, and returns the target buffer.
+
+  This function fills Length bytes of Buffer with zeros, and returns Buffer.
+  
+  If Length > 0 and Buffer is NULL, then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+
+  @param  Buffer      The pointer to the target buffer to fill with zeros.
+  @param  Length      The number of bytes in Buffer to fill with zeros.
+
+  @return Buffer.
+
+**/
+VOID *
+EFIAPI
+ZeroMem (
+  OUT VOID  *Buffer,
+  IN UINTN  Length
+  )
+{
+  if (Length == 0) {
+    return Buffer;
+  }
+
+  ASSERT (Buffer != NULL);
+  ASSERT (Length <= (MAX_ADDRESS - (UINTN)Buffer + 1));
+  return InternalMemZeroMem (Buffer, Length);
+}
diff --git a/MdePkg/Library/UefiPalLib/UefiPalLib.c b/MdePkg/Library/UefiPalLib/UefiPalLib.c
new file mode 100644
index 000000000000..c4c465a90393
--- /dev/null
+++ b/MdePkg/Library/UefiPalLib/UefiPalLib.c
@@ -0,0 +1,127 @@
+/** @file
+  PAL Library implementation retrieving the PAL Entry Point from the SAL System Table
+  register in the EFI System Confguration Table.
+
+  Copyright (c) 2007 - 2008, 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 <PiDxe.h>
+
+#include <IndustryStandard/Sal.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+
+#include <Guid/SalSystemTable.h>
+
+UINT64               mPalProcEntry;
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param Index  The PAL procedure Index number.
+  @param Arg2   The 2nd parameter for PAL procedure calls.
+  @param Arg3   The 3rd parameter for PAL procedure calls.
+  @param Arg4   The 4th parameter for PAL procedure calls.
+
+  @return Structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  )
+{
+  //
+  // mPalProcEntry is initialized in library constructor as PAL entry.
+  //
+  return AsmPalCall (
+           mPalProcEntry,
+           Index,
+           Arg2,
+           Arg3,
+           Arg4
+           );
+
+}
+
+/**
+  The constructor function of UEFI Pal Lib.
+
+  The constructor function looks up the SAL System Table in the EFI System Configuration
+  Table. Once the SAL System Table is found, the PAL Entry Point in the SAL System Table
+  will be derived and stored into a global variable for library usage.
+  It will ASSERT() if the SAL System Table cannot be found or the data in the SAL System
+  Table is not the valid data.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiPalLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                     Status;
+  SAL_ST_ENTRY_POINT_DESCRIPTOR  *SalStEntryDes;
+  SAL_SYSTEM_TABLE_HEADER        *SalSystemTable;
+
+  Status = EfiGetSystemConfigurationTable (
+             &gEfiSalSystemTableGuid,
+             (VOID **) &SalSystemTable
+             );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (SalSystemTable != NULL);
+
+  //
+  // Check the first entry of SAL System Table,
+  // because the SAL entry is in ascending order with the entry type,
+  // the type 0 entry should be the first if exist.
+  //
+  SalStEntryDes = (SAL_ST_ENTRY_POINT_DESCRIPTOR *)(SalSystemTable + 1);
+
+  //
+  // Assure the SAL ENTRY Type is 0
+  //
+  ASSERT (SalStEntryDes->Type == EFI_SAL_ST_ENTRY_POINT);
+
+  mPalProcEntry = SalStEntryDes->PalProcEntry;
+  //
+  // Make sure the PalCallAddress has the valid value
+  //
+  ASSERT (mPalProcEntry != 0);
+
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/UefiPalLib/UefiPalLib.inf b/MdePkg/Library/UefiPalLib/UefiPalLib.inf
new file mode 100644
index 000000000000..d0d7a46abb57
--- /dev/null
+++ b/MdePkg/Library/UefiPalLib/UefiPalLib.inf
@@ -0,0 +1,49 @@
+## @file
+# UEFI Instance of PAL Library Class.
+#
+# This instance of PAL library retrieves the PAL Entry Point from the SAL System Table
+# register in the EFI System Confguration Table.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiPalLib
+  MODULE_UNI_FILE                = UefiPalLib.uni
+  FILE_GUID                      = B7F30170-9E5F-482a-B553-A145A5787003
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PalLib|UEFI_DRIVER UEFI_APPLICATION
+
+  CONSTRUCTOR                    = UefiPalLibConstructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  UefiPalLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiLib
+  BaseLib
+  DebugLib
+
+[Guids]
+  gEfiSalSystemTableGuid        ## CONSUMES ## SystemTable
+
diff --git a/MdePkg/Library/UefiPalLib/UefiPalLib.uni b/MdePkg/Library/UefiPalLib/UefiPalLib.uni
new file mode 100644
index 000000000000..3aadb55878ef
--- /dev/null
+++ b/MdePkg/Library/UefiPalLib/UefiPalLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// UEFI Instance of PAL Library Class.
+//
+// This instance of PAL library retrieves the PAL Entry Point from the SAL System Table
+// register in the EFI System Confguration Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI Instance of PAL Library Class"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This instance of PAL library retrieves the PAL Entry Point from the SAL System Table register in the EFI System Configuration Table."
+
diff --git a/MdePkg/Library/UefiPciLibPciRootBridgeIo/PciLib.c b/MdePkg/Library/UefiPciLibPciRootBridgeIo/PciLib.c
new file mode 100644
index 000000000000..a3c4186eaa35
--- /dev/null
+++ b/MdePkg/Library/UefiPciLibPciRootBridgeIo/PciLib.c
@@ -0,0 +1,1436 @@
+/** @file
+  PCI Library using PCI Root Bridge I/O Protocol.
+
+  Copyright (c) 2007 - 2012, 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 <PiDxe.h>
+
+#include <Protocol/PciRootBridgeIo.h>
+
+#include <Library/PciLib.h>
+#include <Library/BaseLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  Assert the validity of a PCI address. A valid PCI address should contain 1's
+  only in the low 28 bits.
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_ADDRESS(A,M) \
+  ASSERT (((A) & (~0xfffffff | (M))) == 0)
+
+/**
+  Translate PCI Lib address into format of PCI Root Bridge I/O Protocol.
+
+  @param  A  The address that encodes the PCI Bus, Device, Function and
+             Register.
+
+**/
+#define PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS(A) \
+  ((((A) << 4) & 0xff000000) | (((A) >> 4) & 0x00000700) | (((A) << 1) & 0x001f0000) | (LShiftU64((A) & 0xfff, 32)))
+
+//
+// Global varible to cache pointer to PCI Root Bridge I/O protocol.
+//
+EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL      *mPciRootBridgeIo = NULL; 
+
+/**
+  The constructor function caches the pointer to PCI Root Bridge I/O protocol.
+  
+  The constructor function locates PCI Root Bridge I/O protocol from protocol database.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+PciLibConstructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+  
+  Status = gBS->LocateProtocol (&gEfiPciRootBridgeIoProtocolGuid, NULL, (VOID**) &mPciRootBridgeIo);
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (mPciRootBridgeIo != NULL);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Read() service.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+DxePciLibPciRootBridgeIoReadWorker (
+  IN    UINTN                                  Address,
+  IN    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width
+  )
+{
+  UINT32  Data;
+
+  mPciRootBridgeIo->Pci.Read (
+                          mPciRootBridgeIo,
+                          Width,
+                          PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                          1,
+                          &Data
+                          );
+
+  return Data;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Write() service.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specified by Width.
+  Data is returned.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   The width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+DxePciLibPciRootBridgeIoWriteWorker (
+  IN    UINTN                                  Address,
+  IN    EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width,
+  IN    UINT32                                 Data
+  )
+{
+  mPciRootBridgeIo->Pci.Write (
+                          mPciRootBridgeIo,
+                          Width,
+                          PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                          1,
+                          &Data
+                          );
+  return Data;
+}
+
+/**
+  Registers a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  Registers the PCI device specified by Address so all the PCI configuration registers 
+  associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
+  
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciRead8 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint8);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciWrite8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint8, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with
+  an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAnd8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (Address, (UINT8) (PciRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit
+  value, followed a  bitwise OR with another 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (Address, (UINT8) ((PciRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldRead8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldWrite8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     Value
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldWrite8 (PciRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldOr8 (PciRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAnd8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAnd8 (PciRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciBitFieldAndThenOr8 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT8                     AndData,
+  IN      UINT8                     OrData
+  )
+{
+  return PciWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciRead16 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint16);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciWrite16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint16, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAnd16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (Address, (UINT16) (PciRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit
+  value, followed a  bitwise OR with another 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (Address, (UINT16) ((PciRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldRead16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldWrite16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    Value
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldWrite16 (PciRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldOr16 (PciRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 16-bit register.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 16-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAnd16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAnd16 (PciRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciBitFieldAndThenOr16 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT16                    AndData,
+  IN      UINT16                    OrData
+  )
+{
+  return PciWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+
+  @return The read value from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciRead32 (
+  IN      UINTN                     Address
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return DxePciLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint32);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the
+  value specified by Value. Value is returned. This function must guarantee
+  that all PCI read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Value   The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciWrite32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_ADDRESS (Address, 3);
+
+  return DxePciLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint32, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with
+  a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAnd32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (Address, PciRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit
+  value, followed a  bitwise OR with another 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and
+  the value specified by OrData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  AndData The value to AND with the PCI configuration register.
+  @param  OrData  The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (Address, (PciRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldRead32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldWrite32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    Value
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldWrite32 (PciRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldOr32 (PciRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 32-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAnd32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAnd32 (PciRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If Address > 0x0FFFFFFF, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciBitFieldAndThenOr32 (
+  IN      UINTN                     Address,
+  IN      UINTN                     StartBit,
+  IN      UINTN                     EndBit,
+  IN      UINT32                    AndData,
+  IN      UINT32                    OrData
+  )
+{
+  return PciWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciReadBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  OUT     VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If StartAddress > 0x0FFFFFFF, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return Size written to StartAddress.
+
+**/
+UINTN
+EFIAPI
+PciWriteBuffer (
+  IN      UINTN                     StartAddress,
+  IN      UINTN                     Size,
+  IN      VOID                      *Buffer
+  )
+{
+  UINTN                             ReturnValue;
+
+  ASSERT_INVALID_PCI_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.inf b/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.inf
new file mode 100644
index 000000000000..7ab27f5693e5
--- /dev/null
+++ b/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.inf
@@ -0,0 +1,57 @@
+## @file
+# PCI Library that layers on top of the PCI Root Bridge I/O Protocol.
+#
+# This library produces the APIs from the PCI Library and implements these APIs
+#  by calling into the PCI Root Bridge I/O Protocol. The PCI Root Bridge I/O Protocol is
+#  typically produced by a chipset specific DXE driver.
+#  This library binds to the first PCI Root Bridge I/O Protocol in the platform. As a result,
+#  it should only be used on platforms that contain a single PCI root bridge.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiPciLibPciRootBridgeIo
+  MODULE_UNI_FILE                = UefiPciLibPciRootBridgeIo.uni
+  FILE_GUID                      = 90EC42CB-B780-4eb8-8E99-C8E3E5F37530
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION
+
+  CONSTRUCTOR                    = PciLibConstructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseLib
+  UefiBootServicesTableLib
+  DebugLib
+
+[Protocols]
+  gEfiPciRootBridgeIoProtocolGuid               ## CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiPciRootBridgeIoProtocolGuid
+
diff --git a/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.uni b/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.uni
new file mode 100644
index 000000000000..b5498a83276d
--- /dev/null
+++ b/MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.uni
@@ -0,0 +1,25 @@
+// /** @file
+// PCI Library that layers on top of the PCI Root Bridge I/O Protocol.
+//
+// This library produces the APIs from the PCI Library and implements these APIs
+// by calling into the PCI Root Bridge I/O Protocol. The PCI Root Bridge I/O Protocol is
+// typically produced by a chipset specific DXE driver.
+// This library binds to the first PCI Root Bridge I/O Protocol in the platform. As a result,
+// it should only be used on platforms that contain a single PCI root bridge.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "PCI Library that layers on top of the PCI Root Bridge I/O Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library produces the APIs from the PCI Library and implements these APIs by calling into the PCI Root Bridge I/O Protocol. The PCI Root Bridge I/O Protocol is typically produced by a chipset-specific DXE driver. This library binds to the first PCI Root Bridge I/O Protocol in the platform. As a result, it should only be used on platforms that contain a single PCI root bridge."
+
diff --git a/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.c b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.c
new file mode 100644
index 000000000000..3e4fd82228d5
--- /dev/null
+++ b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.c
@@ -0,0 +1,1487 @@
+/** @file
+  PCI Segment Library implementation using PCI Root Bridge I/O Protocol.
+
+  Copyright (c) 2007 - 2012, 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 "PciSegmentLib.h"
+
+//
+// Global variable to record data of PCI Root Bridge I/O Protocol instances
+//
+PCI_ROOT_BRIDGE_DATA   *mPciRootBridgeData     = NULL;
+UINTN                  mNumberOfPciRootBridges = 0;
+
+/**
+  The constructor function caches data of PCI Root Bridge I/O Protocol instances.
+  
+  The constructor function locates PCI Root Bridge I/O protocol instances,
+  and caches the protocol instances, together with their segment numbers and bus ranges.
+  It will ASSERT() if that related operation fails and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+PciSegmentLibConstructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  EFI_STATUS                           Status;
+  UINTN                                Index;
+  UINTN                                HandleCount;
+  EFI_HANDLE                           *HandleBuffer;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL      *PciRootBridgeIo; 
+  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR    *Descriptors;
+
+  HandleCount     = 0;
+  HandleBuffer    = NULL;
+  PciRootBridgeIo = NULL;
+  Descriptors     = NULL;
+
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiPciRootBridgeIoProtocolGuid,
+                  NULL,
+                  &HandleCount,
+                  &HandleBuffer
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  mNumberOfPciRootBridges = HandleCount;
+
+  mPciRootBridgeData = AllocatePool (HandleCount * sizeof (PCI_ROOT_BRIDGE_DATA));
+  ASSERT (mPciRootBridgeData != NULL);
+
+  //
+  // Traverse all PCI Root Bridge I/O Protocol instances, and record the protocol
+  // instances, together with their segment numbers and bus ranges.
+  //
+  for (Index = 0; Index < HandleCount; Index++) {
+    Status = gBS->HandleProtocol (
+                    HandleBuffer[Index],
+                    &gEfiPciRootBridgeIoProtocolGuid,
+                    (VOID **) &PciRootBridgeIo
+                    );
+    ASSERT_EFI_ERROR (Status);
+
+    mPciRootBridgeData[Index].PciRootBridgeIo = PciRootBridgeIo;
+    mPciRootBridgeData[Index].SegmentNumber   = PciRootBridgeIo->SegmentNumber;
+
+    Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Descriptors);
+    ASSERT_EFI_ERROR (Status);
+
+    while (Descriptors->Desc != ACPI_END_TAG_DESCRIPTOR) {
+      if (Descriptors->ResType == ACPI_ADDRESS_SPACE_TYPE_BUS) {
+        mPciRootBridgeData[Index].MinBusNumber = Descriptors->AddrRangeMin;
+        mPciRootBridgeData[Index].MaxBusNumber = Descriptors->AddrRangeMax;
+        break;
+      }
+      Descriptors++;
+    }
+    ASSERT (Descriptors->Desc != ACPI_END_TAG_DESCRIPTOR);
+  }
+
+  FreePool(HandleBuffer);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  The destructor function frees memory allocated by constructor.
+  
+  The destructor function frees memory for data of protocol instances allocated by constructor.
+  It will ASSERT() if that related operation fails and it will always return EFI_SUCCESS. 
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+  
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+PciSegmentLibDestructor (
+  IN EFI_HANDLE                ImageHandle,
+  IN EFI_SYSTEM_TABLE          *SystemTable
+  )
+{
+  FreePool (mPciRootBridgeData);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  According to address, search for the corresponding PCI Root Bridge I/O Protocol instance.
+
+  This internal function extracts segment number and bus number data from address, and
+  retrieves the corresponding PCI Root Bridge I/O Protocol instance.
+
+  @param  Address The address that encodes the Segment, PCI Bus, Device, Function and
+                  Register.
+
+  @return The address for PCI Root Bridge I/O Protocol.
+
+**/
+EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *
+PciSegmentLibSearchForRootBridge (
+  IN UINT64                    Address
+  )
+{
+  UINTN                              Index;
+  UINT64                             SegmentNumber;
+  UINT64                             BusNumber;
+
+  for (Index = 0; Index < mNumberOfPciRootBridges; Index++) {
+    //
+    // Matches segment number of address with the segment number of protocol instance.
+    //
+    SegmentNumber = BitFieldRead64 (Address, 32, 63);
+    if (SegmentNumber == mPciRootBridgeData[Index].SegmentNumber) {
+      //
+      // Matches the bus number of address with bus number range of protocol instance.
+      //
+      BusNumber = BitFieldRead64 (Address, 20, 27);
+      if (BusNumber >= mPciRootBridgeData[Index].MinBusNumber && BusNumber <= mPciRootBridgeData[Index].MaxBusNumber) {
+        return mPciRootBridgeData[Index].PciRootBridgeIo;
+      }
+    }    
+  }
+  return NULL;
+}
+
+/**
+  Internal worker function to read a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Read() service.
+  It reads and returns the PCI configuration register specified by Address,
+  the width of data is specified by Width.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to read
+
+  @return The value read from the PCI configuration register.
+
+**/
+UINT32
+DxePciSegmentLibPciRootBridgeIoReadWorker (
+  IN  UINT64                                 Address,
+  IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width
+  )
+{
+  UINT32                               Data;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL      *PciRootBridgeIo; 
+
+  PciRootBridgeIo = PciSegmentLibSearchForRootBridge (Address);
+  ASSERT (PciRootBridgeIo != NULL);
+
+  PciRootBridgeIo->Pci.Read (
+                         PciRootBridgeIo,
+                         Width,
+                         PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                         1,
+                         &Data
+                         );
+
+  return Data;
+}
+
+/**
+  Internal worker function to writes a PCI configuration register.
+
+  This function wraps EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL.Pci.Write() service.
+  It writes the PCI configuration register specified by Address with the
+  value specified by Data. The width of data is specifed by Width.
+  Data is returned.
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  @param  Width   Width of data to write
+  @param  Data    The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+DxePciSegmentLibPciRootBridgeIoWriteWorker (
+  IN  UINT64                                 Address,
+  IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH  Width,
+  IN  UINT32                                 Data
+  )
+{
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL      *PciRootBridgeIo; 
+
+  PciRootBridgeIo = PciSegmentLibSearchForRootBridge (Address);
+  ASSERT (PciRootBridgeIo != NULL);
+
+  PciRootBridgeIo->Pci.Write (
+                         PciRootBridgeIo,
+                         Width,
+                         PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS (Address),
+                         1,
+                         &Data
+                         );
+
+  return Data;
+}
+
+/**
+  Register a PCI device so PCI configuration registers may be accessed after 
+  SetVirtualAddressMap().
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address The address that encodes the PCI Bus, Device, Function and
+                  Register.
+  
+  @retval RETURN_SUCCESS           The PCI device was registered for runtime access.
+  @retval RETURN_UNSUPPORTED       An attempt was made to call this function 
+                                   after ExitBootServices().
+  @retval RETURN_UNSUPPORTED       The resources required to access the PCI device
+                                   at runtime could not be mapped.
+  @retval RETURN_OUT_OF_RESOURCES  There are not enough resources available to
+                                   complete the registration.
+
+**/
+RETURN_STATUS
+EFIAPI
+PciSegmentRegisterForRuntimeAccess (
+  IN UINTN  Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+  return RETURN_UNSUPPORTED;
+}
+
+/**
+  Reads an 8-bit PCI configuration register.
+
+  Reads and returns the 8-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 8-bit PCI configuration register specified by Address.
+
+**/
+UINT8
+EFIAPI
+PciSegmentRead8 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciSegmentLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint8);
+}
+
+/**
+  Writes an 8-bit PCI configuration register.
+
+  Writes the 8-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentWrite8 (
+  IN UINT64                    Address,
+  IN UINT8                     Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 0);
+
+  return (UINT8) DxePciSegmentLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint8, Value);
+}
+
+/**
+  Performs a bitwise OR of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value.
+
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAnd8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) (PciSegmentRead8 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of an 8-bit PCI configuration register with an 8-bit value,
+  followed a  bitwise OR with another 8-bit value.
+  
+  Reads the 8-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 8-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (Address, (UINT8) ((PciSegmentRead8 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in an 8-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldRead8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead8 (PciSegmentRead8 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  8-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldWrite8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     Value
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldWrite8 (PciSegmentRead8 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 8-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldOr8 (PciSegmentRead8 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 8-bit register.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND between the read result and the value specified by AndData, and
+  writes the result to the 8-bit PCI configuration register specified by
+  Address. The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are
+  serialized. Extra left bits in AndData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAnd8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAnd8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in an 8-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  8-bit port.
+
+  Reads the 8-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 8-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..7.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..7.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT8
+EFIAPI
+PciSegmentBitFieldAndThenOr8 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT8                     AndData,
+  IN UINT8                     OrData
+  )
+{
+  return PciSegmentWrite8 (
+           Address,
+           BitFieldAndThenOr8 (PciSegmentRead8 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 16-bit PCI configuration register.
+
+  Reads and returns the 16-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 16-bit PCI configuration register specified by Address.
+
+**/
+UINT16
+EFIAPI
+PciSegmentRead16 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciSegmentLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint16);
+}
+
+/**
+  Writes a 16-bit PCI configuration register.
+
+  Writes the 16-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT16
+EFIAPI
+PciSegmentWrite16 (
+  IN UINT64                    Address,
+  IN UINT16                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 1);
+
+  return (UINT16) DxePciSegmentLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint16, Value);
+}
+
+/**
+  Performs a bitwise OR of a 16-bit PCI configuration register with
+  a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 16-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address The address that encodes the PCI Segment, Bus, Device, Function and
+                  Register.
+  @param  OrData  The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) | OrData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAnd16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) (PciSegmentRead16 (Address) & AndData));
+}
+
+/**
+  Performs a bitwise AND of a 16-bit PCI configuration register with a 16-bit value,
+  followed a  bitwise OR with another 16-bit value.
+  
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData    The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (Address, (UINT16) ((PciSegmentRead16 (Address) & AndData) | OrData));
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 16-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldRead16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead16 (PciSegmentRead16 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  16-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldWrite16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    Value
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldWrite16 (PciSegmentRead16 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address. 
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldOr16 (PciSegmentRead16 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit PCI configuration, performs a bitwise OR,
+  and writes the result back to the bit field in the 16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 16-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  Extra left bits in OrData are stripped.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 16-bit boundary, then ASSERT().
+  If StartBit is greater than 7, then ASSERT().
+  If EndBit is greater than 7, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    The ordinal of the least significant bit in a byte is bit 0.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    The ordinal of the most significant bit in a byte is bit 7.
+  @param  AndData   The value to AND with the read value from the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAnd16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAnd16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 16-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  16-bit port.
+
+  Reads the 16-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 16-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 15, then ASSERT().
+  If EndBit is greater than 15, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..15.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..15.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT16
+EFIAPI
+PciSegmentBitFieldAndThenOr16 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT16                    AndData,
+  IN UINT16                    OrData
+  )
+{
+  return PciSegmentWrite16 (
+           Address,
+           BitFieldAndThenOr16 (PciSegmentRead16 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a 32-bit PCI configuration register.
+
+  Reads and returns the 32-bit PCI configuration register specified by Address.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+
+  @return The 32-bit PCI configuration register specified by Address.
+
+**/
+UINT32
+EFIAPI
+PciSegmentRead32 (
+  IN UINT64                    Address
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return DxePciSegmentLibPciRootBridgeIoReadWorker (Address, EfiPciWidthUint32);
+}
+
+/**
+  Writes a 32-bit PCI configuration register.
+
+  Writes the 32-bit PCI configuration register specified by Address with the value specified by Value.
+  Value is returned.  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address     The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  Value       The value to write.
+
+  @return The parameter of Value.
+
+**/
+UINT32
+EFIAPI
+PciSegmentWrite32 (
+  IN UINT64                    Address,
+  IN UINT32                    Value
+  )
+{
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (Address, 3);
+
+  return DxePciSegmentLibPciRootBridgeIoWriteWorker (Address, EfiPciWidthUint32, Value);
+}
+
+/**
+  Performs a bitwise OR of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise OR between the read result and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) | OrData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value.
+
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAnd32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (Address, PciSegmentRead32 (Address) & AndData);
+}
+
+/**
+  Performs a bitwise AND of a 32-bit PCI configuration register with a 32-bit value,
+  followed a  bitwise OR with another 32-bit value.
+  
+  Reads the 32-bit PCI configuration register specified by Address,
+  performs a bitwise AND between the read result and the value specified by AndData,
+  performs a bitwise OR between the result of the AND operation and the value specified by OrData,
+  and writes the result to the 32-bit PCI configuration register specified by Address.
+  The value written to the PCI configuration register is returned.
+  This function must guarantee that all PCI read and write operations are serialized.
+  
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+
+  @param  Address   The address that encodes the PCI Segment, Bus, Device, Function, and Register.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (Address, (PciSegmentRead32 (Address) & AndData) | OrData);
+}
+
+/**
+  Reads a bit field of a PCI configuration register.
+
+  Reads the bit field in a 32-bit PCI configuration register. The bit field is
+  specified by the StartBit and the EndBit. The value of the bit field is
+  returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to read.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+
+  @return The value of the bit field read from the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldRead32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit
+  )
+{
+  return BitFieldRead32 (PciSegmentRead32 (Address), StartBit, EndBit);
+}
+
+/**
+  Writes a bit field to a PCI configuration register.
+
+  Writes Value to the bit field of the PCI configuration register. The bit
+  field is specified by the StartBit and the EndBit. All other bits in the
+  destination PCI configuration register are preserved. The new value of the
+  32-bit register is returned.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  Value     The new value of the bit field.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldWrite32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    Value
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldWrite32 (PciSegmentRead32 (Address), StartBit, EndBit, Value)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration, performs a bitwise OR, and
+  writes the result back to the bit field in the 32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise OR between the read result and the value specified by
+  OrData, and writes the result to the 32-bit PCI configuration register
+  specified by Address. The value written to the PCI configuration register is
+  returned. This function must guarantee that all PCI read and write operations
+  are serialized. Extra left bits in OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  OrData    The value to OR with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldOr32 (PciSegmentRead32 (Address), StartBit, EndBit, OrData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit PCI configuration register, performs a bitwise
+  AND, and writes the result back to the bit field in the 32-bit register.
+
+  
+  Reads the 32-bit PCI configuration register specified by Address, performs a bitwise
+  AND between the read result and the value specified by AndData, and writes the result
+  to the 32-bit PCI configuration register specified by Address. The value written to
+  the PCI configuration register is returned.  This function must guarantee that all PCI
+  read and write operations are serialized.  Extra left bits in AndData are stripped.
+  If any reserved bits in Address are set, then ASSERT().
+  If Address is not aligned on a 32-bit boundary, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAnd32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAnd32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData)
+           );
+}
+
+/**
+  Reads a bit field in a 32-bit port, performs a bitwise AND followed by a
+  bitwise OR, and writes the result back to the bit field in the
+  32-bit port.
+
+  Reads the 32-bit PCI configuration register specified by Address, performs a
+  bitwise AND followed by a bitwise OR between the read result and
+  the value specified by AndData, and writes the result to the 32-bit PCI
+  configuration register specified by Address. The value written to the PCI
+  configuration register is returned. This function must guarantee that all PCI
+  read and write operations are serialized. Extra left bits in both AndData and
+  OrData are stripped.
+
+  If any reserved bits in Address are set, then ASSERT().
+  If StartBit is greater than 31, then ASSERT().
+  If EndBit is greater than 31, then ASSERT().
+  If EndBit is less than StartBit, then ASSERT().
+  If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+  If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
+
+  @param  Address   The PCI configuration register to write.
+  @param  StartBit  The ordinal of the least significant bit in the bit field.
+                    Range 0..31.
+  @param  EndBit    The ordinal of the most significant bit in the bit field.
+                    Range 0..31.
+  @param  AndData   The value to AND with the PCI configuration register.
+  @param  OrData    The value to OR with the result of the AND operation.
+
+  @return The value written back to the PCI configuration register.
+
+**/
+UINT32
+EFIAPI
+PciSegmentBitFieldAndThenOr32 (
+  IN UINT64                    Address,
+  IN UINTN                     StartBit,
+  IN UINTN                     EndBit,
+  IN UINT32                    AndData,
+  IN UINT32                    OrData
+  )
+{
+  return PciSegmentWrite32 (
+           Address,
+           BitFieldAndThenOr32 (PciSegmentRead32 (Address), StartBit, EndBit, AndData, OrData)
+           );
+}
+
+/**
+  Reads a range of PCI configuration registers into a caller supplied buffer.
+
+  Reads the range of PCI configuration registers specified by StartAddress and
+  Size into the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be read. Size is
+  returned. When possible 32-bit PCI configuration read cycles are used to read
+  from StartAdress to StartAddress + Size. Due to alignment restrictions, 8-bit
+  and 16-bit PCI configuration read cycles may be used at the beginning and the
+  end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer receiving the data read.
+
+  @return Size
+
+**/
+UINTN
+EFIAPI
+PciSegmentReadBuffer (
+  IN  UINT64                   StartAddress,
+  IN  UINTN                    Size,
+  OUT VOID                     *Buffer
+  )
+{
+  UINTN                                ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return Size;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Read a byte if StartAddress is byte aligned
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Read a word if StartAddress is word aligned
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Read as many double words as possible
+    //
+    WriteUnaligned32 (Buffer, PciSegmentRead32 (StartAddress));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Read the last remaining word if exist
+    //
+    WriteUnaligned16 (Buffer, PciSegmentRead16 (StartAddress));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Read the last remaining byte if exist
+    //
+    *(volatile UINT8 *)Buffer = PciSegmentRead8 (StartAddress);
+  }
+
+  return ReturnValue;
+}
+
+/**
+  Copies the data in a caller supplied buffer to a specified range of PCI
+  configuration space.
+
+  Writes the range of PCI configuration registers specified by StartAddress and
+  Size from the buffer specified by Buffer. This function only allows the PCI
+  configuration registers from a single PCI function to be written. Size is
+  returned. When possible 32-bit PCI configuration write cycles are used to
+  write from StartAdress to StartAddress + Size. Due to alignment restrictions,
+  8-bit and 16-bit PCI configuration write cycles may be used at the beginning
+  and the end of the range.
+
+  If any reserved bits in StartAddress are set, then ASSERT().
+  If ((StartAddress & 0xFFF) + Size) > 0x1000, then ASSERT().
+  If Size > 0 and Buffer is NULL, then ASSERT().
+
+  @param  StartAddress  The starting address that encodes the PCI Segment, Bus, Device,
+                        Function and Register.
+  @param  Size          The size in bytes of the transfer.
+  @param  Buffer        The pointer to a buffer containing the data to write.
+
+  @return The parameter of Size.
+
+**/
+UINTN
+EFIAPI
+PciSegmentWriteBuffer (
+  IN UINT64                    StartAddress,
+  IN UINTN                     Size,
+  IN VOID                      *Buffer
+  )
+{
+  UINTN                                ReturnValue;
+
+  ASSERT_INVALID_PCI_SEGMENT_ADDRESS (StartAddress, 0);
+  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
+
+  if (Size == 0) {
+    return 0;
+  }
+
+  ASSERT (Buffer != NULL);
+
+  //
+  // Save Size for return
+  //
+  ReturnValue = Size;
+
+  if ((StartAddress & BIT0) != 0) {
+    //
+    // Write a byte if StartAddress is byte aligned
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+    StartAddress += sizeof (UINT8);
+    Size -= sizeof (UINT8);
+    Buffer = (UINT8*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16) && (StartAddress & BIT1) != 0) {
+    //
+    // Write a word if StartAddress is word aligned
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  while (Size >= sizeof (UINT32)) {
+    //
+    // Write as many double words as possible
+    //
+    PciSegmentWrite32 (StartAddress, ReadUnaligned32 (Buffer));
+    StartAddress += sizeof (UINT32);
+    Size -= sizeof (UINT32);
+    Buffer = (UINT32*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT16)) {
+    //
+    // Write the last remaining word if exist
+    //
+    PciSegmentWrite16 (StartAddress, ReadUnaligned16 (Buffer));
+    StartAddress += sizeof (UINT16);
+    Size -= sizeof (UINT16);
+    Buffer = (UINT16*)Buffer + 1;
+  }
+
+  if (Size >= sizeof (UINT8)) {
+    //
+    // Write the last remaining byte if exist
+    //
+    PciSegmentWrite8 (StartAddress, *(UINT8*)Buffer);
+  }
+
+  return ReturnValue;
+}
diff --git a/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.h b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.h
new file mode 100644
index 000000000000..07d627e9258c
--- /dev/null
+++ b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/PciSegmentLib.h
@@ -0,0 +1,59 @@
+/** @file
+  Include file of PciSegmentPciRootBridgeIo Library.
+
+  Copyright (c) 2007 - 2009, 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 __DXE_PCI_SEGMENT_LIB__
+#define __DXE_PCI_SEGMENT_LIB__
+
+#include <PiDxe.h>
+
+#include <Protocol/PciRootBridgeIo.h>
+
+#include <Library/PciSegmentLib.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+
+#include <IndustryStandard/Acpi.h>
+
+typedef struct {
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *PciRootBridgeIo;
+  UINT32                             SegmentNumber;
+  UINT64                             MinBusNumber;
+  UINT64                             MaxBusNumber;
+} PCI_ROOT_BRIDGE_DATA;
+
+/**
+  Assert the validity of a PCI Segment address.
+  A valid PCI Segment address should not contain 1's in bits 28..31 and 48..63
+
+  @param  A The address to validate.
+  @param  M Additional bits to assert to be zero.
+
+**/
+#define ASSERT_INVALID_PCI_SEGMENT_ADDRESS(A,M) \
+  ASSERT (((A) & (0xffff0000f0000000ULL | (M))) == 0)
+
+/**
+  Translate PCI Lib address into format of PCI Root Bridge I/O Protocol
+
+  @param  A  The address that encodes the PCI Bus, Device, Function and
+             Register.
+
+**/
+#define PCI_TO_PCI_ROOT_BRIDGE_IO_ADDRESS(A) \
+  ((((UINT32)(A) << 4) & 0xff000000) | (((UINT32)(A) >> 4) & 0x00000700) | (((UINT32)(A) << 1) & 0x001f0000) | (LShiftU64((A) & 0xfff, 32)))
+
+#endif
diff --git a/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.inf b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.inf
new file mode 100644
index 000000000000..1b9d921378a1
--- /dev/null
+++ b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.inf
@@ -0,0 +1,60 @@
+## @file
+# PCI Segment Library that layers on top of the PCI Root Bridge I/O Protocol.
+#
+# This library produces the APIs from the PCI Library and implements these APIs
+#  by calling into the PCI Root Bridge I/O Protocols that are present in the platform.
+#  The PCI Root Bridge I/O Protocols are typically produced by a chipset specific DXE driver.
+#  This library binds to all of the PCI Root Bridge I/O Protocols in the platform and handles
+#  the translation from a PCI segment number into a specific PCI Root Bridge I/O Protocol.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiPciSegmentLibPciRootBridgeIo
+  MODULE_UNI_FILE                = UefiPciSegmentLibPciRootBridgeIo.uni
+  FILE_GUID                      = C6068612-B6E0-48a3-BB92-60E4A4F89EDF
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PciSegmentLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION
+
+  CONSTRUCTOR                    = PciSegmentLibConstructor
+  DESTRUCTOR                     = PciSegmentLibDestructor
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  PciSegmentLib.h
+  PciSegmentLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  MemoryAllocationLib
+  BaseLib
+  UefiBootServicesTableLib
+  DebugLib
+
+[Protocols]
+  gEfiPciRootBridgeIoProtocolGuid               ## CONSUMES
+
+[Depex.common.DXE_DRIVER, Depex.common.DXE_RUNTIME_DRIVER, Depex.common.DXE_SAL_DRIVER, Depex.common.DXE_SMM_DRIVER]
+  gEfiPciRootBridgeIoProtocolGuid
+
diff --git a/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.uni b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.uni
new file mode 100644
index 000000000000..dc4a06aed641
--- /dev/null
+++ b/MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.uni
@@ -0,0 +1,25 @@
+// /** @file
+// PCI Segment Library that layers on top of the PCI Root Bridge I/O Protocol.
+//
+// This library produces the APIs from the PCI Library and implements these APIs
+// by calling into the PCI Root Bridge I/O Protocols that are present in the platform.
+// The PCI Root Bridge I/O Protocols are typically produced by a chipset specific DXE driver.
+// This library binds to all of the PCI Root Bridge I/O Protocols in the platform and handles
+// the translation from a PCI segment number into a specific PCI Root Bridge I/O Protocol.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Layers on top of the PCI Root Bridge I/O Protocol"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library produces the APIs from the PCI Library and implements these APIs by calling into the PCI Root Bridge I/O Protocols that are present in the platform. The PCI Root Bridge I/O Protocols are typically produced by a chipset-specific DXE driver. This library binds to all of the PCI Root Bridge I/O Protocols in the platform and handles the translation from a PCI segment number into a specific PCI Root Bridge I/O Protocol."
+
diff --git a/MdePkg/Library/UefiRuntimeLib/RuntimeLib.c b/MdePkg/Library/UefiRuntimeLib/RuntimeLib.c
new file mode 100644
index 000000000000..d079d6389e24
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeLib/RuntimeLib.c
@@ -0,0 +1,843 @@
+/** @file
+  UEFI Runtime Library implementation for non IPF processor types.
+
+  This library hides the global variable for the EFI Runtime Services so the
+  caller does not need to deal with the possibility of being called from an
+  OS virtual address space. All pointer values are different for a virtual 
+  mapping than from the normal physical mapping at boot services time.
+
+Copyright (c) 2006 - 2010, 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 <Uefi.h>
+#include <Library/UefiRuntimeLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Guid/EventGroup.h>
+
+///
+/// Driver Lib Module Globals
+///
+EFI_EVENT              mEfiVirtualNotifyEvent;
+EFI_EVENT              mEfiExitBootServicesEvent;
+BOOLEAN                mEfiGoneVirtual         = FALSE;
+BOOLEAN                mEfiAtRuntime           = FALSE;
+EFI_RUNTIME_SERVICES   *mInternalRT;
+
+/**
+  Set AtRuntime flag as TRUE after ExitBootServices.
+
+  @param[in]  Event   The Event that is being processed.
+  @param[in]  Context The Event Context.
+
+**/
+VOID
+EFIAPI
+RuntimeLibExitBootServicesEvent (
+  IN EFI_EVENT        Event,
+  IN VOID             *Context
+  )
+{
+  mEfiAtRuntime = TRUE;
+}
+
+/**
+  Fixup internal data so that EFI can be call in virtual mode.
+  Call the passed in Child Notify event and convert any pointers in
+  lib to virtual mode.
+
+  @param[in]    Event   The Event that is being processed.
+  @param[in]    Context The Event Context.
+**/
+VOID
+EFIAPI
+RuntimeLibVirtualNotifyEvent (
+  IN EFI_EVENT        Event,
+  IN VOID             *Context
+  )
+{
+  //
+  // Update global for Runtime Services Table and IO
+  //
+  EfiConvertPointer (0, (VOID **) &mInternalRT);
+
+  mEfiGoneVirtual = TRUE;
+}
+
+/**
+  Initialize runtime Driver Lib if it has not yet been initialized.
+  It will ASSERT() if gRT is NULL or gBS is NULL.
+  It will ASSERT() if that operation fails.
+
+  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.
+  @param[in]  SystemTable   A pointer to the EFI System Table.
+
+  @return     EFI_STATUS    always returns EFI_SUCCESS except EFI_ALREADY_STARTED if already started.
+**/
+EFI_STATUS
+EFIAPI
+RuntimeDriverLibConstruct (
+  IN EFI_HANDLE           ImageHandle,
+  IN EFI_SYSTEM_TABLE     *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  ASSERT (gRT != NULL);
+  ASSERT (gBS != NULL);
+
+  mInternalRT = gRT;
+  //
+  // Register SetVirtualAddressMap () notify function
+  //
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  RuntimeLibVirtualNotifyEvent,
+                  NULL,
+                  &gEfiEventVirtualAddressChangeGuid,
+                  &mEfiVirtualNotifyEvent
+                  );
+
+  ASSERT_EFI_ERROR (Status);
+
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  RuntimeLibExitBootServicesEvent,
+                  NULL,
+                  &gEfiEventExitBootServicesGuid,
+                  &mEfiExitBootServicesEvent
+                  );
+
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  If a runtime driver exits with an error, it must call this routine 
+  to free the allocated resource before the exiting.
+  It will ASSERT() if gBS is NULL.
+  It will ASSERT() if that operation fails.
+
+  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.
+  @param[in]  SystemTable   A pointer to the EFI System Table.
+
+  @retval     EFI_SUCCESS       The Runtime Driver Lib shutdown successfully.
+  @retval     EFI_UNSUPPORTED   Runtime Driver lib was not initialized.
+**/
+EFI_STATUS
+EFIAPI
+RuntimeDriverLibDeconstruct (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  //
+  // Close SetVirtualAddressMap () notify function
+  //
+  ASSERT (gBS != NULL);
+  Status = gBS->CloseEvent (mEfiVirtualNotifyEvent);
+  ASSERT_EFI_ERROR (Status);
+
+  Status = gBS->CloseEvent (mEfiExitBootServicesEvent);
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+/**
+  This function allows the caller to determine if UEFI ExitBootServices() has been called.
+
+  This function returns TRUE after all the EVT_SIGNAL_EXIT_BOOT_SERVICES functions have
+  executed as a result of the OS calling ExitBootServices().  Prior to this time FALSE
+  is returned. This function is used by runtime code to decide it is legal to access
+  services that go away after ExitBootServices().
+
+  @retval  TRUE  The system has finished executing the EVT_SIGNAL_EXIT_BOOT_SERVICES event.
+  @retval  FALSE The system has not finished executing the EVT_SIGNAL_EXIT_BOOT_SERVICES event.
+
+**/
+BOOLEAN
+EFIAPI
+EfiAtRuntime (
+  VOID
+  )
+{
+  return mEfiAtRuntime;
+}
+
+/**
+  This function allows the caller to determine if UEFI SetVirtualAddressMap() has been called. 
+
+  This function returns TRUE after all the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE functions have
+  executed as a result of the OS calling SetVirtualAddressMap(). Prior to this time FALSE
+  is returned. This function is used by runtime code to decide it is legal to access services
+  that go away after SetVirtualAddressMap().
+
+  @retval  TRUE  The system has finished executing the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
+  @retval  FALSE The system has not finished executing the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
+
+**/
+BOOLEAN
+EFIAPI
+EfiGoneVirtual (
+  VOID
+  )
+{
+  return mEfiGoneVirtual;
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service ResetSystem().
+
+  The ResetSystem()function resets the entire platform, including all processors and devices,and reboots the system.
+  Calling this interface with ResetType of EfiResetCold causes a system-wide reset. This sets all circuitry within
+  the system to its initial state. This type of reset is asynchronous to system operation and operates without regard
+  to cycle boundaries. EfiResetCold is tantamount to a system power cycle.
+  Calling this interface with ResetType of EfiResetWarm causes a system-wide initialization. The processors are set to
+  their initial state, and pending cycles are not corrupted. If the system does not support this reset type, then an
+  EfiResetCold must be performed.
+  Calling this interface with ResetType of EfiResetShutdown causes the system to enter a power state equivalent to the
+  ACPI G2/S5 or G3 states. If the system does not support this reset type, then when the system is rebooted, it should
+  exhibit the EfiResetCold attributes.
+  The platform may optionally log the parameters from any non-normal reset that occurs.
+  The ResetSystem() function does not return.
+
+  @param  ResetType   The type of reset to perform.
+  @param  ResetStatus The status code for the reset. If the system reset is part of a normal operation, the status code
+                      would be EFI_SUCCESS. If the system reset is due to some type of failure the most appropriate EFI
+                      Status code would be used.
+  @param  DataSizeThe size, in bytes, of ResetData.
+  @param  ResetData   For a ResetType of EfiResetCold, EfiResetWarm, or EfiResetShutdown the data buffer starts with a
+                      Null-terminated Unicode string, optionally followed by additional binary data. The string is a
+                      description that the caller may use to further indicate the reason for the system reset. ResetData
+                      is only valid if ResetStatus is something other then EFI_SUCCESS. This pointer must be a physical
+                      address. For a ResetType of EfiRestUpdate the data buffer also starts with a Null-terminated string
+                      that is followed by a physical VOID * to an EFI_CAPSULE_HEADER.
+
+**/
+VOID
+EFIAPI
+EfiResetSystem (
+  IN EFI_RESET_TYPE               ResetType,
+  IN EFI_STATUS                   ResetStatus,
+  IN UINTN                        DataSize,
+  IN VOID                         *ResetData OPTIONAL
+  )
+{
+  mInternalRT->ResetSystem (ResetType, ResetStatus, DataSize, ResetData);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetTime().
+
+  The GetTime() function returns a time that was valid sometime during the call to the function.
+  While the returned EFI_TIME structure contains TimeZone and Daylight savings time information,
+  the actual clock does not maintain these values. The current time zone and daylight saving time
+  information returned by GetTime() are the values that were last set via SetTime().
+  The GetTime() function should take approximately the same amount of time to read the time each
+  time it is called. All reported device capabilities are to be rounded up.
+  During runtime, if a PC-AT CMOS device is present in the platform the caller must synchronize
+  access to the device before calling GetTime().
+
+  @param  Time         A pointer to storage to receive a snapshot of the current time.
+  @param  Capabilities An optional pointer to a buffer to receive the real time clock device's
+                       capabilities.
+
+  @retval  EFI_SUCCESS            The operation completed successfully.
+  @retval  EFI_INVALID_PARAMETER  Time is NULL.
+  @retval  EFI_DEVICE_ERROR       The time could not be retrieved due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetTime (
+  OUT EFI_TIME                    *Time,
+  OUT EFI_TIME_CAPABILITIES       *Capabilities  OPTIONAL
+  )
+{
+  return mInternalRT->GetTime (Time, Capabilities);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetTime().
+
+  The SetTime() function sets the real time clock device to the supplied time, and records the
+  current time zone and daylight savings time information. The SetTime() function is not allowed
+  to loop based on the current time. For example, if the device does not support a hardware reset
+  for the sub-resolution time, the code is not to implement the feature by waiting for the time to
+  wrap.
+  During runtime, if a PC-AT CMOS device is present in the platform the caller must synchronize
+  access to the device before calling SetTime().
+
+  @param  Time  A pointer to the current time. Type EFI_TIME is defined in the GetTime()
+                function description. Full error checking is performed on the different
+                fields of the EFI_TIME structure (refer to the EFI_TIME definition in the
+                GetTime() function description for full details), and EFI_INVALID_PARAMETER
+                is returned if any field is out of range.
+
+  @retval  EFI_SUCCESS            The operation completed successfully.
+  @retval  EFI_INVALID_PARAMETER  A time field is out of range.
+  @retval  EFI_DEVICE_ERROR       The time could not be set due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetTime (
+  IN EFI_TIME                   *Time
+  )
+{
+  return mInternalRT->SetTime (Time);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetWakeupTime().
+
+  The alarm clock time may be rounded from the set alarm clock time to be within the resolution
+  of the alarm clock device. The resolution of the alarm clock device is defined to be one second.
+  During runtime, if a PC-AT CMOS device is present in the platform the caller must synchronize
+  access to the device before calling GetWakeupTime().
+
+  @param  Enabled  Indicates if the alarm is currently enabled or disabled.
+  @param  Pending  Indicates if the alarm signal is pending and requires acknowledgement.
+  @param  Time     The current alarm setting. Type EFI_TIME is defined in the GetTime()
+                   function description.
+
+  @retval  EFI_SUCCESS            The alarm settings were returned.
+  @retval  EFI_INVALID_PARAMETER  Enabled is NULL.
+  @retval  EFI_INVALID_PARAMETER  Pending is NULL.
+  @retval  EFI_INVALID_PARAMETER  Time is NULL.
+  @retval  EFI_DEVICE_ERROR       The wakeup time could not be retrieved due to a hardware error.
+  @retval  EFI_UNSUPPORTED        A wakeup timer is not supported on this platform.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetWakeupTime (
+  OUT BOOLEAN                     *Enabled,
+  OUT BOOLEAN                     *Pending,
+  OUT EFI_TIME                    *Time
+  )
+{
+  return mInternalRT->GetWakeupTime (Enabled, Pending, Time);
+}
+
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetWakeupTime()
+
+  Setting a system wakeup alarm causes the system to wake up or power on at the set time.
+  When the alarm fires, the alarm signal is latched until it is acknowledged by calling SetWakeupTime()
+  to disable the alarm. If the alarm fires before the system is put into a sleeping or off state,
+  since the alarm signal is latched the system will immediately wake up. If the alarm fires while
+  the system is off and there is insufficient power to power on the system, the system is powered
+  on when power is restored.
+
+  @param  Enable  Enable or disable the wakeup alarm.
+  @param  Time    If Enable is TRUE, the time to set the wakeup alarm for. Type EFI_TIME
+                  is defined in the GetTime() function description. If Enable is FALSE,
+                  then this parameter is optional, and may be NULL.
+
+  @retval  EFI_SUCCESS            If Enable is TRUE, then the wakeup alarm was enabled.
+                                  If Enable is FALSE, then the wakeup alarm was disabled.
+  @retval  EFI_INVALID_PARAMETER  A time field is out of range.
+  @retval  EFI_DEVICE_ERROR       The wakeup time could not be set due to a hardware error.
+  @retval  EFI_UNSUPPORTED        A wakeup timer is not supported on this platform.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetWakeupTime (
+  IN BOOLEAN                      Enable,
+  IN EFI_TIME                     *Time   OPTIONAL
+  )
+{
+  return mInternalRT->SetWakeupTime (Enable, Time);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetVariable().
+
+  Each vendor may create and manage its own variables without the risk of name conflicts by
+  using a unique VendorGuid. When a variable is set its Attributes are supplied to indicate
+  how the data variable should be stored and maintained by the system. The attributes affect
+  when the variable may be accessed and volatility of the data. Any attempts to access a variable
+  that does not have the attribute set for runtime access will yield the EFI_NOT_FOUND error.
+  If the Data buffer is too small to hold the contents of the variable, the error EFI_BUFFER_TOO_SMALL
+  is returned and DataSize is set to the required buffer size to obtain the data.
+
+  @param  VariableName the name of the vendor's variable, it's a Null-Terminated Unicode String
+  @param  VendorGuid   Unify identifier for vendor.
+  @param  Attributes   Point to memory location to return the attributes of variable. If the point
+                       is NULL, the parameter would be ignored.
+  @param  DataSize     As input, point to the maximum size of return Data-Buffer.
+                       As output, point to the actual size of the returned Data-Buffer.
+  @param  Data         Point to return Data-Buffer.
+
+  @retval  EFI_SUCCESS            The function completed successfully.
+  @retval  EFI_NOT_FOUND          The variable was not found.
+  @retval  EFI_BUFFER_TOO_SMALL   The DataSize is too small for the result. DataSize has
+                                  been updated with the size needed to complete the request.
+  @retval  EFI_INVALID_PARAMETER  VariableName is NULL.
+  @retval  EFI_INVALID_PARAMETER  VendorGuid is NULL.
+  @retval  EFI_INVALID_PARAMETER  DataSize is NULL.
+  @retval  EFI_INVALID_PARAMETER  The DataSize is not too small and Data is NULL.
+  @retval  EFI_DEVICE_ERROR       The variable could not be retrieved due to a hardware error.
+  @retval  EFI_SECURITY_VIOLATION The variable could not be retrieved due to an authentication failure.
+**/
+EFI_STATUS
+EFIAPI
+EfiGetVariable (
+  IN      CHAR16                   *VariableName,
+  IN      EFI_GUID                 *VendorGuid,
+  OUT     UINT32                   *Attributes OPTIONAL,
+  IN OUT  UINTN                    *DataSize,
+  OUT     VOID                     *Data
+  )
+{
+  return mInternalRT->GetVariable (VariableName, VendorGuid, Attributes, DataSize, Data);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextVariableName().
+
+  GetNextVariableName() is called multiple times to retrieve the VariableName and VendorGuid of
+  all variables currently available in the system. On each call to GetNextVariableName() the
+  previous results are passed into the interface, and on output the interface returns the next
+  variable name data. When the entire variable list has been returned, the error EFI_NOT_FOUND
+  is returned.
+
+  @param  VariableNameSize As input, point to maximum size of variable name.
+                           As output, point to actual size of variable name.
+  @param  VariableName     As input, supplies the last VariableName that was returned by
+                           GetNextVariableName().
+                           As output, returns the name of variable. The name
+                           string is Null-Terminated Unicode string.
+  @param  VendorGuid       As input, supplies the last VendorGuid that was returned by
+                           GetNextVriableName().
+                           As output, returns the VendorGuid of the current variable.
+
+  @retval  EFI_SUCCESS           The function completed successfully.
+  @retval  EFI_NOT_FOUND         The next variable was not found.
+  @retval  EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the result.
+                                 VariableNameSize has been updated with the size needed
+                                 to complete the request.
+  @retval  EFI_INVALID_PARAMETER VariableNameSize is NULL.
+  @retval  EFI_INVALID_PARAMETER VariableName is NULL.
+  @retval  EFI_INVALID_PARAMETER VendorGuid is NULL.
+  @retval  EFI_DEVICE_ERROR      The variable name could not be retrieved due to a hardware error.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetNextVariableName (
+  IN OUT UINTN                    *VariableNameSize,
+  IN OUT CHAR16                   *VariableName,
+  IN OUT EFI_GUID                 *VendorGuid
+  )
+{
+  return mInternalRT->GetNextVariableName (VariableNameSize, VariableName, VendorGuid);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextVariableName()
+
+  Variables are stored by the firmware and may maintain their values across power cycles. Each vendor
+  may create and manage its own variables without the risk of name conflicts by using a unique VendorGuid.
+
+  @param  VariableName The name of the vendor's variable; it's a Null-Terminated 
+                       Unicode String
+  @param  VendorGuid   Unify identifier for vendor.
+  @param  Attributes   Points to a memory location to return the attributes of variable. If the point
+                       is NULL, the parameter would be ignored.
+  @param  DataSize     The size in bytes of Data-Buffer.
+  @param  Data         Points to the content of the variable.
+
+  @retval  EFI_SUCCESS            The firmware has successfully stored the variable and its data as
+                                  defined by the Attributes.
+  @retval  EFI_INVALID_PARAMETER  An invalid combination of attribute bits was supplied, or the
+                                  DataSize exceeds the maximum allowed.
+  @retval  EFI_INVALID_PARAMETER  VariableName is an empty Unicode string.
+  @retval  EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.
+  @retval  EFI_DEVICE_ERROR       The variable could not be saved due to a hardware failure.
+  @retval  EFI_WRITE_PROTECTED    The variable in question is read-only.
+  @retval  EFI_WRITE_PROTECTED    The variable in question cannot be deleted.
+  @retval  EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
+                                  set but the AuthInfo does NOT pass the validation check carried
+                                  out by the firmware.
+  @retval  EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiSetVariable (
+  IN CHAR16                       *VariableName,
+  IN EFI_GUID                     *VendorGuid,
+  IN UINT32                       Attributes,
+  IN UINTN                        DataSize,
+  IN VOID                         *Data
+  )
+{
+  return mInternalRT->SetVariable (VariableName, VendorGuid, Attributes, DataSize, Data);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service GetNextHighMonotonicCount().
+
+  The platform's monotonic counter is comprised of two 32-bit quantities: the high 32 bits and
+  the low 32 bits. During boot service time the low 32-bit value is volatile: it is reset to zero
+  on every system reset and is increased by 1 on every call to GetNextMonotonicCount(). The high
+  32-bit value is nonvolatile and is increased by 1 whenever the system resets or whenever the low
+  32-bit count (returned by GetNextMonoticCount()) overflows.
+
+  @param  HighCount The pointer to returned value.
+
+  @retval  EFI_SUCCESS           The next high monotonic count was returned.
+  @retval  EFI_DEVICE_ERROR      The device is not functioning properly.
+  @retval  EFI_INVALID_PARAMETER HighCount is NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiGetNextHighMonotonicCount (
+  OUT UINT32                      *HighCount
+  )
+{
+  return mInternalRT->GetNextHighMonotonicCount (HighCount);
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service ConvertPointer().  
+
+  The ConvertPointer() function is used by an EFI component during the SetVirtualAddressMap() operation.
+  ConvertPointer()must be called using physical address pointers during the execution of SetVirtualAddressMap().
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  Address            The pointer to a pointer that is to be fixed to be the
+                             value needed for the new virtual address mapping being
+                             applied.
+
+  @retval  EFI_SUCCESS            The pointer pointed to by Address was modified.
+  @retval  EFI_NOT_FOUND          The pointer pointed to by Address was not found to be part of
+                                  the current memory map. This is normally fatal.
+  @retval  EFI_INVALID_PARAMETER  Address is NULL.
+  @retval  EFI_INVALID_PARAMETER  *Address is NULL and DebugDispositio
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertPointer (
+  IN UINTN                  DebugDisposition,
+  IN OUT VOID               **Address
+  )
+{
+  return gRT->ConvertPointer (DebugDisposition, Address);
+}
+
+
+/**
+  Determines the new virtual address that is to be used on subsequent memory accesses.
+
+  For IA32, x64, and EBC, this service is a wrapper for the UEFI Runtime Service
+  ConvertPointer().  See the UEFI Specification for details. 
+  For IPF, this function interprets Address as a pointer to an EFI_PLABEL structure
+  and both the EntryPoint and GP fields of an EFI_PLABEL are converted from physical
+  to virtiual addressing.  Since IPF allows the GP to point to an address outside
+  a PE/COFF image, the physical to virtual offset for the EntryPoint field is used
+  to adjust the GP field.  The UEFI Runtime Service ConvertPointer() is used to convert
+  EntryPoint and the status code for this conversion is always returned.   If the convertion
+  of EntryPoint fails, then neither EntryPoint nor GP are modified.  See the UEFI
+  Specification for details on the UEFI Runtime Service ConvertPointer().
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  Address            The pointer to a pointer that is to be fixed to be the
+                             value needed for the new virtual address mapping being
+                             applied.
+
+  @return  EFI_STATUS value from EfiConvertPointer().
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertFunctionPointer (
+  IN UINTN                DebugDisposition,
+  IN OUT VOID             **Address
+  )
+{
+  return EfiConvertPointer (DebugDisposition, Address);
+}
+
+
+/**
+  Convert the standard Lib double linked list to a virtual mapping.
+
+  This service uses EfiConvertPointer() to walk a double linked list and convert all the link
+  pointers to their virtual mappings. This function is only guaranteed to work during the
+  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event and calling it at other times has undefined results.
+
+  @param  DebugDisposition   Supplies type information for the pointer being converted.
+  @param  ListHead           Head of linked list to convert.
+
+  @retval  EFI_SUCCESS  Success to execute the function.
+  @retval  !EFI_SUCCESS Failed to e3xecute the function.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiConvertList (
+  IN UINTN                DebugDisposition,
+  IN OUT LIST_ENTRY       *ListHead
+  )
+{
+  LIST_ENTRY  *Link;
+  LIST_ENTRY  *NextLink;
+  
+  //
+  // For NULL List, return EFI_SUCCESS
+  //
+  if (ListHead == NULL) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Convert all the ForwardLink & BackLink pointers in the list
+  //
+  Link = ListHead;
+  do {
+    NextLink = Link->ForwardLink;
+
+    EfiConvertPointer (
+      Link->ForwardLink == ListHead ? DebugDisposition : 0,
+      (VOID **) &Link->ForwardLink
+      );
+
+    EfiConvertPointer (
+      Link->BackLink == ListHead ? DebugDisposition : 0,
+      (VOID **) &Link->BackLink
+      );
+
+    Link = NextLink;
+  } while (Link != ListHead);
+  return EFI_SUCCESS;
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service SetVirtualAddressMap().
+
+  The SetVirtualAddressMap() function is used by the OS loader. The function can only be called
+  at runtime, and is called by the owner of the system's memory map. I.e., the component which
+  called ExitBootServices(). All events of type EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE must be signaled
+  before SetVirtualAddressMap() returns.
+
+  @param  MemoryMapSize         The size in bytes of VirtualMap.
+  @param  DescriptorSize        The size in bytes of an entry in the VirtualMap.
+  @param  DescriptorVersion     The version of the structure entries in VirtualMap.
+  @param  VirtualMap            An array of memory descriptors which contain new virtual
+                                address mapping information for all runtime ranges. Type
+                                EFI_MEMORY_DESCRIPTOR is defined in the
+                                GetMemoryMap() function description.
+
+  @retval EFI_SUCCESS           The virtual address map has been applied.
+  @retval EFI_UNSUPPORTED       EFI firmware is not at runtime, or the EFI firmware is already in
+                                virtual address mapped mode.
+  @retval EFI_INVALID_PARAMETER DescriptorSize or DescriptorVersion is
+                                invalid.
+  @retval EFI_NO_MAPPING        A virtual address was not supplied for a range in the memory
+                                map that requires a mapping.
+  @retval EFI_NOT_FOUND         A virtual address was supplied for an address that is not found
+                                in the memory map.
+**/
+EFI_STATUS
+EFIAPI
+EfiSetVirtualAddressMap (
+  IN UINTN                          MemoryMapSize,
+  IN UINTN                          DescriptorSize,
+  IN UINT32                         DescriptorVersion,
+  IN CONST EFI_MEMORY_DESCRIPTOR    *VirtualMap
+  )
+{
+  return mInternalRT->SetVirtualAddressMap (
+                        MemoryMapSize,
+                        DescriptorSize,
+                        DescriptorVersion,
+                        (EFI_MEMORY_DESCRIPTOR *) VirtualMap
+                        );
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service UpdateCapsule().
+
+  Passes capsules to the firmware with both virtual and physical mapping. Depending on the intended
+  consumption, the firmware may process the capsule immediately. If the payload should persist across a
+  system reset, the reset value returned from EFI_QueryCapsuleCapabilities must be passed into ResetSystem()
+  and will cause the capsule to be processed by the firmware as part of the reset process.
+
+  @param  CapsuleHeaderArray    Virtual pointer to an array of virtual pointers to the capsules
+                                being passed into update capsule. Each capsules is assumed to
+                                stored in contiguous virtual memory. The capsules in the
+                                CapsuleHeaderArray must be the same capsules as the
+                                ScatterGatherList. The CapsuleHeaderArray must
+                                have the capsules in the same order as the ScatterGatherList.
+  @param  CapsuleCount          The number of pointers to EFI_CAPSULE_HEADER in
+                                CaspuleHeaderArray.
+  @param  ScatterGatherList     Physical pointer to a set of
+                                EFI_CAPSULE_BLOCK_DESCRIPTOR that describes the
+                                location in physical memory of a set of capsules. See Related
+                                Definitions for an explanation of how more than one capsule is
+                                passed via this interface. The capsules in the
+                                ScatterGatherList must be in the same order as the
+                                CapsuleHeaderArray. This parameter is only referenced if
+                                the capsules are defined to persist across system reset.
+
+  @retval EFI_SUCCESS           Valid capsule was passed. If CAPSULE_FLAGS_PERSIT_ACROSS_RESET is not set,
+                                the capsule has been successfully processed by the firmware.
+  @retval EFI_INVALID_PARAMETER CapsuleSize or HeaderSize is NULL.
+  @retval EFI_INVALID_PARAMETER CapsuleCount is 0
+  @retval EFI_DEVICE_ERROR      The capsule update was started, but failed due to a device error.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform.
+  @retval EFI_OUT_OF_RESOURCES  There were insufficient resources to process the capsule.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiUpdateCapsule (
+  IN EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+  IN UINTN                    CapsuleCount,
+  IN EFI_PHYSICAL_ADDRESS     ScatterGatherList OPTIONAL
+  )
+{
+  return mInternalRT->UpdateCapsule (
+                        CapsuleHeaderArray,
+                        CapsuleCount,
+                        ScatterGatherList
+                        );
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service QueryCapsuleCapabilities().
+
+  The QueryCapsuleCapabilities() function allows a caller to test to see if a capsule or
+  capsules can be updated via UpdateCapsule(). The Flags values in the capsule header and
+  size of the entire capsule is checked.
+  If the caller needs to query for generic capsule capability a fake EFI_CAPSULE_HEADER can be
+  constructed where CapsuleImageSize is equal to HeaderSize that is equal to sizeof
+  (EFI_CAPSULE_HEADER). To determine reset requirements,
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET should be set in the Flags field of the
+  EFI_CAPSULE_HEADER.
+  The firmware must support any capsule that has the
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET flag set in EFI_CAPSULE_HEADER. The
+  firmware sets the policy for what capsules are supported that do not have the
+  CAPSULE_FLAGS_PERSIST_ACROSS_RESET flag set.
+
+  @param  CapsuleHeaderArray    Virtual pointer to an array of virtual pointers to the capsules
+                                being passed into update capsule. The capsules are assumed to
+                                stored in contiguous virtual memory.
+  @param  CapsuleCount          The number of pointers to EFI_CAPSULE_HEADER in
+                                CaspuleHeaderArray.
+  @param  MaximumCapsuleSize     On output the maximum size that UpdateCapsule() can
+                                support as an argument to UpdateCapsule() via
+                                CapsuleHeaderArray and ScatterGatherList.
+                                Undefined on input.
+  @param  ResetType             Returns the type of reset required for the capsule update.
+
+  @retval EFI_SUCCESS           A valid answer was returned.
+  @retval EFI_INVALID_PARAMETER MaximumCapsuleSize is NULL.
+  @retval EFI_UNSUPPORTED       The capsule type is not supported on this platform, and
+                                MaximumCapsuleSize and ResetType are undefined.
+  @retval EFI_OUT_OF_RESOURCES  There were insufficient resources to process the query request.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiQueryCapsuleCapabilities (
+  IN  EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+  IN  UINTN                    CapsuleCount,
+  OUT UINT64                   *MaximumCapsuleSize,
+  OUT EFI_RESET_TYPE           *ResetType
+  )
+{
+  return mInternalRT->QueryCapsuleCapabilities (
+                        CapsuleHeaderArray,
+                        CapsuleCount,
+                        MaximumCapsuleSize,
+                        ResetType
+                        );
+}
+
+
+/**
+  This service is a wrapper for the UEFI Runtime Service QueryVariableInfo().
+
+  The QueryVariableInfo() function allows a caller to obtain the information about the
+  maximum size of the storage space available for the EFI variables, the remaining size of the storage
+  space available for the EFI variables and the maximum size of each individual EFI variable,
+  associated with the attributes specified.
+  The returned MaximumVariableStorageSize, RemainingVariableStorageSize,
+  MaximumVariableSize information may change immediately after the call based on other
+  runtime activities including asynchronous error events. Also, these values associated with different
+  attributes are not additive in nature.
+
+  @param  Attributes            Attributes bitmask to specify the type of variables on
+                                which to return information. Refer to the
+                                GetVariable() function description.
+  @param  MaximumVariableStorageSize
+                                On output the maximum size of the storage space
+                                available for the EFI variables associated with the
+                                attributes specified.
+  @param  RemainingVariableStorageSize
+                                Returns the remaining size of the storage space
+                                available for the EFI variables associated with the
+                                attributes specified..
+  @param  MaximumVariableSize   Returns the maximum size of the individual EFI
+                                variables associated with the attributes specified.
+
+  @retval EFI_SUCCESS           A valid answer was returned.
+  @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied.
+  @retval EFI_UNSUPPORTED       EFI_UNSUPPORTED The attribute is not supported on this platform, and the
+                                MaximumVariableStorageSize,
+                                RemainingVariableStorageSize, MaximumVariableSize
+                                are undefined.
+
+**/
+EFI_STATUS
+EFIAPI
+EfiQueryVariableInfo (
+  IN UINT32   Attributes,
+  OUT UINT64  *MaximumVariableStorageSize,
+  OUT UINT64  *RemainingVariableStorageSize,
+  OUT UINT64  *MaximumVariableSize
+  )
+{
+  return mInternalRT->QueryVariableInfo (
+                        Attributes,
+                        MaximumVariableStorageSize,
+                        RemainingVariableStorageSize,
+                        MaximumVariableSize
+                        );
+}
diff --git a/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf b/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
new file mode 100644
index 000000000000..4048e605f89e
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
@@ -0,0 +1,51 @@
+## @file
+# Instance of UEFI Runtime Library.
+#
+# Instance of UEFI Runtime Library, with hooked EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE and
+#  EVT_SIGNAL_EXIT_BOOT_SERVICES event, to provide runtime services.
+# This instance also supports SAL drivers for better performance.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiRuntimeLib
+  MODULE_UNI_FILE                = UefiRuntimeLib.uni
+  FILE_GUID                      = b1ee6c28-54aa-4d17-b705-3e28ccb27b2e
+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiRuntimeLib|DXE_RUNTIME_DRIVER DXE_SAL_DRIVER
+
+  CONSTRUCTOR                    = RuntimeDriverLibConstruct
+  DESTRUCTOR                     = RuntimeDriverLibDeconstruct
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+
+[Sources]
+  RuntimeLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  UefiRuntimeServicesTableLib
+  DebugLib
+ 
+[Guids]
+  gEfiEventExitBootServicesGuid             ## CONSUMES ## Event
+  gEfiEventVirtualAddressChangeGuid         ## CONSUMES ## Event
+
diff --git a/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.uni b/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.uni
new file mode 100644
index 000000000000..7220ae663a53
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.uni
@@ -0,0 +1,23 @@
+// /** @file
+// Instance of UEFI Runtime Library.
+//
+// Instance of UEFI Runtime Library, with hooked EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE and
+// EVT_SIGNAL_EXIT_BOOT_SERVICES event, to provide runtime services.
+// This instance also supports SAL drivers for better performance.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "Instance of UEFI Runtime Library"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "Instance of UEFI Runtime Library, with hooked EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE and EVT_SIGNAL_EXIT_BOOT_SERVICES event, to provide runtime services. This instance also supports SAL drivers for better performance."
+
diff --git a/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.c b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.c
new file mode 100644
index 000000000000..72b631df60e9
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.c
@@ -0,0 +1,49 @@
+/** @file
+  UEFI Runtime Services Table Library.
+
+  This library instance retrieve EFI_RUNTIME_SERVICES pointer from EFI system table
+  in library's constructor.
+
+  Copyright (c) 2006 - 2008, 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 <Uefi.h>
+#include <Library/DebugLib.h>
+
+EFI_RUNTIME_SERVICES  *gRT = NULL;
+
+/**
+  The constructor function caches the pointer of Runtime Services Table.
+
+  The constructor function caches the pointer of Runtime Services Table.
+  It will ASSERT() if the pointer of Runtime Services Table is NULL.
+  It will always return EFI_SUCCESS.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiRuntimeServicesTableLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  //
+  // Cache pointer to the EFI Runtime Services Table
+  //
+  gRT = SystemTable->RuntimeServices;
+  ASSERT (gRT != NULL);
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
new file mode 100644
index 000000000000..d45e8fb353e1
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
@@ -0,0 +1,41 @@
+## @file
+# UEFI Runtime Services Table Library implementation.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiRuntimeServicesTableLib
+  MODULE_UNI_FILE                = UefiRuntimeServicesTableLib.uni
+  FILE_GUID                      = 19cbbb97-ff61-45ff-8c3f-dfa66dd118c8
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiRuntimeServicesTableLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER SMM_CORE
+
+  CONSTRUCTOR                    = UefiRuntimeServicesTableLibConstructor
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiRuntimeServicesTableLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DebugLib
+
diff --git a/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.uni b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.uni
new file mode 100644
index 000000000000..9f045beec02e
--- /dev/null
+++ b/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.uni
@@ -0,0 +1,21 @@
+// /** @file
+// UEFI Runtime Services Table Library implementation.
+//
+// UEFI Runtime Services Table Library implementation.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI Runtime Services Table Library implementation"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "UEFI Runtime Services Table Library implementation."
+
diff --git a/MdePkg/Library/UefiSalLib/UefiSalLib.c b/MdePkg/Library/UefiSalLib/UefiSalLib.c
new file mode 100644
index 000000000000..79e65cbd52b3
--- /dev/null
+++ b/MdePkg/Library/UefiSalLib/UefiSalLib.c
@@ -0,0 +1,139 @@
+/** @file
+  SAL Library implementation retrieving the SAL Entry Point from the SAL System Table
+  register in the EFI System Configuration Table.
+
+  Copyright (c) 2007 - 2010, 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 <PiDxe.h>
+#include <IndustryStandard/Sal.h>
+
+#include <Library/SalLib.h>
+#include <Library/UefiLib.h>
+#include <Library/DebugLib.h>
+
+#include <Guid/SalSystemTable.h>
+
+EFI_PLABEL       mPlabel;
+SAL_PROC         mSalProcEntry;
+
+/**
+  Makes a SAL procedure call.
+  
+  This is a wrapper function to make a SAL procedure call.  
+  No parameter checking is performed on the 8 input parameters,
+  but there are some common rules that the caller should follow
+  when making a SAL call.  Any address passed to SAL as buffers
+  for return parameters must be 8-byte aligned.  Unaligned
+  addresses may cause undefined results.  For those parameters
+  defined as reserved or some fields defined as reserved must be
+  zero filled or the invalid argument return value may be returned
+  or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param  Index       The SAL procedure Index number.
+  @param  Arg2        The 2nd parameter for SAL procedure calls.
+  @param  Arg3        The 3rd parameter for SAL procedure calls.
+  @param  Arg4        The 4th parameter for SAL procedure calls.
+  @param  Arg5        The 5th parameter for SAL procedure calls.
+  @param  Arg6        The 6th parameter for SAL procedure calls.
+  @param  Arg7        The 7th parameter for SAL procedure calls.
+  @param  Arg8        The 8th parameter for SAL procedure calls.
+
+  @return SAL returned registers.
+
+**/
+SAL_RETURN_REGS
+EFIAPI
+SalCall (
+  IN UINT64  Index,
+  IN UINT64  Arg2,
+  IN UINT64  Arg3,
+  IN UINT64  Arg4,
+  IN UINT64  Arg5,
+  IN UINT64  Arg6,
+  IN UINT64  Arg7,
+  IN UINT64  Arg8
+  )
+{
+  //
+  // mSalProcEntry is initialized in library constructor as SAL entry.
+  //
+  return mSalProcEntry(
+           Index,
+           Arg2,
+           Arg3,
+           Arg4,
+           Arg5,
+           Arg6,
+           Arg7,
+           Arg8
+           );
+
+}
+
+/**
+  The constructor function of UEFI SAL Lib.
+
+  The constructor function looks up the SAL System Table in the EFI System Configuration
+  Table. Once the SAL System Table is found, the SAL Entry Point in the SAL System Table
+  will be derived and stored into a global variable for library usage.
+  It will ASSERT() if the SAL System Table cannot be found or the data in the SAL System
+  Table is not the valid data.
+
+  @param  ImageHandle   The firmware allocated handle for the EFI image.
+  @param  SystemTable   A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
+
+**/
+EFI_STATUS
+EFIAPI
+UefiSalLibConstructor (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS                     Status;
+  SAL_ST_ENTRY_POINT_DESCRIPTOR  *SalStEntryDes;
+  SAL_SYSTEM_TABLE_HEADER        *SalSystemTable;
+
+  Status = EfiGetSystemConfigurationTable (
+             &gEfiSalSystemTableGuid,
+             (VOID **) &SalSystemTable
+             );
+  ASSERT_EFI_ERROR (Status);
+  ASSERT (SalSystemTable != NULL);
+
+  //
+  // Check the first entry of SAL System Table,
+  // because the SAL entry is in ascending order with the entry type,
+  // the type 0 entry should be the first if exist.
+  //
+  SalStEntryDes = (SAL_ST_ENTRY_POINT_DESCRIPTOR *)(SalSystemTable + 1);
+
+  //
+  // Assure the SAL ENTRY Type is 0
+  //
+  ASSERT (SalStEntryDes->Type == EFI_SAL_ST_ENTRY_POINT);
+
+  mPlabel.EntryPoint = SalStEntryDes->SalProcEntry;
+  mPlabel.GP = SalStEntryDes->SalGlobalDataPointer;
+  //
+  // Make sure the EntryPoint has the valid value
+  //
+  ASSERT ((mPlabel.EntryPoint != 0) && (mPlabel.GP != 0));
+
+  mSalProcEntry = (SAL_PROC)((UINT64)&(mPlabel.EntryPoint));
+
+  return EFI_SUCCESS;
+}
diff --git a/MdePkg/Library/UefiSalLib/UefiSalLib.inf b/MdePkg/Library/UefiSalLib/UefiSalLib.inf
new file mode 100644
index 000000000000..fbf81f4de932
--- /dev/null
+++ b/MdePkg/Library/UefiSalLib/UefiSalLib.inf
@@ -0,0 +1,47 @@
+## @file
+# UEFI Instance of SAL Library Class.
+#
+# This instance of SAL library retrieves the SAL Entry Point from the SAL System Table
+# register in the EFI System Confguration Table.
+#
+# Copyright (c) 2007 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiSalLib
+  MODULE_UNI_FILE                = UefiSalLib.uni
+  FILE_GUID                      = 4ABCFD77-4A33-4089-B003-5F09BCA940A2
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = SalLib|UEFI_DRIVER UEFI_APPLICATION
+
+  CONSTRUCTOR                    = UefiSalLibConstructor
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources]
+  UefiSalLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  UefiLib
+  DebugLib
+
+[Guids]
+  gEfiSalSystemTableGuid        ## CONSUMES ## SystemTable
+
diff --git a/MdePkg/Library/UefiSalLib/UefiSalLib.uni b/MdePkg/Library/UefiSalLib/UefiSalLib.uni
new file mode 100644
index 000000000000..ba17ab30580b
--- /dev/null
+++ b/MdePkg/Library/UefiSalLib/UefiSalLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// UEFI Instance of SAL Library Class.
+//
+// This instance of SAL library retrieves the SAL Entry Point from the SAL System Table
+// register in the EFI System Confguration Table.
+//
+// Copyright (c) 2007 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI Instance of SAL Library Class"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This instance of SAL library retrieves the SAL Entry Point from the SAL System Table register in the EFI System Configuration Table."
+
diff --git a/MdePkg/Library/UefiScsiLib/UefiScsiLib.c b/MdePkg/Library/UefiScsiLib/UefiScsiLib.c
new file mode 100644
index 000000000000..4d2a099a80d0
--- /dev/null
+++ b/MdePkg/Library/UefiScsiLib/UefiScsiLib.c
@@ -0,0 +1,2067 @@
+/** @file
+  UEFI SCSI Library implementation
+
+  Copyright (c) 2006 - 2015, 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 <Uefi.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiScsiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+  
+#include <IndustryStandard/Scsi.h>
+  
+  
+  //
+  // Scsi Command Length
+  //
+#define EFI_SCSI_OP_LENGTH_SIX      0x6
+#define EFI_SCSI_OP_LENGTH_TEN      0xa
+#define EFI_SCSI_OP_LENGTH_SIXTEEN  0x10
+
+//
+// The context structure used when non-blocking SCSI read/write operation
+// completes.
+//
+typedef struct {
+  ///
+  /// The SCSI request packet to send to the SCSI controller specified by
+  /// the device handle.
+  ///
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET      CommandPacket;
+  ///
+  /// The length of the output sense data.
+  ///
+  UINT8                                *SenseDataLength;
+  ///
+  /// The status of the SCSI host adapter.
+  ///
+  UINT8                                *HostAdapterStatus;
+  ///
+  /// The status of the target SCSI device.
+  ///
+  UINT8                                *TargetStatus;
+  ///
+  /// The length of the data buffer for the SCSI read/write command.
+  ///
+  UINT32                               *DataLength;
+  ///
+  /// The caller event to be signaled when the SCSI read/write command
+  /// completes.
+  ///
+  EFI_EVENT                            CallerEvent;
+} EFI_SCSI_LIB_ASYNC_CONTEXT;
+
+
+
+/**
+  Execute Test Unit Ready SCSI command on a specific SCSI target.
+
+  Executes the Test Unit Ready command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]     ScsiIo             A pointer to the SCSI I/O Protocol instance
+                                    for the specific SCSI target.
+  @param[in]     Timeout            The timeout in 100 ns units to use for the execution
+                                    of this SCSI Request Packet. A Timeout value of
+                                    zero means that this function will wait indefinitely
+                                    for the SCSI Request Packet to execute. If Timeout
+                                    is greater than zero, then this function will return
+                                    EFI_TIMEOUT if the time required to execute the SCSI
+                                    Request Packet is greater than Timeout.
+  @param[in, out] SenseData         A pointer to sense data that was generated by
+                                    the execution of the SCSI Request Packet. This
+                                    buffer must be allocated by the caller.
+                                    If SenseDataLength is 0, then this parameter is
+                                    optional and may be NULL.
+  @param[in, out] SenseDataLength   On input, a pointer to the length in bytes of
+                                    the SenseData buffer. On output, a pointer to
+                                    the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus The status of the SCSI Host Controller that produces
+                                    the SCSI bus containing the SCSI target specified by
+                                    ScsiIo when the SCSI Request Packet was executed.
+                                    See the EFI SCSI I/O Protocol in the UEFI Specification
+                                    for details on the possible return values.
+  @param[out]     TargetStatus      The status returned by the SCSI target specified
+                                    by ScsiIo when the SCSI Request Packet was executed
+                                    on the SCSI Host Controller. See the EFI SCSI I/O
+                                    Protocol in the UEFI Specification for details on
+                                    the possible return values. 
+
+  @retval EFI_SUCCESS               The command was executed successfully.
+                                    See HostAdapterStatus, TargetStatus, SenseDataLength,
+                                    and SenseData in that order for additional status
+                                    information.
+  @retval EFI_NOT_READY             The SCSI Request Packet could not be sent because
+                                    there are too many SCSI Command Packets already
+                                    queued. The SCSI Request Packet was not sent, so
+                                    no additional status information is available.
+                                    The caller may retry again later.
+  @retval EFI_DEVICE_ERROR          A device error occurred while attempting to send
+                                    SCSI Request Packet.  See HostAdapterStatus,
+                                    TargetStatus, SenseDataLength, and SenseData in that
+                                    order for additional status information.
+  @retval EFI_UNSUPPORTED           The command described by the SCSI Request Packet
+                                    is not supported by the SCSI initiator(i.e., SCSI
+                                    Host Controller). The SCSI Request Packet was not
+                                    sent, so no additional status information is available.
+  @retval EFI_TIMEOUT               A timeout occurred while waiting for the SCSI Request
+                                    Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                    SenseDataLength, and SenseData in that order for
+                                    additional status information.
+  @retval EFI_INVALID_PARAMETER     The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiTestUnitReadyCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_SIX];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_SIX);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = NULL;
+  CommandPacket.InTransferLength= 0;
+  CommandPacket.OutDataBuffer    = NULL;
+  CommandPacket.OutTransferLength= 0;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Test Unit Ready Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_TEST_UNIT_READY;
+  CommandPacket.CdbLength       = (UINT8) EFI_SCSI_OP_LENGTH_SIX;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Inquiry SCSI command on a specific SCSI target.
+
+  Executes the Inquiry command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If InquiryDataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If InquiryDataLength is non-zero and InquiryDataBuffer is not NULL, InquiryDataBuffer
+  must meet buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo                 A pointer to the SCSI I/O Protocol instance
+                                         for the specific SCSI target.
+  @param[in]      Timeout                The timeout in 100 ns units to use for the
+                                         execution of this SCSI Request Packet. A Timeout
+                                         value of zero means that this function will wait
+                                         indefinitely for the SCSI Request Packet to execute.
+                                         If Timeout is greater than zero, then this function
+                                         will return EFI_TIMEOUT if the time required to
+                                         execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out] SenseData              A pointer to sense data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If SenseDataLength is 0, then this parameter
+                                         is optional and may be NULL.
+  @param[in, out] SenseDataLength        On input, the length in bytes of the SenseData buffer.
+                                         On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus      The status of the SCSI Host Controller that
+                                         produces the SCSI bus containing the SCSI
+                                         target specified by ScsiIo when the SCSI
+                                         Request Packet was executed.  See the EFI
+                                         SCSI I/O Protocol in the UEFI Specification
+                                         for details on the possible return values.
+  @param[out]     TargetStatus           The status returned by the SCSI target specified
+                                         by ScsiIo when the SCSI Request Packet was
+                                         executed on the SCSI Host Controller.
+                                         See the EFI SCSI I/O Protocol in the UEFI
+                                         Specification for details on the possible
+                                         return values. 
+  @param[in, out] InquiryDataBuffer      A pointer to inquiry data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If InquiryDataLength is 0, then this parameter
+                                         is optional and may be NULL. 
+  @param[in, out] InquiryDataLength      On input, a pointer to the length in bytes
+                                         of the InquiryDataBuffer buffer.
+                                         On output, a pointer to the number of bytes
+                                         written to the InquiryDataBuffer buffer.
+  @param[in]      EnableVitalProductData If TRUE, then the supported vital product
+                                         data for the PageCode is returned in InquiryDataBuffer.
+                                         If FALSE, then the standard inquiry data is
+                                         returned in InquiryDataBuffer and PageCode is ignored.
+  @param[in]      PageCode               The page code of the vital product data.
+                                         It's ignored if EnableVitalProductData is FALSE.
+
+  @retval EFI_SUCCESS                    The command executed successfully. See HostAdapterStatus,
+                                         TargetStatus, SenseDataLength, and SenseData in that order
+                                         for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE            The SCSI Request Packet was executed, but the entire
+                                         InquiryDataBuffer could not be transferred. The actual
+                                         number of bytes transferred is returned in InquiryDataLength.
+  @retval EFI_NOT_READY                  The SCSI Request Packet could not be sent because there
+                                         are too many SCSI Command Packets already queued.
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR               A device error occurred while attempting to send SCSI
+                                         Request Packet.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for additional
+                                         status information.
+  @retval EFI_UNSUPPORTED                The command described by the SCSI Request Packet is not
+                                         supported by the SCSI initiator(i.e., SCSI  Host Controller).
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available.
+  @retval EFI_TIMEOUT                    A timeout occurred while waiting for the SCSI Request
+                                         Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for
+                                         additional status information.
+  @retval EFI_INVALID_PARAMETER          The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiInquiryCommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *InquiryDataBuffer,    OPTIONAL
+  IN OUT UINT32                *InquiryDataLength,
+  IN     BOOLEAN               EnableVitalProductData,
+  IN     UINT8                 PageCode
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_SIX];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (InquiryDataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_SIX);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = InquiryDataBuffer;
+  CommandPacket.InTransferLength= *InquiryDataLength;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+  CommandPacket.Cdb             = Cdb;
+
+  Cdb[0]  = EFI_SCSI_OP_INQUIRY;
+  if (EnableVitalProductData) {
+    Cdb[1] |= 0x01;
+    Cdb[2]  = PageCode;
+  }
+
+  if (*InquiryDataLength > 0xff) {
+    *InquiryDataLength = 0xff;
+  }
+
+  Cdb[4]                      = (UINT8) (*InquiryDataLength);
+  CommandPacket.CdbLength     = (UINT8) EFI_SCSI_OP_LENGTH_SIX;
+  CommandPacket.DataDirection = EFI_SCSI_DATA_IN;
+
+  Status                      = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus          = CommandPacket.HostAdapterStatus;
+  *TargetStatus               = CommandPacket.TargetStatus;
+  *SenseDataLength            = CommandPacket.SenseDataLength;
+  *InquiryDataLength          = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Inquiry SCSI command on a specific SCSI target.
+
+  Executes the Inquiry command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If InquiryDataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If InquiryDataLength is non-zero and InquiryDataBuffer is not NULL, InquiryDataBuffer
+  must meet buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo                 A pointer to the SCSI I/O Protocol instance
+                                         for the specific SCSI target.
+  @param[in]      Timeout                The timeout in 100 ns units to use for the
+                                         execution of this SCSI Request Packet. A Timeout
+                                         value of zero means that this function will wait
+                                         indefinitely for the SCSI Request Packet to execute.
+                                         If Timeout is greater than zero, then this function
+                                         will return EFI_TIMEOUT if the time required to
+                                         execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out] SenseData              A pointer to sense data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If SenseDataLength is 0, then this parameter
+                                         is optional and may be NULL.
+  @param[in, out] SenseDataLength        On input, the length in bytes of the SenseData buffer.
+                                         On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus      The status of the SCSI Host Controller that
+                                         produces the SCSI bus containing the SCSI
+                                         target specified by ScsiIo when the SCSI
+                                         Request Packet was executed.  See the EFI
+                                         SCSI I/O Protocol in the UEFI Specification
+                                         for details on the possible return values.
+  @param[out]     TargetStatus           The status returned by the SCSI target specified
+                                         by ScsiIo when the SCSI Request Packet was
+                                         executed on the SCSI Host Controller.
+                                         See the EFI SCSI I/O Protocol in the UEFI
+                                         Specification for details on the possible
+                                         return values. 
+  @param[in, out] InquiryDataBuffer      A pointer to inquiry data that was generated
+                                         by the execution of the SCSI Request Packet.
+                                         This buffer must be allocated by the caller.
+                                         If InquiryDataLength is 0, then this parameter
+                                         is optional and may be NULL. 
+  @param[in, out] InquiryDataLength      On input, a pointer to the length in bytes
+                                         of the InquiryDataBuffer buffer.
+                                         On output, a pointer to the number of bytes
+                                         written to the InquiryDataBuffer buffer.
+  @param[in]      EnableVitalProductData If TRUE, then the supported vital product
+                                         data is returned in InquiryDataBuffer.
+                                         If FALSE, then the standard inquiry data is
+                                         returned in InquiryDataBuffer. 
+
+  @retval EFI_SUCCESS                    The command was executed successfully. See HostAdapterStatus,
+                                         TargetStatus, SenseDataLength, and SenseData in that order
+                                         for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE            The SCSI Request Packet was executed, but the entire
+                                         InquiryDataBuffer could not be transferred. The actual
+                                         number of bytes transferred is returned in InquiryDataLength.
+  @retval EFI_NOT_READY                  The SCSI Request Packet could not be sent because there
+                                         are too many SCSI Command Packets already queued.
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available. The caller may retry again later.
+  @retval EFI_DEVICE_ERROR               A device error occurred while attempting to send SCSI
+                                         Request Packet.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for additional
+                                         status information.
+  @retval EFI_UNSUPPORTED                The command described by the SCSI Request Packet is not
+                                         supported by the SCSI initiator(i.e., SCSI  Host Controller).
+                                         The SCSI Request Packet was not sent, so no additional
+                                         status information is available.
+  @retval EFI_TIMEOUT                    A timeout occurred while waiting for the SCSI Request
+                                         Packet to execute.  See HostAdapterStatus, TargetStatus,
+                                         SenseDataLength, and SenseData in that order for
+                                         additional status information.
+  @retval EFI_INVALID_PARAMETER          The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiInquiryCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *InquiryDataBuffer,    OPTIONAL
+  IN OUT UINT32                *InquiryDataLength,
+  IN     BOOLEAN               EnableVitalProductData
+  )
+{
+  return ScsiInquiryCommandEx (
+           ScsiIo,
+           Timeout,
+           SenseData,
+           SenseDataLength,
+           HostAdapterStatus,
+           TargetStatus,
+           InquiryDataBuffer,
+           InquiryDataLength,
+           EnableVitalProductData,
+           0
+           );
+}
+
+/**
+  Execute Mode Sense(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Mode Sense(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The DBDField, PageControl, and PageCode parameters
+  are used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo             A pointer to the SCSI I/O Protocol instance
+                                     for the specific SCSI target.
+  @param[in]      Timeout            The timeout in 100 ns units to use for the
+                                     execution of this SCSI Request Packet. A Timeout
+                                     value of zero means that this function will wait
+                                     indefinitely for the SCSI Request Packet to execute.
+                                     If Timeout is greater than zero, then this function
+                                     will return EFI_TIMEOUT if the time required to
+                                     execute the SCSI Request Packet is greater than Timeout.
+  @param[in, out]  SenseData         A pointer to sense data that was generated
+                                     by the execution of the SCSI Request Packet.
+                                     This buffer must be allocated by the caller.
+                                     If SenseDataLength is 0, then this parameter
+                                     is optional and may be NULL.
+  @param[in, out]  SenseDataLength   On input, the length in bytes of the SenseData buffer.
+                                     On output, the number of bytes written to the SenseData buffer. 
+  @param[out]     HostAdapterStatus  The status of the SCSI Host Controller that
+                                     produces the SCSI bus containing the SCSI target
+                                     specified by ScsiIo when the SCSI Request Packet
+                                     was executed. See the EFI SCSI I/O Protocol in the
+                                     UEFI Specification for details on the possible
+                                     return values.
+  @param[out]     TargetStatus       The status returned by the SCSI target specified
+                                     by ScsiIo when the SCSI Request Packet was executed
+                                     on the SCSI Host Controller.  See the EFI SCSI
+                                     I/O Protocol in the UEFI Specification for details
+                                     on the possible return values.
+  @param[in, out]  DataBuffer        A pointer to data that was generated by the
+                                     execution of the SCSI Request Packet.  This
+                                     buffer must be allocated by the caller. If
+                                     DataLength is 0, then this parameter is optional
+                                     and may be NULL. 
+  @param[in, out]  DataLength        On input, a pointer to the length in bytes of
+                                     the DataBuffer buffer.  On output, a pointer
+                                     to the number of bytes written to the DataBuffer
+                                     buffer. 
+  @param[in]      DBDField           Specifies the DBD field of the CDB for this SCSI Command.
+  @param[in]      PageControl        Specifies the PC field of the CDB for this SCSI Command. 
+  @param[in]      PageCode           Specifies the Page Control field of the CDB for this SCSI Command. 
+
+  @retval EFI_SUCCESS                The command was executed successfully.
+                                     See HostAdapterStatus, TargetStatus, SenseDataLength,
+                                     and SenseData in that order for additional status information.
+  @retval EFI_BAD_BUFFER_SIZE        The SCSI Request Packet was executed, but the
+                                     entire DataBuffer could not be transferred.
+                                     The actual number of bytes transferred is returned
+                                     in DataLength.
+  @retval EFI_NOT_READY              The SCSI Request Packet could not be sent because
+                                     there are too many SCSI Command Packets already queued.
+                                     The SCSI Request Packet was not sent, so no additional
+                                     status information is available.  The caller may retry
+                                     again later.
+  @retval EFI_DEVICE_ERROR           A device error occurred while attempting to send
+                                     SCSI Request Packet.  See HostAdapterStatus, TargetStatus,
+                                     SenseDataLength, and SenseData in that order for
+                                     additional status information.
+  @retval EFI_UNSUPPORTED            The command described by the SCSI Request Packet
+                                     is not supported by the SCSI initiator(i.e., SCSI
+                                     Host Controller). The SCSI Request Packet was not
+                                     sent, so no additional status information is available.
+  @retval EFI_TIMEOUT                A timeout occurred while waiting for the SCSI
+                                     Request Packet to execute.  See HostAdapterStatus,
+                                     TargetStatus, SenseDataLength, and SenseData in that
+                                     order for additional status information.
+  @retval EFI_INVALID_PARAMETER      The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiModeSense10Command (
+  IN     EFI_SCSI_IO_PROTOCOL    *ScsiIo,
+  IN     UINT64                  Timeout,
+  IN OUT VOID                    *SenseData,  OPTIONAL
+  IN OUT UINT8                   *SenseDataLength,
+     OUT UINT8                   *HostAdapterStatus,
+     OUT UINT8                   *TargetStatus,
+  IN OUT VOID                    *DataBuffer, OPTIONAL
+  IN OUT UINT32                  *DataLength,
+  IN     UINT8                   DBDField,    OPTIONAL
+  IN     UINT8                   PageControl,
+  IN     UINT8                   PageCode
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_TEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_TEN);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = DataBuffer;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.InTransferLength= *DataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Mode Sense (10) Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_MODE_SEN10;
+  //
+  // DBDField is in Cdb[1] bit3 of (bit7..0)
+  //
+  Cdb[1]                        = (UINT8) ((DBDField << 3) & 0x08);
+  //
+  // PageControl is in Cdb[2] bit7..6, PageCode is in Cdb[2] bit5..0
+  //
+  Cdb[2]                        = (UINT8) (((PageControl << 6) & 0xc0) | (PageCode & 0x3f));
+  Cdb[7]                        = (UINT8) (*DataLength >> 8);
+  Cdb[8]                        = (UINT8) (*DataLength);
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Request Sense SCSI command on a specific SCSI target.
+
+  Executes the Request Sense command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after Timeout 100 ns units.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]       ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]       Timeout              The length of timeout period.
+  @param[in, out]  SenseData            A pointer to output sense data.
+  @param[in, out]  SenseDataLength      The length of output sense data.
+  @param[out]      HostAdapterStatus    The status of Host Adapter.
+  @param[out]      TargetStatus         The status of the target.
+
+  @retval EFI_SUCCESS                   Command is executed successfully.
+  @retval EFI_NOT_READY                 The SCSI Request Packet could not be sent because there are
+                                        too many SCSI Command Packets already queued.
+  @retval EFI_DEVICE_ERROR              A device error occurred while attempting to send SCSI Request Packet.
+  @retval EFI_UNSUPPORTED               The command described by the SCSI Request Packet is not supported by
+                                        the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval EFI_TIMEOUT                   A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval EFI_INVALID_PARAMETER         The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRequestSenseCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_SIX];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_SIX);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = SenseData;
+  CommandPacket.SenseData       = NULL;
+  CommandPacket.InTransferLength= *SenseDataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Request Sense Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_REQUEST_SENSE;
+  Cdb[4]                        = (UINT8) (*SenseDataLength);
+
+  CommandPacket.CdbLength       = (UINT8) EFI_SCSI_OP_LENGTH_SIX;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = 0;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = (UINT8) CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Read Capacity SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read Capacity command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The Pmi parameter is used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      Pmi                  Partial medium indicator.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire
+                                       DataBuffer could not be transferred. The actual
+                                       number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because
+                                       there are too many SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet
+                                       is not supported by the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiReadCapacityCommand (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,    OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,   OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     BOOLEAN               Pmi
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_TEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_TEN);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = DataBuffer;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.InTransferLength= *DataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Read Capacity Command
+  //
+  Cdb[0]  = EFI_SCSI_OP_READ_CAPACITY;
+  if (!Pmi) {
+    //
+    // Partial medium indicator,if Pmi is FALSE, the Cdb.2 ~ Cdb.5 MUST BE ZERO.
+    //
+    ZeroMem ((Cdb + 2), 4);
+  } else {
+    Cdb[8] |= 0x01;
+  }
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Read Capacity SCSI 16 command on a specific SCSI target.
+
+  Executes the SCSI Read Capacity 16 command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The Pmi parameter is used to construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      Pmi                  Partial medium indicator.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire
+                                       DataBuffer could not be transferred. The actual
+                                       number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because
+                                       there are too many SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet
+                                       is not supported by the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiReadCapacity16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,  OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer, OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     BOOLEAN               Pmi
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[16];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, 16);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = DataBuffer;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.InTransferLength= *DataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Read Capacity Command
+  //
+  Cdb[0]  = EFI_SCSI_OP_READ_CAPACITY16;
+  Cdb[1]  = 0x10;
+  if (!Pmi) {
+    //
+    // Partial medium indicator,if Pmi is FALSE, the Cdb.2 ~ Cdb.9 MUST BE ZERO.
+    //
+    ZeroMem ((Cdb + 2), 8);
+  } else {
+    Cdb[14] |= 0x01;
+  }
+
+  Cdb[13] = 0x20;
+  CommandPacket.CdbLength       = 16;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Read(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The StartLba and SectorSize parameters are used to
+  construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 10 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead10Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_TEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_TEN);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.InDataBuffer    = DataBuffer;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.InTransferLength= *DataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Read (10) Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_READ10;
+  WriteUnaligned32 ((UINT32 *)&Cdb[2], SwapBytes32 (StartLba));
+  WriteUnaligned16 ((UINT16 *)&Cdb[7], SwapBytes16 ((UINT16) SectorSize));
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Write(10) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Write(10) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The StartLba and SectorSize parameters are used to construct
+  the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite10Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_TEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_TEN);
+
+  CommandPacket.Timeout         = Timeout;
+  CommandPacket.OutDataBuffer    = DataBuffer;
+  CommandPacket.SenseData       = SenseData;
+  CommandPacket.OutTransferLength= *DataLength;
+  CommandPacket.Cdb             = Cdb;
+  //
+  // Fill Cdb for Write (10) Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_WRITE10;
+  WriteUnaligned32 ((UINT32 *)&Cdb[2], SwapBytes32 (StartLba));
+  WriteUnaligned16 ((UINT16 *)&Cdb[7], SwapBytes16 ((UINT16) SectorSize));
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_OUT;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.OutTransferLength;
+
+  return Status;
+}
+
+/**
+  Execute Read(16) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Read(16) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout
+  after Timeout 100 ns units.  The StartLba and SectorSize parameters are used to
+  construct the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_SIXTEEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_SIXTEEN);
+
+  CommandPacket.Timeout          = Timeout;
+  CommandPacket.InDataBuffer     = DataBuffer;
+  CommandPacket.SenseData        = SenseData;
+  CommandPacket.InTransferLength = *DataLength;
+  CommandPacket.Cdb              = Cdb;
+  //
+  // Fill Cdb for Read (16) Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_READ16;
+  WriteUnaligned64 ((UINT64 *)&Cdb[2], SwapBytes64 (StartLba));
+  WriteUnaligned32 ((UINT32 *)&Cdb[10], SwapBytes32 (SectorSize));
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_SIXTEEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_IN;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.InTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Execute Write(16) SCSI command on a specific SCSI target.
+
+  Executes the SCSI Write(16) command on the SCSI target specified by ScsiIo.
+  If Timeout is zero, then this function waits indefinitely for the command to complete.
+  If Timeout is greater than zero, then the command is executed and will timeout after
+  Timeout 100 ns units.  The StartLba and SectorSize parameters are used to construct
+  the CDB for this SCSI command.
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet buffer
+  alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise EFI_INVALID_PARAMETER
+  gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks of data that shall be transferred.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed, but the entire DataBuffer could
+                                       not be transferred. The actual number of bytes transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be sent because there are too many
+                                       SCSI Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI Request Packet is not supported by
+                                       the SCSI initiator(i.e., SCSI  Host Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet are invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite16Command (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize
+  )
+{
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           Cdb[EFI_SCSI_OP_LENGTH_SIXTEEN];
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  ZeroMem (&CommandPacket, sizeof (EFI_SCSI_IO_SCSI_REQUEST_PACKET));
+  ZeroMem (Cdb, EFI_SCSI_OP_LENGTH_SIXTEEN);
+
+  CommandPacket.Timeout           = Timeout;
+  CommandPacket.OutDataBuffer     = DataBuffer;
+  CommandPacket.SenseData         = SenseData;
+  CommandPacket.OutTransferLength = *DataLength;
+  CommandPacket.Cdb               = Cdb;
+  //
+  // Fill Cdb for Write (16) Command
+  //
+  Cdb[0]                        = EFI_SCSI_OP_WRITE16;
+  WriteUnaligned64 ((UINT64 *)&Cdb[2], SwapBytes64 (StartLba));
+  WriteUnaligned32 ((UINT32 *)&Cdb[10], SwapBytes32 (SectorSize));
+
+  CommandPacket.CdbLength       = EFI_SCSI_OP_LENGTH_SIXTEEN;
+  CommandPacket.DataDirection   = EFI_SCSI_DATA_OUT;
+  CommandPacket.SenseDataLength = *SenseDataLength;
+
+  Status                        = ScsiIo->ExecuteScsiCommand (ScsiIo, &CommandPacket, NULL);
+
+  *HostAdapterStatus            = CommandPacket.HostAdapterStatus;
+  *TargetStatus                 = CommandPacket.TargetStatus;
+  *SenseDataLength              = CommandPacket.SenseDataLength;
+  *DataLength                   = CommandPacket.OutTransferLength;
+
+  return Status;
+}
+
+
+/**
+  Internal helper notify function in which update the result of the
+  non-blocking SCSI Read/Write commands and signal caller event.
+
+  @param  Event    The instance of EFI_EVENT.
+  @param  Context  The parameter passed in.
+
+**/
+VOID
+EFIAPI
+ScsiLibNotify (
+  IN  EFI_EVENT  Event,
+  IN  VOID       *Context
+  )
+{
+  EFI_SCSI_LIB_ASYNC_CONTEXT      *LibContext;
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET *CommandPacket;
+  EFI_EVENT                       CallerEvent;
+
+  LibContext    = (EFI_SCSI_LIB_ASYNC_CONTEXT *) Context;
+  CommandPacket = &LibContext->CommandPacket;
+  CallerEvent  = LibContext->CallerEvent;
+
+  //
+  // Update SCSI Read/Write operation results
+  //
+  *LibContext->SenseDataLength    = CommandPacket->SenseDataLength;
+  *LibContext->HostAdapterStatus  = CommandPacket->HostAdapterStatus;
+  *LibContext->TargetStatus       = CommandPacket->TargetStatus;
+  if (CommandPacket->InDataBuffer != NULL) {
+    *LibContext->DataLength       = CommandPacket->InTransferLength;
+  } else {
+    *LibContext->DataLength       = CommandPacket->OutTransferLength;
+  }
+
+  if (CommandPacket->Cdb != NULL) {
+    FreePool (CommandPacket->Cdb);
+  }
+  FreePool (Context);
+
+  gBS->CloseEvent (Event);
+  gBS->SignalEvent (CallerEvent);
+}
+
+
+/**
+  Execute blocking/non-blocking Read(10) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Read(10) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Read(10) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead10CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  )
+{
+  EFI_SCSI_LIB_ASYNC_CONTEXT      *Context;
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET *CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           *Cdb;
+  EFI_EVENT                       SelfEvent;
+
+  if (Event == NULL) {
+    return ScsiRead10Command (
+             ScsiIo,
+             Timeout,
+             SenseData,
+             SenseDataLength,
+             HostAdapterStatus,
+             TargetStatus,
+             DataBuffer,
+             DataLength,
+             StartLba,
+             SectorSize
+             );
+  }
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  Context = AllocateZeroPool (sizeof (EFI_SCSI_LIB_ASYNC_CONTEXT));
+  if (Context == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Cdb = AllocateZeroPool (EFI_SCSI_OP_LENGTH_TEN);
+  if (Cdb == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto ErrorExit;
+  }
+
+  Context->SenseDataLength        = SenseDataLength;
+  Context->HostAdapterStatus      = HostAdapterStatus;
+  Context->TargetStatus           = TargetStatus;
+  Context->CallerEvent            = Event;
+
+  CommandPacket                   = &Context->CommandPacket;
+  CommandPacket->Timeout          = Timeout;
+  CommandPacket->InDataBuffer     = DataBuffer;
+  CommandPacket->SenseData        = SenseData;
+  CommandPacket->InTransferLength = *DataLength;
+  CommandPacket->Cdb              = Cdb;
+  //
+  // Fill Cdb for Read (10) Command
+  //
+  Cdb[0]                          = EFI_SCSI_OP_READ10;
+  WriteUnaligned32 ((UINT32 *)&Cdb[2], SwapBytes32 (StartLba));
+  WriteUnaligned16 ((UINT16 *)&Cdb[7], SwapBytes16 ((UINT16) SectorSize));
+
+  CommandPacket->CdbLength        = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket->DataDirection    = EFI_SCSI_DATA_IN;
+  CommandPacket->SenseDataLength  = *SenseDataLength;
+
+  //
+  // Create Event
+  //
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  ScsiLibNotify,
+                  Context,
+                  &SelfEvent
+                  );
+  if (EFI_ERROR(Status)) {
+    goto ErrorExit;
+  }
+
+  Status = ScsiIo->ExecuteScsiCommand (ScsiIo, CommandPacket, SelfEvent);
+  if (EFI_ERROR(Status)) {
+    //
+    // Since ScsiLibNotify() will not be signaled if ExecuteScsiCommand()
+    // returns with error, close the event here.
+    //
+    gBS->CloseEvent (SelfEvent);
+    goto ErrorExit;
+  } else {
+    return EFI_SUCCESS;
+  }
+
+ErrorExit:
+  if (Context != NULL) {
+    FreePool (Context);
+  }
+
+  return Status;
+}
+
+
+/**
+  Execute blocking/non-blocking Write(10) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Write(10) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Write(10) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite10CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT32                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  )
+{
+  EFI_SCSI_LIB_ASYNC_CONTEXT      *Context;
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET *CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           *Cdb;
+  EFI_EVENT                       SelfEvent;
+
+  if (Event == NULL) {
+    return ScsiWrite10Command (
+             ScsiIo,
+             Timeout,
+             SenseData,
+             SenseDataLength,
+             HostAdapterStatus,
+             TargetStatus,
+             DataBuffer,
+             DataLength,
+             StartLba,
+             SectorSize
+             );
+  }
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  Context = AllocateZeroPool (sizeof (EFI_SCSI_LIB_ASYNC_CONTEXT));
+  if (Context == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Cdb = AllocateZeroPool (EFI_SCSI_OP_LENGTH_TEN);
+  if (Cdb == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto ErrorExit;
+  }
+
+  Context->SenseDataLength         = SenseDataLength;
+  Context->HostAdapterStatus       = HostAdapterStatus;
+  Context->TargetStatus            = TargetStatus;
+  Context->CallerEvent             = Event;
+
+  CommandPacket                    = &Context->CommandPacket;
+  CommandPacket->Timeout           = Timeout;
+  CommandPacket->OutDataBuffer     = DataBuffer;
+  CommandPacket->SenseData         = SenseData;
+  CommandPacket->OutTransferLength = *DataLength;
+  CommandPacket->Cdb               = Cdb;
+  //
+  // Fill Cdb for Write (10) Command
+  //
+  Cdb[0]                           = EFI_SCSI_OP_WRITE10;
+  WriteUnaligned32 ((UINT32 *)&Cdb[2], SwapBytes32 (StartLba));
+  WriteUnaligned16 ((UINT16 *)&Cdb[7], SwapBytes16 ((UINT16) SectorSize));
+
+  CommandPacket->CdbLength         = EFI_SCSI_OP_LENGTH_TEN;
+  CommandPacket->DataDirection     = EFI_SCSI_DATA_OUT;
+  CommandPacket->SenseDataLength   = *SenseDataLength;
+
+  //
+  // Create Event
+  //
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  ScsiLibNotify,
+                  Context,
+                  &SelfEvent
+                  );
+  if (EFI_ERROR(Status)) {
+    goto ErrorExit;
+  }
+
+  Status = ScsiIo->ExecuteScsiCommand (ScsiIo, CommandPacket, SelfEvent);
+  if (EFI_ERROR(Status)) {
+    //
+    // Since ScsiLibNotify() will not be signaled if ExecuteScsiCommand()
+    // returns with error, close the event here.
+    //
+    gBS->CloseEvent (SelfEvent);
+    goto ErrorExit;
+  } else {
+    return EFI_SUCCESS;
+  }
+
+ErrorExit:
+  if (Context != NULL) {
+    FreePool (Context);
+  }
+
+  return Status;
+}
+
+
+/**
+  Execute blocking/non-blocking Read(16) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Read(16) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               A pointer to SCSI IO protocol.
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           Read 16 command data.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Read(16) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiRead16CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  )
+{
+  EFI_SCSI_LIB_ASYNC_CONTEXT      *Context;
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET *CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           *Cdb;
+  EFI_EVENT                       SelfEvent;
+
+  if (Event == NULL) {
+    return ScsiRead16Command (
+             ScsiIo,
+             Timeout,
+             SenseData,
+             SenseDataLength,
+             HostAdapterStatus,
+             TargetStatus,
+             DataBuffer,
+             DataLength,
+             StartLba,
+             SectorSize
+             );
+  }
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  Context = AllocateZeroPool (sizeof (EFI_SCSI_LIB_ASYNC_CONTEXT));
+  if (Context == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Cdb = AllocateZeroPool (EFI_SCSI_OP_LENGTH_SIXTEEN);
+  if (Cdb == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto ErrorExit;
+  }
+
+  Context->SenseDataLength        = SenseDataLength;
+  Context->HostAdapterStatus      = HostAdapterStatus;
+  Context->TargetStatus           = TargetStatus;
+  Context->CallerEvent            = Event;
+
+  CommandPacket                   = &Context->CommandPacket;
+  CommandPacket->Timeout          = Timeout;
+  CommandPacket->InDataBuffer     = DataBuffer;
+  CommandPacket->SenseData        = SenseData;
+  CommandPacket->InTransferLength = *DataLength;
+  CommandPacket->Cdb              = Cdb;
+  //
+  // Fill Cdb for Read (16) Command
+  //
+  Cdb[0]                          = EFI_SCSI_OP_READ16;
+  WriteUnaligned64 ((UINT64 *)&Cdb[2], SwapBytes64 (StartLba));
+  WriteUnaligned32 ((UINT32 *)&Cdb[10], SwapBytes32 (SectorSize));
+
+  CommandPacket->CdbLength        = EFI_SCSI_OP_LENGTH_SIXTEEN;
+  CommandPacket->DataDirection    = EFI_SCSI_DATA_IN;
+  CommandPacket->SenseDataLength  = *SenseDataLength;
+
+  //
+  // Create Event
+  //
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  ScsiLibNotify,
+                  Context,
+                  &SelfEvent
+                  );
+  if (EFI_ERROR(Status)) {
+    goto ErrorExit;
+  }
+
+  Status = ScsiIo->ExecuteScsiCommand (ScsiIo, CommandPacket, SelfEvent);
+  if (EFI_ERROR(Status)) {
+    //
+    // Since ScsiLibNotify() will not be signaled if ExecuteScsiCommand()
+    // returns with error, close the event here.
+    //
+    gBS->CloseEvent (SelfEvent);
+    goto ErrorExit;
+  } else {
+    return EFI_SUCCESS;
+  }
+
+ErrorExit:
+  if (Context != NULL) {
+    FreePool (Context);
+  }
+
+  return Status;
+}
+
+
+/**
+  Execute blocking/non-blocking Write(16) SCSI command on a specific SCSI
+  target.
+
+  Executes the SCSI Write(16) command on the SCSI target specified by ScsiIo.
+  When Event is NULL, blocking command will be executed. Otherwise non-blocking
+  command will be executed.
+  For blocking I/O, if Timeout is zero, this function will wait indefinitely
+  for the command to complete. If Timeout is greater than zero, then the
+  command is executed and will timeout after Timeout 100 ns units.
+  For non-blocking I/O, if Timeout is zero, Event will be signaled only after
+  the command to completes. If Timeout is greater than zero, Event will also be
+  signaled after Timeout 100 ns units.
+  The StartLba and SectorSize parameters are used to construct the CDB for this
+  SCSI command.
+
+  If ScsiIo is NULL, then ASSERT().
+  If SenseDataLength is NULL, then ASSERT().
+  If HostAdapterStatus is NULL, then ASSERT().
+  If TargetStatus is NULL, then ASSERT().
+  If DataLength is NULL, then ASSERT().
+
+  If SenseDataLength is non-zero and SenseData is not NULL, SenseData must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  If DataLength is non-zero and DataBuffer is not NULL, DataBuffer must meet
+  buffer alignment requirement defined in EFI_SCSI_IO_PROTOCOL. Otherwise
+  EFI_INVALID_PARAMETER gets returned.
+
+  @param[in]      ScsiIo               SCSI IO Protocol to use
+  @param[in]      Timeout              The length of timeout period.
+  @param[in, out] SenseData            A pointer to output sense data.
+  @param[in, out] SenseDataLength      The length of output sense data.
+  @param[out]     HostAdapterStatus    The status of Host Adapter.
+  @param[out]     TargetStatus         The status of the target.
+  @param[in, out] DataBuffer           A pointer to a data buffer.
+  @param[in, out] DataLength           The length of data buffer.
+  @param[in]      StartLba             The start address of LBA.
+  @param[in]      SectorSize           The number of contiguous logical blocks
+                                       of data that shall be transferred.
+  @param[in]      Event                If the SCSI target does not support
+                                       non-blocking I/O, then Event is ignored,
+                                       and blocking I/O is performed. If Event
+                                       is NULL, then blocking I/O is performed.
+                                       If Event is not NULL and non-blocking
+                                       I/O is supported, then non-blocking I/O
+                                       is performed, and Event will be signaled
+                                       when the SCSI Write(16) command
+                                       completes.
+
+  @retval  EFI_SUCCESS                 Command is executed successfully.
+  @retval  EFI_BAD_BUFFER_SIZE         The SCSI Request Packet was executed,
+                                       but the entire DataBuffer could not be
+                                       transferred. The actual number of bytes
+                                       transferred is returned in DataLength.
+  @retval  EFI_NOT_READY               The SCSI Request Packet could not be
+                                       sent because there are too many SCSI
+                                       Command Packets already queued.
+  @retval  EFI_DEVICE_ERROR            A device error occurred while attempting
+                                       to send SCSI Request Packet.
+  @retval  EFI_UNSUPPORTED             The command described by the SCSI
+                                       Request Packet is not supported by the
+                                       SCSI initiator(i.e., SCSI  Host
+                                       Controller)
+  @retval  EFI_TIMEOUT                 A timeout occurred while waiting for the
+                                       SCSI Request Packet to execute.
+  @retval  EFI_INVALID_PARAMETER       The contents of the SCSI Request Packet
+                                       are invalid.
+  @retval  EFI_OUT_OF_RESOURCES        The request could not be completed due
+                                       to a lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+ScsiWrite16CommandEx (
+  IN     EFI_SCSI_IO_PROTOCOL  *ScsiIo,
+  IN     UINT64                Timeout,
+  IN OUT VOID                  *SenseData,   OPTIONAL
+  IN OUT UINT8                 *SenseDataLength,
+     OUT UINT8                 *HostAdapterStatus,
+     OUT UINT8                 *TargetStatus,
+  IN OUT VOID                  *DataBuffer,  OPTIONAL
+  IN OUT UINT32                *DataLength,
+  IN     UINT64                StartLba,
+  IN     UINT32                SectorSize,
+  IN     EFI_EVENT             Event         OPTIONAL
+  )
+{
+  EFI_SCSI_LIB_ASYNC_CONTEXT      *Context;
+  EFI_SCSI_IO_SCSI_REQUEST_PACKET *CommandPacket;
+  EFI_STATUS                      Status;
+  UINT8                           *Cdb;
+  EFI_EVENT                       SelfEvent;
+
+  if (Event == NULL) {
+    return ScsiWrite16Command (
+             ScsiIo,
+             Timeout,
+             SenseData,
+             SenseDataLength,
+             HostAdapterStatus,
+             TargetStatus,
+             DataBuffer,
+             DataLength,
+             StartLba,
+             SectorSize
+             );
+  }
+
+  ASSERT (SenseDataLength != NULL);
+  ASSERT (HostAdapterStatus != NULL);
+  ASSERT (TargetStatus != NULL);
+  ASSERT (DataLength != NULL);
+  ASSERT (ScsiIo != NULL);
+
+  Context = AllocateZeroPool (sizeof (EFI_SCSI_LIB_ASYNC_CONTEXT));
+  if (Context == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Cdb = AllocateZeroPool (EFI_SCSI_OP_LENGTH_SIXTEEN);
+  if (Cdb == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto ErrorExit;
+  }
+
+  Context->SenseDataLength         = SenseDataLength;
+  Context->HostAdapterStatus       = HostAdapterStatus;
+  Context->TargetStatus            = TargetStatus;
+  Context->CallerEvent             = Event;
+
+  CommandPacket                    = &Context->CommandPacket;
+  CommandPacket->Timeout           = Timeout;
+  CommandPacket->OutDataBuffer     = DataBuffer;
+  CommandPacket->SenseData         = SenseData;
+  CommandPacket->OutTransferLength = *DataLength;
+  CommandPacket->Cdb               = Cdb;
+  //
+  // Fill Cdb for Write (16) Command
+  //
+  Cdb[0]                           = EFI_SCSI_OP_WRITE16;
+  WriteUnaligned64 ((UINT64 *)&Cdb[2], SwapBytes64 (StartLba));
+  WriteUnaligned32 ((UINT32 *)&Cdb[10], SwapBytes32 (SectorSize));
+
+  CommandPacket->CdbLength         = EFI_SCSI_OP_LENGTH_SIXTEEN;
+  CommandPacket->DataDirection     = EFI_SCSI_DATA_OUT;
+  CommandPacket->SenseDataLength   = *SenseDataLength;
+
+  //
+  // Create Event
+  //
+  Status = gBS->CreateEvent (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  ScsiLibNotify,
+                  Context,
+                  &SelfEvent
+                  );
+  if (EFI_ERROR(Status)) {
+    goto ErrorExit;
+  }
+
+  Status = ScsiIo->ExecuteScsiCommand (ScsiIo, CommandPacket, SelfEvent);
+  if (EFI_ERROR(Status)) {
+    //
+    // Since ScsiLibNotify() will not be signaled if ExecuteScsiCommand()
+    // returns with error, close the event here.
+    //
+    gBS->CloseEvent (SelfEvent);
+    goto ErrorExit;
+  } else {
+    return EFI_SUCCESS;
+  }
+
+ErrorExit:
+  if (Context != NULL) {
+    FreePool (Context);
+  }
+
+  return Status;
+}
diff --git a/MdePkg/Library/UefiScsiLib/UefiScsiLib.inf b/MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
new file mode 100644
index 000000000000..42bb8a9c54ec
--- /dev/null
+++ b/MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
@@ -0,0 +1,47 @@
+## @file
+# Uefi Scsi Library Instance.
+#
+# This libarary provides the functions to submit Scsi commands defined
+# in SCSI-2 specification for scsi device.
+#
+# Copyright (c) 2006 - 2015, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiScsiLib
+  MODULE_UNI_FILE                = UefiScsiLib.uni
+  FILE_GUID                      = 280E42C3-826E-4573-9772-B74EF1086D95
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiScsiLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER 
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiScsiLib.c
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  BaseMemoryLib
+  DebugLib
+  BaseLib
+  MemoryAllocationLib
+  UefiBootServicesTableLib
+
diff --git a/MdePkg/Library/UefiScsiLib/UefiScsiLib.uni b/MdePkg/Library/UefiScsiLib/UefiScsiLib.uni
new file mode 100644
index 000000000000..67644ce2d81e
--- /dev/null
+++ b/MdePkg/Library/UefiScsiLib/UefiScsiLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Uefi Scsi Library Instance.
+//
+// This libarary provides the functions to submit Scsi commands defined
+// in SCSI-2 specification for scsi device.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI SCSI Library Instance"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library provides the functions to submit SCSI commands defined in SCSI-2 specification for SCSI devices."
+
diff --git a/MdePkg/Library/UefiUsbLib/Hid.c b/MdePkg/Library/UefiUsbLib/Hid.c
new file mode 100644
index 000000000000..9565ef30bc7d
--- /dev/null
+++ b/MdePkg/Library/UefiUsbLib/Hid.c
@@ -0,0 +1,488 @@
+/** @file
+
+  The library provides USB HID Class standard and specific requests defined
+  in USB HID Firmware Specification 7 section : Requests.
+  
+  Copyright (c) 2004 - 2010, 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 "UefiUsbLibInternal.h"
+
+//  
+//  Hid RequestType Bits specifying characteristics of request.
+//  Valid values are 10100001b (0xa1) or 00100001b (0x21).
+//  The following description:
+//    7 Data transfer direction
+//        0 = Host to device
+//        1 = Device to host
+//    6..5 Type
+//        1 = Class
+//    4..0 Recipient
+//        1 = Interface
+//
+
+/**
+  Get the descriptor of the specified USB HID interface.
+
+  Submit a USB get HID descriptor request for the USB device specified by UsbIo
+  and Interface and return the HID descriptor in HidDescriptor.
+  If UsbIo is NULL, then ASSERT().
+  If HidDescriptor is NULL, then ASSERT().
+
+  @param  UsbIo          A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface      The index of the HID interface on the USB target.
+  @param  HidDescriptor  The pointer to the USB HID descriptor that was retrieved from
+                         the specified USB target and interface. Type EFI_USB_HID_DESCRIPTOR
+                         is defined in the MDE Package Industry Standard include file Usb.h.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetHidDescriptor (
+  IN  EFI_USB_IO_PROTOCOL        *UsbIo,
+  IN  UINT8                      Interface,
+  OUT EFI_USB_HID_DESCRIPTOR     *HidDescriptor
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT(UsbIo != NULL);
+  ASSERT(HidDescriptor != NULL);
+
+  Request.RequestType = USB_HID_GET_DESCRIPTOR_REQ_TYPE;
+  Request.Request     = USB_REQ_GET_DESCRIPTOR;
+  Request.Value       = (UINT16) (USB_DESC_TYPE_HID << 8);
+  Request.Index       = Interface;
+  Request.Length      = (UINT16) sizeof (EFI_USB_HID_DESCRIPTOR);
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataIn,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    HidDescriptor,
+                    sizeof (EFI_USB_HID_DESCRIPTOR),
+                    &Status
+                    );
+
+  return Result;
+
+}
+
+/**
+  Get the report descriptor of the specified USB HID interface.
+
+  Submit a USB get HID report descriptor request for the USB device specified by
+  UsbIo and Interface and return the report descriptor in DescriptorBuffer.
+  If UsbIo is NULL, then ASSERT().
+  If DescriptorBuffer is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The index of the report interface on the USB target.
+  @param  DescriptorLength  The size, in bytes, of DescriptorBuffer.
+  @param  DescriptorBuffer  A pointer to the buffer to store the report class descriptor.
+
+  @retval  EFI_SUCCESS           The request executed successfully.
+  @retval  EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                 buffer specified by DescriptorLength and DescriptorBuffer
+                                 is not large enough to hold the result of the request.
+  @retval  EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR      The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetReportDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT16                  DescriptorLength,
+  OUT UINT8                   *DescriptorBuffer
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (DescriptorBuffer != NULL);
+
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_GET_DESCRIPTOR_REQ_TYPE;
+  Request.Request     = USB_REQ_GET_DESCRIPTOR;
+  Request.Value       = (UINT16) (USB_DESC_TYPE_REPORT << 8);
+  Request.Index       = Interface;
+  Request.Length      = DescriptorLength;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataIn,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    DescriptorBuffer,
+                    DescriptorLength,
+                    &Status
+                    );
+
+  return Result;
+
+}
+
+/**
+  Get the HID protocol of the specified USB HID interface.
+
+  Submit a USB get HID protocol request for the USB device specified by UsbIo
+  and Interface and return the protocol retrieved in Protocol.
+  If UsbIo is NULL, then ASSERT().
+  If Protocol is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  Protocol   A pointer to the protocol for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetProtocolRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  OUT UINT8                   *Protocol
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Protocol != NULL);
+
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_GET_REQ_TYPE;
+  Request.Request = EFI_USB_GET_PROTOCOL_REQUEST;
+  Request.Value   = 0;
+  Request.Index   = Interface;
+  Request.Length  = 1;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataIn,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    Protocol,
+                    sizeof (UINT8),
+                    &Status
+                    );
+
+  return Result;
+}
+
+
+
+/**
+  Set the HID protocol of the specified USB HID interface.
+
+  Submit a USB set HID protocol request for the USB device specified by UsbIo
+  and Interface and set the protocol to the value specified by Protocol.
+  If UsbIo is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  Protocol   The protocol value to set for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetProtocolRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   Protocol
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_SET_REQ_TYPE;
+  Request.Request = EFI_USB_SET_PROTOCOL_REQUEST;
+  Request.Value   = Protocol;
+  Request.Index   = Interface;
+  Request.Length  = 0;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbNoData,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    NULL,
+                    0,
+                    &Status
+                    );
+  return Result;
+}
+
+
+/**
+  Set the idle rate of the specified USB HID report.
+
+  Submit a USB set HID report idle request for the USB device specified by UsbIo,
+  Interface, and ReportId, and set the idle rate to the value specified by Duration.
+  If UsbIo is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  ReportId   The identifier of the report to retrieve.
+  @param  Duration   The idle rate to set for the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetIdleRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   ReportId,
+  IN UINT8                   Duration
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_SET_REQ_TYPE;
+  Request.Request = EFI_USB_SET_IDLE_REQUEST;
+  Request.Value   = (UINT16) ((Duration << 8) | ReportId);
+  Request.Index   = Interface;
+  Request.Length  = 0;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbNoData,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    NULL,
+                    0,
+                    &Status
+                    );
+  return Result;
+}
+
+
+/**
+  Get the idle rate of the specified USB HID report.
+
+  Submit a USB get HID report idle request for the USB device specified by UsbIo,
+  Interface, and ReportId, and return the ide rate in Duration.
+  If UsbIo is NULL, then ASSERT().
+  If Duration is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface  The index of the report interface on the USB target.
+  @param  ReportId   The identifier of the report to retrieve.
+  @param  Duration   A pointer to the idle rate retrieved from the specified USB target.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetIdleRequest (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT8                   ReportId,
+  OUT UINT8                   *Duration
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+  
+  ASSERT (UsbIo != NULL);
+  ASSERT (Duration != NULL);
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_GET_REQ_TYPE;
+  Request.Request = EFI_USB_GET_IDLE_REQUEST;
+  Request.Value   = ReportId;
+  Request.Index   = Interface;
+  Request.Length  = 1;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataIn,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    Duration,
+                    1,
+                    &Status
+                    );
+
+  return Result;
+}
+
+
+
+/**
+  Set the report descriptor of the specified USB HID interface.
+
+  Submit a USB set HID report request for the USB device specified by UsbIo,
+  Interface, ReportId, and ReportType, and set the report descriptor using the
+  buffer specified by ReportLength and Report.
+  If UsbIo is NULL, then ASSERT().
+  If Report is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface     The index of the report interface on the USB target.
+  @param  ReportId      The identifier of the report to retrieve.
+  @param  ReportType    The type of report to retrieve.
+  @param  ReportLength  The size, in bytes, of Report.
+  @param  Report        A pointer to the report descriptor buffer to set.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetReportRequest (
+  IN EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN UINT8                   Interface,
+  IN UINT8                   ReportId,
+  IN UINT8                   ReportType,
+  IN UINT16                  ReportLen,
+  IN UINT8                   *Report
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Report != NULL);
+
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_SET_REQ_TYPE;
+  Request.Request = EFI_USB_SET_REPORT_REQUEST;
+  Request.Value   = (UINT16) ((ReportType << 8) | ReportId);
+  Request.Index   = Interface;
+  Request.Length  = ReportLen;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataOut,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    Report,
+                    ReportLen,
+                    &Status
+                    );
+
+  return Result;
+}
+
+
+/**
+  Get the report descriptor of the specified USB HID interface.
+
+  Submit a USB get HID report request for the USB device specified by UsbIo,
+  Interface, ReportId, and ReportType, and return the report in the buffer
+  specified by Report.
+  If UsbIo is NULL, then ASSERT().
+  If Report is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface     The index of the report interface on the USB target.
+  @param  ReportId      The identifier of the report to retrieve.
+  @param  ReportType    The type of report to retrieve.
+  @param  ReportLength  The size, in bytes, of Report.
+  @param  Report        A pointer to the buffer to store the report descriptor.
+
+  @retval  EFI_SUCCESS           The request executed successfully.
+  @retval  EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                 buffer specified by ReportLength and Report is not
+                                 large enough to hold the result of the request.
+  @retval  EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR      The request failed due to a device error.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetReportRequest (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Interface,
+  IN  UINT8                   ReportId,
+  IN  UINT8                   ReportType,
+  IN  UINT16                  ReportLen,
+  OUT UINT8                   *Report
+  )
+{
+  UINT32                  Status;
+  EFI_STATUS              Result;
+  EFI_USB_DEVICE_REQUEST  Request;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Report != NULL);
+
+  //
+  // Fill Device request packet
+  //
+  Request.RequestType = USB_HID_CLASS_GET_REQ_TYPE;
+  Request.Request = EFI_USB_GET_REPORT_REQUEST;
+  Request.Value   = (UINT16) ((ReportType << 8) | ReportId);
+  Request.Index   = Interface;
+  Request.Length  = ReportLen;
+
+  Result = UsbIo->UsbControlTransfer (
+                    UsbIo,
+                    &Request,
+                    EfiUsbDataIn,
+                    PcdGet32 (PcdUsbTransferTimeoutValue),
+                    Report,
+                    ReportLen,
+                    &Status
+                    );
+
+  return Result;
+}
diff --git a/MdePkg/Library/UefiUsbLib/UefiUsbLib.inf b/MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
new file mode 100644
index 000000000000..988f7c054a8d
--- /dev/null
+++ b/MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
@@ -0,0 +1,48 @@
+## @file
+# Uefi Usb Library instance.
+#
+# This library instance provides most usb APIs to support the Hid requests defined in
+# Usb Hid 1.1 spec and the standard requests defined in Usb 1.1 spec.
+#
+# Copyright (c) 2006 - 2014, 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.
+#
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiUsbLib
+  MODULE_UNI_FILE                = UefiUsbLib.uni
+  FILE_GUID                      = 87eb5df9-722a-4241-ad7f-370d0b3a56d7
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = UefiUsbLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+
+
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  UefiUsbLibInternal.h
+  Hid.c
+  UsbDxeLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+[LibraryClasses]
+  DebugLib
+  BaseMemoryLib
+  PcdLib
+
+[Pcd]
+  gEfiMdePkgTokenSpaceGuid.PcdUsbTransferTimeoutValue  ## CONSUMES
+
diff --git a/MdePkg/Library/UefiUsbLib/UefiUsbLib.uni b/MdePkg/Library/UefiUsbLib/UefiUsbLib.uni
new file mode 100644
index 000000000000..1a86975e60cd
--- /dev/null
+++ b/MdePkg/Library/UefiUsbLib/UefiUsbLib.uni
@@ -0,0 +1,22 @@
+// /** @file
+// Uefi Usb Library instance.
+//
+// This library instance provides most usb APIs to support the Hid requests defined in
+// Usb Hid 1.1 spec and the standard requests defined in Usb 1.1 spec.
+//
+// Copyright (c) 2006 - 2014, 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.
+//
+// **/
+
+
+#string STR_MODULE_ABSTRACT             #language en-US "UEFI USB Library instance"
+
+#string STR_MODULE_DESCRIPTION          #language en-US "This library instance provides most USB APIs to support the HID requests defined in the USB HID 1.1 specification and the standard requests defined in the USB 1.1 specification."
+
diff --git a/MdePkg/Library/UefiUsbLib/UefiUsbLibInternal.h b/MdePkg/Library/UefiUsbLib/UefiUsbLibInternal.h
new file mode 100644
index 000000000000..3d66d983120a
--- /dev/null
+++ b/MdePkg/Library/UefiUsbLib/UefiUsbLibInternal.h
@@ -0,0 +1,29 @@
+/** @file
+  
+  Common header file shared by all source files.
+
+  This file includes package header files, library classes and protocol, PPI & GUID definitions.
+
+  Copyright (c) 2006 - 2008, 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_USB_LIB_INTERNAL_H_
+#define _UEFI_USB_LIB_INTERNAL_H_
+
+#include <Uefi.h>
+
+#include <Library/UefiUsbLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/PcdLib.h>
+
+#include <IndustryStandard/Usb.h>
+
+
+#endif
diff --git a/MdePkg/Library/UefiUsbLib/UsbDxeLib.c b/MdePkg/Library/UefiUsbLib/UsbDxeLib.c
new file mode 100644
index 000000000000..6d481fa75d40
--- /dev/null
+++ b/MdePkg/Library/UefiUsbLib/UsbDxeLib.c
@@ -0,0 +1,672 @@
+/** @file
+
+  The library provides the USB Standard Device Requests defined 
+  in Usb specification 9.4 section.
+  
+  Copyright (c) 2004 - 2008, 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 "UefiUsbLibInternal.h"
+
+
+/**
+  Get the descriptor of the specified USB device.
+
+  Submit a USB get descriptor request for the USB device specified by UsbIo, Value,
+  and Index, and return the descriptor in the buffer specified by Descriptor.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Descriptor is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Value             The device request value.
+  @param  Index             The device request index.
+  @param  DescriptorLength  The size, in bytes, of Descriptor.
+  @param  Descriptor        A pointer to the descriptor buffer to get.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS           The request executed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed because the
+                                buffer specified by DescriptorLength and Descriptor
+                                is not large enough to hold the result of the request.
+  @retval EFI_TIMEOUT           A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR      The request failed due to a device error. The transfer
+                                status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Value,
+  IN  UINT16                  Index,
+  IN  UINT16                  DescriptorLength,
+  OUT VOID                    *Descriptor,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Descriptor != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_GET_DESCRIPTOR_REQ_TYPE;
+  DevReq.Request      = USB_REQ_GET_DESCRIPTOR;
+  DevReq.Value        = Value;
+  DevReq.Index        = Index;
+  DevReq.Length       = DescriptorLength;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbDataIn,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  Descriptor,
+                  DescriptorLength,
+                  Status
+                  );
+}
+
+
+/**
+  Set the descriptor of the specified USB device.
+
+  Submit a USB set descriptor request for the USB device specified by UsbIo,
+  Value, and Index, and set the descriptor using the buffer specified by DesriptorLength
+  and Descriptor.  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Descriptor is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Value             The device request value.
+  @param  Index             The device request index.
+  @param  DescriptorLength  The size, in bytes, of Descriptor.
+  @param  Descriptor        A pointer to the descriptor buffer to set.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval  EFI_SUCCESS       The request executed successfully.
+  @retval  EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval  EFI_DEVICE_ERROR  The request failed due to a device error.
+                             The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetDescriptor (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Value,
+  IN  UINT16                  Index,
+  IN  UINT16                  DescriptorLength,
+  IN  VOID                    *Descriptor,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Descriptor != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_SET_DESCRIPTOR_REQ_TYPE;
+  DevReq.Request      = USB_REQ_SET_DESCRIPTOR;
+  DevReq.Value        = Value;
+  DevReq.Index        = Index;
+  DevReq.Length       = DescriptorLength;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbDataOut,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  Descriptor,
+                  DescriptorLength,
+                  Status
+                  );
+}
+
+
+/**
+  Get the interface setting of the specified USB device.
+
+  Submit a USB get interface request for the USB device specified by UsbIo,
+  and Interface, and place the result in the buffer specified by AlternateSetting.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If AlternateSetting is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The interface index value.
+  @param  AlternateSetting  A pointer to the alternate setting to be retrieved.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetInterface (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Interface,
+  OUT UINT16                  *AlternateSetting,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (AlternateSetting != NULL);
+  ASSERT (Status != NULL);
+
+  *AlternateSetting = 0;
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_GET_INTERFACE_REQ_TYPE;
+  DevReq.Request      = USB_REQ_GET_INTERFACE;
+  DevReq.Index        = Interface;
+  DevReq.Length       = 1;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbDataIn,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  AlternateSetting,
+                  1,
+                  Status
+                  );
+}
+
+
+/**
+  Set the interface setting of the specified USB device.
+
+  Submit a USB set interface request for the USB device specified by UsbIo, and
+  Interface, and set the alternate setting to the value specified by AlternateSetting.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo             A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Interface         The interface index value.
+  @param  AlternateSetting  The alternate setting to be set.
+  @param  Status            A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS  The request executed successfully.
+  @retval EFI_TIMEOUT  A timeout occurred executing the request.
+  @retval EFI_SUCCESS  The request failed due to a device error.
+                       The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetInterface (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  Interface,
+  IN  UINT16                  AlternateSetting,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_SET_INTERFACE_REQ_TYPE;
+  DevReq.Request      = USB_REQ_SET_INTERFACE;
+  DevReq.Value        = AlternateSetting;
+  DevReq.Index        = Interface;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbNoData,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  NULL,
+                  0,
+                  Status
+                  );
+}
+
+
+/**
+  Get the device configuration.
+
+  Submit a USB get configuration request for the USB device specified by UsbIo
+  and place the result in the buffer specified by ConfigurationValue. The status
+  of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If ConfigurationValue is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo               A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  ConfigurationValue  A pointer to the device configuration to be retrieved.
+  @param  Status              A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS        The request executed successfully.
+  @retval EFI_TIMEOUT        A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR   The request failed due to a device error.
+                             The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetConfiguration (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  OUT UINT16                  *ConfigurationValue,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (ConfigurationValue != NULL);
+  ASSERT (Status != NULL);
+
+  *ConfigurationValue = 0;
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_GET_CONFIGURATION_REQ_TYPE;
+  DevReq.Request      = USB_REQ_GET_CONFIG;
+  DevReq.Length       = 1;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbDataIn,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  ConfigurationValue,
+                  1,
+                  Status
+                  );
+}
+
+
+/**
+  Set the device configuration.
+
+  Submit a USB set configuration request for the USB device specified by UsbIo
+  and set the device configuration to the value specified by ConfigurationValue.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo               A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  ConfigurationValue  The device configuration value to be set.
+  @param  Status              A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetConfiguration (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT16                  ConfigurationValue,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  DevReq.RequestType  = USB_DEV_SET_CONFIGURATION_REQ_TYPE;
+  DevReq.Request      = USB_REQ_SET_CONFIG;
+  DevReq.Value        = ConfigurationValue;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbNoData,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  NULL,
+                  0,
+                  Status
+                  );
+}
+
+
+/**
+  Set the specified feature of the specified device.
+
+  Submit a USB set device feature request for the USB device specified by UsbIo,
+  Recipient, and Target to the value specified by Value.  The status of the
+  transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient  The USB data recipient type (i.e. Device, Interface, Endpoint).
+                     Type USB_TYPES_DEFINITION is defined in the MDE Package Industry
+                     Standard include file Usb.h.
+  @param  Value      The value of the feature to be set.
+  @param  Target     The index of the device to be set.
+  @param  Status     A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbSetFeature (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Value,
+  IN  UINT16                  Target,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  switch (Recipient) {
+
+  case USB_TARGET_DEVICE:
+    DevReq.RequestType = USB_DEV_SET_FEATURE_REQ_TYPE_D;
+    break;
+
+  case USB_TARGET_INTERFACE:
+    DevReq.RequestType = USB_DEV_SET_FEATURE_REQ_TYPE_I;
+    break;
+
+  case USB_TARGET_ENDPOINT:
+    DevReq.RequestType = USB_DEV_SET_FEATURE_REQ_TYPE_E;
+    break;
+
+  default:
+    break;
+  }
+  //
+  // Fill device request, see USB1.1 spec
+  //
+  DevReq.Request  = USB_REQ_SET_FEATURE;
+  DevReq.Value    = Value;
+  DevReq.Index    = Target;
+
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbNoData,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  NULL,
+                  0,
+                  Status
+                  );
+}
+
+
+/**
+  Clear the specified feature of the specified device.
+
+  Submit a USB clear device feature request for the USB device specified by UsbIo,
+  Recipient, and Target to the value specified by Value.  The status of the transfer
+  is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo      A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient  The USB data recipient type (i.e. Device, Interface, Endpoint).
+                     Type USB_TYPES_DEFINITION is defined in the MDE Package Industry Standard
+                     include file Usb.h.
+  @param  Value      The value of the feature to be cleared.
+  @param  Target     The index of the device to be cleared.
+  @param  Status     A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbClearFeature (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Value,
+  IN  UINT16                  Target,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Status != NULL);
+
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  switch (Recipient) {
+
+  case USB_TARGET_DEVICE:
+    DevReq.RequestType = USB_DEV_CLEAR_FEATURE_REQ_TYPE_D;
+    break;
+
+  case USB_TARGET_INTERFACE:
+    DevReq.RequestType = USB_DEV_CLEAR_FEATURE_REQ_TYPE_I;
+    break;
+
+  case USB_TARGET_ENDPOINT:
+    DevReq.RequestType = USB_DEV_CLEAR_FEATURE_REQ_TYPE_E;
+    break;
+
+  default:
+    break;
+  }
+  //
+  // Fill device request, see USB1.1 spec
+  //
+  DevReq.Request  = USB_REQ_CLEAR_FEATURE;
+  DevReq.Value    = Value;
+  DevReq.Index    = Target;
+
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbNoData,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  NULL,
+                  0,
+                  Status
+                  );
+}
+
+
+/**
+  Get the status of the specified device.
+
+  Submit a USB device get status request for the USB device specified by UsbIo,
+  Recipient, and Target and place the result in the buffer specified by DeviceStatus.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If DeviceStatus is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo         A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Recipient     The USB data recipient type (i.e. Device, Interface, Endpoint).
+                        Type USB_TYPES_DEFINITION is defined in the MDE Package Industry Standard
+                        include file Usb.h.
+  @param  Target        The index of the device to be get the status of.
+  @param  DeviceStatus  A pointer to the device status to be retrieved.
+  @param  Status        A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbGetStatus (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  USB_TYPES_DEFINITION    Recipient,
+  IN  UINT16                  Target,
+  OUT UINT16                  *DeviceStatus,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_USB_DEVICE_REQUEST  DevReq;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (DeviceStatus != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
+
+  switch (Recipient) {
+
+  case USB_TARGET_DEVICE:
+    DevReq.RequestType = USB_DEV_GET_STATUS_REQ_TYPE_D;
+    break;
+
+  case USB_TARGET_INTERFACE:
+    DevReq.RequestType = USB_DEV_GET_STATUS_REQ_TYPE_I;
+    break;
+
+  case USB_TARGET_ENDPOINT:
+    DevReq.RequestType = USB_DEV_GET_STATUS_REQ_TYPE_E;
+    break;
+
+  default:
+    break;
+  }
+  //
+  // Fill device request, see USB1.1 spec
+  //
+  DevReq.Request  = USB_REQ_GET_STATUS;
+  DevReq.Value    = 0;
+  DevReq.Index    = Target;
+  DevReq.Length   = 2;
+
+  return UsbIo->UsbControlTransfer (
+                  UsbIo,
+                  &DevReq,
+                  EfiUsbDataIn,
+                  PcdGet32 (PcdUsbTransferTimeoutValue),
+                  DeviceStatus,
+                  2,
+                  Status
+                  );
+}
+
+
+/**
+  Clear halt feature of the specified usb endpoint.
+
+  Retrieve the USB endpoint descriptor specified by UsbIo and EndPoint.
+  If the USB endpoint descriptor can not be retrieved, then return EFI_NOT_FOUND.
+  If the endpoint descriptor is found, then clear the halt feature of this USB endpoint.
+  The status of the transfer is returned in Status.
+  If UsbIo is NULL, then ASSERT().
+  If Status is NULL, then ASSERT().
+
+  @param  UsbIo     A pointer to the USB I/O Protocol instance for the specific USB target.
+  @param  Endpoint  The endpoint address.
+  @param  Status    A pointer to the status of the transfer.
+
+  @retval EFI_SUCCESS       The request executed successfully.
+  @retval EFI_TIMEOUT       A timeout occurred executing the request.
+  @retval EFI_DEVICE_ERROR  The request failed due to a device error.
+                            The transfer status is returned in Status.
+  @retval EFI_NOT_FOUND     The specified USB endpoint descriptor can not be found
+
+**/
+EFI_STATUS
+EFIAPI
+UsbClearEndpointHalt (
+  IN  EFI_USB_IO_PROTOCOL     *UsbIo,
+  IN  UINT8                   Endpoint,
+  OUT UINT32                  *Status
+  )
+{
+  EFI_STATUS                    Result;
+  EFI_USB_ENDPOINT_DESCRIPTOR   EndpointDescriptor;
+  EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDescriptor;
+  UINT8                         Index;
+
+  ASSERT (UsbIo != NULL);
+  ASSERT (Status != NULL);
+
+  ZeroMem (&EndpointDescriptor, sizeof (EFI_USB_ENDPOINT_DESCRIPTOR));
+  //
+  // First search the endpoint descriptor for that endpoint addr
+  //
+  Result = UsbIo->UsbGetInterfaceDescriptor (
+                    UsbIo,
+                    &InterfaceDescriptor
+                    );
+  if (EFI_ERROR (Result)) {
+    return Result;
+  }
+
+  for (Index = 0; Index < InterfaceDescriptor.NumEndpoints; Index++) {
+    Result = UsbIo->UsbGetEndpointDescriptor (
+                      UsbIo,
+                      Index,
+                      &EndpointDescriptor
+                      );
+    if (EFI_ERROR (Result)) {
+      continue;
+    }
+
+    if (EndpointDescriptor.EndpointAddress == Endpoint) {
+      break;
+    }
+  }
+
+  if (Index == InterfaceDescriptor.NumEndpoints) {
+    //
+    // No such endpoint
+    //
+    return EFI_NOT_FOUND;
+  }
+
+  Result = UsbClearFeature (
+            UsbIo,
+            USB_TARGET_ENDPOINT,
+            USB_FEATURE_ENDPOINT_HALT,
+            EndpointDescriptor.EndpointAddress,
+            Status
+            );
+
+  return Result;
+}
diff --git a/MdePkg/License.txt b/MdePkg/License.txt
new file mode 100644
index 000000000000..5bcfc5f0a75f
--- /dev/null
+++ b/MdePkg/License.txt
@@ -0,0 +1,25 @@
+Copyright (c) 2012, Intel Corporation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/MdePkg/MdePkg.dec b/MdePkg/MdePkg.dec
new file mode 100644
index 000000000000..6256e0c0897c
--- /dev/null
+++ b/MdePkg/MdePkg.dec
@@ -0,0 +1,2140 @@
+## @file  MdePkg.dec
+# This Package provides all definitions, library classes and libraries instances.
+#
+# It also provides the definitions(including PPIs/PROTOCOLs/GUIDs) of
+# EFI1.10/UEFI2.6/PI1.4 and some Industry Standards.
+#
+# Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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.
+#
+##
+
+
+[Defines]
+  DEC_SPECIFICATION              = 0x00010005
+  PACKAGE_NAME                   = MdePkg
+  PACKAGE_UNI_FILE               = MdePkg.uni
+  PACKAGE_GUID                   = 1E73767F-8F52-4603-AEB4-F29B510B6766
+  PACKAGE_VERSION                = 1.06
+
+
+[Includes]
+  Include
+
+[Includes.IA32]
+  Include/Ia32
+
+[Includes.X64]
+  Include/X64
+
+[Includes.IPF]
+  Include/Ipf
+
+[Includes.EBC]
+  Include/Ebc
+
+[Includes.ARM]
+  Include/Arm
+
+[Includes.AARCH64]
+  Include/AArch64
+
+[LibraryClasses]
+  ##  @libraryclass  Provides most usb APIs to support the Hid requests defined in Usb Hid 1.1 spec
+  #                  and the standard requests defined in Usb 1.1 spec.
+  ##
+  UefiUsbLib|Include/Library/UefiUsbLib.h
+
+  ##  @libraryclass  Provides a service to retrieve a pointer to the EFI Runtime Services Table.
+  #                  Only available to DXE and UEFI module types.
+  UefiRuntimeServicesTableLib|Include/Library/UefiRuntimeServicesTableLib.h
+
+  ##  @libraryclass  Provides library functions for each of the UEFI Runtime Services.
+  #                  Only available to DXE and UEFI module types.
+  UefiRuntimeLib|Include/Library/UefiRuntimeLib.h
+
+  ##  @libraryclass  Provides library functions for common UEFI operations.
+  #                  Only available to DXE and UEFI module types.
+  ##
+  UefiLib|Include/Library/UefiLib.h
+
+  ##  @libraryclass  Module entry point library for UEFI drivers, DXE Drivers, DXE SMM Driver and DXE Runtime Drivers
+  UefiDriverEntryPoint|Include/Library/UefiDriverEntryPoint.h
+
+  ##  @libraryclass  UEFI Decompress Library Functions defintion for UEFI compress algorithm.
+  UefiDecompressLib|Include/Library/UefiDecompressLib.h
+
+  ##  @libraryclass  Provides a service to retrieve a pointer to the EFI Boot Services Table.
+  #                  Only available to DXE and UEFI module types.
+  UefiBootServicesTableLib|Include/Library/UefiBootServicesTableLib.h
+
+  ##  @libraryclass  Module entry point library for UEFI Applications.
+  UefiApplicationEntryPoint|Include/Library/UefiApplicationEntryPoint.h
+
+  ##  @libraryclass  Provides calibrated delay and performance counter services.
+  TimerLib|Include/Library/TimerLib.h
+
+  ##  @libraryclass  Provides library functions to access SMBUS devices.
+  #                  Libraries of this class must be ported to a specific SMBUS controller.
+  SmbusLib|Include/Library/SmbusLib.h
+
+  ##  @libraryclass  Provides the functions to submit Scsi commands defined in SCSI-2 specification for scsi device.
+  UefiScsiLib|Include/Library/UefiScsiLib.h
+
+  ##  @libraryclass  Provides a service to publish discovered system resources.
+  ResourcePublicationLib|Include/Library/ResourcePublicationLib.h
+
+  ##  @libraryclass  Provides services to log status code records.
+  ReportStatusCodeLib|Include/Library/ReportStatusCodeLib.h
+
+  ##  @libraryclass  Provides services to print a formatted string to a buffer.
+  #                  All combinations of Unicode and ASCII strings are supported.
+  ##
+  PrintLib|Include/Library/PrintLib.h
+
+  ##  @libraryclass  Provides an ordered collection data structure.
+  OrderedCollectionLib|Include/Library/OrderedCollectionLib.h
+
+  ##  @libraryclass  Provides services to send progress/error codes to a POST card.
+  PostCodeLib|Include/Library/PostCodeLib.h
+
+  ##  @libraryclass  Provides services to log the execution times and retrieve them later.
+  PerformanceLib|Include/Library/PerformanceLib.h
+
+  ##  @libraryclass  Provides a service to retrieve a pointer to the PEI Services Table.
+  PeiServicesTablePointerLib|Include/Library/PeiServicesTablePointerLib.h
+
+  ##  @libraryclass  Provides library functions for all PEI Services.
+  PeiServicesLib|Include/Library/PeiServicesLib.h
+
+  ##  @libraryclass  Module entry point library for PEIM.
+  PeimEntryPoint|Include/Library/PeimEntryPoint.h
+
+  ##  @libraryclass  Module entry point library for PEI core.
+  PeiCoreEntryPoint|Include/Library/PeiCoreEntryPoint.h
+
+  ##  @libraryclass  Provides services to load and relocate a PE/COFF image.
+  PeCoffLib|Include/Library/PeCoffLib.h
+  ##  @libraryclass  Provides extra action services for unloading and relocating a PE/COFF image on some specific platform such
+  ## as NT32 emulator.
+  PeCoffExtraActionLib|Include/Library/PeCoffExtraActionLib.h
+
+  ##  @libraryclass  Provides a service to retrieve the PE/COFF entry point from a PE/COFF image.
+  PeCoffGetEntryPointLib|Include/Library/PeCoffGetEntryPointLib.h
+
+  ##  @libraryclass  Provides services to access PCI Configuration Space on a platform with multiple PCI segments.
+  PciSegmentLib|Include/Library/PciSegmentLib.h
+
+  ##  @libraryclass  Provides services to access PCI Configuration Space.
+  PciLib|Include/Library/PciLib.h
+
+  ##  @libraryclass  Provides services to access PCI Configuration Space using the MMIO PCI Express window.
+  PciExpressLib|Include/Library/PciExpressLib.h
+
+  ##  @libraryclass  Provides services to access PCI Configuration Space using the I/O ports 0xCF8 and 0xCFC.
+  PciCf8Lib|Include/Library/PciCf8Lib.h
+
+  ##  @libraryclass  Provides library services to get and set Platform Configuration Database entries.
+  PcdLib|Include/Library/PcdLib.h
+
+  ##  @libraryclass  Provides services to allocate and free memory buffers of various memory types and alignments.
+  MemoryAllocationLib|Include/Library/MemoryAllocationLib.h
+
+  ##  @libraryclass  Provide services to access I/O Ports and MMIO registers.
+  IoLib|Include/Library/IoLib.h
+
+  ##  @libraryclass  Provide services to create, get and update HSTI table in AIP protocol.
+  HstiLib|Include/Library/HstiLib.h
+
+  ##  @libraryclass  Provides services to create and parse HOBs. Only available for PEI and DXE module types.
+  HobLib|Include/Library/HobLib.h
+
+  ##  @libraryclass  Provides a service to retrieve a pointer to the DXE Services Table.
+  #                  Only available to DXE module types.
+  ##
+  DxeServicesTableLib|Include/Library/DxeServicesTableLib.h
+
+  ##  @libraryclass  Module entry point library for DXE core.
+  DxeCoreEntryPoint|Include/Library/DxeCoreEntryPoint.h
+
+  ##  @libraryclass  Provides library functions to construct and parse UEFI Device Paths.
+  DevicePathLib|Include/Library/DevicePathLib.h
+
+  ##  @libraryclass  Provides services to print debug and assert messages to a debug output device.
+  DebugLib|Include/Library/DebugLib.h
+
+  ##  @libraryclass  Provides CPU architecture specific functions that can not be defined in the Base Library
+  #                  due to dependencies on the PAL Library
+  ##
+  CpuLib|Include/Library/CpuLib.h
+
+  ##  @libraryclass  Provides services to maintain instruction and data caches.
+  CacheMaintenanceLib|Include/Library/CacheMaintenanceLib.h
+
+  ##  @libraryclass  Provides copy memory, fill memory, zero memory, and GUID functions.
+  BaseMemoryLib|Include/Library/BaseMemoryLib.h
+
+  ##  @libraryclass  Provides string functions, linked list functions, math functions, synchronization functions
+  #                  and CPU architecture specific functions.
+  ##
+  BaseLib|Include/Library/BaseLib.h
+
+  ##  @libraryclass  This library provides common functions to process the different guided section data.
+  ExtractGuidedSectionLib|Include/Library/ExtractGuidedSectionLib.h
+
+  ##  @libraryclass  Provides three common serial I/O port functions.
+  SerialPortLib|Include/Library/SerialPortLib.h
+
+  ##  @libraryclass  Provides a set of PI library functions and macros for DXE phase.
+  DxeServicesLib|Include/Library/DxeServicesLib.h
+
+  ##  @libraryclass  Provides synchronization functions.
+  ##
+  SynchronizationLib|Include/Library/SynchronizationLib.h
+
+  ##  @libraryclass  Defines library APIs used by modules to save S3 Boot
+  #                  Script Opcodes.  These OpCode will be restored by S3
+  #                  related modules.
+  S3BootScriptLib|Include/Library/S3BootScriptLib.h
+
+  ##  @libraryclass  I/O and MMIO Library Services that do I/O and also enable
+  #                  the I/O operatation to be replayed during an S3 resume.
+  #                  This library class maps directly on top of the IoLib class.
+  S3IoLib|Include/Library/S3IoLib.h
+
+  ##  @libraryclass  PCI configuration Library Services that do PCI configuration
+  #                  and also enable the PCI operations to be replayed during an
+  #                  S3 resume. This library class maps directly on top of the
+  #                  PciLib class.
+  S3PciLib|Include/Library/S3PciLib.h
+
+  ##  @libraryclass  Smbus Library Services that do SMBus transactions and also
+  #                  enable the operatation to be replayed during an S3 resume.
+  #                  This library class maps directly on top of the SmbusLib class.
+  S3SmbusLib|Include/Library/S3SmbusLib.h
+
+  ##  @libraryclass  Stall Services that do stall and also enable the Stall
+  #                  operatation to be replayed during an S3 resume. This
+  #                  library class maps directly on top of the Timer class.
+  S3StallLib|Include/Library/S3StallLib.h
+
+  ##  @libraryclass  Defines library APIs used by modules to get/set print error level.
+  DebugPrintErrorLevelLib|Include/Library/DebugPrintErrorLevelLib.h
+
+  ##  @libraryclass  provides EFI_FILE_HANDLE services
+  FileHandleLib|Include/Library/FileHandleLib.h
+
+[LibraryClasses.IA32, LibraryClasses.X64]
+  ##  @libraryclass  Abstracts both S/W SMI generation and detection.
+  ##
+  SmmLib|Include/Library/SmmLib.h
+
+  ##  @libraryclass  Provides a service to retrieve a pointer to the SMM Services Table.
+  #                  Only available to SMM/DXE Combined and SMM module types.
+  SmmServicesTableLib|Include/Library/SmmServicesTableLib.h
+
+  ##  @libraryclass  Provides services for Smm Memory Operation.
+  #
+  SmmMemLib|Include/Library/SmmMemLib.h
+
+  ##  @libraryclass  Provides services to enable/disable periodic SMI handlers.
+  #
+  SmmPeriodicSmiLib|Include/Library/SmmPeriodicSmiLib.h
+
+  ##  @libraryclass  Provides services to generate random number.
+  #
+  RngLib|Include/Library/RngLib.h
+
+  ##  @libraryclass  Provides services to log the SMI handler registration.
+  SmiHandlerProfileLib|Include/Library/SmiHandlerProfileLib.h
+
+[LibraryClasses.IPF]
+  ##  @libraryclass  The SAL Library provides a service to make a SAL CALL.
+  SalLib|Include/Library/SalLib.h
+
+  ##  @libraryclass  Provides library services to make PAL Calls.
+  PalLib|Include/Library/PalLib.h
+
+  ##  @libraryclass  Provides library services to make Extended SAL Calls.
+  ExtendedSalLib|Include/Library/ExtendedSalLib.h
+
+[Guids]
+  #
+  # GUID defined in UEFI2.1/UEFI2.0/EFI1.1
+  #
+  ## Include/Guid/GlobalVariable.h
+  gEfiGlobalVariableGuid         = { 0x8BE4DF61, 0x93CA, 0x11D2, { 0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiVT100PlusGuid              = { 0x7BAEC70B, 0x57E0, 0x4C76, { 0x8E, 0x87, 0x2F, 0x9E, 0x28, 0x08, 0x83, 0x43 }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiVT100Guid                  = { 0xDFA66065, 0xB419, 0x11D3, { 0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiPcAnsiGuid                 = { 0xE0C14753, 0xF9BE, 0x11D2, { 0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiVTUTF8Guid                 = { 0xAD15A0D6, 0x8BEC, 0x4ACF, { 0xA0, 0x73, 0xD0, 0x1D, 0xE7, 0x7E, 0x2D, 0x88 }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiUartDevicePathGuid         = { 0x37499a9d, 0x542f, 0x4c89, { 0xa0, 0x26, 0x35, 0xda, 0x14, 0x20, 0x94, 0xe4 }}
+
+  ## Include/Guid/PcAnsi.h
+  gEfiSasDevicePathGuid          = { 0xd487ddb4, 0x008b, 0x11d9, { 0xaf, 0xdc, 0x00, 0x10, 0x83, 0xff, 0xca, 0x4d }}
+
+  ## Include/Guid/Gpt.h
+  gEfiPartTypeLegacyMbrGuid      = { 0x024DEE41, 0x33E7, 0x11D3, { 0x9D, 0x69, 0x00, 0x08, 0xC7, 0x81, 0xF3, 0x9F }}
+
+  ## Include/Guid/Gpt.h
+  gEfiPartTypeSystemPartGuid     = { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B }}
+
+  ## Include/Guid/Gpt.h
+  gEfiPartTypeUnusedGuid         = { 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}
+
+  ## Include/Guid/DebugImageInfoTable.h
+  gEfiDebugImageInfoTableGuid    = { 0x49152E77, 0x1ADA, 0x4764, { 0xB7, 0xA2, 0x7A, 0xFE, 0xFE, 0xD9, 0x5E, 0x8B }}
+
+  ## Include/Guid/Acpi.h
+  gEfiAcpiTableGuid              = { 0x8868E871, 0xE4F1, 0x11D3, { 0xBC, 0x22, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Guid/Acpi.h
+  gEfiAcpi20TableGuid            = { 0x8868E871, 0xE4F1, 0x11D3, { 0xBC, 0x22, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Guid/Acpi.h
+  gEfiAcpi10TableGuid            = { 0xEB9D2D30, 0x2D88, 0x11D3, { 0x9A, 0x16, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/SmBios.h
+  gEfiSmbiosTableGuid            = { 0xEB9D2D31, 0x2D88, 0x11D3, { 0x9A, 0x16, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/Mps.h
+  gEfiMpsTableGuid               = { 0xEB9D2D2F, 0x2D88, 0x11D3, { 0x9A, 0x16, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/SalSystemTable.h
+  gEfiSalSystemTableGuid         = { 0xEB9D2D32, 0x2D88, 0x11D3, { 0x9A, 0x16, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/AuthenticationInfo.h
+  gEfiAuthenticationChapLocalGuid = { 0xC280C73E, 0x15CA, 0x11DA, { 0xB0, 0xCA, 0x00, 0x10, 0x83, 0xFF, 0xCA, 0x4D }}
+
+  ## Include/Protocol/AuthenticationInfo.h
+  gEfiAuthenticationChapRadiusGuid = { 0xD6062B50, 0x15CA, 0x11DA, { 0x92, 0x19, 0x00, 0x10, 0x83, 0xFF, 0xCA, 0x4D }}
+
+  ## Include/Guid/FileSystemVolumeLabelInfo.h
+  gEfiFileSystemVolumeLabelInfoIdGuid = { 0xDB47D7D3, 0xFE81, 0x11D3, { 0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/FileSystemInfo.h
+  gEfiFileSystemInfoGuid         = { 0x09576E93, 0x6D3F, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Guid/FileInfo.h
+  gEfiFileInfoGuid               = { 0x09576E92, 0x6D3F, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/Bis.h
+  gBootObjectAuthorizationParmsetGuid = { 0xEDD35E31, 0x07B9, 0x11D2, { 0x83, 0xA3, 0x00, 0xA0, 0xC9, 0x1F, 0xAD, 0xCF }}
+
+  ## Include/Protocol/PlatformToDriverConfiguration.h
+  gEfiPlatformToDriverConfigurationClpGuid = { 0x345ecc0e, 0xcb6, 0x4b75, { 0xbb, 0x57, 0x1b, 0x12, 0x9c, 0x47, 0x33,0x3e }}
+
+  ## Include/Guid/HiiKeyBoardLayout.h
+  gEfiHiiKeyBoardLayoutGuid      = { 0x14982a4f, 0xb0ed, 0x45b8, { 0xa8, 0x11, 0x5a, 0x7a, 0x9b, 0xc2, 0x32, 0xdf }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmMD5Guid       = { 0x0AF7C79C, 0x65B5, 0x4319, { 0xB0, 0xAE, 0x44, 0xEC, 0x48, 0x4E, 0x4A, 0xD7 }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha512Guid    = { 0xCAA4381E, 0x750C, 0x4770, { 0xB8, 0x70, 0x7A, 0x23, 0xB4, 0xE4, 0x21, 0x30 }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha384Guid    = { 0xEFA96432, 0xDE33, 0x4DD2, { 0xAE, 0xE6, 0x32, 0x8C, 0x33, 0xDF, 0x77, 0x7A }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha256Guid    = { 0x51AA59DE, 0xFDF2, 0x4EA3, { 0xBC, 0x63, 0x87, 0x5F, 0xB7, 0x84, 0x2E, 0xE9 }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha224Guid    = { 0x8DF01A06, 0x9BD5, 0x4BF7, { 0xB0, 0x21, 0xDB, 0x4F, 0xD9, 0xCC, 0xF4, 0x5B }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha1Guid      = { 0x2AE9D80F, 0x3FB2, 0x4095, { 0xB7, 0xB1, 0xE9, 0x31, 0x57, 0xB9, 0x46, 0xB6 }}
+
+  ## Include/Guid/EventGroup.h
+  gEfiEventReadyToBootGuid       = { 0x7CE88FB3, 0x4BD7, 0x4679, { 0x87, 0xA8, 0xA8, 0xD8, 0xDE, 0xE5, 0x0D, 0x2B }}
+
+  ## Include/Guid/EventGroup.h
+  gEfiEventMemoryMapChangeGuid   = { 0x78BEE926, 0x692F, 0x48FD, { 0x9E, 0xDB, 0x01, 0x42, 0x2E, 0xF0, 0xD7, 0xAB }}
+
+  ## Include/Guid/EventGroup.h
+  gEfiEventVirtualAddressChangeGuid = { 0x13FA7698, 0xC831, 0x49C7, { 0x87, 0xEA, 0x8F, 0x43, 0xFC, 0xC2, 0x51, 0x96 }}
+
+  ## Include/Guid/EventGroup.h
+  gEfiEventExitBootServicesGuid  = { 0x27ABF055, 0xB1B8, 0x4C26, { 0x80, 0x48, 0x74, 0x8F, 0x37, 0xBA, 0xA2, 0xDF }}
+
+  ## Include/Protocol/DebugPort.h
+  gEfiDebugPortVariableGuid      = { 0xEBA4E8D2, 0x3858, 0x41EC, { 0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60, 0xD0 }}
+
+  ## Include/Protocol/DebugPort.h
+  gEfiDebugPortDevicePathGuid    = { 0xEBA4E8D2, 0x3858, 0x41EC, { 0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60, 0xD0 }}
+
+  ## Include/Guid/HiiPlatformSetupFormset.h
+  gEfiHiiPlatformSetupFormsetGuid = { 0x93039971, 0x8545, 0x4b04, { 0xb4, 0x5e, 0x32, 0xeb, 0x83, 0x26, 0x04, 0x0e }}
+
+  ## Include/Guid/HiiPlatformSetupFormset.h
+  gEfiHiiDriverHealthFormsetGuid = { 0xf22fc20c, 0x8cf4, 0x45eb, { 0x8e, 0x6, 0xad, 0x4e, 0x50, 0xb9, 0x5d, 0xd3 }}
+
+  ## Include/Guid/HiiPlatformSetupFormset.h
+  gEfiHiiUserCredentialFormsetGuid = { 0x337f4407, 0x5aee, 0x4b83, { 0xb2, 0xa7, 0x4e, 0xad, 0xca, 0x30, 0x88, 0xcd }}
+
+  ## Include/Guid/HiiFormMapMethodGuid.h
+  gEfiHiiStandardFormGuid = { 0x3bd2f4ec, 0xe524, 0x46e4, { 0xa9, 0xd8, 0x51, 0x1, 0x17, 0x42, 0x55, 0x62 }}
+
+  ## Include/Guid/MemoryOverwriteControl.h
+  gEfiMemoryOverwriteControlDataGuid = { 0xe20939be, 0x32d4, 0x41be, {0xa1, 0x50, 0x89, 0x7f, 0x85, 0xd4, 0x98, 0x29 }}
+
+  ## Include/IndustryStandard/MemoryOverwriteRequestControlLock.h
+  gEfiMemoryOverwriteRequestControlLockGuid = { 0xBB983CCF, 0x151D, 0x40E1, {0xA0, 0x7B, 0x4A, 0x17, 0xBE, 0x16, 0x82, 0x92}}
+
+  ## Include/Guid/WinCertificate.h
+  gEfiCertTypeRsa2048Sha256Guid = { 0xa7717414, 0xc616, 0x4977, {0x94, 0x20, 0x84, 0x47, 0x12, 0xa7, 0x35, 0xbf }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeCmcGuid   = { 0x2DCE8BB1, 0xBDD7, 0x450e, { 0xB9, 0xAD, 0x9C, 0xF4, 0xEB, 0xD4, 0xF8, 0x90 }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeCpeGuid   = { 0x4E292F96, 0xD843, 0x4a55, { 0xA8, 0xC2, 0xD4, 0x81, 0xF2, 0x7E, 0xBE, 0xEE }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeMceGuid   = { 0xE8F56FFE, 0x919C, 0x4cc5, { 0xBA, 0x88, 0x65, 0xAB, 0xE1, 0x49, 0x13, 0xBB }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypePcieGuid  = { 0xCF93C01F, 0x1A16, 0x4dfc, { 0xB8, 0xBC, 0x9C, 0x4D, 0xAF, 0x67, 0xC1, 0x04 }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeInitGuid  = { 0xCC5263E8, 0x9308, 0x454a, { 0x89, 0xD0, 0x34, 0x0B, 0xD3, 0x9B, 0xC9, 0x8E }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeNmiGuid   = { 0x5BAD89FF, 0xB7E6, 0x42c9, { 0x81, 0x4A, 0xCF, 0x24, 0x85, 0xD6, 0xE9, 0x8A }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeBootGuid  = { 0x3D61A466, 0xAB40, 0x409a, { 0xA6, 0x98, 0xF3, 0x62, 0xD4, 0x64, 0xB3, 0x8F }}
+
+  ## Include/Guid/Cper.h
+  gEfiEventNotificationTypeDmarGuid  = { 0x667DD791, 0xC6B3, 0x4c27, { 0x8A, 0x6B, 0x0F, 0x8E, 0x72, 0x2D, 0xEB, 0x41 }}
+
+  ## Include/Guid/Cper.h
+  gEfiProcessorGenericErrorSectionGuid  = { 0x9876ccad, 0x47b4, 0x4bdb, { 0xb6, 0x5e, 0x16, 0xf1, 0x93, 0xc4, 0xf3, 0xdb }}
+
+  ## Include/Guid/Cper.h
+  gEfiProcessorSpecificErrorSectionGuid = { 0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d }}
+
+  ## Include/Guid/Cper.h
+  gEfiIa32X64ProcessorErrorSectionGuid  = { 0xdc3ea0b0, 0xa144, 0x4797, { 0xb9, 0x5b, 0x53, 0xfa, 0x24, 0x2b, 0x6e, 0x1d }}
+
+  ## Include/Guid/Cper.h
+  gEfiPlatformMemoryErrorSectionGuid = { 0xa5bc1114, 0x6f64, 0x4ede, { 0xb8, 0x63, 0x3e, 0x83, 0xed, 0x7c, 0x83, 0xb1 }}
+
+  ## Include/Guid/Cper.h
+  gEfiPcieErrorSectionGuid           = { 0xd995e954, 0xbbc1, 0x430f, { 0xad, 0x91, 0xb4, 0x4d, 0xcb, 0x3c, 0x6f, 0x35 }}
+
+  ## Include/Guid/Cper.h
+  gEfiFirmwareErrorSectionGuid       = { 0x81212a96, 0x09ed, 0x4996, { 0x94, 0x71, 0x8d, 0x72, 0x9c, 0x8e, 0x69, 0xed }}
+
+  ## Include/Guid/Cper.h
+  gEfiPciBusErrorSectionGuid         = { 0xc5753963, 0x3b84, 0x4095, { 0xbf, 0x78, 0xed, 0xda, 0xd3, 0xf9, 0xc9, 0xdd }}
+
+  ## Include/Guid/Cper.h
+  gEfiPciDevErrorSectionGuid         = { 0xeb5e4685, 0xca66, 0x4769, { 0xb6, 0xa2, 0x26, 0x06, 0x8b, 0x00, 0x13, 0x26 }}
+
+  ## Include/Guid/Cper.h
+  gEfiDMArGenericErrorSectionGuid    = { 0x5b51fef7, 0xc79d, 0x4434, { 0x8f, 0x1b, 0xaa, 0x62, 0xde, 0x3e, 0x2c, 0x64 }}
+
+  ## Include/Guid/Cper.h
+  gEfiDirectedIoDMArErrorSectionGuid = { 0x71761d37, 0x32b2, 0x45cd, { 0xa7, 0xd0, 0xb0, 0xfe, 0xdd, 0x93, 0xe8, 0xcf }}
+
+  ## Include/Guid/Cper.h
+  gEfiIommuDMArErrorSectionGuid      = { 0x036f84e1, 0x7f37, 0x428c, { 0xa7, 0x9e, 0x57, 0x5f, 0xdf, 0xaa, 0x84, 0xec }}
+
+  #
+  # GUID defined in UEFI2.2
+  #
+  ## Include/Protocol/UserManager.h
+  gEfiEventUserProfileChangedGuid = { 0xbaf1e6de, 0x209e, 0x4adb, {0x8d, 0x96, 0xfd, 0x8b, 0x71, 0xf3, 0xf6, 0x83 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassUnknownGuid = { 0x5cf32e68, 0x7660, 0x449b, { 0x80, 0xe6, 0x7e, 0xa3, 0x6e, 0x3, 0xf6, 0xa8 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassPasswordGuid = { 0xf8e5058c, 0xccb6, 0x4714, { 0xb2, 0x20, 0x3f, 0x7e, 0x3a, 0x64, 0xb, 0xd1 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassSmartCardGuid = { 0x5f03ba33, 0x8c6b, 0x4c24, { 0xaa, 0x2e, 0x14, 0xa2, 0x65, 0x7b, 0xd4, 0x54 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassFingerprintGuid = { 0x32cba21f, 0xf308, 0x4cbc, { 0x9a, 0xb5, 0xf5, 0xa3, 0x69, 0x9f, 0x4, 0x4a }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassHandprintGuid = { 0x5917ef16, 0xf723, 0x4bb9, { 0xa6, 0x4b, 0xd8, 0xc5, 0x32, 0xf4, 0xd8, 0xb5 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserCredentialClassSecureCardGuid = { 0x8a6b4a83, 0x42fe, 0x45d2, { 0xa2, 0xef, 0x46, 0xf0, 0x6c, 0x7d, 0x98, 0x52 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserInfoAccessSetupAdminGuid = { 0x85b75607, 0xf7ce, 0x471e, { 0xb7, 0xe4, 0x2a, 0xea, 0x5f, 0x72, 0x32, 0xee }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserInfoAccessSetupNormalGuid = { 0x1db29ae0, 0x9dcb, 0x43bc, { 0x8d, 0x87, 0x5d, 0xa1, 0x49, 0x64, 0xdd, 0xe2 }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserInfoAccessSetupRestrictedGuid = { 0xbdb38125, 0x4d63, 0x49f4, { 0x82, 0x12, 0x61, 0xcf, 0x5a, 0x19, 0xa, 0xf8 }}
+
+  ## Include/Guid/ImageAuthentication.h
+  gEfiImageSecurityDatabaseGuid  = { 0xd719b2cb, 0x3d3a, 0x4596, {0xa3, 0xbc, 0xda, 0xd0,  0xe, 0x67, 0x65, 0x6f }}
+  gEfiCertSha256Guid             = { 0xc1c41626, 0x504c, 0x4092, {0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28 }}
+  gEfiCertRsa2048Guid            = { 0x3c5766e8, 0x269c, 0x4e34, {0xaa, 0x14, 0xed, 0x77, 0x6e, 0x85, 0xb3, 0xb6 }}
+  gEfiCertRsa2048Sha256Guid      = { 0xe2b36190, 0x879b, 0x4a3d, {0xad, 0x8d, 0xf2, 0xe7, 0xbb, 0xa3, 0x27, 0x84 }}
+  gEfiCertSha1Guid               = { 0x826ca512, 0xcf10, 0x4ac9, {0xb1, 0x87, 0xbe,  0x1, 0x49, 0x66, 0x31, 0xbd }}
+  gEfiCertRsa2048Sha1Guid        = { 0x67f8444f, 0x8743, 0x48f1, {0xa3, 0x28, 0x1e, 0xaa, 0xb8, 0x73, 0x60, 0x80 }}
+  gEfiCertX509Guid               = { 0xa5c059a1, 0x94e4, 0x4aa7, {0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72 }}
+
+  #
+  # GUIDs defined in UEFI2.3.1
+  #
+  ## Include/Protocol/Kms.h
+  gEfiKmsFormatGeneric128Guid    = { 0xec8a3d69, 0x6ddf, 0x4108, {0x94, 0x76, 0x73, 0x37, 0xfc, 0x52, 0x21, 0x36 }}
+  gEfiKmsFormatGeneric160Guid    = { 0xa3b3e6f8, 0xefca, 0x4bc1, {0x88, 0xfb, 0xcb, 0x87, 0x33, 0x9b, 0x25, 0x79 }}
+  gEfiKmsFormatGeneric256Guid    = { 0x70f64793, 0xc323, 0x4261, {0xac, 0x2c, 0xd8, 0x76, 0xf2, 0x7c, 0x53, 0x45 }}
+  gEfiKmsFormatGeneric512Guid    = { 0x978fe043, 0xd7af, 0x422e, {0x8a, 0x92, 0x2b, 0x48, 0xe4, 0x63, 0xbd, 0xe6 }}
+  gEfiKmsFormatGeneric1024Guid   = { 0x43be0b44, 0x874b, 0x4ead, {0xb0, 0x9c, 0x24, 0x1a, 0x4f, 0xbd, 0x7e, 0xb3 }}
+  gEfiKmsFormatGeneric2048Guid   = { 0x40093f23, 0x630c, 0x4626, {0x9c, 0x48, 0x40, 0x37, 0x3b, 0x19, 0xcb, 0xbe }}
+  gEfiKmsFormatGeneric3072Guid   = { 0xb9237513, 0x6c44, 0x4411, {0xa9, 0x90, 0x21, 0xe5, 0x56, 0xe0, 0x5a, 0xde }}
+  gEfiKmsFormatMd2128Guid        = { 0x78be11c4, 0xee44, 0x4a22, {0x9f, 0x05, 0x03, 0x85, 0x2e, 0xc5, 0xc9, 0x78 }}
+  gEfiKmsFormatMdc2128Guid       = { 0xf7ad60f8, 0xefa8, 0x44a3, {0x91, 0x13, 0x23, 0x1f, 0x39, 0x9e, 0xb4, 0xc7 }}
+  gEfiKmsFormatMd4128Guid        = { 0xd1c17aa1, 0xcac5, 0x400f, {0xbe, 0x17, 0xe2, 0xa2, 0xae, 0x06, 0x67, 0x7c }}
+  gEfiKmsFormatMdc4128Guid       = { 0x3fa4f847, 0xd8eb, 0x4df4, {0xbd, 0x49, 0x10, 0x3a, 0x0a, 0x84, 0x7b, 0xbc }}
+  gEfiKmsFormatMd5128Guid        = { 0xdcbc3662, 0x9cda, 0x4b52, {0xa0, 0x4c, 0x82, 0xeb, 0x1d, 0x23, 0x48, 0xc7 }}
+  gEfiKmsFormatMd5sha128Guid     = { 0x1c178237, 0x6897, 0x459e, {0x9d, 0x36, 0x67, 0xce, 0x8e, 0xf9, 0x4f, 0x76 }}
+  gEfiKmsFormatSha1160Guid       = { 0x453c5e5a, 0x482d, 0x43f0, {0x87, 0xc9, 0x59, 0x41, 0xf3, 0xa3, 0x8a, 0xc2 }}
+  gEfiKmsFormatSha256256Guid     = { 0x6bb4f5cd, 0x8022, 0x448d, {0xbc, 0x6d, 0x77, 0x1b, 0xae, 0x93, 0x5f, 0xc6 }}
+  gEfiKmsFormatSha512512Guid     = { 0x2f240e12, 0xe14d, 0x475c, {0x83, 0xb0, 0xef, 0xff, 0x22, 0xd7, 0x7b, 0xe7 }}
+  gEfiKmsFormatAesxts128Guid     = { 0x4776e33f, 0xdb47, 0x479a, {0xa2, 0x5f, 0xa1, 0xcd, 0x0a, 0xfa, 0xb3, 0x8b }}
+  gEfiKmsFormatAesxts256Guid     = { 0xdc7e8613, 0xc4bb, 0x4db0, {0x84, 0x62, 0x13, 0x51, 0x13, 0x57, 0xab, 0xe2 }}
+  gEfiKmsFormatAescbc128Guid     = { 0xa0e8ee6a, 0x0e92, 0x44d4, {0x86, 0x1b, 0x0e, 0xaa, 0x4a, 0xca, 0x44, 0xa2 }}
+  gEfiKmsFormatAescbc256Guid     = { 0xd7e69789, 0x1f68, 0x45e8, {0x96, 0xef, 0x3b, 0x64, 0x07, 0xa5, 0xb2, 0xdc }}
+  gEfiKmsFormatRsasha11024Guid   = { 0x56417bed, 0x6bbe, 0x4882, {0x86, 0xa0, 0x3a, 0xe8, 0xbb, 0x17, 0xf8, 0xf9 }}
+  gEfiKmsFormatRsasha12048Guid   = { 0xf66447d4, 0x75a6, 0x463e, {0xa8, 0x19, 0x07, 0x7f, 0x2d, 0xda, 0x05, 0xe9 }}
+  gEfiKmsFormatRsasha2562048Guid = { 0xa477af13, 0x877d, 0x4060, {0xba, 0xa1, 0x25, 0xd1, 0xbe, 0xa0, 0x8a, 0xd3 }}
+  gEfiKmsFormatRsasha2563072Guid = { 0x4e1356c2,  0xeed, 0x463f, {0x81, 0x47, 0x99, 0x33, 0xab, 0xdb, 0xc7, 0xd5 }}
+
+  ## Include/Guid/ImageAuthentication.h
+  gEfiCertSha224Guid             = { 0xb6e5233,  0xa65c, 0x44c9, {0x94, 0x7,  0xd9, 0xab, 0x83, 0xbf, 0xc8, 0xbd }}
+  gEfiCertSha384Guid             = { 0xff3e5307, 0x9fd0, 0x48c9, {0x85, 0xf1, 0x8a, 0xd5, 0x6c, 0x70, 0x1e,  0x1 }}
+  gEfiCertSha512Guid             = { 0x93e0fae,  0xa6c4, 0x4f50, {0x9f, 0x1b, 0xd4, 0x1e, 0x2b, 0x89, 0xc1, 0x9a }}
+  gEfiCertPkcs7Guid              = { 0x4aafd29d, 0x68df, 0x49ee, {0x8a, 0xa9, 0x34, 0x7d, 0x37, 0x56, 0x65, 0xa7 }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashAlgorithmSha1NoPadGuid = { 0x24c5dc2f, 0x53e2, 0x40ca, { 0x9e, 0xd6, 0xa5, 0xd9, 0xa4, 0x9f, 0x46, 0x3b }}
+  gEfiHashAlgorithmSha256NoPadGuid = { 0x8628752a, 0x6cb7, 0x4814, { 0x96, 0xfc, 0x24, 0xa8, 0x15, 0xac, 0x22, 0x26 }}
+
+  #
+  # GUIDs defined in UEFI2.4
+  #
+  ## Include/Guid/FmpCapsule.h
+  gEfiFmpCapsuleGuid             =  { 0x6dcbd5ed, 0xe82d, 0x4c44, {0xbd, 0xa1, 0x71, 0x94, 0x19, 0x9a, 0xd9, 0x2a }}
+
+  ## Include/Guid/ImageAuthentication.h
+  gEfiCertX509Sha256Guid         = { 0x3bd2a492, 0x96c0, 0x4079, {0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed }}
+  gEfiCertX509Sha384Guid         = { 0x7076876e, 0x80c2, 0x4ee6, {0xaa, 0xd2, 0x28, 0xb3, 0x49, 0xa6, 0x86, 0x5b }}
+  gEfiCertX509Sha512Guid         = { 0x446dbf63, 0x2502, 0x4cda, {0xbc, 0xfa, 0x24, 0x65, 0xd2, 0xb0, 0xfe, 0x9d }}
+
+  ## Include/Protocol/Rng.h
+  gEfiRngAlgorithmSp80090Hash256Guid = { 0xa7af67cb, 0x603b, 0x4d42, {0xba, 0x21, 0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96 }}
+  gEfiRngAlgorithmSp80090Hmac256Guid = { 0xc5149b43, 0xae85, 0x4f53, {0x99, 0x82, 0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7 }}
+  gEfiRngAlgorithmSp80090Ctr256Guid  = { 0x44f0de6e, 0x4d8c, 0x4045, {0xa8, 0xc7, 0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e }}
+  gEfiRngAlgorithmX9313DesGuid       = { 0x63c4785a, 0xca34, 0x4012, {0xa3, 0xc8, 0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46 }}
+  gEfiRngAlgorithmX931AesGuid        = { 0xacd03321, 0x777e, 0x4d3d, {0xb1, 0xc8, 0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9 }}
+  gEfiRngAlgorithmRaw                = { 0xe43176d7, 0xb6e8, 0x4827, {0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61 }}
+
+  ## Include/Protocol/AdapterInformation.h
+  gEfiAdapterInfoMediaStateGuid       = { 0xD7C74207, 0xA831, 0x4A26, {0xB1, 0xF5, 0xD1, 0x93, 0x06, 0x5C, 0xE8, 0xB6 }}
+  gEfiAdapterInfoNetworkBootGuid      = { 0x1FBD2960, 0x4130, 0x41E5, {0x94, 0xAC, 0xD2, 0xCF, 0x03, 0x7F, 0xB3, 0x7C }}
+  gEfiAdapterInfoSanMacAddressGuid    = { 0x114da5ef, 0x2cf1, 0x4e12, {0x9b, 0xbb, 0xc4, 0x70, 0xb5, 0x52, 0x5, 0xd9 }}
+
+  ## Include/Guid/CapsuleReport.h
+  gEfiCapsuleReportGuid               = { 0x39b68c46, 0xf7fb, 0x441b, {0xb6, 0xec, 0x16, 0xb0, 0xf6, 0x98, 0x21, 0xf3 }}
+
+  #
+  # GUIDs defined in UEFI2.5
+  #
+
+  ## Include/Guid/PropertiesTable.h
+  gEfiPropertiesTableGuid        = { 0x880aaca3, 0x4adc, 0x4a04, {0x90, 0x79, 0xb7, 0x47, 0x34, 0x8, 0x25, 0xe5 }}
+
+  ## Include/Guid/SystemResourceTable.h
+  gEfiSystemResourceTableGuid    = { 0xb122a263, 0x3661, 0x4f68, {0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 }}
+
+  ## Include/Protocol/AdapterInformation.h
+  gEfiAdapterInfoUndiIpv6SupportGuid = { 0x4bd56be3, 0x4975, 0x4d8a, {0xa0, 0xad, 0xc4, 0x91, 0x20, 0x4b, 0x5d, 0x4d }}
+
+  ## Include/Protocol/RegularExpressionProtocol.h
+  gEfiRegexSyntaxTypePosixExtendedGuid = {0x5F05B20F, 0x4A56, 0xC231, {0xFA, 0x0B, 0xA7, 0xB1, 0xF1, 0x10, 0x04, 0x1D }}
+
+  ## Include/Protocol/RegularExpressionProtocol.h
+  gEfiRegexSyntaxTypeEcma262Guid = { 0x9A473A4A, 0x4CEB, 0xB95A, {0x41, 0x5E, 0x5B, 0xA0, 0xBC, 0x63, 0x9B, 0x2E }}
+
+  ## Include/Protocol/RegularExpressionProtocol.h
+  gEfiRegexSyntaxTypePerlGuid = {0x63E60A51, 0x497D, 0xD427, {0xC4, 0xA5, 0xB8, 0xAB, 0xDC, 0x3A, 0xAE, 0xB6 }}
+
+  ## Include/Guid/Cper.h
+  gEfiPlatformMemory2ErrorSectionGuid = { 0x61EC04FC, 0x48E6, 0xD813, { 0x25, 0xC9, 0x8D, 0xAA, 0x44, 0x75, 0x0B, 0x12 }}
+
+  ## Include/Protocol/BlockIoCrypto.h
+  gEfiBlockIoCryptoAlgoAesXtsGuid            = { 0x2f87ba6a, 0x5c04, 0x4385, {0xa7, 0x80, 0xf3, 0xbf, 0x78, 0xa9, 0x7b, 0xec }}
+  gEfiBlockIoCryptoAlgoAesCbcMsBitlockerGuid = { 0x689e4c62, 0x70bf, 0x4cf3, {0x88, 0xbb, 0x33, 0xb3, 0x18, 0x26, 0x86, 0x70 }}
+
+  ## Include/Protocol/SmartCardEdge.h
+  gEfiPaddingRsassaPkcs1V1P5Guid = { 0x9317ec24, 0x7cb0, 0x4d0e, {0x8b, 0x32, 0x2e, 0xd9, 0x20, 0x9c, 0xd8, 0xaf }}
+  gEfiPaddingRsassaPssGuid       = { 0x7b2349e0, 0x522d, 0x4f8e, {0xb9, 0x27, 0x69, 0xd9, 0x7c, 0x9e, 0x79, 0x5f }}
+  gEfiPaddingNoneGuid            = { 0x3629ddb1, 0x228c, 0x452e, {0xb6, 0x16, 0x09, 0xed, 0x31, 0x6a, 0x97, 0x00 }}
+  gEfiPaddingRsaesPkcs1V1P5Guid  = { 0xe1c1d0a9, 0x40b1, 0x4632, {0xbd, 0xcc, 0xd9, 0xd6, 0xe5, 0x29, 0x56, 0x31 }}
+  gEfiPaddingRsaesOaepGuid       = { 0xc1e63ac4, 0xd0cf, 0x4ce6, {0x83, 0x5b, 0xee, 0xd0, 0xe6, 0xa8, 0xa4, 0x5b }}
+
+  ## Include/Guid/SmBios.h
+  gEfiSmbios3TableGuid = { 0xF2FD1544, 0x9794, 0x4A2C, { 0x99, 0x2E, 0xE5, 0xBB, 0xCF, 0x20, 0xE3, 0x94 }}
+
+  ## Include/Protocol/BootManagerPolicy.h
+  gEfiBootManagerPolicyConsoleGuid    = { 0xCAB0E94C, 0xE15F, 0x11E3, { 0x91, 0x8D, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA }}
+  gEfiBootManagerPolicyNetworkGuid    = { 0xD04159DC, 0xE15F, 0x11E3, { 0xB2, 0x61, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA }}
+  gEfiBootManagerPolicyConnectAllGuid = { 0x113B2126, 0xFC8A, 0x11E3, { 0xBD, 0x6C, 0xB8, 0xE8, 0x56, 0x2C, 0xBA, 0xFA }}
+
+  ## Include/Protocol/DevicePath.h
+  gEfiVirtualDiskGuid            = { 0x77AB535A, 0x45FC, 0x624B, {0x55, 0x60, 0xF7, 0xB2, 0x81, 0xD1, 0xF9, 0x6E }}
+  gEfiVirtualCdGuid              = { 0x3D5ABD30, 0x4175, 0x87CE, {0x6D, 0x64, 0xD2, 0xAD, 0xE5, 0x23, 0xC4, 0xBB }}
+  gEfiPersistentVirtualDiskGuid  = { 0x5CEA02C9, 0x4D07, 0x69D3, {0x26, 0x9F ,0x44, 0x96, 0xFB, 0xE0, 0x96, 0xF9 }}
+  gEfiPersistentVirtualCdGuid    = { 0x08018188, 0x42CD, 0xBB48, {0x10, 0x0F, 0x53, 0x87, 0xD5, 0x3D, 0xED, 0x3D }}
+
+  #
+  # GUIDs defined in UEFI2.6
+  #
+
+  ## Include/Guid/MemoryAttributesTable.h
+  gEfiMemoryAttributesTableGuid        = { 0xdcfa911d, 0x26eb, 0x469f, {0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20}}
+
+  ## Include/Guid/Cper.h
+  gEfiArmProcessorErrorSectionGuid     = { 0xe19e3d16, 0xbc11, 0x11e4, { 0x9c, 0xaa, 0xc2, 0x05, 0x1d, 0x5d, 0x46, 0xb0 }}
+
+  ## Guid for Image decoder
+  ## Include/Protocol/ImageDecoder.h
+  gEfiHiiImageDecoderNameJpegGuid           = { 0xefefd093, 0x0d9b, 0x46eb, { 0xa8, 0x56, 0x48, 0x35, 0x07, 0x00, 0xc9, 0x08 }}
+  gEfiHiiImageDecoderNamePngGuid            = { 0xaf060190, 0x5e3a, 0x4025, { 0xaf, 0xbd, 0xe1, 0xf9, 0x05, 0xbf, 0xaa, 0x4c }}
+
+  #
+  # GUID defined in PI1.0
+  #
+  ## Include/Guid/AprioriFileName.h
+  gPeiAprioriFileNameGuid        = { 0x1b45cc0a, 0x156a, 0x428a, { 0XAF, 0x62,  0x49, 0x86, 0x4d, 0xa0, 0xe6, 0xe6 }}
+
+  ## Include/Guid/Apriori.h
+  gAprioriGuid                   = { 0xFC510EE7, 0xFFDC, 0x11D4, { 0xBD, 0x41, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Guid/FirmwareFileSystem2.h
+  gEfiFirmwareFileSystem2Guid     = { 0x8c8ce578, 0x8a3d, 0x4f1c, { 0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 }}
+
+  ## Include/Guid/FirmwareFileSystem2.h
+  gEfiFirmwareVolumeTopFileGuid  = { 0x1BA0062E, 0xC779, 0x4582, { 0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x09 }}
+
+  ## Include/Guid/MemoryAllocationHob.h
+  gEfiHobMemoryAllocModuleGuid   = { 0xF8E21975, 0x0899, 0x4F58, { 0xA4, 0xBE, 0x55, 0x25, 0xA9, 0xC6, 0xD7, 0x7A }}
+
+  ## Include/Guid/MemoryAllocationHob.h
+  gEfiHobMemoryAllocStackGuid    = { 0x4ED4BF27, 0x4092, 0x42E9, { 0x80, 0x7D, 0x52, 0x7B, 0x1D, 0x00, 0xC9, 0xBD }}
+
+  ## Include/Guid/MemoryAllocationHob.h
+  gEfiHobMemoryAllocBspStoreGuid = { 0x564B33CD, 0xC92A, 0x4593, { 0x90, 0xBF, 0x24, 0x73, 0xE4, 0x3C, 0x63, 0x22 }}
+
+  ## Include/Guid/EventLegacyBios.h
+  gEfiEventLegacyBootGuid        = { 0x2A571201, 0x4966, 0x47F6, { 0x8B, 0x86, 0xF3, 0x1E, 0x41, 0xF3, 0x2F, 0x10 }}
+
+  ## Include/Guid/HobList.h
+  gEfiHobListGuid                = { 0x7739F24C, 0x93D7, 0x11D4, { 0x9A, 0x3A, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Guid/DxeServices.h
+  gEfiDxeServicesTableGuid       = { 0x05AD34BA, 0x6F02, 0x4214, { 0x95, 0x2E, 0x4D, 0xA0, 0x39, 0x8E, 0x2B, 0xB9 }}
+
+  ## Include/Guid/MdePkgTokenSpace.h
+  gEfiMdePkgTokenSpaceGuid       = { 0x914AEBE7, 0x4635, 0x459b, { 0xAA, 0x1C, 0x11, 0xE2, 0x19, 0xB0, 0x3A, 0x10 }}
+
+  ## Include/Guid/HardwareErrorVariable.h
+  gEfiHardwareErrorVariableGuid  = { 0x414E6BDD, 0xE47B, 0x47cc, { 0xB2, 0x44, 0xBB, 0x61, 0x02, 0x0C, 0xF5, 0x16 }}
+
+  #
+  # GUID defined in PI1.2
+  #
+  ## Include/Guid/EventGroup.h
+  gEfiEventDxeDispatchGuid       = { 0x7081E22F, 0xCAC6, 0x4053, { 0x94, 0x68, 0x67, 0x57, 0x82, 0xCF, 0x88, 0xE5 }}
+
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify Ide interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoIdeInterfaceGuid   = { 0x5E948FE3, 0x26D3, 0x42B5, { 0xAF, 0x17, 0x61, 0x02, 0x87, 0x18, 0x8D, 0xEC }}
+
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify Scsi interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoScsiInterfaceGuid  = { 0x08F74BAA, 0xEA36, 0x41D9, { 0x95, 0x21, 0x21, 0xA7, 0x0F, 0x87, 0x80, 0xBC }}
+
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify Usb interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoUsbInterfaceGuid   = { 0xCB871572, 0xC11A, 0x47B5, { 0xB4, 0x92, 0x67, 0x5E, 0xAF, 0xA7, 0x77, 0x27 }}
+
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify Ahci interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoAhciInterfaceGuid  = { 0x9e498932, 0x4abc, 0x45af, { 0xa3, 0x4d, 0x02, 0x47, 0x78, 0x7b, 0xe7, 0xc6 }}
+
+  ## Include/Guid/StatusCodeDataTypeId.h
+  gEfiStatusCodeDataTypeStringGuid = { 0x92D11080, 0x496F, 0x4D95, { 0xBE, 0x7E, 0x03, 0x74, 0x88, 0x38, 0x2B, 0x0A }}
+
+  ## Include/Guid/StatusCodeDataTypeId.h
+  gEfiStatusCodeSpecificDataGuid   = { 0x335984BD, 0xE805, 0x409A, { 0xB8, 0xF8, 0xD2, 0x7E, 0xCE, 0x5F, 0xF7, 0xA6 }}
+
+  ## Include/Guid/FirmwareFileSystem3.h
+  gEfiFirmwareFileSystem3Guid      = { 0x5473c07a, 0x3dcb, 0x4dca, { 0xbd, 0x6f, 0x1e, 0x96, 0x89, 0xe7, 0x34, 0x9a }}
+
+  #
+  # GUID defined in PI1.2.1
+  #
+  ## Include/Guid/EventGroup.h
+  gEfiEndOfDxeEventGroupGuid        = { 0x2ce967a, 0xdd7e, 0x4ffc, { 0x9e, 0xe7, 0x81, 0xc, 0xf0, 0x47, 0x8, 0x80 }}
+
+  ## Include/Guid/FirmwareContentsSigned.h
+  gEfiFirmwareContentsSignedGuid    = { 0xf9d89e8, 0x9259, 0x4f76, { 0xa5, 0xaf, 0xc, 0x89, 0xe3, 0x40, 0x23, 0xdf }}
+
+  ## Include/Guid/VectorHandoffTable.h
+  gEfiVectorHandoffTableGuid        = { 0x996ec11c, 0x5397, 0x4e73, { 0xb5, 0x8f, 0x82, 0x7e, 0x52, 0x90, 0x6d, 0xef }}
+
+  ## Include/IndustryStandard/Hsti.h
+  gAdapterInfoPlatformSecurityGuid  = {0x6be272c7, 0x1320, 0x4ccd, { 0x90, 0x17, 0xd4, 0x61, 0x2c, 0x01, 0x2b, 0x25 }}
+
+  #
+  # GUID defined in PI1.3
+  #
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify Nvme interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoNvmeInterfaceGuid  = { 0x3ab14680, 0x5d3f, 0x4a4d, { 0xbc, 0xdc, 0xcc, 0x38, 0x0, 0x18, 0xc7, 0xf7 }}
+
+  #
+  # GUID defined in PI1.4
+  #
+  ## Include/Guid/GraphicsInfoHob.h
+  gEfiGraphicsInfoHobGuid           = { 0x39f62cce, 0x6825, 0x4669, { 0xbb, 0x56, 0x54, 0x1a, 0xba, 0x75, 0x3a, 0x07 }}
+
+  ## Guid for EFI_DISK_INFO_PROTOCOL.Interface to specify UFS interface.
+  ## Include/Protocol/DiskInfo.h
+  gEfiDiskInfoUfsInterfaceGuid   = { 0x4b3029cc, 0x6b98, 0x47fb, { 0xbc, 0x96, 0x76, 0xdc, 0xb8, 0x4, 0x41, 0xf0 }}
+
+  #
+  # GUID defined in PI1.5
+  #
+  ## Include/Guid/GraphicsInfoHob.h
+  gEfiGraphicsDeviceInfoHobGuid     = { 0xe5cb2ac9, 0xd35d, 0x4430, { 0x93, 0x6e, 0x1d, 0xe3, 0x32, 0x47, 0x8d, 0xe7 }}
+
+  #
+  # GUID defined in Windows UEFI Firmware Update Platform doc
+  #
+  ## Include/IndustryStandard/WindowsUxCapsule.h
+  gWindowsUxCapsuleGuid          = { 0x3b8c8162, 0x188c, 0x46a4, { 0xae, 0xc9, 0xbe, 0x43, 0xf1, 0xd6, 0x56, 0x97}}
+
+[Guids.IA32, Guids.X64]
+  ## Include/Guid/Cper.h
+  gEfiIa32X64ErrorTypeCacheCheckGuid = { 0xA55701F5, 0xE3EF, 0x43de, { 0xAC, 0x72, 0x24, 0x9B, 0x57, 0x3F, 0xAD, 0x2C }}
+
+  ## Include/Guid/Cper.h
+  gEfiIa32X64ErrorTypeTlbCheckGuid   = { 0xFC06B535, 0x5E1F, 0x4562, { 0x9F, 0x25, 0x0A, 0x3B, 0x9A, 0xDB, 0x63, 0xC3 }}
+
+  ## Include/Guid/Cper.h
+  gEfiIa32X64ErrorTypeBusCheckGuid   = { 0x1CF3F8B3, 0xC5B1, 0x49a2, { 0xAA, 0x59, 0x5E, 0xEF, 0x92, 0xFF, 0xA6, 0x3C }}
+
+  ## Include/Guid/Cper.h
+  gEfiIa32X64ErrorTypeMsCheckGuid    = { 0x48AB7F57, 0xDC34, 0x4f6c, { 0xA7, 0xD3, 0xB0, 0xB5, 0xB0, 0xA7, 0x43, 0x14 }}
+
+[Ppis]
+  ## Include/Ppi/MasterBootMode.h
+  gEfiPeiMasterBootModePpiGuid = { 0x7408d748, 0xfc8c, 0x4ee6, {0x92, 0x88, 0xc4, 0xbe, 0xc0, 0x92, 0xa4, 0x10 } }
+
+  ## Include/Ppi/DxeIpl.h
+  gEfiDxeIplPpiGuid = {0xae8ce5d, 0xe448, 0x4437, {0xa8, 0xd7, 0xeb, 0xf5, 0xf1, 0x94, 0xf7, 0x31 }}
+
+  ## Include/Ppi/MemoryDiscovered.h
+  gEfiPeiMemoryDiscoveredPpiGuid = {0xf894643d, 0xc449, 0x42d1, {0x8e, 0xa8, 0x85, 0xbd, 0xd8, 0xc6, 0x5b, 0xde } }
+
+  ## Include/Ppi/BootInRecoveryMode.h
+  gEfiPeiBootInRecoveryModePpiGuid = { 0x17ee496a, 0xd8e4, 0x4b9a, {0x94, 0xd1, 0xce, 0x82, 0x72, 0x30, 0x8, 0x50 } }
+
+  ## Include/Ppi/EndOfPeiPhase.h
+  gEfiEndOfPeiSignalPpiGuid = {0x605EA650, 0xC65C, 0x42e1, {0xBA, 0x80, 0x91, 0xA5, 0x2A, 0xB6, 0x18, 0xC6 } }
+
+  ## Include/Ppi/Reset.h
+  gEfiPeiResetPpiGuid = { 0xef398d58, 0x9dfd, 0x4103, {0xbf, 0x94, 0x78, 0xc6, 0xf4, 0xfe, 0x71, 0x2f } }
+
+  ## Include/Ppi/StatusCode.h
+  gEfiPeiStatusCodePpiGuid = { 0x229832d3, 0x7a30, 0x4b36, {0xb8, 0x27, 0xf4, 0xc, 0xb7, 0xd4, 0x54, 0x36 } }
+
+  ## Include/Ppi/Security2.h
+  gEfiPeiSecurity2PpiGuid = { 0xdcd0be23, 0x9586, 0x40f4, { 0xb6, 0x43, 0x6, 0x52, 0x2c, 0xed, 0x4e, 0xde } }
+
+  ## Include/Ppi/TemporaryRamSupport.h
+  gEfiTemporaryRamSupportPpiGuid = { 0xdbe23aa9, 0xa345, 0x4b97, {0x85, 0xb6, 0xb2, 0x26, 0xf1, 0x61, 0x73, 0x89} }
+
+  ## Include/Ppi/CpuIo.h
+  gEfiPeiCpuIoPpiInstalledGuid = { 0xe6af1f7b, 0xfc3f, 0x46da, {0xa8, 0x28, 0xa3, 0xb4, 0x57, 0xa4, 0x42, 0x82 } }
+
+  ## Include/Ppi/PciCfg2.h
+  gEfiPciCfg2PpiGuid = { 0x57a449a, 0x1fdc, 0x4c06, { 0xbf, 0xc9, 0xf5, 0x3f, 0x6a, 0x99, 0xbb, 0x92 } }
+
+  ## Include/Ppi/Stall.h
+  gEfiPeiStallPpiGuid = { 0x1f4c6f90, 0xb06b, 0x48d8, {0xa2, 0x01, 0xba, 0xe5, 0xf1, 0xcd, 0x7d, 0x56 } }
+
+  ## Include/Ppi/ReadOnlyVariable2.h
+  gEfiPeiReadOnlyVariable2PpiGuid = { 0x2ab86ef5, 0xecb5, 0x4134, { 0xb5, 0x56, 0x38, 0x54, 0xca, 0x1f, 0xe1, 0xb4 } }
+
+  ## Include/Ppi/SecPlatformInformation.h
+  gEfiSecPlatformInformationPpiGuid = { 0x6f8c2b35, 0xfef4, 0x448d, {0x82, 0x56, 0xe1, 0x1b, 0x19, 0xd6, 0x10, 0x77 } }
+
+  ## Include/Ppi/LoadImage.h
+  gEfiPeiLoadedImagePpiGuid = { 0xc1fcd448, 0x6300, 0x4458, { 0xb8, 0x64, 0x28, 0xdf, 0x1, 0x53, 0x64, 0xbc } }
+
+  ## Include/Ppi/Smbus2.h
+  gEfiPeiSmbus2PpiGuid = { 0x9ca93627, 0xb65b, 0x4324, { 0xa2, 0x2, 0xc0, 0xb4, 0x61, 0x76, 0x45, 0x43 } }
+
+  ## Include/Ppi/FirmwareVolumeInfo.h
+  gEfiPeiFirmwareVolumeInfoPpiGuid = { 0x49edb1c1, 0xbf21, 0x4761, { 0xbb, 0x12, 0xeb, 0x0, 0x31, 0xaa, 0xbb, 0x39 } }
+
+  ## Include/Ppi/LoadFile.h
+  gEfiPeiLoadFilePpiGuid = { 0xb9e0abfe, 0x5979, 0x4914, { 0x97, 0x7f, 0x6d, 0xee, 0x78, 0xc2, 0x78, 0xa6 } }
+
+  ## Include/Ppi/Decompress.h
+  gEfiPeiDecompressPpiGuid = { 0x1a36e4e7, 0xfab6, 0x476a, { 0x8e, 0x75, 0x69, 0x5a, 0x5, 0x76, 0xfd, 0xd7 } }
+
+  ## Include/Ppi/Pcd.h
+  gPcdPpiGuid = { 0x6e81c58, 0x4ad7, 0x44bc, { 0x83, 0x90, 0xf1, 0x2, 0x65, 0xf7, 0x24, 0x80 } }
+
+  ## Include/Ppi/PcdInfo.h
+  gGetPcdInfoPpiGuid                 = { 0x4d8b155b, 0xc059, 0x4c8f, { 0x89, 0x26,  0x6, 0xfd, 0x43, 0x31, 0xdb, 0x8a } }
+
+  #
+  # PPIs defined in PI 1.2.
+  #
+
+  ## Include/Ppi/RecoveryModule.h
+  gEfiPeiRecoveryModulePpiGuid       = { 0xFB6D9542, 0x612D, 0x4f45, { 0x87, 0x2f, 0x5c, 0xff, 0x52, 0xe9, 0x3d, 0xcf }}
+
+  ## Include/Ppi/DeviceRecoveryModule.h
+  gEfiPeiDeviceRecoveryModulePpiGuid = { 0x0DE2CE25, 0x446A, 0x45a7, { 0xBF, 0xC9, 0x37, 0xDA, 0x26, 0x34, 0x4B, 0x37 }}
+
+  ## Include/Ppi/BlockIo.h
+  gEfiPeiVirtualBlockIoPpiGuid       = { 0x695d8aa1, 0x42ee, 0x4c46, { 0x80, 0x5c, 0x6e, 0xa6, 0xbc, 0xe7, 0x99, 0xe3 }}
+
+  ## Include/Ppi/S3Resume2.h
+  gEfiPeiS3Resume2PpiGuid             = { 0x6D582DBC, 0xDB85, 0x4514, {0x8F, 0xCC, 0x5A, 0xDF, 0x62, 0x27, 0xB1, 0x47 }}
+
+  ## Include/Ppi/ReportStatusCodeHandler.h
+  gEfiPeiRscHandlerPpiGuid           = { 0x65d394, 0x9951, 0x4144, {0x82, 0xa3, 0xa, 0xfc, 0x85, 0x79, 0xc2, 0x51 }}
+
+  ## Include/Ppi/PiPcd.h
+  gEfiPeiPcdPpiGuid                  = { 0x1f34d25, 0x4de2, 0x23ad, { 0x3f, 0xf3, 0x36, 0x35, 0x3f, 0xf3, 0x23, 0xf1 } }
+
+  #
+  # PPIs defined in PI 1.2.1.
+  #
+
+  ## Include/Ppi/PiPcdInfo.h
+  gEfiGetPcdInfoPpiGuid              = { 0xa60c6b59, 0xe459, 0x425d, { 0x9c, 0x69,  0xb, 0xcc, 0x9c, 0xb2, 0x7d, 0x81 } }
+
+  ## Include/Ppi/TemporaryRamDone.h
+  gEfiTemporaryRamDonePpiGuid        = { 0xceab683c, 0xec56, 0x4a2d, { 0xa9, 0x6, 0x40, 0x53, 0xfa, 0x4e, 0x9c, 0x16 } }
+
+  ## Include/Ppi/VectorHandoffInfo.h
+  gEfiVectorHandoffInfoPpiGuid       = { 0x3cd652b4, 0x6d33, 0x4dce, { 0x89, 0xdb, 0x83, 0xdf, 0x97, 0x66, 0xfc, 0xca }}
+
+  ## Include/Ppi/IsaHc.h
+  gEfiIsaHcPpiGuid                   = { 0x8d48bd70, 0xc8a3, 0x4c06, {0x90, 0x1b, 0x74, 0x79, 0x46, 0xaa, 0xc3, 0x58 } }
+
+  ## Include/Ppi/SuperIo.h
+  gEfiSioPpiGuid                     = { 0x23a464ad, 0xcb83, 0x48b8, {0x94, 0xab, 0x1a, 0x6f, 0xef, 0xcf, 0xe5, 0x22 } }
+
+  #
+  # PPIs defined in PI 1.3.
+  #
+
+  ## Include/Ppi/I2cMaster.h
+  gEfiPeiI2cMasterPpiGuid            = { 0xb3bfab9b, 0x9f9c, 0x4e8b, { 0xad, 0x37, 0x7f, 0x8c, 0x51, 0xfc, 0x62, 0x80 }}
+
+  ## Include/Ppi/FirmwareVolumeInfo2.h
+  gEfiPeiFirmwareVolumeInfo2PpiGuid  = { 0xea7ca24b, 0xded5, 0x4dad, { 0xa3, 0x89, 0xbf, 0x82, 0x7e, 0x8f, 0x9b, 0x38 } }
+
+  #
+  # PPIs defined in PI 1.4.
+  #
+
+  ## Include/Ppi/Graphics.h
+  gEfiPeiGraphicsPpiGuid             = { 0x6ecd1463, 0x4a4a, 0x461b, { 0xaf, 0x5f, 0x5a, 0x33, 0xe3, 0xb2, 0x16, 0x2b } }
+
+  ## Include/Ppi/MpServices.h
+  gEfiPeiMpServicesPpiGuid           = { 0xee16160a, 0xe8be, 0x47a6, { 0x82, 0xa, 0xc6, 0x90, 0xd, 0xb0, 0x25, 0xa } }
+
+  ## Include/Ppi/Capsule.h
+  gEfiPeiCapsulePpiGuid             = { 0x3acf33ee, 0xd892, 0x40f4, { 0xa2, 0xfc, 0x38, 0x54, 0xd2, 0xe1, 0x32, 0x3d }}
+  ## Keep name backwards compatible before PI Version 1.4
+  gPeiCapsulePpiGuid                = { 0x3acf33ee, 0xd892, 0x40f4, { 0xa2, 0xfc, 0x38, 0x54, 0xd2, 0xe1, 0x32, 0x3d }}
+
+  ## Include/Ppi/Reset2.h
+  gEfiPeiReset2PpiGuid              = { 0x6cc45765, 0xcce4, 0x42fd, {0xbc, 0x56, 0x1, 0x1a, 0xaa, 0xc6, 0xc9, 0xa8 } }
+
+  ## Include/Ppi/BlockIo2.h
+  gEfiPeiVirtualBlockIo2PpiGuid     = { 0x26cc0fad, 0xbeb3, 0x478a, { 0x91, 0xb2, 0xc, 0x18, 0x8f, 0x72, 0x61, 0x98 }}
+
+  ## Include/Ppi/SecPlatformInformation.h
+  gEfiSecPlatformInformation2PpiGuid = { 0x9e9f374b, 0x8f16, 0x4230, {0x98, 0x24, 0x58, 0x46, 0xee, 0x76, 0x6a, 0x97 } }
+
+[Protocols]
+  ## Include/Protocol/Pcd.h
+  gPcdProtocolGuid               = { 0x11B34006, 0xD85B, 0x4D0A, { 0xA2, 0x90, 0xD5, 0xA5, 0x71, 0x31, 0x0E, 0xF7 }}
+
+  ## Include/Protocol/PcdInfo.h
+  gGetPcdInfoProtocolGuid        = { 0x5be40f57, 0xfa68, 0x4610, { 0xbb, 0xbf, 0xe9, 0xc5, 0xfc, 0xda, 0xd3, 0x65 } }
+
+  #
+  # Protocols defined in PI1.0.
+  #
+
+  ## Include/Protocol/Bds.h
+  gEfiBdsArchProtocolGuid        = { 0x665E3FF6, 0x46CC, 0x11D4, { 0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/Cpu.h
+  gEfiCpuArchProtocolGuid        = { 0x26BACCB1, 0x6F42, 0x11D4, { 0xBC, 0xE7, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Protocol/Metronome.h
+  gEfiMetronomeArchProtocolGuid  = { 0x26BACCB2, 0x6F42, 0x11D4, { 0xBC, 0xE7, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Protocol/MonotonicCounter.h
+  gEfiMonotonicCounterArchProtocolGuid = { 0x1DA97072, 0xBDDC, 0x4B30, { 0x99, 0xF1, 0x72, 0xA0, 0xB5, 0x6F, 0xFF, 0x2A }}
+
+  ## Include/Protocol/RealTimeClock.h
+  gEfiRealTimeClockArchProtocolGuid = { 0x27CFAC87, 0x46CC, 0x11D4, { 0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/Reset.h
+  gEfiResetArchProtocolGuid      = { 0x27CFAC88, 0x46CC, 0x11D4, { 0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/Runtime.h
+  gEfiRuntimeArchProtocolGuid    = { 0xb7dfb4e1, 0x052f, 0x449f, { 0x87, 0xbe, 0x98, 0x18, 0xfc, 0x91, 0xb7, 0x33 }}
+
+  ## Include/Protocol/Security.h
+  gEfiSecurityArchProtocolGuid   = { 0xA46423E3, 0x4617, 0x49F1, { 0xB9, 0xFF, 0xD1, 0xBF, 0xA9, 0x11, 0x58, 0x39 }}
+
+  ## Include/Protocol/SecurityPolicy.h
+  gEfiSecurityPolicyProtocolGuid = { 0x78E4D245, 0xCD4D, 0x4A05, { 0xA2, 0xBA, 0x47, 0x43, 0xE8, 0x6C, 0xFC, 0xAB }}
+
+  ## Include/Protocol/Timer.h
+  gEfiTimerArchProtocolGuid      = { 0x26BACCB3, 0x6F42, 0x11D4, { 0xBC, 0xE7, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Protocol/VariableWrite.h
+  gEfiVariableWriteArchProtocolGuid = { 0x6441F818, 0x6362, 0x4E44, { 0xB5, 0x70, 0x7D, 0xBA, 0x31, 0xDD, 0x24, 0x53 }}
+
+  ## Include/Protocol/Variable.h
+  gEfiVariableArchProtocolGuid   = { 0x1E5668E2, 0x8481, 0x11D4, { 0xBC, 0xF1, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
+
+  ## Include/Protocol/WatchdogTimer.h
+  gEfiWatchdogTimerArchProtocolGuid = { 0x665E3FF5, 0x46CC, 0x11D4, { 0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/StatusCode.h
+  gEfiStatusCodeRuntimeProtocolGuid = { 0xD2B2B828, 0x0826, 0x48A7, { 0xB3, 0xDF, 0x98, 0x3C, 0x00, 0x60, 0x24, 0xF0 }}
+
+  ## Include/Protocol/SmbusHc.h
+  gEfiSmbusHcProtocolGuid        = {0xe49d33ed, 0x513d, 0x4634, { 0xb6, 0x98, 0x6f, 0x55, 0xaa, 0x75, 0x1c, 0x1b} }
+
+  ## Include/Protocol/FirmwareVolume2.h
+  gEfiFirmwareVolume2ProtocolGuid = { 0x220e73b6, 0x6bdb, 0x4413, { 0x84, 0x5, 0xb9, 0x74, 0xb1, 0x8, 0x61, 0x9a } }
+
+  ## Include/Protocol/FirmwareVolumeBlock.h
+  gEfiFirmwareVolumeBlockProtocolGuid = { 0x8f644fa9, 0xe850, 0x4db1, {0x9c, 0xe2, 0xb, 0x44, 0x69, 0x8e, 0x8d, 0xa4 } }
+
+  ## Include/Protocol/Capsule.h
+  gEfiCapsuleArchProtocolGuid    = { 0x5053697E, 0x2CBC, 0x4819, { 0x90, 0xD9, 0x05, 0x80, 0xDE, 0xEE, 0x57, 0x54 }}
+
+  #
+  # Protocols defined in PI 1.2.
+  #
+
+  ## Include/Protocol/MpService.h
+  gEfiMpServiceProtocolGuid = { 0x3fdda605, 0xa76e, 0x4f46, { 0xad, 0x29, 0x12, 0xf4, 0x53, 0x1b, 0x3d, 0x08 }}
+
+  ## Include/Protocol/PciHostBridgeResourceAllocation.h
+  gEfiPciHostBridgeResourceAllocationProtocolGuid = { 0xCF8034BE, 0x6768, 0x4d8b, { 0xb7, 0x39, 0x7c, 0xce, 0x68, 0x3a, 0x9f, 0xbe }}
+
+  ## Include/Protocol/PciPlatform.h
+  gEfiPciPlatformProtocolGuid    = { 0x07d75280, 0x27d4, 0x4d69, { 0x90, 0xd0, 0x56, 0x43, 0xe2, 0x38, 0xb3, 0x41 }}
+
+  ## Include/Protocol/PciOverride.h
+  gEfiPciOverrideProtocolGuid    = { 0xb5b35764, 0x460c, 0x4a06, {0x99, 0xfc, 0x77, 0xa1, 0x7c, 0x1b, 0x5c, 0xeb }}
+
+  ## Include/Protocol/PciEnumerationComplete.h
+  gEfiPciEnumerationCompleteProtocolGuid    = { 0x30cfe3e7, 0x3de1, 0x4586, {0xbe, 0x20, 0xde, 0xab, 0xa1, 0xb3, 0xb7, 0x93}}
+
+
+  ## Include/Protocol/IncompatiblePciDeviceSupport.h
+  gEfiIncompatiblePciDeviceSupportProtocolGuid = { 0xeb23f55a, 0x7863, 0x4ac2, { 0x8d, 0x3d, 0x95, 0x65, 0x35, 0xde, 0x03, 0x75 }}
+
+  ## Include/Protocol/PciHotPlugInit.h
+  gEfiPciHotPlugInitProtocolGuid = { 0xaa0e8bc1, 0xdabc, 0x46b0, { 0xa8, 0x44, 0x37, 0xb8, 0x16, 0x9b, 0x2b, 0xea }}
+
+  ## This protocol is used to add or remove all PCI child devices on the PCI root bridge.
+  #  Include/Protocol/PciHotPlugRequest.h
+  gEfiPciHotPlugRequestProtocolGuid = { 0x19CB87AB, 0x2CB9, 0x4665, { 0x83, 0x60, 0xDD, 0xCF, 0x60, 0x54, 0xF7, 0x9D }}
+
+  ## Include/Protocol/IdeControllerInit.h
+  gEfiIdeControllerInitProtocolGuid = { 0xa1e37052, 0x80d9, 0x4e65, { 0xa3, 0x17, 0x3e, 0x9a, 0x55, 0xc4, 0x3e, 0xc9 }}
+
+  ## Disk Info protocol is used to export Inquiry Data for a drive.
+  #  Include/Protocol/DiskInfo.h
+  gEfiDiskInfoProtocolGuid       = { 0xD432A67F, 0x14DC, 0x484B, { 0xB3, 0xBB, 0x3F, 0x02, 0x91, 0x84, 0x93, 0x27 }}
+
+  ## Include/Protocol/Smbios.h
+  gEfiSmbiosProtocolGuid          = {0x3583ff6, 0xcb36, 0x4940, { 0x94, 0x7e, 0xb9, 0xb3, 0x9f, 0x4a, 0xfa, 0xf7}}
+
+  ## Include/Protocol/S3SaveState.h
+  gEfiS3SaveStateProtocolGuid     = {0xe857caf6, 0xc046, 0x45dc, { 0xbe, 0x3f, 0xee, 0x7, 0x65, 0xfb, 0xa8, 0x87}}
+
+  ## Include/Protocol/S3SmmSaveState.h
+  gEfiS3SmmSaveStateProtocolGuid  = {0x320afe62, 0xe593, 0x49cb, { 0xa9, 0xf1, 0xd4, 0xc2, 0xf4, 0xaf, 0x1, 0x4c}}
+
+  ## Include/Protocol/ReportStatusCodeHandler.h
+  gEfiRscHandlerProtocolGuid      = { 0x86212936, 0xe76, 0x41c8, { 0xa0, 0x3a, 0x2a, 0xf2, 0xfc, 0x1c, 0x39, 0xe2 }}
+
+  ## Include/Protocol/SmmReportStatusCodeHandler.h
+  gEfiSmmRscHandlerProtocolGuid   = { 0x2ff29fa7, 0x5e80, 0x4ed9, { 0xb3, 0x80, 0x1, 0x7d, 0x3c, 0x55, 0x4f, 0xf4 }}
+
+  ## Include/Protocol/AcpiSystemDescriptionTable.h
+  gEfiAcpiSdtProtocolGuid         = { 0xeb97088e, 0xcfdf, 0x49c6, { 0xbe, 0x4b, 0xd9, 0x6, 0xa5, 0xb2, 0xe, 0x86 }}
+
+  ## Include/Protocol/SuperIo.h
+  gEfiSioProtocolGuid             = { 0x215fdd18, 0xbd50, 0x4feb, { 0x89, 0xb, 0x58, 0xca, 0xb, 0x47, 0x39, 0xe9 }}
+
+  ## Include/Protocol/SmmCpuIo2.h
+  gEfiSmmCpuIo2ProtocolGuid        = { 0x3242a9d8, 0xce70, 0x4aa0, { 0x95, 0x5d, 0x5e, 0x7b, 0x14, 0x0d, 0xe4, 0xd2 }}
+
+  ## Include/Protocol/SmmBase2.h
+  gEfiSmmBase2ProtocolGuid        = { 0xf4ccbfb7, 0xf6e0, 0x47fd, { 0x9d, 0xd4, 0x10, 0xa8, 0xf1, 0x50, 0xc1, 0x91 }}
+
+  ## Include/Protocol/SmmAccess2.h
+  gEfiSmmAccess2ProtocolGuid      = { 0xc2702b74, 0x800c, 0x4131, { 0x87, 0x46, 0x8f, 0xb5, 0xb8, 0x9c, 0xe4, 0xac }}
+
+  ## Include/Protocol/SmmControl2.h
+  gEfiSmmControl2ProtocolGuid     = { 0x843dc720, 0xab1e, 0x42cb, { 0x93, 0x57, 0x8a, 0x0, 0x78, 0xf3, 0x56, 0x1b}}
+
+  ## Include/Protocol/SmmConfiguration.h
+  gEfiSmmConfigurationProtocolGuid= { 0x26eeb3de, 0xb689, 0x492e, { 0x80, 0xf0, 0xbe, 0x8b, 0xd7, 0xda, 0x4b, 0xa7 }}
+
+  ## Include/Protocol/SmmReadyToLock.h
+  gEfiSmmReadyToLockProtocolGuid  = { 0x47b7fa8c, 0xf4bd, 0x4af6, { 0x82, 0x00, 0x33, 0x30, 0x86, 0xf0, 0xd2, 0xc8 }}
+
+  ## Include/Protocol/DxeSmmReadyToLock.h
+  gEfiDxeSmmReadyToLockProtocolGuid = { 0x60ff8964, 0xe906, 0x41d0, { 0xaf, 0xed, 0xf2, 0x41, 0xe9, 0x74, 0xe0, 0x8e }}
+
+  ## Include/Protocol/SmmCommunication.h
+  gEfiSmmCommunicationProtocolGuid  = { 0xc68ed8e2, 0x9dc6, 0x4cbd, { 0x9d, 0x94, 0xdb, 0x65, 0xac, 0xc5, 0xc3, 0x32 }}
+
+  ## Include/Protocol/SmmStatusCode.h
+  gEfiSmmStatusCodeProtocolGuid   = { 0x6afd2b77, 0x98c1, 0x4acd, { 0xa6, 0xf9, 0x8a, 0x94, 0x39, 0xde, 0xf, 0xb1}}
+
+  ## Include/Protocol/SmmCpu.h
+  gEfiSmmCpuProtocolGuid          = { 0xeb346b97, 0x975f, 0x4a9f, { 0x8b, 0x22, 0xf8, 0xe9, 0x2b, 0xb3, 0xd5, 0x69 }}
+
+  ## Include/Protocol/SmmPciRootBridgeIo.h
+  gEfiSmmPciRootBridgeIoProtocolGuid = { 0x8bc1714d, 0xffcb, 0x41c3, { 0x89, 0xdc, 0x6c, 0x74, 0xd0, 0x6d, 0x98, 0xea }}
+
+  ## Include/Protocol/SmmSwDispatch2.h
+  gEfiSmmSwDispatch2ProtocolGuid  = { 0x18a3c6dc, 0x5eea, 0x48c8, {0xa1, 0xc1, 0xb5, 0x33, 0x89, 0xf9, 0x89, 0x99 }}
+
+  ## Include/Protocol/SmmSxDispatch2.h
+  gEfiSmmSxDispatch2ProtocolGuid  = { 0x456d2859, 0xa84b, 0x4e47, {0xa2, 0xee, 0x32, 0x76, 0xd8, 0x86, 0x99, 0x7d }}
+
+  ## Include/Protocol/SmmPeriodicTimerDispatch2.h
+  gEfiSmmPeriodicTimerDispatch2ProtocolGuid = { 0x4cec368e, 0x8e8e, 0x4d71, {0x8b, 0xe1, 0x95, 0x8c, 0x45, 0xfc, 0x8a, 0x53 }}
+
+  ## Include/Protocol/SmmUsbDispatch2.h
+  gEfiSmmUsbDispatch2ProtocolGuid = { 0xee9b8d90, 0xc5a6, 0x40a2, {0xbd, 0xe2, 0x52, 0x55, 0x8d, 0x33, 0xcc, 0xa1 }}
+
+  ## Include/Protocol/SmmGpiDispatch2.h
+  gEfiSmmGpiDispatch2ProtocolGuid = { 0x25566b03, 0xb577, 0x4cbf, {0x95, 0x8c, 0xed, 0x66, 0x3e, 0xa2, 0x43, 0x80 }}
+
+  ## Include/Protocol/SmmStandbyButtonDispatch2.h
+  gEfiSmmStandbyButtonDispatch2ProtocolGuid = { 0x7300c4a1, 0x43f2, 0x4017, {0xa5, 0x1b, 0xc8, 0x1a, 0x7f, 0x40, 0x58, 0x5b }}
+
+  ## Include/Protocol/SmmPowerButtonDispatch2.h
+  gEfiSmmPowerButtonDispatch2ProtocolGuid = { 0x1b1183fa, 0x1823, 0x46a7, {0x88, 0x72, 0x9c, 0x57, 0x87, 0x55, 0x40, 0x9d }}
+
+  ## Include/Protocol/SmmIoTrapDispatch2.h
+  gEfiSmmIoTrapDispatch2ProtocolGuid = { 0x58dc368d, 0x7bfa, 0x4e77, {0xab, 0xbc, 0xe, 0x29, 0x41, 0x8d, 0xf9, 0x30 }}
+
+  ## Include/Protocol/PiPcd.h
+  gEfiPcdProtocolGuid = { 0x13a3f0f6, 0x264a, 0x3ef0, { 0xf2, 0xe0, 0xde, 0xc5, 0x12, 0x34, 0x2f, 0x34 } }
+
+  ## Include/Protocol/FirmwareVolumeBlock.h
+  gEfiFirmwareVolumeBlock2ProtocolGuid = { 0x8f644fa9, 0xe850, 0x4db1, {0x9c, 0xe2, 0xb, 0x44, 0x69, 0x8e, 0x8d, 0xa4 } }
+
+  ## Include/Protocol/CpuIo2.h
+  gEfiCpuIo2ProtocolGuid = {0xad61f191, 0xae5f, 0x4c0e, {0xb9, 0xfa, 0xe8, 0x69, 0xd2, 0x88, 0xc6, 0x4f } }
+
+  ## Include/Protocol/LegacyRegion2.h
+  gEfiLegacyRegion2ProtocolGuid = {0x70101eaf, 0x85, 0x440c, {0xb3, 0x56, 0x8e, 0xe3, 0x6f, 0xef, 0x24, 0xf0 } }
+
+  ## Include/Protocol/McaInitPmi.h
+  gEfiSalMcaInitPmiProtocolGuid = { 0xb60dc6e8, 0x3b6f, 0x11d5, {0xaf, 0x9, 0x0, 0xa0, 0xc9, 0x44, 0xa0, 0x5b } }
+
+  ## Include/Protocol/ExtendedSalBootService.h
+  gEfiExtendedSalBootServiceProtocolGuid  = { 0xde0ee9a4, 0x3c7a, 0x44f2, {0xb7, 0x8b, 0xe3, 0xcc, 0xd6, 0x9c, 0x3a, 0xf7 } }
+
+  ## Include/Protocol/ExtendedSalServiceClasses.h
+  gEfiExtendedSalBaseIoServicesProtocolGuid = { 0x5aea42b5, 0x31e1, 0x4515, {0xbc, 0x31, 0xb8, 0xd5, 0x25, 0x75, 0x65, 0xa6 } }
+  gEfiExtendedSalStallServicesProtocolGuid = { 0x53a58d06, 0xac27, 0x4d8c, {0xb5, 0xe9, 0xf0, 0x8a, 0x80, 0x65, 0x41, 0x70 } }
+  gEfiExtendedSalRtcServicesProtocolGuid = { 0x7e97a470, 0xefdb, 0x4d02, {0x8f, 0xce, 0x61, 0x90, 0xd2, 0x7b, 0xa2, 0x96 } }
+  gEfiExtendedSalVariableServicesProtocolGuid = { 0x4ecb6c53, 0xc641, 0x4370, {0x8c, 0xb2, 0x3b, 0x0e, 0x49, 0x6e, 0x83, 0x78 } }
+  gEfiExtendedSalMtcServicesProtocolGuid = { 0x899afd18, 0x75e8, 0x408b, {0xa4, 0x1a, 0x6e, 0x2e, 0x7e, 0xcd, 0xf4, 0x54 } }
+  gEfiExtendedSalResetServicesProtocolGuid = { 0x7d019990, 0x8ce1, 0x46f5, {0xa7, 0x76, 0x3c, 0x51, 0x98, 0x67, 0x6a, 0xa0 } }
+  gEfiExtendedSalStatusCodeServicesProtocolGuid = { 0xdbd91d, 0x55e9, 0x420f, {0x96, 0x39, 0x5e, 0x9f, 0x84, 0x37, 0xb4, 0x4f } }
+  gEfiExtendedSalFvBlockServicesProtocolGuid = { 0xa2271df1, 0xbcbb, 0x4f1d, {0x98, 0xa9, 0x06, 0xbc, 0x17, 0x2f, 0x07, 0x1a } }
+  gEfiExtendedSalMpServicesProtocolGuid = { 0x697d81a2, 0xcf18, 0x4dc0, {0x9e, 0x0d, 0x06, 0x11, 0x3b, 0x61, 0x8a, 0x3f } }
+  gEfiExtendedSalPalServicesProtocolGuid = { 0xe1cd9d21, 0x0fc2, 0x438d, {0x97, 0x03, 0x04, 0xe6, 0x6d, 0x96, 0x1e, 0x57 } }
+  gEfiExtendedSalBaseServicesProtocolGuid = { 0xd9e9fa06, 0x0fe0, 0x41c3, {0x96, 0xfb, 0x83, 0x42, 0x5a, 0x33, 0x94, 0xf8 } }
+  gEfiExtendedSalMcaServicesProtocolGuid = { 0x2a591128, 0x6cc7, 0x42b1, {0x8a, 0xf0, 0x58, 0x93, 0x3b, 0x68, 0x2d, 0xbb } }
+  gEfiExtendedSalPciServicesProtocolGuid = { 0xa46b1a31, 0xad66, 0x4905, {0x92, 0xf6, 0x2b, 0x46, 0x59, 0xdc, 0x30, 0x63 } }
+  gEfiExtendedSalCacheServicesProtocolGuid = { 0xedc9494, 0x2743, 0x4ba5, { 0x88, 0x18, 0x0a, 0xef, 0x52, 0x13, 0xf1, 0x88 } }
+  gEfiExtendedSalMcaLogServicesProtocolGuid = { 0xcb3fd86e, 0x38a3, 0x4c03, {0x9a, 0x5c, 0x90, 0xcf, 0xa3, 0xa2, 0xab, 0x7a } }
+
+  #
+  # Protocols defined in PI 1.2.1
+  #
+
+  ## Include/Protocol/Security2.h
+  gEfiSecurity2ArchProtocolGuid   = { 0x94ab2f58, 0x1438, 0x4ef1, {0x91, 0x52, 0x18, 0x94, 0x1a, 0x3a, 0x0e, 0x68 } }
+
+  ## Include/Protocol/SmmEndOfDxe.h
+  gEfiSmmEndOfDxeProtocolGuid = { 0x24e70042, 0xd5c5, 0x4260, { 0x8c, 0x39, 0xa, 0xd3, 0xaa, 0x32, 0xe9, 0x3d }}
+
+  ## Include/Protocol/IsaHc.h
+  gEfiIsaHcProtocolGuid               = { 0xbcdaf080, 0x1bde, 0x4e22, {0xae, 0x6a, 0x43, 0x54, 0x1e, 0x12, 0x8e, 0xc4 } }
+  gEfiIsaHcServiceBindingProtocolGuid = { 0xfad7933a, 0x6c21, 0x4234, {0xa4, 0x34, 0x0a, 0x8a, 0x0d, 0x2b, 0x07, 0x81 } }
+
+  ## Include/Protocol/SuperIoControl.h
+  gEfiSioControlProtocolGuid          = { 0xb91978df, 0x9fc1, 0x427d, { 0xbb, 0x5, 0x4c, 0x82, 0x84, 0x55, 0xca, 0x27 } }
+
+  ## Include/Protocol/PiPcdInfo.h
+  gEfiGetPcdInfoProtocolGuid      = { 0xfd0f4478,  0xefd, 0x461d, { 0xba, 0x2d, 0xe5, 0x8c, 0x45, 0xfd, 0x5f, 0x5e } }
+
+  #
+  # Protocols defined in PI 1.3.
+  #
+
+  ## Include/Protocol/I2cMaster.h
+  gEfiI2cMasterProtocolGuid = { 0xcd72881f, 0x45b5, 0x4feb, { 0x98, 0xc8, 0x31, 0x3d, 0xa8, 0x11, 0x74, 0x62 }}
+
+  ## Include/Protocol/I2cIo.h
+  gEfiI2cIoProtocolGuid = { 0xb60a3e6b, 0x18c4, 0x46e5, { 0xa2, 0x9a, 0xc9, 0xa1, 0x06, 0x65, 0xa2, 0x8e }}
+
+  ## Include/Protocol/I2cEnumerate.h
+  gEfiI2cEnumerateProtocolGuid = { 0xda8cd7c4, 0x1c00, 0x49e2, { 0x80, 0x3e, 0x52, 0x14, 0xe7, 0x01, 0x89, 0x4c }}
+
+  ## Include/Protocol/I2cHost.h
+  gEfiI2cHostProtocolGuid = { 0xa5aab9e3, 0xc727, 0x48cd, { 0x8b, 0xbf, 0x42, 0x72, 0x33, 0x85, 0x49, 0x48 }}
+
+  ## Include/Protocol/I2cBusConfigurationManagement.h
+  gEfiI2cBusConfigurationManagementProtocolGuid = { 0x55b71fb5, 0x17c6, 0x410e, { 0xb5, 0xbd, 0x5f, 0xa2, 0xe3, 0xd4, 0x46, 0x6b }}
+
+  #
+  # Protocols defined in UEFI2.1/UEFI2.0/EFI1.1
+  #
+
+  ## Include/Protocol/DebugPort.h
+  gEfiDebugPortProtocolGuid      = { 0xEBA4E8D2, 0x3858, 0x41EC, { 0xA2, 0x81, 0x26, 0x47, 0xBA, 0x96, 0x60, 0xD0 }}
+
+  ## Include/Protocol/DebugSupport.h
+  gEfiDebugSupportProtocolGuid   = { 0x2755590C, 0x6F3C, 0x42FA, { 0x9E, 0xA4, 0xA3, 0xBA, 0x54, 0x3C, 0xDA, 0x25 }}
+
+  ## Include/Protocol/Decompress.h
+  gEfiDecompressProtocolGuid     = { 0xD8117CFE, 0x94A6, 0x11D4, { 0x9A, 0x3A, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/DeviceIo.h
+  gEfiDeviceIoProtocolGuid       = { 0xAF6AC311, 0x84C3, 0x11D2, { 0x8E, 0x3C, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/DevicePath.h
+  gEfiDevicePathProtocolGuid     = { 0x09576E91, 0x6D3F, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/DevicePathFromText.h
+  gEfiDevicePathFromTextProtocolGuid = { 0x05C99A21, 0xC70F, 0x4AD2, { 0x8A, 0x5F, 0x35, 0xDF, 0x33, 0x43, 0xF5, 0x1E }}
+
+  ## Include/Protocol/DevicePathToText.h
+  gEfiDevicePathToTextProtocolGuid = { 0x8B843E20, 0x8132, 0x4852, { 0x90, 0xCC, 0x55, 0x1A, 0x4E, 0x4A, 0x7F, 0x1C }}
+
+  ## Include/Protocol/DevicePathUtilities.h
+  gEfiDevicePathUtilitiesProtocolGuid = { 0x0379BE4E, 0xD706, 0x437D, { 0xB0, 0x37, 0xED, 0xB8, 0x2F, 0xB7, 0x72, 0xA4 }}
+
+  ## Include/Protocol/DriverBinding.h
+  gEfiDriverBindingProtocolGuid  = { 0x18A031AB, 0xB443, 0x4D1A, { 0xA5, 0xC0, 0x0C, 0x09, 0x26, 0x1E, 0x9F, 0x71 }}
+
+  ## Include/Protocol/PlatformDriverOverride.h
+  gEfiPlatformDriverOverrideProtocolGuid = { 0x6b30c738, 0xa391, 0x11d4, {0x9a, 0x3b, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d } }
+
+  ## Include/Protocol/DriverFamilyOverride.h
+  gEfiDriverFamilyOverrideProtocolGuid = { 0xb1ee129e, 0xda36, 0x4181, { 0x91, 0xf8, 0x4, 0xa4, 0x92, 0x37, 0x66, 0xa7 }}
+
+  ## Include/Protocol/BusSpecificDriverOverride.h
+  gEfiBusSpecificDriverOverrideProtocolGuid = { 0x3BC1B285, 0x8A15, 0x4A82, { 0xAA, 0xBF, 0x4D, 0x7D, 0x13, 0xFB, 0x32, 0x65 }}
+
+  ## Include/Protocol/DriverDiagnostics2.h
+  gEfiDriverDiagnostics2ProtocolGuid = { 0x4D330321, 0x025F, 0x4AAC, { 0x90, 0xD8, 0x5E, 0xD9, 0x00, 0x17, 0x3B, 0x63 }}
+
+  ## Include/Protocol/DriverDiagnostics.h
+  gEfiDriverDiagnosticsProtocolGuid = { 0x0784924F, 0xE296, 0x11D4, { 0x9A, 0x49, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/ComponentName2.h
+  gEfiComponentName2ProtocolGuid = { 0x6A7A5CFF, 0xE8D9, 0x4F70, { 0xBA, 0xDA, 0x75, 0xAB, 0x30, 0x25, 0xCE, 0x14 }}
+
+  ## Include/Protocol/ComponentName.h
+  gEfiComponentNameProtocolGuid  = { 0x107A772C, 0xD5E1, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/DriverConfiguration2.h
+  gEfiDriverConfiguration2ProtocolGuid = { 0xBFD7DC1D, 0x24F1, 0x40D9, { 0x82, 0xE7, 0x2E, 0x09, 0xBB, 0x6B, 0x4E, 0xBE }}
+
+  ## Include/Protocol/DriverConfiguration.h
+  gEfiDriverConfigurationProtocolGuid = { 0x107A772B, 0xD5E1, 0x11D4, { 0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/PlatformToDriverConfiguration.h
+  gEfiPlatformToDriverConfigurationProtocolGuid = { 0x642cd590, 0x8059, 0x4c0a, { 0xa9, 0x58, 0xc5, 0xec, 0x7, 0xd2, 0x3c, 0x4b } }
+
+  ## Include/Protocol/DriverSupportedEfiVersion.h
+  gEfiDriverSupportedEfiVersionProtocolGuid = { 0x5c198761, 0x16a8, 0x4e69, { 0x97, 0x2c, 0x89, 0xd6, 0x79, 0x54, 0xf8, 0x1d } }
+
+  ## Include/Protocol/SimpleTextIn.h
+  gEfiSimpleTextInProtocolGuid   = { 0x387477C1, 0x69C7, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/SimpleTextInEx.h
+  gEfiSimpleTextInputExProtocolGuid = {0xdd9e7534, 0x7762, 0x4698, { 0x8c, 0x14, 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa } }
+
+  ## Include/Protocol/SimpleTextOut.h
+  gEfiSimpleTextOutProtocolGuid  = { 0x387477C2, 0x69C7, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/SimplePointer.h
+  gEfiSimplePointerProtocolGuid  = { 0x31878C87, 0x0B75, 0x11D5, { 0x9A, 0x4F, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/AbsolutePointer.h
+  gEfiAbsolutePointerProtocolGuid = { 0x8D59D32B, 0xC655, 0x4AE9, { 0x9B, 0x15, 0xF2, 0x59, 0x04, 0x99, 0x2A, 0x43 } }
+
+  ## Include/Protocol/SerialIo.h
+  gEfiSerialIoProtocolGuid       = { 0xBB25CF6F, 0xF1D4, 0x11D2, { 0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD }}
+
+  ## Include/Protocol/GraphicsOutput.h
+  gEfiGraphicsOutputProtocolGuid = { 0x9042A9DE, 0x23DC, 0x4A38, { 0x96, 0xFB, 0x7A, 0xDE, 0xD0, 0x80, 0x51, 0x6A }}
+
+  ## Include/Protocol/EdidDiscovered.h
+  gEfiEdidDiscoveredProtocolGuid = { 0x1C0C34F6, 0xD380, 0x41FA, { 0xA0, 0x49, 0x8A, 0xD0, 0x6C, 0x1A, 0x66, 0xAA }}
+
+  ## Include/Protocol/EdidActive.h
+  gEfiEdidActiveProtocolGuid     = { 0xBD8C1056, 0x9F36, 0x44EC, { 0x92, 0xA8, 0xA6, 0x33, 0x7F, 0x81, 0x79, 0x86 }}
+
+  ## Include/Protocol/EdidOverride.h
+  gEfiEdidOverrideProtocolGuid   = { 0x48ECB431, 0xFB72, 0x45C0, { 0xA9, 0x22, 0xF4, 0x58, 0xFE, 0x04, 0x0B, 0xD5 }}
+
+  ## Include/Protocol/UgaIo.h
+  gEfiUgaIoProtocolGuid          = { 0x61A4D49E, 0x6F68, 0x4F1B, { 0xB9, 0x22, 0xA8, 0x6E, 0xED, 0x0B, 0x07, 0xA2 }}
+
+  ## Include/Protocol/UgaDraw.h
+  gEfiUgaDrawProtocolGuid        = { 0x982C298B, 0xF4FA, 0x41CB, { 0xB8, 0x38, 0x77, 0xAA, 0x68, 0x8F, 0xB8, 0x39 }}
+
+  ## Include/Protocol/LoadedImage.h
+  gEfiLoadedImageProtocolGuid    = { 0x5B1B31A1, 0x9562, 0x11D2, { 0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/LoadedImage.h
+  gEfiLoadedImageDevicePathProtocolGuid = { 0xbc62157e, 0x3e33, 0x4fec, {0x99, 0x20, 0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf }}
+
+  ## Include/Protocol/LoadFile.h
+  gEfiLoadFileProtocolGuid       = { 0x56EC3091, 0x954C, 0x11D2, { 0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/LoadFile2.h
+  gEfiLoadFile2ProtocolGuid       = { 0x4006c0c1, 0xfcb3, 0x403e, {0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d }}
+
+  ## Include/Protocol/SimpleFileSystem.h
+  gEfiSimpleFileSystemProtocolGuid = { 0x964E5B22, 0x6459, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/TapeIo.h
+  gEfiTapeIoProtocolGuid         = { 0x1E93E633, 0xD65A, 0x459E, { 0xAB, 0x84, 0x93, 0xD9, 0xEC, 0x26, 0x6D, 0x18 }}
+
+  ## Include/Protocol/DiskIo.h
+  gEfiDiskIoProtocolGuid         = { 0xCE345171, 0xBA0B, 0x11D2, { 0x8E, 0x4F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/BlockIo.h
+  gEfiBlockIoProtocolGuid        = { 0x964E5B21, 0x6459, 0x11D2, { 0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/UnicodeCollation.h
+  gEfiUnicodeCollationProtocolGuid = { 0x1D85CD7F, 0xF43D, 0x11D2, { 0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/UnicodeCollation.h
+  gEfiUnicodeCollation2ProtocolGuid = {0xa4c751fc, 0x23ae, 0x4c3e, { 0x92, 0xe9, 0x49, 0x64, 0xcf, 0x63, 0xf3, 0x49 }}
+
+  ## Include/Protocol/PciRootBridgeIo.h
+  gEfiPciRootBridgeIoProtocolGuid = { 0x2F707EBB, 0x4A1A, 0x11D4, { 0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/PciIo.h
+  gEfiPciIoProtocolGuid          = { 0x4CF5B200, 0x68B8, 0x4CA5, { 0x9E, 0xEC, 0xB2, 0x3E, 0x3F, 0x50, 0x02, 0x9A }}
+
+  ## Include/Protocol/ScsiIo.h
+  gEfiScsiIoProtocolGuid         = { 0x932F47e6, 0x2362, 0x4002, { 0x80, 0x3E, 0x3C, 0xD5, 0x4B, 0x13, 0x8F, 0x85 }}
+
+  ## Include/Protocol/ScsiPassThruExt.h
+  gEfiExtScsiPassThruProtocolGuid = { 0x143b7632, 0xb81b, 0x4cb7, {0xab, 0xd3, 0xb6, 0x25, 0xa5, 0xb9, 0xbf, 0xfe }}
+
+  ## Include/Protocol/ScsiPassThru.h
+  gEfiScsiPassThruProtocolGuid   = { 0xA59E8FCF, 0xBDA0, 0x43BB, { 0x90, 0xB1, 0xD3, 0x73, 0x2E, 0xCA, 0xA8, 0x77 }}
+
+  ## Include/Protocol/IScsiInitiatorName.h
+  gEfiIScsiInitiatorNameProtocolGuid = { 0x59324945, 0xEC44, 0x4C0D, { 0xB1, 0xCD, 0x9D, 0xB1, 0x39, 0xDF, 0x07, 0x0C }}
+
+  ## Include/Protocol/Usb2HostController.h
+  gEfiUsb2HcProtocolGuid         = { 0x3E745226, 0x9818, 0x45B6, { 0xA2, 0xAC, 0xD7, 0xCD, 0x0E, 0x8B, 0xA2, 0xBC }}
+
+  ## Include/Protocol/UsbHostController.h
+  gEfiUsbHcProtocolGuid          = { 0xF5089266, 0x1AA0, 0x4953, { 0x97, 0xD8, 0x56, 0x2F, 0x8A, 0x73, 0xB5, 0x19 }}
+
+  ## Include/Protocol/UsbIo.h
+  gEfiUsbIoProtocolGuid          = { 0x2B2F68D6, 0x0CD2, 0x44CF, { 0x8E, 0x8B, 0xBB, 0xA2, 0x0B, 0x1B, 0x5B, 0x75 }}
+
+  ## Include/Protocol/AcpiTable.h
+  gEfiAcpiTableProtocolGuid      = { 0xFFE06BDD, 0x6107, 0x46A6, { 0x7B, 0xB2, 0x5A, 0x9C, 0x7E, 0xC5, 0x27, 0x5C }}
+
+  ## Include/Protocol/Ebc.h
+  gEfiEbcProtocolGuid            = { 0x13AC6DD1, 0x73D0, 0x11D4, { 0xB0, 0x6B, 0x00, 0xAA, 0x00, 0xBD, 0x6D, 0xE7 }}
+
+  ## Include/Protocol/SimpleNetwork.h
+  gEfiSimpleNetworkProtocolGuid  = { 0xA19832B9, 0xAC25, 0x11D3, { 0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/NetworkInterfaceIdentifier.h
+  gEfiNetworkInterfaceIdentifierProtocolGuid_31 = { 0x1ACED566, 0x76ED, 0x4218, { 0xBC, 0x81, 0x76, 0x7F, 0x1F, 0x97, 0x7A, 0x89 }}
+
+  ## Include/Protocol/NetworkInterfaceIdentifier.h
+  gEfiNetworkInterfaceIdentifierProtocolGuid = { 0xE18541CD, 0xF755, 0x4F73, { 0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29 }}
+
+  ## Include/Protocol/PxeBaseCodeCallBack.h
+  gEfiPxeBaseCodeCallbackProtocolGuid = { 0x245DCA21, 0xFB7B, 0x11D3, { 0x8F, 0x01, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B }}
+
+  ## Include/Protocol/PxeBaseCode.h
+  gEfiPxeBaseCodeProtocolGuid    = { 0x03C4E603, 0xAC28, 0x11D3, { 0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D }}
+
+  ## Include/Protocol/Bis.h
+  gEfiBisProtocolGuid            = { 0x0B64AAB0, 0x5429, 0x11D4, { 0x98, 0x16, 0x00, 0xA0, 0xC9, 0x1F, 0xAD, 0xCF }}
+
+  ## Include/Protocol/ManagedNetwork.h
+  gEfiManagedNetworkServiceBindingProtocolGuid = { 0xF36FF770, 0xA7E1, 0x42CF, { 0x9E, 0xD2, 0x56, 0xF0, 0xF2, 0x71, 0xF4, 0x4C }}
+
+  ## Include/Protocol/ManagedNetwork.h
+  gEfiManagedNetworkProtocolGuid = { 0x7ab33a91, 0xace5, 0x4326, { 0xb5, 0x72, 0xe7, 0xee, 0x33, 0xd3, 0x9f, 0x16 }}
+
+  ## Include/Protocol/Arp.h
+  gEfiArpServiceBindingProtocolGuid = { 0xF44C00EE, 0x1F2C, 0x4A00, { 0xAA, 0x09, 0x1C, 0x9F, 0x3E, 0x08, 0x00, 0xA3 }}
+
+  ## Include/Protocol/Arp.h
+  gEfiArpProtocolGuid            = { 0xF4B427BB, 0xBA21, 0x4F16, { 0xBC, 0x4E, 0x43, 0xE4, 0x16, 0xAB, 0x61, 0x9C }}
+
+  ## Include/Protocol/Dhcp4.h
+  gEfiDhcp4ServiceBindingProtocolGuid = { 0x9D9A39D8, 0xBD42, 0x4A73, { 0xA4, 0xD5, 0x8E, 0xE9, 0x4B, 0xE1, 0x13, 0x80 }}
+
+  ## Include/Protocol/Dhcp4.h
+  gEfiDhcp4ProtocolGuid          = { 0x8A219718, 0x4EF5, 0x4761, { 0x91, 0xC8, 0xC0, 0xF0, 0x4B, 0xDA, 0x9E, 0x56 }}
+
+  ## Include/Protocol/Tcp4.h
+  gEfiTcp4ServiceBindingProtocolGuid = { 0x00720665, 0x67EB, 0x4A99, { 0xBA, 0xF7, 0xD3, 0xC3, 0x3A, 0x1C, 0x7C, 0xC9 }}
+
+  ## Include/Protocol/Tcp4.h
+  gEfiTcp4ProtocolGuid           = { 0x65530BC7, 0xA359, 0x410F, { 0xB0, 0x10, 0x5A, 0xAD, 0xC7, 0xEC, 0x2B, 0x62 }}
+
+  ## Include/Protocol/Ip4.h
+  gEfiIp4ServiceBindingProtocolGuid = { 0xC51711E7, 0xB4BF, 0x404A, { 0xBF, 0xB8, 0x0A, 0x04, 0x8E, 0xF1, 0xFF, 0xE4 }}
+
+  ## Include/Protocol/Ip4.h
+  gEfiIp4ProtocolGuid            = { 0x41D94CD2, 0x35B6, 0x455A, { 0x82, 0x58, 0xD4, 0xE5, 0x13, 0x34, 0xAA, 0xDD }}
+
+  ## Include/Protocol/Ip4Config.h
+  gEfiIp4ConfigProtocolGuid      = { 0x3B95AA31, 0x3793, 0x434B, { 0x86, 0x67, 0xC8, 0x07, 0x08, 0x92, 0xE0, 0x5E }}
+
+  ## Include/Protocol/Udp4.h
+  gEfiUdp4ServiceBindingProtocolGuid = { 0x83F01464, 0x99BD, 0x45E5, { 0xB3, 0x83, 0xAF, 0x63, 0x05, 0xD8, 0xE9, 0xE6 }}
+
+  ## Include/Protocol/Udp4.h
+  gEfiUdp4ProtocolGuid           = { 0x3AD9DF29, 0x4501, 0x478D, { 0xB1, 0xF8, 0x7F, 0x7F, 0xE7, 0x0E, 0x50, 0xF3 }}
+
+  ## Include/Protocol/Mtftp4.h
+  gEfiMtftp4ServiceBindingProtocolGuid = { 0x2FE800BE, 0x8F01, 0x4AA6, { 0x94, 0x6B, 0xD7, 0x13, 0x88, 0xE1, 0x83, 0x3F }}
+
+  ## Include/Protocol/Mtftp4.h
+  gEfiMtftp4ProtocolGuid         = { 0x78247C57, 0x63DB, 0x4708, { 0x99, 0xC2, 0xA8, 0xB4, 0xA9, 0xA6, 0x1F, 0x6B }}
+
+  ## Include/Protocol/AuthenticationInfo.h
+  gEfiAuthenticationInfoProtocolGuid = { 0x7671D9D0, 0x53DB, 0x4173, { 0xAA, 0x69, 0x23, 0x27, 0xF2, 0x1F, 0x0B, 0xC7 }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashServiceBindingProtocolGuid = { 0x42881c98, 0xa4f3, 0x44b0, { 0xa3, 0x9d, 0xdf, 0xa1, 0x86, 0x67, 0xd8, 0xcd }}
+
+  ## Include/Protocol/Hash.h
+  gEfiHashProtocolGuid           = { 0xC5184932, 0xDBA5, 0x46DB, { 0xA5, 0xBA, 0xCC, 0x0B, 0xDA, 0x9C, 0x14, 0x35 }}
+
+  ## Include/Protocol/TcgService.h
+  gEfiTcgProtocolGuid            = { 0xf541796d, 0xa62e, 0x4954, { 0xa7, 0x75, 0x95, 0x84, 0xf6, 0x1b, 0x9c, 0xdd }}
+
+  ## Include/Protocol/TrEEProtocol.h
+  gEfiTrEEProtocolGuid           = {0x607f766c, 0x7455, 0x42be, { 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f }}
+
+  ## Include/Protocol/Tcg2Protocol.h
+  gEfiTcg2ProtocolGuid           = {0x607f766c, 0x7455, 0x42be, { 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f }}
+  gEfiTcg2FinalEventsTableGuid   = {0x1e2ed096, 0x30e2, 0x4254, { 0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25 }}
+
+  ## Include/Protocol/FormBrowser2.h
+  gEfiFormBrowser2ProtocolGuid   =   {0xb9d4c360, 0xbcfb, 0x4f9b, {0x92, 0x98, 0x53, 0xc1, 0x36, 0x98, 0x22, 0x58}}
+
+  ## Include/Protocol/HiiString.h
+  gEfiHiiStringProtocolGuid      =   {0x0fd96974, 0x23aa, 0x4cdc, {0xb9, 0xcb, 0x98, 0xd1, 0x77, 0x50, 0x32, 0x2a}}
+
+  ## Include/Protocol/HiiImage.h
+  gEfiHiiImageProtocolGuid       =   {0x31a6406a, 0x6bdf, 0x4e46, {0xb2, 0xa2, 0xeb, 0xaa, 0x89, 0xc4, 0x09, 0x20}}
+
+  ## Include/Protocol/HiiConfigRouting.h
+  gEfiHiiConfigRoutingProtocolGuid = {0x587e72d7, 0xcc50, 0x4f79, {0x82, 0x09, 0xca, 0x29, 0x1f, 0xc1, 0xa1, 0x0f}}
+
+  ## Include/Protocol/HiiDatabase.h
+  gEfiHiiDatabaseProtocolGuid    =   {0xef9fc172, 0xa1b2, 0x4693, {0xb3, 0x27, 0x6d, 0x32, 0xfc, 0x41, 0x60, 0x42}}
+
+  ## Include/Protocol/HiiFont.h
+  gEfiHiiFontProtocolGuid        =   {0xe9ca4775, 0x8657, 0x47fc, {0x97, 0xe7, 0x7e, 0xd6, 0x5a, 0x08, 0x43, 0x24}}
+
+  ## Include/Protocol/HiiConfigAccess.h
+  gEfiHiiConfigAccessProtocolGuid =  {0x330d4706, 0xf2a0, 0x4e4f, {0xa3, 0x69, 0xb6, 0x6f, 0xa8, 0xd5, 0x43, 0x85}}
+
+  ## Include/Protocol/HiiPackageList.h
+  gEfiHiiPackageListProtocolGuid  = { 0x6a1ee763, 0xd47a, 0x43b4, {0xaa, 0xbe, 0xef, 0x1d, 0xe2, 0xab, 0x56, 0xfc}}
+
+  #
+  # Protocols defined in UEFI2.2
+  #
+  ## Include/Protocol/Ip6.h
+  gEfiIp6ServiceBindingProtocolGuid    = { 0xec835dd3, 0xfe0f, 0x617b, {0xa6, 0x21, 0xb3, 0x50, 0xc3, 0xe1, 0x33, 0x88 }}
+
+  ## Include/Protocol/Ip6.h
+  gEfiIp6ProtocolGuid                  = { 0x2c8759d5, 0x5c2d, 0x66ef, {0x92, 0x5f, 0xb6, 0x6c, 0x10, 0x19, 0x57, 0xe2 }}
+
+  ## Include/Protocol/Ip6Config.h
+  gEfiIp6ConfigProtocolGuid            = { 0x937fe521, 0x95ae, 0x4d1a, {0x89, 0x29, 0x48, 0xbc, 0xd9, 0x0a, 0xd3, 0x1a }}
+
+  ## Include/Protocol/Mtftp6.h
+  gEfiMtftp6ServiceBindingProtocolGuid = { 0xd9760ff3, 0x3cca, 0x4267, {0x80, 0xf9, 0x75, 0x27, 0xfa, 0xfa, 0x42, 0x23 }}
+
+  ## Include/Protocol/Mtftp6.h
+  gEfiMtftp6ProtocolGuid               = { 0xbf0a78ba, 0xec29, 0x49cf, {0xa1, 0xc9, 0x7a, 0xe5, 0x4e, 0xab, 0x6a, 0x51 }}
+
+  ## Include/Protocol/Dhcp6.h
+  gEfiDhcp6ServiceBindingProtocolGuid  = { 0x9fb9a8a1, 0x2f4a, 0x43a6, {0x88, 0x9c, 0xd0, 0xf7, 0xb6, 0xc4, 0x7a, 0xd5 }}
+
+  ## Include/Protocol/Dhcp6.h
+  gEfiDhcp6ProtocolGuid                = { 0x87c8bad7, 0x595, 0x4053, {0x82, 0x97, 0xde, 0xde, 0x39, 0x5f, 0x5d, 0x5b }}
+
+  ## Include/Protocol/Udp6.h
+  gEfiUdp6ServiceBindingProtocolGuid   = { 0x66ed4721, 0x3c98, 0x4d3e, {0x81, 0xe3, 0xd0, 0x3d, 0xd3, 0x9a, 0x72, 0x54 }}
+
+  ## Include/Protocol/Udp6.h
+  gEfiUdp6ProtocolGuid                 = { 0x4f948815, 0xb4b9, 0x43cb, {0x8a, 0x33, 0x90, 0xe0, 0x60, 0xb3, 0x49, 0x55 }}
+
+  ## Include/Protocol/Tcp6.h
+  gEfiTcp6ServiceBindingProtocolGuid   = { 0xec20eb79, 0x6c1a, 0x4664, {0x9a, 0x0d, 0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64 }}
+
+  ## Include/Protocol/Tcp6.h
+  gEfiTcp6ProtocolGuid                 = { 0x46e44855, 0xbd60, 0x4ab7, {0xab, 0x0d, 0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77 }}
+
+  ## Include/Protocol/VlanConfig.h
+  gEfiVlanConfigProtocolGuid           = { 0x9e23d768, 0xd2f3, 0x4366, {0x9f, 0xc3, 0x3a, 0x7a, 0xba, 0x86, 0x43, 0x74 }}
+
+  ## Include/Protocol/Eap.h
+  gEfiEapProtocolGuid                  = { 0x5d9f96db, 0xe731, 0x4caa, {0xa0, 0xd, 0x72, 0xe1, 0x87, 0xcd, 0x77, 0x62 }}
+
+  ## Include/Protocol/EapManagement.h
+  gEfiEapManagementProtocolGuid        = { 0xbb62e663, 0x625d, 0x40b2, {0xa0, 0x88, 0xbb, 0xe8, 0x36, 0x23, 0xa2, 0x45 }}
+
+  ## Include/Protocol/Ftp4.h
+  gEfiFtp4ServiceBindingProtocolGuid   = { 0xfaaecb1, 0x226e, 0x4782, {0xaa, 0xce, 0x7d, 0xb9, 0xbc, 0xbf, 0x4d, 0xaf }}
+
+  ## Include/Protocol/Ftp4.h
+  gEfiFtp4ProtocolGuid                 = { 0xeb338826, 0x681b, 0x4295, {0xb3, 0x56, 0x2b, 0x36, 0x4c, 0x75, 0x7b, 0x9 }}
+
+  ## Include/Protocol/IpSecConfig.h
+  gEfiIpSecConfigProtocolGuid          = { 0xce5e5929, 0xc7a3, 0x4602, {0xad, 0x9e, 0xc9, 0xda, 0xf9, 0x4e, 0xbf, 0xcf }}
+
+  ## Include/Protocol/DriverHealth.h
+  gEfiDriverHealthProtocolGuid         = { 0x2a534210, 0x9280, 0x41d8, {0xae, 0x79, 0xca, 0xda, 0x1, 0xa2, 0xb1, 0x27 }}
+
+  ## Include/Protocol/DeferredImageLoad.h
+  gEfiDeferredImageLoadProtocolGuid    = { 0x15853d7c, 0x3ddf, 0x43e0, {0xa1, 0xcb, 0xeb, 0xf8, 0x5b, 0x8f, 0x87, 0x2c }}
+
+  ## Include/Protocol/UserCredential.h
+  gEfiUserCredentialProtocolGuid       = { 0x71ee5e94, 0x65b9, 0x45d5, {0x82, 0x1a, 0x3a, 0x4d, 0x86, 0xcf, 0xe6, 0xbe }}
+
+  ## Include/Protocol/UserManager.h
+  gEfiUserManagerProtocolGuid          = { 0x6fd5b00c, 0xd426, 0x4283, {0x98, 0x87, 0x6c, 0xf5, 0xcf, 0x1c, 0xb1, 0xfe }}
+
+  ## Include/Protocol/AtaPassThru.h
+  gEfiAtaPassThruProtocolGuid          = { 0x1d3de7f0, 0x807, 0x424f, {0xaa, 0x69, 0x11, 0xa5, 0x4e, 0x19, 0xa4, 0x6f }}
+
+  #
+  # Protocols defined in UEFI2.3
+  #
+  ## Include/Protocol/FirmwareManagement.h
+  gEfiFirmwareManagementProtocolGuid   = { 0x86c77a67, 0xb97, 0x4633, {0xa1, 0x87, 0x49, 0x10, 0x4d, 0x6, 0x85, 0xc7 }}
+
+  ## Include/Protocol/IpSec.h
+  gEfiIpSecProtocolGuid                = { 0xdfb386f7, 0xe100, 0x43ad, {0x9c, 0x9a, 0xed, 0x90, 0xd0, 0x8a, 0x5e, 0x12 }}
+
+  ## Include/Protocol/IpSec.h
+  gEfiIpSec2ProtocolGuid               = { 0xa3979e64, 0xace8, 0x4ddc, {0xbc, 0x7, 0x4d, 0x66, 0xb8, 0xfd, 0x9, 0x77 }}
+
+  #
+  # Protocols defined in UEFI2.3.1
+  #
+  ## Include/Protocol/Kms.h
+  gEfiKmsProtocolGuid                  = { 0xEC3A978D, 0x7C4E, 0x48FA, {0x9A, 0xBE, 0x6A, 0xD9, 0x1C, 0xC8, 0xF8, 0x11 }}
+
+  ## Include/Protocol/BlockIo2.h
+  gEfiBlockIo2ProtocolGuid             = { 0xa77b2472, 0xe282, 0x4e9f, {0xa2, 0x45, 0xc2, 0xc0, 0xe2, 0x7b, 0xbc, 0xc1 }}
+
+  ## Include/Protocol/StorageSecurityCommand.h
+  gEfiStorageSecurityCommandProtocolGuid = { 0xc88b0b6d, 0x0dfc, 0x49a7, {0x9c, 0xb4, 0x49, 0x7, 0x4b, 0x4c, 0x3a, 0x78 }}
+
+  ## Include/Protocol/UserCredential2.h
+  gEfiUserCredential2ProtocolGuid      = { 0xe98adb03, 0xb8b9, 0x4af8, {0xba, 0x20, 0x26, 0xe9, 0x11, 0x4c, 0xbc, 0xe5 }}
+
+  #
+  # Protocols defined in UEFI2.4
+  #
+  ## Include/Protocol/DiskIo2.h
+  gEfiDiskIo2ProtocolGuid              = { 0x151c8eae, 0x7f2c, 0x472c, { 0x9e, 0x54, 0x98, 0x28, 0x19, 0x4f, 0x6a, 0x88 }}
+
+  ## Include/Protocol/Timestamp.h
+  gEfiTimestampProtocolGuid            = { 0xafbfde41, 0x2e6e, 0x4262, {0xba, 0x65, 0x62, 0xb9, 0x23, 0x6e, 0x54, 0x95 }}
+
+  ## Include/Protocol/Rng.h
+  gEfiRngProtocolGuid                  = { 0x3152bca5, 0xeade, 0x433d, {0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44 }}
+
+  ## Include/Protocol/AdapterInformation.h
+  gEfiAdapterInformationProtocolGuid   = { 0xE5DD1403, 0xD622, 0xC24E, {0x84, 0x88, 0xC7, 0x1B, 0x17, 0xF5, 0xE8, 0x02 }}
+
+  #
+  # Protocols defined in UEFI2.5
+  #
+  ## Include/Protocol/NvmExpressPassthru.h
+  gEfiNvmExpressPassThruProtocolGuid   = { 0x52c78312, 0x8edc, 0x4233, { 0x98, 0xf2, 0x1a, 0x1a, 0xa5, 0xe3, 0x88, 0xa5 }}
+
+  ## Include/Protocol/Hash2.h
+  gEfiHash2ServiceBindingProtocolGuid  = { 0xda836f8d, 0x217f, 0x4ca0, { 0x99, 0xc2, 0x1c, 0xa4, 0xe1, 0x60, 0x77, 0xea }}
+
+  ## Include/Protocol/Hash2.h
+  gEfiHash2ProtocolGuid                = { 0x55b1d734, 0xc5e1, 0x49db, { 0x96, 0x47, 0xb1, 0x6a, 0xfb, 0xe, 0x30, 0x5b }}
+
+  ## Include/Protocol/BlockIoCrypto.h
+  gEfiBlockIoCryptoProtocolGuid        = { 0xa00490ba, 0x3f1a, 0x4b4c, { 0xab, 0x90, 0x4f, 0xa9, 0x97, 0x26, 0xa1, 0xe8 }}
+
+  ## Include/Protocol/SmartCardReader.h
+  gEfiSmartCardReaderProtocolGuid      = { 0x2a4d1adf, 0x21dc, 0x4b81, {0xa4, 0x2f, 0x8b, 0x8e, 0xe2, 0x38, 0x00, 0x60 }}
+
+  ## Include/Protocol/SmartCardEdge.h
+  gEfiSmartCardEdgeProtocolGuid        = { 0xd317f29b, 0xa325, 0x4712, {0x9b, 0xf1, 0xc6, 0x19, 0x54, 0xdc, 0x19, 0x8c }}
+
+  ## Include/Protocol/UsbFunctionIo.h
+  gEfiUsbFunctionIoProtocolGuid        = { 0x32d2963a, 0xfe5d, 0x4f30, {0xb6, 0x33, 0x6e, 0x5d, 0xc5, 0x58, 0x3, 0xcc }}
+
+  ## Include/Protocol/BluetoothHc.h
+  gEfiBluetoothHcProtocolGuid         = { 0xb3930571, 0xbeba, 0x4fc5, { 0x92, 0x3, 0x94, 0x27, 0x24, 0x2e, 0x6a, 0x43 }}
+
+  ## Include/Protocol/BluetoothIo.h
+  gEfiBluetoothIoServiceBindingProtocolGuid   = { 0x388278d3, 0x7b85, 0x42f0, { 0xab, 0xa9, 0xfb, 0x4b, 0xfd, 0x69, 0xf5, 0xab }}
+  gEfiBluetoothIoProtocolGuid                 = { 0x467313de, 0x4e30, 0x43f1, { 0x94, 0x3e, 0x32, 0x3f, 0x89, 0x84, 0x5d, 0xb5 }}
+
+  ## Include/Protocol/BluetoothConfig.h
+  gEfiBluetoothConfigProtocolGuid             = { 0x62960cf3, 0x40ff, 0x4263, { 0xa7, 0x7c, 0xdf, 0xde, 0xbd, 0x19, 0x1b, 0x4b }}
+
+  ## Include/Protocol/RegularExpressionProtocol.h
+  gEfiRegularExpressionProtocolGuid = { 0xB3F79D9A, 0x436C, 0xDC11, {0xB0, 0x52, 0xCD, 0x85, 0xDF, 0x52, 0x4C, 0xE6 }}
+
+  ## Include/Protocol/BootManagerPolicy.h
+  gEfiBootManagerPolicyProtocolGuid    = { 0xfedf8e0c, 0xe147, 0x11e3, { 0x99, 0x03, 0xb8, 0xe8, 0x56, 0x2c, 0xba, 0xfa }}
+
+  ## Include/Protocol/HiiConfigKeyword.h
+  gEfiConfigKeywordHandlerProtocolGuid = {0x0a8badd5, 0x03b8, 0x4d19, {0xb1, 0x28, 0x7b, 0x8f, 0x0e, 0xda, 0xa5, 0x96}}
+
+  ## Include/Protocol/WiFi.h
+  gEfiWiFiProtocolGuid                 = { 0xda55bc9, 0x45f8, 0x4bb4, {0x87, 0x19, 0x52, 0x24, 0xf1, 0x8a, 0x4d, 0x45 }}
+
+  ## Include/Protocol/EapManagement2.h
+  gEfiEapManagement2ProtocolGuid       = { 0x5e93c847, 0x456d, 0x40b3, {0xa6, 0xb4, 0x78, 0xb0, 0xc9, 0xcf, 0x7f, 0x20 }}
+
+  ## Include/Protocol/EapConfiguration.h
+  gEfiEapConfigurationProtocolGuid     = { 0xe5b58dbb, 0x7688, 0x44b4, {0x97, 0xbf, 0x5f, 0x1d, 0x4b, 0x7c, 0xc8, 0xdb }}
+
+  ## Include/Protocol/Pkcs7Verify.h
+  gEfiPkcs7VerifyProtocolGuid          = { 0x47889fb2, 0xd671, 0x4fab, { 0xa0, 0xca, 0xdf, 0x0e, 0x44, 0xdf, 0x70, 0xd6 }}
+
+  ## Include/Protocol/Ip4Config2.h
+  gEfiIp4Config2ProtocolGuid           =  { 0x5b446ed1, 0xe30b, 0x4faa, {0x87, 0x1a, 0x36, 0x54, 0xec, 0xa3, 0x60, 0x80 }}
+
+  ## Include/Protocol/Dns4.h
+  gEfiDns4ServiceBindingProtocolGuid   = { 0xb625b186, 0xe063, 0x44f7, { 0x89, 0x5, 0x6a, 0x74, 0xdc, 0x6f, 0x52, 0xb4 }}
+
+  ## Include/Protocol/Dns4.h
+  gEfiDns4ProtocolGuid                 = { 0xae3d28cc, 0xe05b, 0x4fa1, { 0xa0, 0x11, 0x7e, 0xb5, 0x5a, 0x3f, 0x14, 0x1 }}
+
+  ## Include/Protocol/Dns6.h
+  gEfiDns6ServiceBindingProtocolGuid   = { 0x7f1647c8, 0xb76e, 0x44b2, { 0xa5, 0x65, 0xf7, 0xf, 0xf1, 0x9c, 0xd1, 0x9e }}
+
+  ## Include/Protocol/Dns6.h
+  gEfiDns6ProtocolGuid                 = { 0xca37bc1f, 0xa327, 0x4ae9, { 0x82, 0x8a, 0x8c, 0x40, 0xd8, 0x50, 0x6a, 0x17 }}
+
+  ## Include/Protocol/Http.h
+  gEfiHttpServiceBindingProtocolGuid   = { 0xbdc8e6af, 0xd9bc, 0x4379, {0xa7, 0x2a, 0xe0, 0xc4, 0xe7, 0x5d, 0xae, 0x1c }}
+
+  ## Include/Protocol/Http.h
+  gEfiHttpProtocolGuid                 = { 0x7a59b29b, 0x910b, 0x4171, {0x82, 0x42, 0xa8, 0x5a, 0x0d, 0xf2, 0x5b, 0x5b }}
+
+  ## Include/Protocol/HttpUtilities.h
+  gEfiHttpUtilitiesProtocolGuid        = { 0x3e35c163, 0x4074, 0x45dd, {0x43, 0x1e, 0x23, 0x98, 0x9d, 0xd8, 0x6b, 0x32 }}
+
+  ## Include/Protocol/Tls.h
+  gEfiTlsServiceBindingProtocolGuid   = { 0x952cb795, 0xff36, 0x48cf, {0xa2, 0x49, 0x4d, 0xf4, 0x86, 0xd6, 0xab, 0x8d }}
+
+  ## Include/Protocol/Tls.h
+  gEfiTlsProtocolGuid                 = { 0xca959f, 0x6cfa, 0x4db1, {0x95, 0xbc, 0xe4, 0x6c, 0x47, 0x51, 0x43, 0x90 }}
+  
+  ## Include/Protocol/TlsConfig.h
+  gEfiTlsConfigurationProtocolGuid    = { 0x1682fe44, 0xbd7a, 0x4407, { 0xb7, 0xc7, 0xdc, 0xa3, 0x7c, 0xa3, 0x92, 0x2d }}
+
+  ## Include/Protocol/Rest.h
+  gEfiRestProtocolGuid                 =  { 0x0db48a36, 0x4e54, 0xea9c, {0x9b, 0x09, 0x1e, 0xa5, 0xbe, 0x3a, 0x66, 0x0b }}
+
+  ## Include/Protocol/Supplicant.h
+  gEfiSupplicantServiceBindingProtocolGuid  = { 0x45bcd98e, 0x59ad, 0x4174, { 0x95, 0x46, 0x34, 0x4a, 0x7, 0x48, 0x58, 0x98 }}
+  gEfiSupplicantProtocolGuid                = { 0x54fcc43e, 0xaa89, 0x4333, { 0x9a, 0x85, 0xcd, 0xea, 0x24, 0x5, 0x1e, 0x9e }}
+
+  #
+  # Protocols defined in UEFI2.6
+  #
+  ## Include/Protocol/WiFi2.h
+  gEfiWiFi2ProtocolGuid                = { 0x1b0fb9bf, 0x699d, 0x4fdd, {0xa7, 0xc3, 0x25, 0x46, 0x68, 0x1b, 0xf6, 0x3b }}
+
+  ## Include/Protocol/RamDisk.h
+  gEfiRamDiskProtocolGuid              = { 0xab38a0df, 0x6873, 0x44a9, { 0x87, 0xe6, 0xd4, 0xeb, 0x56, 0x14, 0x84, 0x49 }}
+
+  ## Include/Protocol/ImageDecoder.h
+  ##
+  ## In UEFI 2.6 spec,this guid value is duplicate with
+  ## EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID. Now update this guid value to
+  ## avoid the duplicate guid issue. So its value is not consistent with
+  ## UEFI spec definition now. We have proposed to update UEFI spec to
+  ## use this new guid. After new spec released, we will remove this
+  ## comments.
+  ##
+  gEfiHiiImageDecoderProtocolGuid      = { 0x9e66f251, 0x727c, 0x418c, { 0xbf, 0xd6, 0xc2, 0xb4, 0x25, 0x28, 0x18, 0xea }}
+
+  ## Include/Protocol/HiiImageEx.h
+  gEfiHiiImageExProtocolGuid           = { 0x1a1241e6, 0x8f19, 0x41a9, { 0xbc, 0xe,  0xe8, 0xef, 0x39, 0xe0, 0x65, 0x46 }}
+
+  ## Include/Protocol/SdMmcPassThru.h
+  gEfiSdMmcPassThruProtocolGuid        = { 0x716ef0d9, 0xff83, 0x4f69, {0x81, 0xe9, 0x51, 0x8b, 0xd3, 0x9a, 0x8e, 0x70 }}
+
+  ## Include/Protocol/EraseBlock.h
+  gEfiEraseBlockProtocolGuid           = { 0x95a9a93e, 0xa86e, 0x4926, {0xaa, 0xef, 0x99, 0x18, 0xe7, 0x72, 0xd9, 0x87 }}
+
+  #
+  # Protocols defined in Shell2.0
+  #
+  ## Include/Protocol/Shell.h
+  gEfiShellProtocolGuid                = { 0x6302d008, 0x7f9b, 0x4f30, {0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e }}
+
+  ## Include/Protocol/ShellParameters.h
+  gEfiShellParametersProtocolGuid      = { 0x752f3136, 0x4e16, 0x4fdc, {0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca }}
+
+  #
+  # Protocols defined in Shell2.1
+  #
+  ## Include/Protocol/ShellDynamicCommand.h
+  gEfiShellDynamicCommandProtocolGuid  = { 0x3c7200e9, 0x005f, 0x4ea4, {0x87, 0xde, 0xa3, 0xdf, 0xac, 0x8a, 0x27, 0xc3 }}
+
+#
+# [Error.gEfiMdePkgTokenSpaceGuid]
+#   0x80000001 | Invalid value provided.
+#   0x80000002 | Reserved bits must be set to zero.
+#   0x80000003 | Incorrect progress code provided.
+#
+
+[PcdsFeatureFlag]
+  ## Indicates if the component name protocol will be installed.<BR><BR>
+  #   TRUE  - Does not install component name protocol.<BR>
+  #   FALSE - Install component name protocol.<BR>
+  # @Prompt Disable Component Name Protocol.
+  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|FALSE|BOOLEAN|0x0000000d
+
+  ## Indicates if the diagnostics name protocol will be installed.<BR><BR>
+  #   TRUE  - Does not install diagnostics name protocol.<BR>
+  #   FALSE - Install diagnostics name protocol.<BR>
+  # @Prompt Disable Diagnostics Name protocol.
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|FALSE|BOOLEAN|0x0000000e
+
+  ## Indicates if the component name2 protocol will be installed.<BR><BR>
+  #   TRUE  - Does not install component name2 protocol.<BR>
+  #   FALSE - Install component name2 protocol.<BR>
+  # @Prompt Disable Component Name2 Protocol.
+  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|FALSE|BOOLEAN|0x00000010
+
+  ## Indicates if the diagnostics2 name protocol will be installed.<BR><BR>
+  #   TRUE  - Does not install diagnostics2 name protocol.<BR>
+  #   FALSE - Install diagnostics2 name protocol.<BR>
+  # @Prompt Disable Diagnostics2 Name Protocol.
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|FALSE|BOOLEAN|0x00000011
+
+  ## Indicates if EFI 1.1 ISO 639-2 language supports are obsolete<BR><BR>
+  #   TRUE  - Deprecate global variable LangCodes.<BR>
+  #   FALSE - Does not deprecate global variable LangCodes.<BR>
+  # @Prompt Deprecate Global Variable LangCodes.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLangDeprecate|FALSE|BOOLEAN|0x00000012
+
+  ## Indicates if UGA Draw Protocol is still consumed.<BR><BR>
+  #   TRUE  - Consume UGA Draw protocol.<BR>
+  #   FALSE - Does not consume UGA Draw protocol.<BR>
+  # @Prompt Consume UGA Draw Protocol.
+  gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE|BOOLEAN|0x00000027
+
+  ## Indicates if a check will be made to see if a specified node is a member of linked list
+  #  in the following BaseLib functions: GetNextNode(), IsNull(), IsNodeAtEnd(), SwapListEntries().<BR><BR>
+  #   TRUE  - Verify a specified node is a member of linked list.<BR>
+  #   FALSE - Does not verify a specified node is a member of linked list.<BR>
+  # @Prompt Verify Node In List.
+  gEfiMdePkgTokenSpaceGuid.PcdVerifyNodeInList|FALSE|BOOLEAN|0x00000028
+
+  ## If TRUE, OrderedCollectionLib is instructed to validate the
+  #  ORDERED_COLLECTION structure at the end of such operations (typically
+  #  structure modifications) that justify validation of the structure for unit
+  #  testing purposes.
+  # @Prompt Validate ORDERED_COLLECTION structure
+  gEfiMdePkgTokenSpaceGuid.PcdValidateOrderedCollection|FALSE|BOOLEAN|0x0000002a
+
+[PcdsFixedAtBuild]
+  ## Status code value for indicating a watchdog timer has expired.
+  # EFI_COMPUTING_UNIT_HOST_PROCESSOR | EFI_CU_HP_EC_TIMER_EXPIRED
+  # @Prompt Progress Code for WatchDog Timer Expired.
+  # @ValidList  0x80000003 | 0x00011003
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueEfiWatchDogTimerExpired|0x00011003|UINT32|0x00000013
+
+  ## Status code value for indicating the invocation of SetVirtualAddressMap()
+  # EFI_SOFTWARE_EFI_RUNTIME_SERVICE | EFI_SW_RS_PC_SET_VIRTUAL_ADDRESS_MAP
+  # @Prompt Progress Code for Invocation of SetVirtualAddressMap.
+  # @ValidList  0x80000003 | 0x03111004
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueSetVirtualAddressMap|0x03111004|UINT32|0x00000014
+
+  ## Status code value for indicating the start of memory test
+  # EFI_COMPUTING_UNIT_MEMORY | EFI_CU_MEMORY_PC_TEST
+  # @Prompt Progress Code for Memory Test Start.
+  # @ValidList  0x80000003 | 0x00051006
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMemoryTestStarted|0x00051006|UINT32|0x00000015
+
+  ## Status code value for indicating memory error in memory test
+  # EFI_COMPUTING_UNIT_MEMORY | EFI_CU_MEMORY_EC_UNCORRECTABLE
+  # @Prompt Progress Code for Memory Error.
+  # @ValidList  0x80000003 | 0x00051003
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueUncorrectableMemoryError|0x00051003|UINT32|0x00000016
+
+  ## Status code value for console operation failure.
+  # EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR
+  # @Prompt Progress Code for Console Error.
+  # @ValidList  0x80000003 | 0x01040006
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueRemoteConsoleError|0x01040006|UINT32|0x00000017
+
+  ## Status code value for console reset operation failure.
+  # EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_RESET
+  # @Prompt Progress Code for Console Reset.
+  # @ValidList  0x80000003 | 0x01040001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueRemoteConsoleReset|0x01040001|UINT32|0x00000018
+
+  ## Status code value for console input operation failure.
+  # EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_INPUT_ERROR
+  # @Prompt Progress Code for Console Input Error.
+  # @ValidList  0x80000003 | 0x01040007
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueRemoteConsoleInputError|0x01040007|UINT32|0x00000019
+
+  ## Status code value for console output operation failure.
+  # EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_OUTPUT_ERROR
+  # @Prompt Progress Code for Console Output Error.
+  # @ValidList  0x80000003 | 0x01040008
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueRemoteConsoleOutputError|0x01040008|UINT32|0x0000001a
+
+  ## Status code value for mouse operation failure.
+  # EFI_PERIPHERAL_MOUSE | EFI_P_EC_INTERFACE_ERROR
+  # @Prompt Progress Code for Module Device Failure.
+  # @ValidList  0x80000003 | 0x01020005
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMouseInterfaceError|0x01020005|UINT32|0x30001000
+
+  ## Status code value for indicating mouse device has been enabled.
+  # EFI_PERIPHERAL_MOUSE | EFI_P_PC_ENABLE
+  # @Prompt Progress Code for Enable Mouse Device.
+  # @ValidList  0x80000003 | 0x01020004
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMouseEnable|0x01020004|UINT32|0x30001001
+
+  ## Status code value for indicating mouse device has been disabled.
+  # EFI_PERIPHERAL_MOUSE | EFI_P_PC_DISABLE
+  # @Prompt Progress Code for Disable Mouse Device.
+  # @ValidList  0x80000003 | 0x01020002
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMouseDisable|0x01020002|UINT32|0x30001002
+
+  ## Status code value for enabling keyboard device.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_ENABLE
+  # @Prompt Progress Code for Enable Keyboard Device.
+  # @ValidList  0x80000003 | 0x01010004
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardEnable|0x01010004|UINT32|0x30001003
+
+  ## Status code value for disabling keyboard device.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_DISABLE
+  # @Prompt Progress Code for Disable Keyboard Device.
+  # @ValidList  0x80000003 | 0x01010002
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardDisable|0x01010002|UINT32|0x30001004
+
+  ## Status code value for indicating presence of keyboard.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_PRESENCE_DETECT
+  # @Prompt Progress Code for Detect Keyboard Device.
+  # @ValidList  0x80000003 | 0x01010003
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardPresenceDetect|0x01010003|UINT32|0x30001005
+
+  ## Status code value for keyboard operation reset operation.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_RESET
+  # @Prompt Progress Code for Keyboard Device Reset.
+  # @ValidList  0x80000003 | 0x01010001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardReset|0x01010001|UINT32|0x30001006
+
+  ## Status code value for keyboard clear buffer operation.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_CLEAR_BUFFER
+  # @Prompt Progress Code for Keyboard Device Clear Buffer.
+  # @ValidList  0x80000003 | 0x01011000
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardClearBuffer|0x01011000|UINT32|0x30001007
+
+  ## Status code value for keyboard device self-test.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST
+  # @Prompt Progress Code for Keyboard Device SelfTest.
+  # @ValidList  0x80000003 | 0x01011001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardSelfTest|0x01011001|UINT32|0x30001008
+
+  ## Status code value for indicating keyboard device failure.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INTERFACE_ERROR
+  # @Prompt Progress Code for Keyboard Device Failure.
+  # @ValidList  0x80000003 | 0x01010005
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardInterfaceError|0x01010005|UINT32|0x30001009
+
+  ## Status code value for indicating keyboard input handler failure.
+  # EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INPUT_ERROR
+  # @Prompt Progress Code for Keyboard Input Failure.
+  # @ValidList  0x80000003 | 0x01010007
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueKeyboardInputError|0x01010007|UINT32|0x3000100a
+
+  ## Status code value for mouse input handler failure.
+  # EFI_PERIPHERAL_MOUSE | EFI_P_EC_INPUT_ERROR
+  # @Prompt Progress Code for Mouse Input Failure.
+  # @ValidList  0x80000003 | 0x01020007
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMouseInputError|0x01020007|UINT32|0x3000100b
+
+  ## Status code value for mouse device reset operation.
+  # EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET
+  # @Prompt Progress Code for Mouse Device Reset.
+  # @ValidList  0x80000003 | 0x01020001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueMouseReset|0x01020001|UINT32|0x3000100c
+
+  ## Status code value for indicating the handoff from PEI phase to DXE phase.
+  # EFI_SOFTWARE_PEI_CORE | EFI_SW_PEI_CORE_PC_HANDOFF_TO_NEXT
+  # @Prompt Progress Code for Handoff from Pei phase to Dxe phase.
+  # @ValidList  0x80000003 | 0x3021001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValuePeiHandoffToDxe|0x3021001|UINT32|0x3000100d
+
+  ## Status code value for indicating one PEIM is dispatched.
+  #  EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_BEGIN
+  # @Prompt Progress Code for Dispatching One PEIM.
+  # @ValidList  0x80000003 | 0x3020002
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValuePeimDispatch|0x3020002|UINT32|0x3000100e
+
+  ## Status code value for PeiCore entry.
+  #  EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT
+  # @Prompt Progress Code for PeiCore Entry.
+  # @ValidList  0x80000003 | 0x3020000
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValuePeiCoreEntry|0x3020000|UINT32|0x3000100f
+
+  ## Status code value for DxeCore entry.
+  # EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_ENTRY_POINT
+  # @Prompt Progress Code for DxeCore Entry.
+  # @ValidList  0x80000003 | 0x3041000
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeCoreEntry|0x3041000|UINT32|0x30001010
+
+  ## Status code value for handoff from DxeCore to BDS.
+  # EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT
+  # @Prompt Progress Code for Handoff from DxeCore to BDS.
+  # @ValidList  0x80000003 | 0x3041001
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeCoreHandoffToBds|0x3041001|UINT32|0x30001011
+
+  ## Status code value for indicating boot service exit.
+  # EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES
+  # @Prompt Progress Code for Exit of Boot Service.
+  # @ValidList  0x80000003 | 0x3101019
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueBootServiceExit|0x3101019|UINT32|0x30001012
+
+  ## Status code value for indicating the beginning of DXE driver.
+  # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_BEGIN
+  # @Prompt Progress Code for Begin of DXE Driver.
+  # @ValidList  0x80000003 | 0x3040002
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverBegin|0x3040002|UINT32|0x30001013
+
+  ## Status code value for indicating the end of DXE drive.
+  # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_END
+  # @Prompt Progress Code for End of DXE Driver.
+  # @ValidList  0x80000003 | 0x3040003
+  gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverEnd|0x3040003|UINT32|0x30001014
+
+  ## This flag is used to control build time optimization based on debug print level.
+  #  Its default value is 0xFFFFFFFF to expose all debug print level.
+  #  BIT0  - Initialization message.<BR>
+  #  BIT1  - Warning message.<BR>
+  #  BIT2  - Load Event message.<BR>
+  #  BIT3  - File System message.<BR>
+  #  BIT4  - Allocate or Free Pool message.<BR>
+  #  BIT5  - Allocate or Free Page message.<BR>
+  #  BIT6  - Information message.<BR>
+  #  BIT7  - Dispatcher message.<BR>
+  #  BIT8  - Variable message.<BR>
+  #  BIT10 - Boot Manager message.<BR>
+  #  BIT12 - BlockIo Driver message.<BR>
+  #  BIT14 - Network Driver message.<BR>
+  #  BIT16 - UNDI Driver message.<BR>
+  #  BIT17 - LoadFile message.<BR>
+  #  BIT19 - Event message.<BR>
+  #  BIT20 - Global Coherency Database changes message.<BR>
+  #  BIT21 - Memory range cachability changes message.<BR>
+  #  BIT22 - Detailed debug message.<BR>
+  #  BIT31 - Error message.<BR>
+  # @Prompt Fixed Debug Message Print Level.
+  gEfiMdePkgTokenSpaceGuid.PcdFixedDebugPrintErrorLevel|0xFFFFFFFF|UINT32|0x30001016
+
+[PcdsFixedAtBuild,PcdsPatchableInModule]
+  ## Indicates the maximum length of unicode string used in the following
+  #  BaseLib functions: StrLen(), StrSize(), StrCmp(), StrnCmp(), StrCpy(), StrnCpy()<BR><BR>
+  #  0  - No length check for unicode string.<BR>
+  #  >0 - Maximum length of unicode string.<BR>
+  # @Prompt Maximum Length of Unicode String.
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength|1000000|UINT32|0x00000001
+
+  ## Indicates the maximum length of ascii string used in the following
+  #  BaseLib functions: AsciiStrLen(), AsciiStrSize(), AsciiStrCmp(), AsciiStrnCmp(),
+  #  AsciiStrCpy(), AsciiStrnCpy(). <BR><BR>
+  #  0  - No length check for ascii string.<BR>
+  #  >0 - Maximum length of ascii string.<BR>
+  # @Prompt Maximum Length of Ascii String.
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength|1000000|UINT32|0x00000002
+
+  ## Indicates the maximum node number of linked list.<BR><BR>
+  #  0  - No node number check for linked list.<BR>
+  #  >0 - Maximum node number of linked list.<BR>
+  # @Prompt Maximum Length of Linked List.
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength|1000000|UINT32|0x00000003
+
+  ## Indicates the maximum node number of device path.<BR><BR>
+  #  0  - No node number check for device path.<BR>
+  #  >0 - Maximum node number of device path.<BR>
+  # @Prompt Maximum node number of device path.
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumDevicePathNodeCount|0|UINT32|0x00000029
+
+  ## Indicates the timeout tick of holding spin lock.<BR><BR>
+  #  0  - No timeout.<BR>
+  #  >0 - Timeout tick of holding spin lock.<BR>
+  # @Prompt Spin Lock Timeout (us).
+  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout|10000000|UINT32|0x00000004
+
+  ## The mask is used to control DebugLib behavior.<BR><BR>
+  #  BIT0 - Enable Debug Assert.<BR>
+  #  BIT1 - Enable Debug Print.<BR>
+  #  BIT2 - Enable Debug Code.<BR>
+  #  BIT3 - Enable Clear Memory.<BR>
+  #  BIT4 - Enable BreakPoint as ASSERT.<BR>
+  #  BIT5 - Enable DeadLoop as ASSERT.<BR>
+  # @Prompt Debug Property.
+  # @Expression  0x80000002 | (gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask & 0xC0) == 0
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0|UINT8|0x00000005
+
+  ## This flag is used to control the print out Debug message.<BR><BR>
+  #  BIT0  - Initialization message.<BR>
+  #  BIT1  - Warning message.<BR>
+  #  BIT2  - Load Event message.<BR>
+  #  BIT3  - File System message.<BR>
+  #  BIT4  - Allocate or Free Pool message.<BR>
+  #  BIT5  - Allocate or Free Page message.<BR>
+  #  BIT6  - Information message.<BR>
+  #  BIT7  - Dispatcher message.<BR>
+  #  BIT8  - Variable message.<BR>
+  #  BIT10 - Boot Manager message.<BR>
+  #  BIT12 - BlockIo Driver message.<BR>
+  #  BIT14 - Network Driver message.<BR>
+  #  BIT16 - UNDI Driver message.<BR>
+  #  BIT17 - LoadFile message.<BR>
+  #  BIT19 - Event message.<BR>
+  #  BIT20 - Global Coherency Database changes message.<BR>
+  #  BIT21 - Memory range cachability changes message.<BR>
+  #  BIT22 - Detailed debug message.<BR>
+  #  BIT31 - Error message.<BR>
+  # @Prompt Debug Message Print Level.
+  # @Expression  0x80000002 | (gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel & 0x7F84AA00) == 0
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000|UINT32|0x00000006
+
+  ## The mask is used to control ReportStatusCodeLib behavior.<BR><BR>
+  #  BIT0 - Enable Progress Code.<BR>
+  #  BIT1 - Enable Error Code.<BR>
+  #  BIT2 - Enable Debug Code.<BR>
+  # @Prompt Report Status Code Property.
+  # @Expression  0x80000002 | (gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask & 0xF8) == 0
+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0|UINT8|0x00000007
+
+  ## This value is used to fill a segment of memory when PcdDebugPropertyMask Clear Memory is enabled.
+  # @Prompt Value to Clear Memory.
+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue|0xAF|UINT8|0x00000008
+
+  ## The mask is used to control PerformanceLib behavior.<BR><BR>
+  #  BIT0 - Enable Performance Measurement.<BR>
+  # @Prompt Performance Measurement Property.
+  # @Expression  0x80000002 | (gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask & 0xFE) == 0
+  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask|0|UINT8|0x00000009
+
+  ## The mask is used to control PostCodeLib behavior.<BR><BR>
+  #  BIT0 - Enable Post Code.<BR>
+  #  BIT1 - Enable Post Code with Description.<BR>
+  # @Prompt Post Code Property.
+  # @Expression  0x80000002 | (gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask & 0xFC) == 0
+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask|0|UINT8|0x0000000b
+
+  ## The bit width of data to be written to Port80. The default value is 8.
+  # @Prompt Port80 Data Width
+  # @ValidList  0x80000001 | 8, 16, 32
+  gEfiMdePkgTokenSpaceGuid.PcdPort80DataWidth|8|UINT8|0x0000002d
+
+  ## This value is used to configure X86 Processor FSB clock.
+  # @Prompt FSB Clock.
+  gEfiMdePkgTokenSpaceGuid.PcdFSBClock|200000000|UINT32|0x0000000c
+
+  ## The maximum printable number of characters. UefLib functions: AsciiPrint(), AsciiErrorPrint(),
+  #  PrintXY(), AsciiPrintXY(), Print(), ErrorPrint() base on this PCD value to print characters.
+  # @Prompt Maximum Printable Number of Characters.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|320|UINT32|0x101
+
+  ## This is the print buffer length for FileHandleLib.
+  #  FileHandlePrintLine() sizes buffers based on this PCD value for printing.
+  # @Prompt Number of Printable Characters.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiFileHandleLibPrintBufferSize|1536|UINT16|0x201
+
+  ## Indicates the allowable maximum number in extract handler table.
+  # @Prompt Maximum Number of GuidedExtractHandler.
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumGuidedExtractHandler|0x10|UINT32|0x00000025
+
+  ## Indicates the default timeouts for USB transfers in milliseconds.
+  # @Prompt USB Transfer Timeout (ms).
+  gEfiMdePkgTokenSpaceGuid.PcdUsbTransferTimeoutValue|3000|UINT32|0x00000026
+
+  ## This value is used to set the available memory address to store Guided Extract Handlers.
+  #  The required memory space is decided by the value of PcdMaximumGuidedExtractHandler.
+  # @Prompt Memory Address of GuidedExtractHandler Table.
+  gEfiMdePkgTokenSpaceGuid.PcdGuidedExtractHandlerTableAddress|0x1000000|UINT64|0x30001015
+
+[PcdsFixedAtBuild.IPF, PcdsPatchableInModule.IPF]
+  ## The base address of IO port space for IA64 arch.
+  # @Prompt IA64 IO Port Space Base Address.
+  gEfiMdePkgTokenSpaceGuid.PcdIoBlockBaseAddressForIpf|0x0ffffc000000|UINT64|0x0000000f
+
+[PcdsFixedAtBuild, PcdsPatchableInModule, PcdsDynamic, PcdsDynamicEx]
+  ## This value is used to set the base address of PCI express hierarchy.
+  # @Prompt PCI Express Base Address.
+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000|UINT64|0x0000000a
+
+  ## Default current ISO 639-2 language: English & French.
+  # @Prompt Default Value of LangCodes Variable.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLangCodes|"engfraengfra"|VOID*|0x0000001c
+
+  ## Default current ISO 639-2 language: English.
+  # @Prompt Default Value of Lang Variable.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLang|"eng"|VOID*|0x0000001d
+
+  ## Default platform supported RFC 4646 languages: (American) English & French.
+  # @Prompt Default Value of PlatformLangCodes Variable.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultPlatformLangCodes|"en;fr;en-US;fr-FR"|VOID*|0x0000001e
+
+  ## Default current RFC 4646 language: (American) English.
+  # @Prompt Default Value of PlatformLang Variable.
+  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultPlatformLang|"en-US"|VOID*|0x0000001f
+
+  ## Indicates the default baud rate of UART.
+  # @Prompt Default UART Baud Rate.
+  # @ValidList  0x80000001 | 115200, 57600, 38400, 19200, 9600, 7200, 4800, 3600, 2400, 2000, 1800, 1200, 600, 300, 150, 134, 110, 75, 50
+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate|115200|UINT64|0x00000020
+
+  ## Indicates the number of efficient data bit in UART transaction.
+  # @Prompt Default UART Data Bit.
+  # @ValidRange 0x80000001 | 5 - 8
+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultDataBits|8|UINT8|0x00000021
+
+  ## Indicates the setting of data parity in UART transaction.<BR><BR>
+  # 0 - Default Parity.<BR>
+  # 1 - No Parity.<BR>
+  # 2 - Even Parity.<BR>
+  # 3 - Odd Parity.<BR>
+  # 4 - Mark Parity.<BR>
+  # 5 - Space Parity.<BR>
+  # @Prompt Default UART Parity.
+  # @ValidRange 0x80000001 | 0 - 5
+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultParity|1|UINT8|0x00000022
+
+  ## Indicates the setting of stop bit in UART transaction.<BR><BR>
+  # 0 - Default Stop Bits.<BR>
+  # 1 - One Stop Bit.<BR>
+  # 2 - One Five Stop Bits.<BR>
+  # 3 - Two Stop Bits.<BR>
+  # @Prompt Default UART Stop Bits.
+  # @ValidRange 0x80000001 | 0 - 3
+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultStopBits|1|UINT8|0x00000023
+
+  ## Indicates the usable type of terminal.<BR><BR>
+  #  0 - PCANSI<BR>
+  #  1 - VT100<BR>
+  #  2 - VT100+<BR>
+  #  3 - UTF8<BR>
+  #  4 - TTYTERM, NOT defined in UEFI SPEC<BR>
+  # @Prompt Default Terminal Type.
+  # @ValidRange 0x80000001 | 0 - 4
+  gEfiMdePkgTokenSpaceGuid.PcdDefaultTerminalType|0|UINT8|0x00000024
+
+  ## Indicates the receive FIFO depth of UART controller.<BR><BR>
+  # @Prompt Default UART Receive FIFO Depth.
+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultReceiveFifoDepth|1|UINT16|0x00000030
+
+  ## Error level for hardware recorder.
+  #  If value 0, platform does not support feature of hardware error record.
+  # @Prompt Error Level For Hardware Recorder
+  gEfiMdePkgTokenSpaceGuid.PcdHardwareErrorRecordLevel|0|UINT16|0x0000002b
+
+  ## The number of seconds that the firmware will wait before initiating the original default boot selection.
+  #  A value of 0 indicates that the default boot selection is to be initiated immediately on boot.
+  #  The value of 0xFFFF then firmware will wait for user input before booting.
+  # @Prompt Boot Timeout (s)
+  gEfiMdePkgTokenSpaceGuid.PcdPlatformBootTimeOut|0xffff|UINT16|0x0000002c
+
+[UserExtensions.TianoCore."ExtraFiles"]
+  MdePkgExtra.uni
diff --git a/MdePkg/MdePkg.dsc b/MdePkg/MdePkg.dsc
new file mode 100644
index 000000000000..9912bb755ffe
--- /dev/null
+++ b/MdePkg/MdePkg.dsc
@@ -0,0 +1,185 @@
+## @file
+# EFI/PI MdePkg Package
+#
+# Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+#
+##
+
+[Defines]
+  PLATFORM_NAME                  = Mde
+  PLATFORM_GUID                  = 082F8BFC-0455-4859-AE3C-ECD64FB81642
+  PLATFORM_VERSION               = 1.06
+  DSC_SPECIFICATION              = 0x00010005
+  OUTPUT_DIRECTORY               = Build/Mde
+  SUPPORTED_ARCHITECTURES        = IA32|IPF|X64|EBC|ARM|AARCH64
+  BUILD_TARGETS                  = DEBUG|RELEASE|NOOPT
+  SKUID_IDENTIFIER               = DEFAULT
+
+[PcdsFeatureFlag]
+  gEfiMdePkgTokenSpaceGuid.PcdUgaConsumeSupport|TRUE
+
+[PcdsFixedAtBuild]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x0f
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
+
+[PcdsFixedAtBuild.IPF]
+  gEfiMdePkgTokenSpaceGuid.PcdIoBlockBaseAddressForIpf|0x0ffffc000000
+
+###################################################################################################
+#
+# Components Section - list of the modules and components that will be processed by compilation
+#                      tools and the EDK II tools to generate PE32/PE32+/Coff image files.
+#
+# Note: The EDK II DSC file is not used to specify how compiled binary images get placed
+#       into firmware volume images. This section is just a list of modules to compile from
+#       source into UEFI-compliant binaries.
+#       It is the FDF file that contains information on combining binary files into firmware
+#       volume images, whose concept is beyond UEFI and is described in PI specification.
+#       Binary modules do not need to be listed in this section, as they should be
+#       specified in the FDF file. For example: Shell binary (Shell_Full.efi), FAT binary (Fat.efi),
+#       Logo (Logo.bmp), and etc.
+#       There may also be modules listed in this section that are not required in the FDF file,
+#       When a module listed here is excluded from FDF file, then UEFI-compliant binary will be
+#       generated for it, but the binary will not be put into any firmware volume.
+#
+###################################################################################################
+
+[Components]
+  MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
+  MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
+  MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
+  MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf
+  MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
+  MdePkg/Library/BaseLib/BaseLib.inf
+  MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
+  MdePkg/Library/BaseOrderedCollectionRedBlackTreeLib/BaseOrderedCollectionRedBlackTreeLib.inf
+  MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf
+  MdePkg/Library/BasePciExpressLib/BasePciExpressLib.inf
+  MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf
+  MdePkg/Library/BasePciLibPciExpress/BasePciLibPciExpress.inf
+  MdePkg/Library/BasePciSegmentLibPci/BasePciSegmentLibPci.inf
+  MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
+  MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
+  MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
+  MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
+  MdePkg/Library/BasePostCodeLibDebug/BasePostCodeLibDebug.inf
+  MdePkg/Library/BasePostCodeLibPort80/BasePostCodeLibPort80.inf
+  MdePkg/Library/BasePrintLib/BasePrintLib.inf
+  MdePkg/Library/BaseReportStatusCodeLibNull/BaseReportStatusCodeLibNull.inf
+  MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
+  MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf
+  MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
+  MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
+  MdePkg/Library/BaseSmbusLibNull/BaseSmbusLibNull.inf
+
+  MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf
+  MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf
+  MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
+  MdePkg/Library/DxeHobLib/DxeHobLib.inf
+  MdePkg/Library/DxePcdLib/DxePcdLib.inf
+  MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
+  MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
+  MdePkg/Library/DxeSmbusLib/DxeSmbusLib.inf
+  MdePkg/Library/DxeIoLibCpuIo2/DxeIoLibCpuIo2.inf
+  MdePkg/Library/DxeHstiLib/DxeHstiLib.inf
+
+  MdePkg/Library/DxeRuntimePciExpressLib/DxeRuntimePciExpressLib.inf
+
+  MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf
+  MdePkg/Library/PeiDxePostCodeLibReportStatusCode/PeiDxePostCodeLibReportStatusCode.inf
+  MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.inf
+  MdePkg/Library/PeiHobLib/PeiHobLib.inf
+  MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.inf
+  MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
+  MdePkg/Library/PeiMemoryLib/PeiMemoryLib.inf
+  MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
+  MdePkg/Library/PeiPcdLib/PeiPcdLib.inf
+  MdePkg/Library/PeiResourcePublicationLib/PeiResourcePublicationLib.inf
+  MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
+  MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
+  MdePkg/Library/PeiSmbusLibSmbus2Ppi/PeiSmbusLibSmbus2Ppi.inf
+  MdePkg/Library/PeiPciLibPciCfg2/PeiPciLibPciCfg2.inf
+  MdePkg/Library/PeiPciSegmentLibPciCfg2/PeiPciSegmentLibPciCfg2.inf
+
+  MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
+  MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
+  MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
+  MdePkg/Library/UefiDebugLibDebugPortProtocol/UefiDebugLibDebugPortProtocol.inf
+  MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.inf
+  MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
+  MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.inf
+  MdePkg/Library/UefiDevicePathLibDevicePathProtocol/UefiDevicePathLibDevicePathProtocol.inf
+  MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
+  MdePkg/Library/UefiLib/UefiLib.inf
+  MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
+  MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf
+  MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
+  MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
+  MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
+  MdePkg/Library/UefiPciLibPciRootBridgeIo/UefiPciLibPciRootBridgeIo.inf
+  MdePkg/Library/UefiPciSegmentLibPciRootBridgeIo/UefiPciSegmentLibPciRootBridgeIo.inf
+  MdePkg/Library/SmmLibNull/SmmLibNull.inf
+  MdePkg/Library/BaseExtractGuidedSectionLib/BaseExtractGuidedSectionLib.inf
+
+[Components.IA32, Components.X64]
+  MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
+  MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.inf
+  MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.inf
+  MdePkg/Library/BaseMemoryLibOptPei/BaseMemoryLibOptPei.inf
+  MdePkg/Library/BaseMemoryLibRepStr/BaseMemoryLibRepStr.inf
+  MdePkg/Library/BaseMemoryLibSse2/BaseMemoryLibSse2.inf
+  MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.inf
+  MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf
+  MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
+  MdePkg/Library/SmmIoLibSmmCpuIo2/SmmIoLibSmmCpuIo2.inf
+  MdePkg/Library/SmmPciLibPciRootBridgeIo/SmmPciLibPciRootBridgeIo.inf
+  MdePkg/Library/SmmServicesTableLib/SmmServicesTableLib.inf
+  MdePkg/Library/SmmMemoryAllocationLib/SmmMemoryAllocationLib.inf
+  MdePkg/Library/SmmPeriodicSmiLib/SmmPeriodicSmiLib.inf
+  MdePkg/Library/BaseS3BootScriptLibNull/BaseS3BootScriptLibNull.inf
+  MdePkg/Library/BaseS3IoLib/BaseS3IoLib.inf
+  MdePkg/Library/BaseS3PciLib/BaseS3PciLib.inf
+  MdePkg/Library/BaseS3SmbusLib/BaseS3SmbusLib.inf
+  MdePkg/Library/BaseS3StallLib/BaseS3StallLib.inf
+  MdePkg/Library/SmmMemLib/SmmMemLib.inf
+  MdePkg/Library/BaseRngLib/BaseRngLib.inf
+  MdePkg/Library/SmmPciExpressLib/SmmPciExpressLib.inf
+  MdePkg/Library/SmiHandlerProfileLibNull/SmiHandlerProfileLibNull.inf
+
+[Components.IPF]
+  MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
+  MdePkg/Library/BasePalLibNull/BasePalLibNull.inf
+  MdePkg/Library/PeiPalLib/PeiPalLib.inf
+  MdePkg/Library/PeiServicesTablePointerLibKr7/PeiServicesTablePointerLibKr7.inf
+  MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf
+  MdePkg/Library/UefiPalLib/UefiPalLib.inf
+  MdePkg/Library/UefiSalLib/UefiSalLib.inf
+  MdePkg/Library/DxeExtendedSalLib/DxeExtendedSalLib.inf
+  MdePkg/Library/DxeIoLibEsal/DxeIoLibEsal.inf
+  MdePkg/Library/DxePalLibEsal/DxePalLibEsal.inf
+  MdePkg/Library/DxePciLibEsal/DxePciLibEsal.inf
+  MdePkg/Library/DxePciSegmentLibEsal/DxePciSegmentLibEsal.inf
+  MdePkg/Library/DxeRuntimeExtendedSalLib/DxeRuntimeExtendedSalLib.inf
+  MdePkg/Library/DxeSalLibEsal/DxeSalLibEsal.inf
+  MdePkg/Library/DxeTimerLibEsal/DxeTimerLibEsal.inf  
+  
+[Components.EBC]
+  MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
+  MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
+
+[Components.ARM, Components.AARCH64]
+  MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
+
+[BuildOptions]
+  *_*_*_CC_FLAGS = -D DISABLE_NEW_DEPRECATED_INTERFACES
diff --git a/MdePkg/MdePkg.uni b/MdePkg/MdePkg.uni
new file mode 100644
index 000000000000..9f9bdd40e2c4
--- /dev/null
+++ b/MdePkg/MdePkg.uni
@@ -0,0 +1,404 @@
+// /** @file
+// This Package provides all definitions, library classes and libraries instances.
+//
+// It also provides the definitions(including PPIs/PROTOCOLs/GUIDs) of
+// EFI1.10/UEFI2.4/PI1.3 and some Industry Standards.
+//
+// Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+
+#string STR_PACKAGE_ABSTRACT            #language en-US "This Package provides all definitions, library classes and libraries instances."
+
+#string STR_PACKAGE_DESCRIPTION         #language en-US "It also provides the definitions(including PPIs/PROTOCOLs/GUIDs) of EFI1.10/UEFI2.4/PI1.3 and some Industry Standards."
+
+
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueEfiWatchDogTimerExpired_PROMPT  #language en-US "Progress Code for WatchDog Timer Expired"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueEfiWatchDogTimerExpired_HELP  #language en-US "Status code value for indicating a watchdog timer has expired. EFI_COMPUTING_UNIT_HOST_PROCESSOR | EFI_CU_HP_EC_TIMER_EXPIRED"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_ERR_80000003 #language en-US "Incorrect progress code provided."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueSetVirtualAddressMap_PROMPT  #language en-US "Progress Code for Invocation of SetVirtualAddressMap"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueSetVirtualAddressMap_HELP  #language en-US "Status code value for indicating the invocation of SetVirtualAddressMap() EFI_SOFTWARE_EFI_RUNTIME_SERVICE | EFI_SW_RS_PC_SET_VIRTUAL_ADDRESS_MAP"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMemoryTestStarted_PROMPT  #language en-US "Progress Code for Memory Test Start"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMemoryTestStarted_HELP  #language en-US "Status code value for indicating the start of memory test EFI_COMPUTING_UNIT_MEMORY | EFI_CU_MEMORY_PC_TEST"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueUncorrectableMemoryError_PROMPT  #language en-US "Progress Code for Memory Error"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueUncorrectableMemoryError_HELP  #language en-US "Status code value for indicating memory error in memory test EFI_COMPUTING_UNIT_MEMORY | EFI_CU_MEMORY_EC_UNCORRECTABLE"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleError_PROMPT  #language en-US "Progress Code for Console Error"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleError_HELP  #language en-US "Status code value for console operation failure. EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleReset_PROMPT  #language en-US "Progress Code for Console Reset"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleReset_HELP  #language en-US "Status code value for console reset operation failure. EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_RESET"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleInputError_PROMPT  #language en-US "Progress Code for Console Input Error"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleInputError_HELP  #language en-US "Status code value for console input operation failure. EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_INPUT_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleOutputError_PROMPT  #language en-US "Progress Code for Console Output Error"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueRemoteConsoleOutputError_HELP  #language en-US "Status code value for console output operation failure. EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_OUTPUT_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseInterfaceError_PROMPT  #language en-US "Progress Code for Module Device Failure"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseInterfaceError_HELP  #language en-US "Status code value for mouse operation failure. EFI_PERIPHERAL_MOUSE | EFI_P_EC_INTERFACE_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseEnable_PROMPT  #language en-US "Progress Code for Enable Mouse Device"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseEnable_HELP  #language en-US "Status code value for indicating mouse device has been enabled. EFI_PERIPHERAL_MOUSE | EFI_P_PC_ENABLE"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseDisable_PROMPT  #language en-US "Progress Code for Disable Mouse Device"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseDisable_HELP  #language en-US "Status code value for indicating mouse device has been disabled. EFI_PERIPHERAL_MOUSE | EFI_P_PC_DISABLE"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardEnable_PROMPT  #language en-US "Progress Code for Enable Keyboard Device"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardEnable_HELP  #language en-US "Status code value for enabling keyboard device. EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_ENABLE"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardDisable_PROMPT  #language en-US "Progress Code for Disable Keyboard Device"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardDisable_HELP  #language en-US "Status code value for disabling keyboard device. EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_DISABLE"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardPresenceDetect_PROMPT  #language en-US "Progress Code for Detect Keyboard Device"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardPresenceDetect_HELP  #language en-US "Status code value for indicating presence of keyboard. EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_PRESENCE_DETECT"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardReset_PROMPT  #language en-US "Progress Code for Keyboard Device Reset"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardReset_HELP  #language en-US "Status code value for keyboard operation reset operation. EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_RESET"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardClearBuffer_PROMPT  #language en-US "Progress Code for Keyboard Device Clear Buffer"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardClearBuffer_HELP  #language en-US "Status code value for keyboard clear buffer operation. EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_CLEAR_BUFFER"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardSelfTest_PROMPT  #language en-US "Progress Code for Keyboard Device SelfTest"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardSelfTest_HELP  #language en-US "Status code value for keyboard device self-test. EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardInterfaceError_PROMPT  #language en-US "Progress Code for Keyboard Device Failure"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardInterfaceError_HELP  #language en-US "Status code value for indicating keyboard device failure. EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INTERFACE_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardInputError_PROMPT  #language en-US "Progress Code for Keyboard Input Failure"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueKeyboardInputError_HELP  #language en-US "Status code value for indicating keyboard input handler failure. EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INPUT_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseInputError_PROMPT  #language en-US "Progress Code for Mouse Input Failure"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseInputError_HELP  #language en-US "Status code value for mouse input handler failure. EFI_PERIPHERAL_MOUSE | EFI_P_EC_INPUT_ERROR"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseReset_PROMPT  #language en-US "Progress Code for Mouse Device Reset"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueMouseReset_HELP  #language en-US "Status code value for mouse device reset operation. EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeiHandoffToDxe_PROMPT  #language en-US "Progress Code for Handoff from PEI phase to DXE phase"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeiHandoffToDxe_HELP  #language en-US "Status code value for indicating the handoff from PEI phase to DXE phase. EFI_SOFTWARE_PEI_CORE | EFI_SW_PEI_CORE_PC_HANDOFF_TO_NEXT"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeimDispatch_PROMPT  #language en-US "Progress Code for Dispatching One PEIM"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeimDispatch_HELP  #language en-US "Status code value for indicating one PEIM is dispatched. EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_BEGIN"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeiCoreEntry_PROMPT  #language en-US "Progress Code for PeiCore Entry"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValuePeiCoreEntry_HELP  #language en-US "Status code value for PeiCore entry. EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeCoreEntry_PROMPT  #language en-US "Progress Code for DxeCore Entry"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeCoreEntry_HELP  #language en-US "Status code value for DxeCore entry. EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_ENTRY_POINT"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeCoreHandoffToBds_PROMPT  #language en-US "Progress Code for Handoff from DxeCore to BDS"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeCoreHandoffToBds_HELP  #language en-US "Status code value for handoff from DxeCore to BDS. EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueBootServiceExit_PROMPT  #language en-US "Progress Code for Exit of Boot Service"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueBootServiceExit_HELP  #language en-US "Status code value for indicating boot service exit. EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeDriverBegin_PROMPT  #language en-US "Progress Code for Begin of DXE Driver"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeDriverBegin_HELP  #language en-US "Status code value for indicating the beginning of DXE driver. EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_BEGIN"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeDriverEnd_PROMPT  #language en-US "Progress Code for End of DXE Driver"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdStatusCodeValueDxeDriverEnd_HELP  #language en-US "Status code value for indicating the end of DXE drive. EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_END"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumUnicodeStringLength_PROMPT  #language en-US "Maximum Length of Unicode String"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumUnicodeStringLength_HELP  #language en-US "Sets the maximum number of unicode characters used for string functions.  This affects the following BaseLib functions: StrLen(), StrSize(), StrCmp(), StrnCmp(), StrCpy(), StrnCpy()<BR><BR>\n"
+                                                                                         "0  - No length check for unicode string.<BR>\n"
+                                                                                         ">0 - Maximum length of unicode string.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumAsciiStringLength_PROMPT  #language en-US "Maximum Length of Ascii String"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumAsciiStringLength_HELP  #language en-US "Sets the maximum number of ASCII characters used for string functions.  This affects the following BaseLib functions: AsciiStrLen(), AsciiStrSize(), AsciiStrCmp(), AsciiStrnCmp(), AsciiStrCpy(), AsciiStrnCpy(). <BR><BR>\n"
+                                                                                       "0  - No length check for ASCII string.<BR>\n"
+                                                                                       ">0 - Maximum length of ASCII string.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumLinkedListLength_PROMPT  #language en-US "Maximum Length of Linked List"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumLinkedListLength_HELP  #language en-US "Indicates the maximum node number of linked list.<BR><BR>\n"
+                                                                                      "0  - No node number check for linked list.<BR>\n"
+                                                                                      ">0 - Maximum node number of linked list.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumDevicePathNodeCount_PROMPT  #language en-US "Maximum node number of device path"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumDevicePathNodeCount_HELP  #language en-US "Indicates the maximum node number of device path.<BR><BR>\n"
+                                                                                         "0  - No node number check for device path.<BR>\n"
+                                                                                         ">0 - Maximum node number of device path.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdSpinLockTimeout_PROMPT  #language en-US "Spin Lock Timeout (us)"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdSpinLockTimeout_HELP  #language en-US "Indicates the timeout tick of holding spin lock.<BR><BR>\n"
+                                                                              "0  - No timeout.<BR>\n"
+                                                                              ">0 - Timeout tick of holding spin lock.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugPropertyMask_PROMPT  #language en-US "Debug Property"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugPropertyMask_HELP  #language en-US "The mask is used to control DebugLib behavior.<BR><BR>\n"
+                                                                                "BIT0 - Enable Debug Assert.<BR>\n"
+                                                                                "BIT1 - Enable Debug Print.<BR>\n"
+                                                                                "BIT2 - Enable Debug Code.<BR>\n"
+                                                                                "BIT3 - Enable Clear Memory.<BR>\n"
+                                                                                "BIT4 - Enable BreakPoint as ASSERT.<BR>\n"
+                                                                                "BIT5 - Enable DeadLoop as ASSERT.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_ERR_80000002 #language en-US "Reserved bits must be set to zero."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugPrintErrorLevel_PROMPT  #language en-US "Debug Message Print Level"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugPrintErrorLevel_HELP  #language en-US "This flag is used to control the print out Debug message.<BR><BR>\n"
+                                                                                   "BIT0  - Initialization message.<BR>\n"
+                                                                                   "BIT1  - Warning message.<BR>\n"
+                                                                                   "BIT2  - Load Event message.<BR>\n"
+                                                                                   "BIT3  - File System message.<BR>\n"
+                                                                                   "BIT4  - Allocate or Free Pool message.<BR>\n"
+                                                                                   "BIT5  - Allocate or Free Page message.<BR>\n"
+                                                                                   "BIT6  - Information message.<BR>\n"
+                                                                                   "BIT7  - Dispatcher message.<BR>\n"
+                                                                                   "BIT8  - Variable message.<BR>\n"
+                                                                                   "BIT10 - Boot Manager message.<BR>\n"
+                                                                                   "BIT12 - BlockIo Driver message.<BR>\n"
+                                                                                   "BIT14 - Network Driver message.<BR>\n"
+                                                                                   "BIT16 - UNDI Driver message.<BR>\n"
+                                                                                   "BIT17 - LoadFile message.<BR>\n"
+                                                                                   "BIT19 - Event message.<BR>\n"
+                                                                                   "BIT20 - Global Coherency Database changes message.<BR>\n"
+                                                                                   "BIT21 - Memory range cacheability changes message.<BR>\n"
+                                                                                   "BIT22 - Detailed debug message.<BR>\n"
+                                                                                   "BIT31 - Error message.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdFixedDebugPrintErrorLevel_PROMPT  #language en-US "Fixed Debug Message Print Level"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdFixedDebugPrintErrorLevel_HELP  #language en-US "This flag is used to control build time optimization based on debug print level.<BR><BR>\n"
+                                                                                   "BIT0  - Initialization message.<BR>\n"
+                                                                                   "BIT1  - Warning message.<BR>\n"
+                                                                                   "BIT2  - Load Event message.<BR>\n"
+                                                                                   "BIT3  - File System message.<BR>\n"
+                                                                                   "BIT4  - Allocate or Free Pool message.<BR>\n"
+                                                                                   "BIT5  - Allocate or Free Page message.<BR>\n"
+                                                                                   "BIT6  - Information message.<BR>\n"
+                                                                                   "BIT7  - Dispatcher message.<BR>\n"
+                                                                                   "BIT8  - Variable message.<BR>\n"
+                                                                                   "BIT10 - Boot Manager message.<BR>\n"
+                                                                                   "BIT12 - BlockIo Driver message.<BR>\n"
+                                                                                   "BIT14 - Network Driver message.<BR>\n"
+                                                                                   "BIT16 - UNDI Driver message.<BR>\n"
+                                                                                   "BIT17 - LoadFile message.<BR>\n"
+                                                                                   "BIT19 - Event message.<BR>\n"
+                                                                                   "BIT20 - Global Coherency Database changes message.<BR>\n"
+                                                                                   "BIT21 - Memory range cacheability changes message.<BR>\n"
+                                                                                   "BIT22 - Detailed debug message.<BR>\n"
+                                                                                   "BIT31 - Error message.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdReportStatusCodePropertyMask_PROMPT  #language en-US "Report Status Code Property"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdReportStatusCodePropertyMask_HELP  #language en-US "The mask is used to control ReportStatusCodeLib behavior.<BR><BR>\n"
+                                                                                           "BIT0 - Enable Progress Code.<BR>\n"
+                                                                                           "BIT1 - Enable Error Code.<BR>\n"
+                                                                                           "BIT2 - Enable Debug Code.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugClearMemoryValue_PROMPT  #language en-US "Value to Clear Memory"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDebugClearMemoryValue_HELP  #language en-US "This value is used to fill a segment of memory when PcdDebugPropertyMask Clear Memory is enabled."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPerformanceLibraryPropertyMask_PROMPT  #language en-US "Performance Measurement Property"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPerformanceLibraryPropertyMask_HELP  #language en-US "The mask is used to control PerformanceLib behavior.<BR><BR>\n"
+                                                                                             "BIT0 - Enable Performance Measurement.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPostCodePropertyMask_PROMPT  #language en-US "Post Code Property"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPostCodePropertyMask_HELP  #language en-US "The mask is used to control PostCodeLib behavior.<BR><BR>\n"
+                                                                                   "BIT0 - Enable Post Code.<BR>\n"
+                                                                                   "BIT1 - Enable Post Code with Description.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdFSBClock_PROMPT  #language en-US "FSB Clock"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdFSBClock_HELP  #language en-US "This value is used to configure X86 Processor FSB clock."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiLibMaxPrintBufferSize_PROMPT  #language en-US "Maximum Printable Number of Characters"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiLibMaxPrintBufferSize_HELP  #language en-US "The maximum printable number of characters. UefLib functions: AsciiPrint(), AsciiErrorPrint(), PrintXY(), AsciiPrintXY(), Print(), ErrorPrint() base on this PCD value to print characters."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumGuidedExtractHandler_PROMPT  #language en-US "Maximum Number of GuidedExtractHandler"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdMaximumGuidedExtractHandler_HELP  #language en-US "Indicates the allowable maximum number in extract handler table."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUsbTransferTimeoutValue_PROMPT  #language en-US "USB Transfer Timeout (ms)"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUsbTransferTimeoutValue_HELP  #language en-US "Indicates the default timeouts for USB transfers in milliseconds."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdGuidedExtractHandlerTableAddress_PROMPT  #language en-US "Memory Address of GuidedExtractHandler Table"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdGuidedExtractHandlerTableAddress_HELP  #language en-US "This value is used to set the available memory address to store Guided Extract Handlers. The required memory space is decided by the value of PcdMaximumGuidedExtractHandler."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPciExpressBaseAddress_PROMPT  #language en-US "PCI Express Base Address"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPciExpressBaseAddress_HELP  #language en-US "This value is used to set the base address of PCI express hierarchy."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLangCodes_PROMPT  #language en-US "Default Value of LangCodes Variable"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLangCodes_HELP  #language en-US "Default current ISO 639-2 language: English & French."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLang_PROMPT  #language en-US "Default Value of Lang Variable"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLang_HELP  #language en-US "Default current ISO 639-2 language: English."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultPlatformLangCodes_PROMPT  #language en-US "Default Value of PlatformLangCodes Variable"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultPlatformLangCodes_HELP  #language en-US "Default platform supported RFC 4646 languages: (American) English & French."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultPlatformLang_PROMPT  #language en-US "Default Value of PlatformLang Variable"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultPlatformLang_HELP  #language en-US "Default current RFC 4646 language: (American) English."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultBaudRate_PROMPT  #language en-US "Default UART Baud Rate"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultBaudRate_HELP  #language en-US "Indicates the default baud rate of UART."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_ERR_80000001 #language en-US "Invalid value provided."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultDataBits_PROMPT  #language en-US "Default UART Data Bit"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultDataBits_HELP  #language en-US "Indicates the number of efficient data bit in UART transaction."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultParity_PROMPT  #language en-US "Default UART Parity"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultParity_HELP  #language en-US "Indicates the setting of data parity in UART transaction.<BR><BR>\n"
+                                                                                "0 - Default Parity.<BR>\n"
+                                                                                "1 - No Parity.<BR>\n"
+                                                                                "2 - Even Parity.<BR>\n"
+                                                                                "3 - Odd Parity.<BR>\n"
+                                                                                "4 - Mark Parity.<BR>\n"
+                                                                                "5 - Space Parity.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultStopBits_PROMPT  #language en-US "Default UART Stop Bits"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultStopBits_HELP  #language en-US "Indicates the setting of stop bit in UART transaction.<BR><BR>\n"
+                                                                                  "0 - Default Stop Bits.<BR>\n"
+                                                                                  "1 - One Stop Bit.<BR>\n"
+                                                                                  "2 - One Five Stop Bits.<BR>\n"
+                                                                                  "3 - Two Stop Bits.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDefaultTerminalType_PROMPT  #language en-US "Default Terminal Type"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDefaultTerminalType_HELP  #language en-US "Selects default terminal type.<BR><BR>\n"
+                                                                                  "0 - PCANSI<BR>\n"
+                                                                                  "1 - VT100<BR>\n"
+                                                                                  "2 - VT100+<BR>\n"
+                                                                                  "3 - UTF8<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdIoBlockBaseAddressForIpf_PROMPT  #language en-US "IA64 IO Port Space Base Address."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdIoBlockBaseAddressForIpf_HELP  #language en-US "The base address of IO port space for IA64 arch."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdComponentNameDisable_PROMPT  #language en-US "Disable Component Name Protocol"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdComponentNameDisable_HELP  #language en-US "Indicates if the component name protocol will be installed.<BR><BR>\n"
+                                                                                   "TRUE  - Does not install component name protocol.<BR>\n"
+                                                                                   "FALSE - Install component name protocol.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDriverDiagnosticsDisable_PROMPT  #language en-US "Disable Diagnostics Name protocol"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDriverDiagnosticsDisable_HELP  #language en-US "Indicates if the diagnostics name protocol will be installed.<BR><BR>\n"
+                                                                                       "TRUE  - Does not install diagnostics name protocol.<BR>\n"
+                                                                                       "FALSE - Install diagnostics name protocol.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdComponentName2Disable_PROMPT  #language en-US "Disable Component Name2 Protocol"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdComponentName2Disable_HELP  #language en-US "Indicates if the component name2 protocol will be installed.<BR><BR>\n"
+                                                                                    "TRUE  - Does not install component name2 protocol.<BR>\n"
+                                                                                    "FALSE - Install component name2 protocol.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDriverDiagnostics2Disable_PROMPT  #language en-US "Disable Diagnostics2 Name Protocol"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdDriverDiagnostics2Disable_HELP  #language en-US "Indicates if the diagnostics2 name protocol will be installed.<BR><BR>\n"
+                                                                                        "TRUE  - Does not install diagnostics2 name protocol.<BR>\n"
+                                                                                        "FALSE - Install diagnostics2 name protocol.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLangDeprecate_PROMPT  #language en-US "Deprecate Global Variable LangCodes"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiVariableDefaultLangDeprecate_HELP  #language en-US "Indicates if EFI 1.1 ISO 639-2 language supports are obsolete<BR><BR>\n"
+                                                                                               "TRUE  - Deprecate global variable LangCodes.<BR>\n"
+                                                                                               "FALSE - Does not deprecate global variable LangCodes.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUgaConsumeSupport_PROMPT  #language en-US "Consume UGA Draw Protocol"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUgaConsumeSupport_HELP  #language en-US "Indicates if UGA Draw Protocol is still consumed.<BR><BR>\n"
+                                                                                "TRUE  - Consume UGA Draw protocol.<BR>\n"
+                                                                                "FALSE - Does not consume UGA Draw protocol.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdVerifyNodeInList_PROMPT  #language en-US "Verify Node In List"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdVerifyNodeInList_HELP  #language en-US "Indicates if a check will be made to see if a specified node is a member of linked list in the following BaseLib functions: GetNextNode(), IsNull(), IsNodeAtEnd(), SwapListEntries().<BR><BR>\n"
+                                                                               "TRUE  - Verify a specified node is a member of linked list.<BR>\n"
+                                                                               "FALSE - Does not verify a specified node is a member of linked list.<BR>"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdValidateOrderedCollection_PROMPT  #language en-US "Validate ORDERED_COLLECTION structure"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdValidateOrderedCollection_HELP  #language en-US "If TRUE, OrderedCollectionLib is instructed to validate the ORDERED_COLLECTION structure at the end of such operations (typically structure modifications) that justify validation of the structure for unit testing purposes."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiFileHandleLibPrintBufferSize_PROMPT  #language en-US "Number of Printable Characters."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUefiFileHandleLibPrintBufferSize_HELP  #language en-US "This is the print buffer length for FileHandleLib.\n"
+                                                                                               "FileHandlePrintLine() sizes buffers based on this PCD value for printing."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdHardwareErrorRecordLevel_PROMPT  #language en-US "Error Level For Hardware Recorder"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdHardwareErrorRecordLevel_HELP  #language en-US "Error level for hardware recorder.\n"
+                                                                                       "If value 0, platform does not support feature of hardware error record."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPlatformBootTimeOut_PROMPT  #language en-US "Boot Timeout (s)"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPlatformBootTimeOut_HELP  #language en-US "The number of seconds that the firmware will wait before initiating the original default boot selection.\n"
+                                                                                  "A value of 0 indicates that the default boot selection is to be initiated immediately on boot.\n"
+                                                                                  "The value of 0xFFFF then firmware will wait for user input before booting."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPort80DataWidth_PROMPT  #language en-US "Port80 Data Width"
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdPort80DataWidth_HELP  #language en-US "The bit width of data to be written to Port80. The default value is 8. "
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultReceiveFifoDepth_PROMPT  #language en-US "Default UART Receive FIFO Depth."
+
+#string STR_gEfiMdePkgTokenSpaceGuid_PcdUartDefaultReceiveFifoDepth_HELP  #language en-US "Indicates the receive FIFO depth of UART controller.<BR><BR>"
+
diff --git a/MdePkg/MdePkgExtra.uni b/MdePkg/MdePkgExtra.uni
new file mode 100644
index 000000000000..f864d8233161
--- /dev/null
+++ b/MdePkg/MdePkgExtra.uni
@@ -0,0 +1,20 @@
+// /** @file
+// Mde Package Localized Strings and Content.
+//
+// Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>
+//
+// Portions copyright (c) 2008 - 2009, Apple Inc. 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.
+//
+// **/
+
+#string STR_PROPERTIES_PACKAGE_NAME 
+#language en-US 
+"Mde package"